Implemented attestation message flow for Chrome OS.

chromeos/attestation/attestation_unittest.cc

Index: chromeos/attestation/attestation_unittest.cc
diff --git a/chromeos/attestation/attestation_unittest.cc b/chromeos/attestation/attestation_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c69ea47330f7157c5e9171ee4b13a074e2ce92b9
--- /dev/null
+++ b/chromeos/attestation/attestation_unittest.cc
@@ -0,0 +1,293 @@
+// 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.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"
+
+

[Mattias Nissler (ping if slow), 2013/01/16 10:39:26]

remove extra blank line

[dkrahn, 2013/01/17 23:36:24]

Done.

+using testing::_;
+using testing::Invoke;
+using testing::StrictMock;
+using testing::WithArgs;
+
+namespace chromeos {
+namespace attestation {
+
+namespace {
+
+void DbusCallbackFalse(const BoolDBusMethodCallback& callback) {

[Mattias Nissler (ping if slow), 2013/01/16 10:39:26]

nit: You spell Dbus with capital B elsewhere (i.e. DBus). Make consistent?

[dkrahn, 2013/01/17 23:36:24]

Done.

+  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.
+  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);
+
+  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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+TEST(AttestationTest, GetCertificate_FailIsEnrolled) {
+  // 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);
+  Attestation::CertificateCallback mock_callback = base::Bind(
+      &MockObserver::MockCertificateCallback,
+      base::Unretained(&observer));
+
+  MessageLoop message_loop;
+  Attestation attestation(&async_caller, &client, &proxy);
+  attestation.GetCertificate("test", mock_callback);
+  message_loop.RunUntilIdle();
+}
+
+}  // namespace chromeos
+}  // namespace attestation

[Mattias Nissler (ping if slow), 2013/01/16 10:39:26]

swap last two lines

[dkrahn, 2013/01/17 23:36:24]

Done.