Use new test API's for U2fRegisterOperation tests

Replace all old expectation function calls for tests in
u2f_register_operation_unittests.cc file.

Note: As legacy old in u2f_sign_unittest.cc still uses the old API,
we keep the old API and remove it once U2F sign logic is migrated to
GetAssertionTask.

Bug: 843788
Change-Id: I60ba3a47361a95f82fe173fdbab9d9bb4d29e3e4
Reviewed-on: https://chromium-review.googlesource.com/1069784
Commit-Queue: Jun Choi <hongjunchoi@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565741}

device/fido/fido_test_data.h

@@ -310,6 +310,107 @@ constexpr uint8_t kU2fFakeRegisterCommand[] = {
     0x00, 0x00,
 };
 
+constexpr uint8_t kU2fConditionNotSatisfiedResponse[] = {0x69, 0x85};
+
+constexpr uint8_t kU2fWrongDataResponse[] = {0x6A, 0x80};
+
+constexpr uint8_t kApduEncodedNoErrorRegisterResponse[] = {
+    // Reserved byte
+    0x05,
+    // User public key
+    0x04, 0xE8, 0x76, 0x25, 0x89, 0x6E, 0xE4, 0xE4, 0x6D, 0xC0, 0x32, 0x76,
+    0x6E, 0x80, 0x87, 0x96, 0x2F, 0x36, 0xDF, 0x9D, 0xFE, 0x8B, 0x56, 0x7F,
+    0x37, 0x63, 0x01, 0x5B, 0x19, 0x90, 0xA6, 0x0E, 0x14, 0x27, 0xDE, 0x61,
+    0x2D, 0x66, 0x41, 0x8B, 0xDA, 0x19, 0x50, 0x58, 0x1E, 0xBC, 0x5C, 0x8C,
+    0x1D, 0xAD, 0x71, 0x0C, 0xB1, 0x4C, 0x22, 0xF8, 0xC9, 0x70, 0x45, 0xF4,
+    0x61, 0x2F, 0xB2, 0x0C, 0x91,
+    // Key handle length
+    0x40,
+    // Key handle
+    0x3E, 0xBD, 0x89, 0xBF, 0x77, 0xEC, 0x50, 0x97, 0x55, 0xEE, 0x9C, 0x26,
+    0x35, 0xEF, 0xAA, 0xAC, 0x7B, 0x2B, 0x9C, 0x5C, 0xEF, 0x17, 0x36, 0xC3,
+    0x71, 0x7D, 0xA4, 0x85, 0x34, 0xC8, 0xC6, 0xB6, 0x54, 0xD7, 0xFF, 0x94,
+    0x5F, 0x50, 0xB5, 0xCC, 0x4E, 0x78, 0x05, 0x5B, 0xDD, 0x39, 0x6B, 0x64,
+    0xF7, 0x8D, 0xA2, 0xC5, 0xF9, 0x62, 0x00, 0xCC, 0xD4, 0x15, 0xCD, 0x08,
+    0xFE, 0x42,
+    // X.509 Certificate
+    0x00, 0x38, 0x30, 0x82, 0x02, 0x4A, 0x30, 0x82, 0x01, 0x32, 0xA0, 0x03,
+    0x02, 0x01, 0x02, 0x02, 0x04, 0x04, 0x6C, 0x88, 0x22, 0x30, 0x0D, 0x06,
+    0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x05, 0x00,
+    0x30, 0x2E, 0x31, 0x2C, 0x30, 0x2A, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
+    0x23, 0x59, 0x75, 0x62, 0x69, 0x63, 0x6F, 0x20, 0x55, 0x32, 0x46, 0x20,
+    0x52, 0x6F, 0x6F, 0x74, 0x20, 0x43, 0x41, 0x20, 0x53, 0x65, 0x72, 0x69,
+    0x61, 0x6C, 0x20, 0x34, 0x35, 0x37, 0x32, 0x30, 0x30, 0x36, 0x33, 0x31,
+    0x30, 0x20, 0x17, 0x0D, 0x31, 0x34, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30,
+    0x30, 0x30, 0x30, 0x30, 0x5A, 0x18, 0x0F, 0x32, 0x30, 0x35, 0x30, 0x30,
+    0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5A, 0x30, 0x2C,
+    0x31, 0x2A, 0x30, 0x28, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x21, 0x59,
+    0x75, 0x62, 0x69, 0x63, 0x6F, 0x20, 0x55, 0x32, 0x46, 0x20, 0x45, 0x45,
+    0x20, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6C, 0x20, 0x32, 0x34, 0x39, 0x31,
+    0x38, 0x32, 0x33, 0x32, 0x34, 0x37, 0x37, 0x30, 0x30, 0x59, 0x30, 0x13,
+    0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A,
+    0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x3C,
+    0xCA, 0xB9, 0x2C, 0xCB, 0x97, 0x28, 0x7E, 0xE8, 0xE6, 0x39, 0x43, 0x7E,
+    0x21, 0xFC, 0xD6, 0xB6, 0xF1, 0x65, 0xB2, 0xD5, 0xA3, 0xF3, 0xDB, 0x13,
+    0x1D, 0x31, 0xC1, 0x6B, 0x74, 0x2B, 0xB4, 0x76, 0xD8, 0xD1, 0xE9, 0x90,
+    0x80, 0xEB, 0x54, 0x6C, 0x9B, 0xBD, 0xF5, 0x56, 0xE6, 0x21, 0x0F, 0xD4,
+    0x27, 0x85, 0x89, 0x9E, 0x78, 0xCC, 0x58, 0x9E, 0xBE, 0x31, 0x0F, 0x6C,
+    0xDB, 0x9F, 0xF4, 0xA3, 0x3B, 0x30, 0x39, 0x30, 0x22, 0x06, 0x09, 0x2B,
+    0x06, 0x01, 0x04, 0x01, 0x82, 0xC4, 0x0A, 0x02, 0x04, 0x15, 0x31, 0x2E,
+    0x33, 0x2E, 0x36, 0x2E, 0x31, 0x2E, 0x34, 0x2E, 0x31, 0x2E, 0x34, 0x31,
+    0x34, 0x38, 0x32, 0x2E, 0x31, 0x2E, 0x32, 0x30, 0x13, 0x06, 0x0B, 0x2B,
+    0x06, 0x01, 0x04, 0x01, 0x82, 0xE5, 0x1C, 0x02, 0x01, 0x01, 0x04, 0x04,
+    0x03, 0x02, 0x04, 0x30, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86,
+    0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00,
+    0x9F, 0x9B, 0x05, 0x22, 0x48, 0xBC, 0x4C, 0xF4, 0x2C, 0xC5, 0x99, 0x1F,
+    0xCA, 0xAB, 0xAC, 0x9B, 0x65, 0x1B, 0xBE, 0x5B, 0xDC, 0xDC, 0x8E, 0xF0,
+    0xAD, 0x2C, 0x1C, 0x1F, 0xFB, 0x36, 0xD1, 0x87, 0x15, 0xD4, 0x2E, 0x78,
+    0xB2, 0x49, 0x22, 0x4F, 0x92, 0xC7, 0xE6, 0xE7, 0xA0, 0x5C, 0x49, 0xF0,
+    0xE7, 0xE4, 0xC8, 0x81, 0xBF, 0x2E, 0x94, 0xF4, 0x5E, 0x4A, 0x21, 0x83,
+    0x3D, 0x74, 0x56, 0x85, 0x1D, 0x0F, 0x6C, 0x14, 0x5A, 0x29, 0x54, 0x0C,
+    0x87, 0x4F, 0x30, 0x92, 0xC9, 0x34, 0xB4, 0x3D, 0x22, 0x2B, 0x89, 0x62,
+    0xC0, 0xF4, 0x10, 0xCE, 0xF1, 0xDB, 0x75, 0x89, 0x2A, 0xF1, 0x16, 0xB4,
+    0x4A, 0x96, 0xF5, 0xD3, 0x5A, 0xDE, 0xA3, 0x82, 0x2F, 0xC7, 0x14, 0x6F,
+    0x60, 0x04, 0x38, 0x5B, 0xCB, 0x69, 0xB6, 0x5C, 0x99, 0xE7, 0xEB, 0x69,
+    0x19, 0x78, 0x67, 0x03, 0xC0, 0xD8, 0xCD, 0x41, 0xE8, 0xF7, 0x5C, 0xCA,
+    0x44, 0xAA, 0x8A, 0xB7, 0x25, 0xAD, 0x8E, 0x79, 0x9F, 0xF3, 0xA8, 0x69,
+    0x6A, 0x6F, 0x1B, 0x26, 0x56, 0xE6, 0x31, 0xB1, 0xE4, 0x01, 0x83, 0xC0,
+    0x8F, 0xDA, 0x53, 0xFA, 0x4A, 0x8F, 0x85, 0xA0, 0x56, 0x93, 0x94, 0x4A,
+    0xE1, 0x79, 0xA1, 0x33, 0x9D, 0x00, 0x2D, 0x15, 0xCA, 0xBD, 0x81, 0x00,
+    0x90, 0xEC, 0x72, 0x2E, 0xF5, 0xDE, 0xF9, 0x96, 0x5A, 0x37, 0x1D, 0x41,
+    0x5D, 0x62, 0x4B, 0x68, 0xA2, 0x70, 0x7C, 0xAD, 0x97, 0xBC, 0xDD, 0x17,
+    0x85, 0xAF, 0x97, 0xE2, 0x58, 0xF3, 0x3D, 0xF5, 0x6A, 0x03, 0x1A, 0xA0,
+    0x35, 0x6D, 0x8E, 0x8D, 0x5E, 0xBC, 0xAD, 0xC7, 0x4E, 0x07, 0x16, 0x36,
+    0xC6, 0xB1, 0x10, 0xAC, 0xE5, 0xCC, 0x9B, 0x90, 0xDF, 0xEA, 0xCA, 0xE6,
+    0x40, 0xFF, 0x1B, 0xB0, 0xF1, 0xFE, 0x5D, 0xB4, 0xEF, 0xF7, 0xA9, 0x5F,
+    0x06, 0x07, 0x33, 0xF5,
+    // Signature
+    0x30, 0x45, 0x02, 0x20, 0x32, 0x47, 0x79, 0xC6, 0x8F, 0x33, 0x80, 0x28,
+    0x8A, 0x11, 0x97, 0xB6, 0x09, 0x5F, 0x7A, 0x6E, 0xB9, 0xB1, 0xB1, 0xC1,
+    0x27, 0xF6, 0x6A, 0xE1, 0x2A, 0x99, 0xFE, 0x85, 0x32, 0xEC, 0x23, 0xB9,
+    0x02, 0x21, 0x00, 0xE3, 0x95, 0x16, 0xAC, 0x4D, 0x61, 0xEE, 0x64, 0x04,
+    0x4D, 0x50, 0xB4, 0x15, 0xA6, 0xA4, 0xD4, 0xD8, 0x4B, 0xA6, 0xD8, 0x95,
+    0xCB, 0x5A, 0xB7, 0xA1, 0xAA, 0x7D, 0x08, 0x1D, 0xE3, 0x41, 0xFA,
+    // Status bytes
+    0x90, 0x00,
+};
+
+constexpr uint8_t kApduEncodedNoErrorSignResponse[] = {
+    // User presence
+    0x01,
+    // Sign count(4 bytes)
+    0x00, 0x00, 0x00, 0x3B,
+    // Signature
+    0x30, 0x44, 0x02, 0x20, 0x7B, 0xDE, 0x0A, 0x52, 0xAC, 0x1F, 0x4C, 0x8B,
+    0x27, 0xE0, 0x03, 0xA3, 0x70, 0xCD, 0x66, 0xA4, 0xC7, 0x11, 0x8D, 0xD2,
+    0x2D, 0x54, 0x47, 0x83, 0x5F, 0x45, 0xB9, 0x9C, 0x68, 0x42, 0x3F, 0xF7,
+    0x02, 0x20, 0x3C, 0x51, 0x7B, 0x47, 0x87, 0x7F, 0x85, 0x78, 0x2D, 0xE1,
+    0x00, 0x86, 0xA7, 0x83, 0xD1, 0xE7, 0xDF, 0x4E, 0x36, 0x39, 0xE7, 0x71,
+    0xF5, 0xF6, 0xAF, 0xA3, 0x5A, 0xAD, 0x53, 0x73, 0x85, 0x8E,
+    // Status bytes
+    0x90, 0x00,
+};
+
 // U2F response blob produced by a U2F registration request used in example 6
 // of the CTAP spec.
 // https://fidoalliance.org/specs/fido-v2.0-rd-20170927/fido-client-to-authenticator-protocol-v2.0-rd-20170927.html

device/fido/make_credential_handler_unittest.cc

@@ -107,11 +107,9 @@ TEST_F(FidoMakeCredentialHandlerTest, TestU2fRegisterWithFlagEnabled) {
   EXPECT_CALL(*device, GetId()).WillRepeatedly(testing::Return("device0"));
   device->ExpectCtap2CommandAndRespondWith(
       CtapRequestCommand::kAuthenticatorGetInfo, base::nullopt);
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(fido_parsing_utils::Materialize(
-                                    test_data::kU2fRegisterCommandApdu),
-                                _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   discovery()->AddDevice(std::move(device));
   callback().WaitForCallback();
@@ -127,11 +125,9 @@ TEST_F(FidoMakeCredentialHandlerTest, TestU2fRegisterWithoutFlagEnabled) {
 
   auto device = std::make_unique<MockFidoDevice>();
   EXPECT_CALL(*device, GetId()).WillRepeatedly(testing::Return("device0"));
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(fido_parsing_utils::Materialize(
-                                    test_data::kU2fRegisterCommandApdu),
-                                _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   discovery()->AddDevice(std::move(device));
   callback().WaitForCallback();

device/fido/make_credential_task_unittest.cc

@@ -90,10 +90,6 @@ class FidoMakeCredentialTaskTest : public testing::Test {
   TestMakeCredentialTaskCallback callback_receiver_;
 };
 
-MATCHER_P(IsCommand, command, "") {
-  return base::make_span(arg) == command;
-}
-
 TEST_F(FidoMakeCredentialTaskTest, MakeCredentialSuccess) {
   auto device = std::make_unique<MockFidoDevice>();
 
@@ -114,7 +110,7 @@ TEST_F(FidoMakeCredentialTaskTest, MakeCredentialSuccess) {
   EXPECT_TRUE(device->device_info());
 }
 
-TEST_F(FidoMakeCredentialTaskTest, TestMakeCredentialWithIncorrectRpIdHash) {
+TEST_F(FidoMakeCredentialTaskTest, MakeCredentialWithIncorrectRpIdHash) {
   auto device = std::make_unique<MockFidoDevice>();
 
   device->ExpectCtap2CommandAndRespondWith(
@@ -136,11 +132,9 @@ TEST_F(FidoMakeCredentialTaskTest, FallbackToU2fRegisterSuccess) {
 
   device->ExpectCtap2CommandAndRespondWith(
       CtapRequestCommand::kAuthenticatorGetInfo, base::nullopt);
-  EXPECT_CALL(
-      *device,
-      DeviceTransactPtr(
-          IsCommand(base::make_span(test_data::kU2fRegisterCommandApdu)), _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   const auto task = CreateMakeCredentialTask(device.get());
   make_credential_callback_receiver().WaitForCallback();
@@ -153,11 +147,9 @@ TEST_F(FidoMakeCredentialTaskTest, FallbackToU2fRegisterSuccess) {
 TEST_F(FidoMakeCredentialTaskTest, TestDefaultU2fRegisterOperationWithoutFlag) {
   RemoveCtapFlag();
   auto device = std::make_unique<MockFidoDevice>();
-  EXPECT_CALL(
-      *device,
-      DeviceTransactPtr(
-          IsCommand(base::make_span(test_data::kU2fRegisterCommandApdu)), _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   const auto task = CreateMakeCredentialTask(device.get());
   make_credential_callback_receiver().WaitForCallback();

device/fido/mock_fido_device.h

@@ -42,7 +42,9 @@ class MockFidoDevice : public FidoDevice {
   void DeviceTransact(std::vector<uint8_t> command, DeviceCallback cb) override;
 
   // Old interface ------------------------------------------------------------
-
+  // TODO(hongjunchoi): Remove all old test interface functions once U2F sign
+  // logic is migrated to GetAssertionTask.
+  // See: https://crbug.com/843788
   static void NotSatisfied(const std::vector<uint8_t>& command,
                            DeviceCallback& cb);
   static void WrongData(const std::vector<uint8_t>& command,

device/fido/u2f_register_operation_unittest.cc

@@ -18,9 +18,6 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-// TODO(hongjunchoi): Remove all old test expectations to new test API's
-// provided by MockFidoDevice.
-// See: https://crbug.com/843788
 namespace device {
 
 using ::testing::_;
@@ -53,10 +50,6 @@ CtapMakeCredentialRequest CreateRegisterRequest(
       std::vector<PublicKeyCredentialDescriptor>(), is_individual_attestation);
 }
 
-std::vector<uint8_t> GetTestRegisterCommand() {
-  return fido_parsing_utils::Materialize(test_data::kU2fRegisterCommandApdu);
-}
-
 using TestRegisterCallback = ::device::test::StatusAndValueCallbackReceiver<
     CtapDeviceResponseCode,
     base::Optional<AuthenticatorMakeCredentialResponse>>;
@@ -78,8 +71,9 @@ TEST_F(U2fRegisterOperationTest, TestRegisterSuccess) {
   auto request = CreateRegisterRequest();
   auto device = std::make_unique<MockFidoDevice>();
   EXPECT_CALL(*device, GetId()).WillRepeatedly(testing::Return("device"));
-  EXPECT_CALL(*device, DeviceTransactPtr(GetTestRegisterCommand(), _))
-      .WillOnce(testing::Invoke(MockFidoDevice::NoErrorRegister));
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   auto u2f_register = std::make_unique<U2fRegisterOperation>(
       device.get(), register_callback_receiver().callback(),
@@ -117,10 +111,16 @@ TEST_F(U2fRegisterOperationTest, TestDelayedSuccess) {
 
   auto device = std::make_unique<MockFidoDevice>();
   EXPECT_CALL(*device, GetId()).WillRepeatedly(testing::Return("device"));
+
   // Device error out once waiting for user presence before retrying.
-  EXPECT_CALL(*device, DeviceTransactPtr(GetTestRegisterCommand(), _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NotSatisfied))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  ::testing::InSequence s;
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kU2fConditionNotSatisfiedResponse);
+
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   auto u2f_register = std::make_unique<U2fRegisterOperation>(
       device.get(), register_callback_receiver().callback(),
@@ -154,20 +154,16 @@ TEST_F(U2fRegisterOperationTest, TestRegistrationWithExclusionList) {
   // will invoke MockFidoDevice::WrongData as the authenticator did not create
   // the two key handles provided in the exclude list. At the third call,
   // MockFidoDevice::NoErrorRegister will be invoked after registration.
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(
-                  fido_parsing_utils::Materialize(
-                      test_data::kU2fCheckOnlySignCommandApduWithKeyAlpha),
-                  _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::WrongData));
-  EXPECT_CALL(
-      *device,
-      DeviceTransactPtr(fido_parsing_utils::Materialize(
-                            test_data::kU2fCheckOnlySignCommandApduWithKeyBeta),
-                        _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::WrongData));
-  EXPECT_CALL(*device, DeviceTransactPtr(GetTestRegisterCommand(), _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  ::testing::InSequence s;
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fCheckOnlySignCommandApduWithKeyAlpha,
+      test_data::kU2fWrongDataResponse);
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fCheckOnlySignCommandApduWithKeyBeta,
+      test_data::kU2fWrongDataResponse);
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fRegisterCommandApdu,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   auto u2f_register = std::make_unique<U2fRegisterOperation>(
       device.get(), register_callback_receiver().callback(),
@@ -207,29 +203,19 @@ TEST_F(U2fRegisterOperationTest, TestRegistrationWithDuplicateHandle) {
   // MockFidoDevice::NoErrorSign. Once duplicate key handle is found, bogus
   // registration is called to confirm user presence. This invokes
   // MockFidoDevice::NoErrorRegister.
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(
-                  fido_parsing_utils::Materialize(
-                      test_data::kU2fCheckOnlySignCommandApduWithKeyAlpha),
-                  _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::WrongData));
-  EXPECT_CALL(
-      *device,
-      DeviceTransactPtr(fido_parsing_utils::Materialize(
-                            test_data::kU2fCheckOnlySignCommandApduWithKeyBeta),
-                        _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::WrongData));
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(
-                  fido_parsing_utils::Materialize(
-                      test_data::kU2fCheckOnlySignCommandApduWithKeyGamma),
-                  _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorSign));
-  EXPECT_CALL(*device,
-              DeviceTransactPtr(fido_parsing_utils::Materialize(
-                                    test_data::kU2fFakeRegisterCommand),
-                                _))
-      .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+  ::testing::InSequence s;
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fCheckOnlySignCommandApduWithKeyAlpha,
+      test_data::kU2fWrongDataResponse);
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fCheckOnlySignCommandApduWithKeyBeta,
+      test_data::kU2fWrongDataResponse);
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fCheckOnlySignCommandApduWithKeyGamma,
+      test_data::kApduEncodedNoErrorSignResponse);
+  device->ExpectRequestAndRespondWith(
+      test_data::kU2fFakeRegisterCommand,
+      test_data::kApduEncodedNoErrorRegisterResponse);
 
   auto u2f_register = std::make_unique<U2fRegisterOperation>(
       device.get(), register_callback_receiver().callback(),
@@ -256,10 +242,12 @@ TEST_F(U2fRegisterOperationTest, TestIndividualAttestation) {
 
     auto device = std::make_unique<MockFidoDevice>();
     EXPECT_CALL(*device, GetId()).WillRepeatedly(::testing::Return("device"));
-    EXPECT_CALL(*device,
-                DeviceTransactPtr(
-                    IndicatesIndividualAttestation(individual_attestation), _))
-        .WillOnce(::testing::Invoke(MockFidoDevice::NoErrorRegister));
+
+    device->ExpectRequestAndRespondWith(
+        individual_attestation
+            ? test_data::kU2fRegisterCommandApduWithIndividualAttestation
+            : test_data::kU2fRegisterCommandApdu,
+        test_data::kApduEncodedNoErrorRegisterResponse);
 
     auto u2f_register = std::make_unique<U2fRegisterOperation>(
         device.get(), cb.callback(), std::move(request));