Add AndroidManagementClient

chrome/browser/chromeos/policy/android_management_client_unittest.cc

+// Copyright (c) 2016 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 <string>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "chrome/browser/chromeos/policy/android_management_client.h"
+#include "components/policy/core/common/cloud/mock_device_management_service.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_test_util.h"
+#include "policy/proto/device_management_backend.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::SaveArg;
+using testing::StrictMock;
+using testing::_;
+
+namespace em = enterprise_management;
+
+namespace policy {
+
+namespace {
+
+const char kOAuthToken[] = "fake-oauth-token";
+
+MATCHER_P(MatchProto, expected, "matches protobuf") {
+  return arg.SerializePartialAsString() == expected.SerializePartialAsString();
+}
+
+// A mock class to allow us to set expectations on upload callbacks.
+class MockStatusCallbackObserver {
+ public:
+  MockStatusCallbackObserver() {}
+
+  MOCK_METHOD1(OnCallbackComplete, void(AndroidManagementClient::Result));
+};
+
+}  // namespace
+
+class AndroidManagementClientTest : public testing::Test {
+ protected:
+  AndroidManagementClientTest() {
+    android_management_request_.mutable_check_android_management_request();
+    android_management_response_.mutable_check_android_management_response();
+  }
+
+  void SetUp() { CreateClient(); }
+
+  void ExpectCheckAndroidManagement(const std::string& oauth_token,

[Thiemo Nagel, 2016/04/28 13:27:00]

Since this is only used once, I'd consider it more readable to delete the method
and move the code to the test.

[Polina Bondarenko, 2016/04/28 16:18:40]

Done.

+                                    std::string* client_id) {
+    EXPECT_CALL(
+        service_,
+        CreateJob(DeviceManagementRequestJob::TYPE_ANDROID_MANAGEMENT_CHECK,
+                  request_context_))
+        .WillOnce(service_.SucceedJob(android_management_response_));
+    EXPECT_CALL(service_,
+                StartJob(dm_protocol::kValueRequestCheckAndroidManagement,
+                         std::string(), oauth_token, std::string(), _,
+                         MatchProto(android_management_request_)))
+        .WillOnce(SaveArg<4>(client_id));
+  }
+
+  void CreateClient() {
+    request_context_ =
+        new net::TestURLRequestContextGetter(loop_.task_runner());
+    AndroidManagementClient::SetAccessTokenForTesting(kOAuthToken);
+    client_.reset(
+        new AndroidManagementClient(&service_, request_context_, "", nullptr));
+  }
+
+  // Request protobuf is used as extectation for the client requests.
+  em::DeviceManagementRequest android_management_request_;
+
+  // Protobuf is used in successfil responsees.
+  em::DeviceManagementResponse android_management_response_;
+
+  base::MessageLoop loop_;
+  MockDeviceManagementService service_;
+  StrictMock<MockStatusCallbackObserver> callback_observer_;
+  std::unique_ptr<AndroidManagementClient> client_;
+  // Pointer to the client's request context.
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  std::string oauh_token_;
+};
+
+TEST_F(AndroidManagementClientTest, CheckAndroidManagementCall) {
+  std::string client_id;
+  ExpectCheckAndroidManagement(kOAuthToken, &client_id);
+  EXPECT_CALL(
+      callback_observer_,
+      OnCallbackComplete(AndroidManagementClient::Result::RESULT_UNMANAGED))
+      .Times(1);
+
+  AndroidManagementClient::StatusCallback callback =
+      base::Bind(&MockStatusCallbackObserver::OnCallbackComplete,
+                 base::Unretained(&callback_observer_));
+  client_->StartCheckAndroidManagement(callback);
+  ASSERT_LT(client_id.size(), 64U);
+}
+
+}  // namespace policy