text: // 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 "components/policy/core/common/cloud/user_info_fetcher.h"
  
  #include "base/test/task_environment.h"
  #include "base/values.h"
  #include "google_apis/gaia/google_service_auth_error.h"
  #include "net/http/http_status_code.h"
  #include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
  #include "services/network/test/test_url_loader_factory.h"
  #include "testing/gmock/include/gmock/gmock.h"
  #include "testing/gtest/include/gtest/gtest.h"
  
  using testing::_;
  
  namespace policy {
  
  namespace {
  
  static const char kUserInfoUrl[] =
      "https://www.googleapis.com/oauth2/v1/userinfo";
  static const char kUserInfoResponse[] =
      "{"
      "  \"email\": \"test_user@test.com\","
      "  \"verified_email\": true,"
      "  \"hd\": \"test.com\""
      "}";
  
  class MockUserInfoFetcherDelegate : public UserInfoFetcher::Delegate {
   public:
    MockUserInfoFetcherDelegate() {}
    ~MockUserInfoFetcherDelegate() {}
    MOCK_METHOD1(OnGetUserInfoFailure,
                 void(const GoogleServiceAuthError& error));
    MOCK_METHOD1(OnGetUserInfoSuccess, void(const base::DictionaryValue* result));
  };
  
  MATCHER_P(MatchDict, expected, "matches DictionaryValue") {
    return *arg == *expected;
  }
  
  class UserInfoFetcherTest : public testing::Test {
   public:
    UserInfoFetcherTest() = default;
    UserInfoFetcherTest(const UserInfoFetcherTest&) = delete;
    UserInfoFetcherTest& operator=(const UserInfoFetcherTest&) = delete;
    ~UserInfoFetcherTest() override = default;
  
   protected:
    base::test::TaskEnvironment task_env_;
    network::TestURLLoaderFactory loader_factory_;
  };
  
  TEST_F(UserInfoFetcherTest, FailedFetch) {
    MockUserInfoFetcherDelegate delegate;
    UserInfoFetcher fetcher(
        &delegate,
        base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
            &loader_factory_));
    fetcher.Start("access_token");
  
    // Fake a failed fetch - should result in the failure callback being invoked.
    EXPECT_CALL(delegate, OnGetUserInfoFailure(_));
    EXPECT_TRUE(loader_factory_.SimulateResponseForPendingRequest(
        kUserInfoUrl, std::string(), net::HTTP_INTERNAL_SERVER_ERROR));
    task_env_.RunUntilIdle();
  }
  
  TEST_F(UserInfoFetcherTest, SuccessfulFetch) {
    MockUserInfoFetcherDelegate delegate;
    UserInfoFetcher fetcher(
        &delegate,
        base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
            &loader_factory_));
    fetcher.Start("access_token");
  
    // Generate what we expect our result will look like (should match
    // parsed kUserInfoResponse).
    base::Value dict(base::Value::Type::DICTIONARY);
    dict.SetKey("email", base::Value("test_user@test.com"));
    dict.SetKey("verified_email", base::Value(true));
    dict.SetKey("hd", base::Value("test.com"));
  
    // Fake a successful fetch - should result in the data being parsed and
    // the values passed off to the success callback.
    EXPECT_CALL(delegate, OnGetUserInfoSuccess(MatchDict(&dict)));
    EXPECT_TRUE(loader_factory_.SimulateResponseForPendingRequest(
        kUserInfoUrl, kUserInfoResponse));
  }
  
  }  // namespace
  
  }  // namespace policy
  