Implemented attestation message flow for Chrome OS.

chromeos/attestation/attestation_flow_unittest.cc

Index: chromeos/attestation/attestation_flow_unittest.cc
diff --git a/chromeos/attestation/attestation_flow_unittest.cc b/chromeos/attestation/attestation_flow_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..08a0d0cb08d9d15d5789e5fcf54e09624713e78d
--- /dev/null
+++ b/chromeos/attestation/attestation_flow_unittest.cc
@@ -0,0 +1,292 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "chromeos/attestation/mock_attestation_flow.h"
+#include "chromeos/cryptohome/mock_async_method_caller.h"
+#include "chromeos/dbus/mock_cryptohome_client.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::Invoke;
+using testing::StrictMock;
+using testing::WithArgs;
+
+namespace chromeos {
+namespace attestation {
+
+namespace {
+
+void DBusCallbackFalse(const BoolDBusMethodCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
+}
+
+void DBusCallbackTrue(const BoolDBusMethodCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+void DBusCallbackFail(const BoolDBusMethodCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_FAILURE, false));
+}
+
+void AsyncCallbackFalse(cryptohome::AsyncMethodCaller::Callback callback) {
+  callback.Run(false, cryptohome::MOUNT_ERROR_NONE);
+}
+
+}  // namespace
+
+TEST(AttestationTest, GetCertificate) {
+  // Use StrictMock when it is important that calls get triggered exactly once.

[Mattias Nissler (ping if slow), 2013/01/18 13:38:46]

This comment is not accurate: "Exactly once" you specify with Times(1) (which
you do below). I guess you mean to say that some calls shouldn't get triggered
at all and that is what you want to make sure gets tested?

[dkrahn, 2013/01/22 22:50:11]

Yes - comment corrected.

+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateEnrollRequest(_))
+      .Times(1);
+  std::string fake_enroll_response =
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationEnrollRequest;
+  fake_enroll_response += "_response";
+  EXPECT_CALL(async_caller, AsyncTpmAttestationEnroll(fake_enroll_response, _))
+      .Times(1);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateCertRequest(false, _))
+      .Times(1);
+  std::string fake_cert_response =
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest;
+  fake_cert_response += "_response";
+  EXPECT_CALL(async_caller,
+              AsyncTpmAttestationFinishCertRequest(fake_cert_response, _))
+      .Times(1);

[Mattias Nissler (ping if slow), 2013/01/18 13:38:46]

Suggestion: It looks like that you might want to check as well that these calls
happen in the right sequence, which you can do with the InSequence() class.

[dkrahn, 2013/01/22 22:50:11]

Good idea. Done.

+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackFalse));
+
+  StrictMock<MockServerProxy> proxy;
+  proxy.DeferToFake(true);
+  EXPECT_CALL(proxy, SendEnrollRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationEnrollRequest,
+      _)).Times(1);
+  EXPECT_CALL(proxy, SendCertificateRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest,
+      _)).Times(1);
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(
+      true,
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCert)).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();

[Mattias Nissler (ping if slow), 2013/01/18 13:38:46]

according to base/message_loop.h you should use base::RunLoop instead.

[dkrahn, 2013/01/22 22:50:11]

Done.

+}
+
+TEST(AttestationTest, GetCertificate_NoEK) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(false, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateEnrollRequest(_))
+      .Times(1);
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackFalse));
+
+  // We're not expecting any server calls in this case.
+  StrictMock<MockServerProxy> proxy;
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, ""))
+      .Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_EKRejected) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateEnrollRequest(_))
+      .Times(1);
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackFalse));
+
+  StrictMock<MockServerProxy> proxy;
+  proxy.DeferToFake(false);
+  EXPECT_CALL(proxy, SendEnrollRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationEnrollRequest,
+      _)).Times(1);
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, ""))
+      .Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_FailEnroll) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateEnrollRequest(_))
+      .Times(1);
+  std::string fake_enroll_response =
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationEnrollRequest;
+  fake_enroll_response += "_response";
+  EXPECT_CALL(async_caller, AsyncTpmAttestationEnroll(fake_enroll_response, _))
+      .WillOnce(WithArgs<1>(Invoke(AsyncCallbackFalse)));
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackFalse));
+
+  StrictMock<MockServerProxy> proxy;
+  proxy.DeferToFake(true);
+  EXPECT_CALL(proxy, SendEnrollRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationEnrollRequest,
+      _)).Times(1);
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, "")).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetOwnerCertificateAlreadyEnrolled) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateCertRequest(true, _))
+      .Times(1);
+  std::string fake_cert_response =
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest;
+  fake_cert_response += "_response";
+  EXPECT_CALL(async_caller,
+              AsyncTpmAttestationFinishCertRequest(fake_cert_response, _))
+      .Times(1);
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackTrue));
+
+  StrictMock<MockServerProxy> proxy;
+  proxy.DeferToFake(true);
+  EXPECT_CALL(proxy, SendCertificateRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest,
+      _)).Times(1);
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(
+      true,
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCert)).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("attest-ent-machine", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_FailCreateCertRequest) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(false, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateCertRequest(false, _))
+      .Times(1);
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackTrue));
+
+  // We're not expecting any server calls in this case.
+  StrictMock<MockServerProxy> proxy;
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, "")).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_CertRequestRejected) {
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+  async_caller.SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+  EXPECT_CALL(async_caller, AsyncTpmAttestationCreateCertRequest(false, _))
+      .Times(1);
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackTrue));
+
+  StrictMock<MockServerProxy> proxy;
+  proxy.DeferToFake(false);
+  EXPECT_CALL(proxy, SendCertificateRequest(
+      cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest,
+      _)).Times(1);
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, "")).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_FailIsEnrolled) {

[Mattias Nissler (ping if slow), 2013/01/18 13:38:46]

What's the difference between this test and GetCertificate_NoEK? They seem to be
identical to me expect for the async_caller setup which you claim is not
receiving any calls. I'm probably missing something.

[dkrahn, 2013/01/22 22:50:11]

The difference is the use of 'DBusCallbackFail' as the callback for
TpmAttestationIsEnrolled.  This test verifies that the code handles this failure
properly.

+  // Not expecting any calls in this case.
+  StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
+
+  chromeos::MockCryptohomeClient client;
+  EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
+      .WillRepeatedly(Invoke(DBusCallbackFail));
+
+  // Not expecting any calls in this case.
+  StrictMock<MockServerProxy> proxy;
+
+  StrictMock<MockObserver> observer;
+  EXPECT_CALL(observer, MockCertificateCallback(false, "")).Times(1);
+  AttestationFlow::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  AttestationFlow flow(&async_caller, &client, &proxy);
+  flow.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+}  // namespace attestation
+}  // namespace chromeos