Make ONCCertificateImporter async.

chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc

 // Copyright 2013 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/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_network_configuration_updater.h"
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/network/fake_network_device_handler.h"
 #include "chromeos/network/mock_managed_network_configuration_handler.h"
-#include "chromeos/network/onc/mock_certificate_importer.h"
+#include "chromeos/network/onc/onc_certificate_importer.h"
 #include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_service_impl.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 38 matching lines @@
 };
 
 class FakeWebTrustedCertsObserver
     : public UserNetworkConfigurationUpdater::WebTrustedCertsObserver {
  public:
   virtual void OnTrustAnchorsChanged(
       const net::CertificateList& trust_anchors) OVERRIDE {
     trust_anchors_ = trust_anchors;
   }
   net::CertificateList trust_anchors_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeWebTrustedCertsObserver);
 };
 
 class FakeNetworkDeviceHandler : public chromeos::FakeNetworkDeviceHandler {
   public:
    FakeNetworkDeviceHandler() : allow_roaming_(false) {}
 
    virtual void SetCellularAllowRoaming(bool allow_roaming) OVERRIDE {
      allow_roaming_ = allow_roaming;
    }
 
    bool allow_roaming_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeNetworkDeviceHandler);
+};
+
+class FakeCertificateImporter : public chromeos::onc::CertificateImporter {
+ public:
+  FakeCertificateImporter()
+      : expected_onc_source_(::onc::ONC_SOURCE_UNKNOWN), call_count_(0) {}
+  virtual ~FakeCertificateImporter() {}
+
+  void SetTrustedCertificatesResult(
+      net::CertificateList onc_trusted_certificates) {
+    onc_trusted_certificates_ = onc_trusted_certificates;
+  }
+
+  void SetExpectedONCCertificates(const base::ListValue& certificates) {
+    expected_onc_certificates_.reset(certificates.DeepCopy());
+  }
+
+  void SetExpectedONCSource(::onc::ONCSource source) {
+    expected_onc_source_ = source;
+  }
+
+  unsigned int GetAndResetImportCount() {
+    unsigned int count = call_count_;
+    call_count_ = 0;
+    return count;
+  }
+
+  virtual void ImportCertificates(const base::ListValue& certificates,
+                                  ::onc::ONCSource source,
+                                  const DoneCallback& done_callback) OVERRIDE {
+    if (expected_onc_source_ != ::onc::ONC_SOURCE_UNKNOWN)
+      EXPECT_EQ(expected_onc_source_, source);
+    if (expected_onc_certificates_) {
+      EXPECT_TRUE(chromeos::onc::test_utils::Equals(
+          expected_onc_certificates_.get(), &certificates));
+    }
+    ++call_count_;
+    done_callback.Run(true, onc_trusted_certificates_);
+  }
+
+ private:
+  ::onc::ONCSource expected_onc_source_;
+  scoped_ptr<base::ListValue> expected_onc_certificates_;
+  net::CertificateList onc_trusted_certificates_;
+  unsigned int call_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeCertificateImporter);
 };
 
 const char kFakeONC[] =
     "{ \"NetworkConfigurations\": ["
     "    { \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5040}\","
     "      \"Type\": \"WiFi\","
     "      \"Name\": \"My WiFi Network\","
     "      \"WiFi\": {"
     "        \"SSID\": \"ssid-none\","
     "        \"Security\": \"None\" }"
@@ skipping 38 matching lines @@
 ACTION_P(SetCertificateList, list) {
   if (arg2)
     *arg2 = list;
   return true;
 }
 
 }  // namespace
 
 class NetworkConfigurationUpdaterTest : public testing::Test {
  protected:
-  NetworkConfigurationUpdaterTest() {
-  }
+  NetworkConfigurationUpdaterTest() : certificate_importer_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(false));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
 
     scoped_ptr<base::DictionaryValue> fake_toplevel_onc =
         chromeos::onc::ReadDictionaryFromJson(kFakeONC);
 
     base::ListValue* network_configs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kNetworkConfigurations, &network_configs);
     AppendAll(*network_configs, &fake_network_configs_);
 
     base::DictionaryValue* global_config = NULL;
     fake_toplevel_onc->GetDictionaryWithoutPathExpansion(
         onc::toplevel_config::kGlobalNetworkConfiguration, &global_config);
     fake_global_network_config_.MergeDictionary(global_config);
 
     base::ListValue* certs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kCertificates, &certs);
     AppendAll(*certs, &fake_certificates_);
 
-    certificate_importer_ =
-        new StrictMock<chromeos::onc::MockCertificateImporter>();
+    certificate_importer_ = new FakeCertificateImporter;
     certificate_importer_owned_.reset(certificate_importer_);
   }
 
   virtual void TearDown() OVERRIDE {
     network_configuration_updater_.reset();
     provider_.Shutdown();
     base::RunLoop().RunUntilIdle();
   }
 
   void MarkPolicyProviderInitialized() {
@@ skipping 47 matching lines @@
   FakeNetworkDeviceHandler network_device_handler_;
 
   // Not used directly. Required for CrosSettings.
   chromeos::ScopedTestDeviceSettingsService scoped_device_settings_service_;
   chromeos::ScopedTestCrosSettings scoped_cros_settings_;
 
   // Ownership of certificate_importer_owned_ is passed to the
   // NetworkConfigurationUpdater. When that happens, |certificate_importer_|
   // continues to point to that instance but |certificate_importer_owned_| is
   // released.
-  StrictMock<chromeos::onc::MockCertificateImporter>* certificate_importer_;
+  FakeCertificateImporter* certificate_importer_;
   scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer_owned_;
 
   StrictMock<MockConfigurationPolicyProvider> provider_;
   scoped_ptr<PolicyServiceImpl> policy_service_;
   FakeUser fake_user_;
 
   TestingProfile profile_;
 
   scoped_ptr<NetworkConfigurationUpdater> network_configuration_updater_;
   content::TestBrowserThreadBundle thread_bundle_;
@@ skipping 52 matching lines @@
              POLICY_SCOPE_USER,
              new base::StringValue(onc_policy),
              NULL);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(onc::ONC_SOURCE_USER_POLICY,
                         _,
                         IsEqualTo(network_configs_repaired),
                         IsEqualTo(global_config_repaired)));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY,  _));
+  certificate_importer_->SetExpectedONCSource(onc::ONC_SOURCE_USER_POLICY);
 
   CreateNetworkConfigurationUpdaterForUserPolicy(
       false /* do not allow trusted certs from policy */,
       true /* set certificate importer */);
   MarkPolicyProviderInitialized();
+  EXPECT_EQ(1u, certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_F(NetworkConfigurationUpdaterTest,
        DoNotAllowTrustedCertificatesFromPolicy) {
   net::CertificateList cert_list;
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(onc::ONC_SOURCE_USER_POLICY, _, _, _));
-  EXPECT_CALL(*certificate_importer_, ImportCertificates(_, _, _))
-      .WillRepeatedly(SetCertificateList(cert_list));
+  certificate_importer_->SetTrustedCertificatesResult(cert_list);
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           false /* do not allow trusted certs from policy */,
           true /* set certificate importer */);
   MarkPolicyProviderInitialized();
 
   // Certificates with the "Web" trust flag set should not be forwarded to
   // observers.
   FakeWebTrustedCertsObserver observer;
@@ skipping 15 matching lines @@
   EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _))
       .Times(AnyNumber());
 
   net::CertificateList cert_list;
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
 
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY, _))
-      .WillRepeatedly(SetCertificateList(cert_list));
+  certificate_importer_->SetExpectedONCSource(onc::ONC_SOURCE_USER_POLICY);
+  certificate_importer_->SetTrustedCertificatesResult(cert_list);
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           true /* allow trusted certs from policy */,
           true /* set certificate importer */);
   MarkPolicyProviderInitialized();
 
   base::RunLoop().RunUntilIdle();
 
   // Certificates with the "Web" trust flag set will be returned.
   net::CertificateList trust_anchors;
   updater->GetWebTrustedCertificates(&trust_anchors);
   EXPECT_EQ(1u, trust_anchors.size());
 }
 
 TEST_F(NetworkConfigurationUpdaterTest,
        AllowTrustedCertificatesFromPolicyOnUpdate) {
   // Ignore network configuration changes.
   EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _))
       .Times(AnyNumber());
 
   // Start with an empty certificate list.
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY, _))
-      .WillRepeatedly(SetCertificateList(net::CertificateList()));
-
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           true /* allow trusted certs from policy */,
           true /* set certificate importer */);
   MarkPolicyProviderInitialized();
 
   FakeWebTrustedCertsObserver observer;
   updater->AddTrustedCertsObserver(&observer);
 
   base::RunLoop().RunUntilIdle();
 
   // Verify that the returned certificate list is empty.
-  Mock::VerifyAndClearExpectations(certificate_importer_);
   {
     net::CertificateList trust_anchors;
     updater->GetWebTrustedCertificates(&trust_anchors);
     EXPECT_TRUE(trust_anchors.empty());
   }
   EXPECT_TRUE(observer.trust_anchors_.empty());
 
   // Now use a non-empty certificate list to test the observer notification.
   net::CertificateList cert_list;
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
-
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY, _))
-      .WillOnce(SetCertificateList(cert_list));
+  certificate_importer_->SetTrustedCertificatesResult(cert_list);
 
   // Change to any non-empty policy, so that updates are triggered. The actual
   // content of the policy is irrelevant.
   PolicyMap policy;
   policy.Set(key::kOpenNetworkConfiguration,
              POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC),
              NULL);
   UpdateProviderPolicy(policy);
@@ skipping 16 matching lines @@
   PolicyMap policy;
   policy.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(onc::ONC_SOURCE_USER_POLICY,
                         kFakeUsernameHash,
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
-  EXPECT_CALL(*certificate_importer_, ImportCertificates(_, _ , _)).Times(0);
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           true /* allow trusted certs from policy */,
           false /* do not set certificate importer */);
   MarkPolicyProviderInitialized();
 
   Mock::VerifyAndClearExpectations(&network_config_handler_);
-  Mock::VerifyAndClearExpectations(certificate_importer_);
+  EXPECT_EQ(0u, certificate_importer_->GetAndResetImportCount());
 
-  EXPECT_CALL(network_config_handler_,
-              SetPolicy(onc::ONC_SOURCE_USER_POLICY,
-                        kFakeUsernameHash,
-                        IsEqualTo(&fake_network_configs_),
-                        IsEqualTo(&fake_global_network_config_)))
-      .Times(0);
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 onc::ONC_SOURCE_USER_POLICY,
-                                  _));
+  certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
+  certificate_importer_->SetExpectedONCSource(onc::ONC_SOURCE_USER_POLICY);
 
   ASSERT_TRUE(certificate_importer_owned_);
   updater->SetCertificateImporterForTest(certificate_importer_owned_.Pass());
+  EXPECT_EQ(1u, certificate_importer_->GetAndResetImportCount());
 }
 
 class NetworkConfigurationUpdaterTestWithParam
     : public NetworkConfigurationUpdaterTest,
       public testing::WithParamInterface<const char*> {
  protected:
   // Returns the currently tested ONC source.
   onc::ONCSource CurrentONCSource() {
     if (GetParam() == key::kOpenNetworkConfiguration)
       return onc::ONC_SOURCE_USER_POLICY;
@@ skipping 30 matching lines @@
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 CurrentONCSource(),
-                                  _))
-      .Times(ExpectedImportCertificatesCallCount());
+  certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
+  certificate_importer_->SetExpectedONCSource(CurrentONCSource());
 
   CreateNetworkConfigurationUpdater();
   MarkPolicyProviderInitialized();
+  EXPECT_EQ(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam,
        PolicyNotSetBeforePolicyProviderInitialized) {
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
 
-  EXPECT_CALL(network_config_handler_,
-              SetPolicy(CurrentONCSource(),
-                        ExpectedUsernameHash(),
-                        IsEqualTo(&fake_network_configs_),
-                        IsEqualTo(&fake_global_network_config_)))
-      .Times(0);
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 CurrentONCSource(),
-                                  _))
-      .Times(0);
-
   CreateNetworkConfigurationUpdater();
 
   Mock::VerifyAndClearExpectations(&network_config_handler_);
-  Mock::VerifyAndClearExpectations(certificate_importer_);
+  EXPECT_EQ(0u, certificate_importer_->GetAndResetImportCount());
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 CurrentONCSource(),
-                                  _))
-      .Times(ExpectedImportCertificatesCallCount());
+  certificate_importer_->SetExpectedONCSource(CurrentONCSource());
+  certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
   MarkPolicyProviderInitialized();
+  EXPECT_EQ(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam,
        PolicyAppliedImmediatelyIfProvidersInitialized) {
   MarkPolicyProviderInitialized();
 
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 CurrentONCSource(),
-                                  _))
-      .Times(ExpectedImportCertificatesCallCount());
+  certificate_importer_->SetExpectedONCSource(CurrentONCSource());
+  certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
   CreateNetworkConfigurationUpdater();
+
+  EXPECT_EQ(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam, PolicyChange) {
   // Ignore the initial updates.
   EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _)).Times(AtLeast(1));
-  EXPECT_CALL(*certificate_importer_, ImportCertificates(_, _, _))
-      .Times(AtLeast(ExpectedImportCertificatesCallCount()));
 
   CreateNetworkConfigurationUpdater();
   MarkPolicyProviderInitialized();
 
   Mock::VerifyAndClearExpectations(&network_config_handler_);
-  Mock::VerifyAndClearExpectations(certificate_importer_);
+  EXPECT_LE(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 
   // The Updater should update if policy changes.
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         _,
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEqualTo(&fake_certificates_),
-                                 CurrentONCSource(),
-                                  _))
-      .Times(ExpectedImportCertificatesCallCount());
+  certificate_importer_->SetExpectedONCSource(CurrentONCSource());
+  certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&network_config_handler_);
-  Mock::VerifyAndClearExpectations(certificate_importer_);
+  EXPECT_EQ(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 
   // Another update is expected if the policy goes away.
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(), _, IsEmpty(), IsEmpty()));
-  EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(IsEmpty(), CurrentONCSource(), _))
-      .Times(ExpectedImportCertificatesCallCount());
+  certificate_importer_->SetExpectedONCCertificates(base::ListValue());
 
   policy.Erase(GetParam());
   UpdateProviderPolicy(policy);
+  EXPECT_EQ(ExpectedImportCertificatesCallCount(),
+            certificate_importer_->GetAndResetImportCount());
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy