Emulate StartAuthPolicyService from FakeUpstartClient

chromeos/dbus/fake_auth_policy_client_unittest.cc

 // Copyright 2017 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 "chromeos/dbus/fake_auth_policy_client.h"
 
 #include "base/bind.h"
+#include "components/signin/core/account_id/account_id.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace {
 
 const char kCorrectMachineName[] = "machine_name";
 const char kCorrectUserName[] = "user@realm.com";
 
 void JoinAdCallback(const std::string& machine_name,
                     const std::string& user_principal_name,
                     authpolicy::ErrorType expected,
                     authpolicy::ErrorType actual) {
   EXPECT_EQ(expected, actual) << "with machine name: " << machine_name
                               << ", and user name: " << user_principal_name;
 }
 
+void AuthenticateUserCallback(const std::string& user_principal_name,
+                              authpolicy::ErrorType expected,
+                              authpolicy::ErrorType actual,
+                              const std::string& obj_guid) {
+  EXPECT_EQ(expected, actual) << "with user name: " << user_principal_name;
+}
+
+void RefreshDevicePolicyCallback(bool expected, bool actual) {
+  EXPECT_EQ(expected, actual);
+}
+
+void RefreshUserPolicyCallback(const std::string& user_principal_name,
+                               bool expected,
+                               bool actual) {
+  EXPECT_EQ(expected, actual) << "with user name: " << user_principal_name;
+}
+
 void TestDomainJoin(const std::string& machine_name,
                     const std::string& user_principal_name,
                     authpolicy::ErrorType expected) {
   FakeAuthPolicyClient client;
+  client.Start();
   client.JoinAdDomain(
       machine_name, user_principal_name, /* password_fd */ -1,
       base::Bind(&JoinAdCallback, machine_name, user_principal_name, expected));
 }
 
 }  // namespace
 
 // Tests parsing machine name.
 TEST(FakeAuthPolicyClientTest, JoinAdDomain_ParseMachineName) {
   TestDomainJoin("correct_length1", kCorrectUserName, authpolicy::ERROR_NONE);
@@ skipping 13 matching lines @@
                  authpolicy::ERROR_PARSE_UPN_FAILED);
   TestDomainJoin(kCorrectMachineName, "", authpolicy::ERROR_PARSE_UPN_FAILED);
   TestDomainJoin(kCorrectMachineName, "user@",
                  authpolicy::ERROR_PARSE_UPN_FAILED);
   TestDomainJoin(kCorrectMachineName, "@realm",
                  authpolicy::ERROR_PARSE_UPN_FAILED);
   TestDomainJoin(kCorrectMachineName, "user@realm@com",
                  authpolicy::ERROR_PARSE_UPN_FAILED);
 }
 
+// Tests calls to not started authpolicyd fails.
+TEST(FakeAuthPolicyClientTest, NotStartedAuthPolicyService) {
+  FakeAuthPolicyClient client;
+  client.JoinAdDomain(
+      kCorrectMachineName, kCorrectUserName, /* password_fd */ -1,
+      base::Bind(&JoinAdCallback, kCorrectMachineName, kCorrectUserName,

[hashimoto, 2017/02/06 04:15:49]

How about using lambdas?

Instead of base::Bind(&JoinAdCallback, ...), you can write
 base::Bind([](authpolicy::ErrorType error){
   EXPECT_EQ(authpolicy::ERROR_DBUS_FAILURE, error);
 });

The same goes for other callbacks.

[Roman Sorokin (ftl), 2017/02/06 10:30:40]

Thanks for the hint! Changed for the all calls.

+                 authpolicy::ERROR_DBUS_FAILURE));
+  client.AuthenticateUser(
+      kCorrectUserName, /* password_fd */ -1,
+      base::Bind(&AuthenticateUserCallback, kCorrectUserName,
+                 authpolicy::ERROR_DBUS_FAILURE));
+  client.RefreshDevicePolicy(base::Bind(&RefreshDevicePolicyCallback, false));
+  client.RefreshUserPolicy(
+      AccountId::FromUserEmail(kCorrectUserName),
+      base::Bind(&RefreshUserPolicyCallback, kCorrectUserName, false));
+}
+
 }  // namespace chromeos