// 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.
//
// A complete set of unit tests for OAuth2MintTokenFlow.

#include <string>
#include <vector>

#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/time/time.h"
#include "google_apis/gaia/gaia_urls.h"
#include "google_apis/gaia/google_service_auth_error.h"
#include "google_apis/gaia/oauth2_access_token_consumer.h"
#include "google_apis/gaia/oauth2_access_token_fetcher_impl.h"
#include "google_apis/gaia/oauth2_api_call_flow.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_status_code.h"
#include "net/url_request/test_url_fetcher_factory.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "net/url_request/url_fetcher_factory.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_status.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using net::HttpRequestHeaders;
using net::ScopedURLFetcherFactory;
using net::TestURLFetcher;
using net::URLFetcher;
using net::URLFetcherDelegate;
using net::URLFetcherFactory;
using net::URLRequestStatus;
using testing::_;
using testing::Return;

namespace {

static std::string CreateBody() {
  return "some body";
}

static GURL CreateApiUrl() {
  return GURL("https://www.googleapis.com/someapi");
}

static std::vector<std::string> CreateTestScopes() {
  std::vector<std::string> scopes;
  scopes.push_back("scope1");
  scopes.push_back("scope2");
  return scopes;
}

class MockUrlFetcherFactory : public ScopedURLFetcherFactory,
                              public URLFetcherFactory {
 public:
  MockUrlFetcherFactory()
      : ScopedURLFetcherFactory(this) {
  }
  virtual ~MockUrlFetcherFactory() {}

  MOCK_METHOD4(
      CreateURLFetcher,
      URLFetcher* (int id,
                   const GURL& url,
                   URLFetcher::RequestType request_type,
                   URLFetcherDelegate* d));
};

class MockAccessTokenFetcher : public OAuth2AccessTokenFetcherImpl {
 public:
  MockAccessTokenFetcher(OAuth2AccessTokenConsumer* consumer,
                         net::URLRequestContextGetter* getter,
                         const std::string& refresh_token)
      : OAuth2AccessTokenFetcherImpl(consumer, getter, refresh_token) {}
  ~MockAccessTokenFetcher() {}

  MOCK_METHOD3(Start,
               void(const std::string& client_id,
                    const std::string& client_secret,
                    const std::vector<std::string>& scopes));
};

class MockApiCallFlow : public OAuth2ApiCallFlow {
 public:
  MockApiCallFlow(net::URLRequestContextGetter* context,
                  const std::string& refresh_token,
                  const std::string& access_token,
                  const std::vector<std::string>& scopes)
      : OAuth2ApiCallFlow(context, refresh_token, access_token, scopes) {}
  ~MockApiCallFlow() {}

  MOCK_METHOD0(CreateApiCallUrl, GURL ());
  MOCK_METHOD0(CreateApiCallBody, std::string ());
  MOCK_METHOD1(ProcessApiCallSuccess,
      void (const URLFetcher* source));
  MOCK_METHOD1(ProcessApiCallFailure,
      void (const URLFetcher* source));
  MOCK_METHOD1(ProcessNewAccessToken,
      void (const std::string& access_token));
  MOCK_METHOD1(ProcessMintAccessTokenFailure,
      void (const GoogleServiceAuthError& error));
  MOCK_METHOD0(CreateAccessTokenFetcher, OAuth2AccessTokenFetcher* ());
};

}  // namespace

class OAuth2ApiCallFlowTest : public testing::Test {
 protected:
  void SetupAccessTokenFetcher(const std::vector<std::string>& scopes) {
    EXPECT_CALL(*access_token_fetcher_,
                Start(GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
                      GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
                      scopes)).Times(1);
    EXPECT_CALL(*flow_, CreateAccessTokenFetcher())
        .WillOnce(Return(access_token_fetcher_.release()));
  }

  TestURLFetcher* CreateURLFetcher(
      const GURL& url, bool fetch_succeeds,
      int response_code, const std::string& body) {
    TestURLFetcher* url_fetcher = new TestURLFetcher(0, url, flow_.get());
    URLRequestStatus::Status status =
        fetch_succeeds ? URLRequestStatus::SUCCESS : URLRequestStatus::FAILED;
    url_fetcher->set_status(URLRequestStatus(status, 0));

    if (response_code != 0)
      url_fetcher->set_response_code(response_code);

    if (!body.empty())
      url_fetcher->SetResponseString(body);

    return url_fetcher;
  }

  void CreateFlow(const std::string& refresh_token,
                  const std::string& access_token,
                  const std::vector<std::string>& scopes) {
    scoped_refptr<net::TestURLRequestContextGetter> request_context_getter =
        new net::TestURLRequestContextGetter(
            message_loop_.message_loop_proxy());
    flow_.reset(new MockApiCallFlow(
        request_context_getter, refresh_token, access_token, scopes));
    access_token_fetcher_.reset(new MockAccessTokenFetcher(
        flow_.get(), request_context_getter, refresh_token));
  }

  TestURLFetcher* SetupApiCall(bool succeeds, net::HttpStatusCode status) {
    std::string body(CreateBody());
    GURL url(CreateApiUrl());
    EXPECT_CALL(*flow_, CreateApiCallBody()).WillOnce(Return(body));
    EXPECT_CALL(*flow_, CreateApiCallUrl()).WillOnce(Return(url));
    TestURLFetcher* url_fetcher =
        CreateURLFetcher(url, succeeds, status, std::string());
    EXPECT_CALL(factory_, CreateURLFetcher(_, url, _, _))
        .WillOnce(Return(url_fetcher));
    return url_fetcher;
  }

  MockUrlFetcherFactory factory_;
  scoped_ptr<MockApiCallFlow> flow_;
  scoped_ptr<MockAccessTokenFetcher> access_token_fetcher_;
  base::MessageLoop message_loop_;
};

TEST_F(OAuth2ApiCallFlowTest, FirstApiCallSucceeds) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, at, scopes);
  TestURLFetcher* url_fetcher = SetupApiCall(true, net::HTTP_OK);
  EXPECT_CALL(*flow_, ProcessApiCallSuccess(url_fetcher));
  flow_->Start();
  flow_->OnURLFetchComplete(url_fetcher);
}

TEST_F(OAuth2ApiCallFlowTest, SecondApiCallSucceeds) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, at, scopes);
  TestURLFetcher* url_fetcher1 = SetupApiCall(true, net::HTTP_UNAUTHORIZED);
  flow_->Start();
  SetupAccessTokenFetcher(scopes);
  flow_->OnURLFetchComplete(url_fetcher1);
  TestURLFetcher* url_fetcher2 = SetupApiCall(true, net::HTTP_OK);
  EXPECT_CALL(*flow_, ProcessApiCallSuccess(url_fetcher2));
  flow_->OnGetTokenSuccess(
      at,
      base::Time::Now() + base::TimeDelta::FromMinutes(3600));
  flow_->OnURLFetchComplete(url_fetcher2);
}

TEST_F(OAuth2ApiCallFlowTest, SecondApiCallFails) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, at, scopes);
  TestURLFetcher* url_fetcher1 = SetupApiCall(true, net::HTTP_UNAUTHORIZED);
  flow_->Start();
  SetupAccessTokenFetcher(scopes);
  flow_->OnURLFetchComplete(url_fetcher1);
  TestURLFetcher* url_fetcher2 = SetupApiCall(false, net::HTTP_UNAUTHORIZED);
  EXPECT_CALL(*flow_, ProcessApiCallFailure(url_fetcher2));
  flow_->OnGetTokenSuccess(
      at,
      base::Time::Now() + base::TimeDelta::FromMinutes(3600));
  flow_->OnURLFetchComplete(url_fetcher2);
}

TEST_F(OAuth2ApiCallFlowTest, NewTokenGenerationFails) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, at, scopes);
  TestURLFetcher* url_fetcher = SetupApiCall(true, net::HTTP_UNAUTHORIZED);
  flow_->Start();
  SetupAccessTokenFetcher(scopes);
  flow_->OnURLFetchComplete(url_fetcher);
  GoogleServiceAuthError error(
      GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
  EXPECT_CALL(*flow_, ProcessMintAccessTokenFailure(error));
  flow_->OnGetTokenFailure(error);
}

TEST_F(OAuth2ApiCallFlowTest, EmptyAccessTokenFirstApiCallSucceeds) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, std::string(), scopes);
  SetupAccessTokenFetcher(scopes);
  TestURLFetcher* url_fetcher = SetupApiCall(true, net::HTTP_OK);
  EXPECT_CALL(*flow_, ProcessApiCallSuccess(url_fetcher));
  flow_->Start();
  flow_->OnGetTokenSuccess(
      at,
      base::Time::Now() + base::TimeDelta::FromMinutes(3600));
  flow_->OnURLFetchComplete(url_fetcher);
}

TEST_F(OAuth2ApiCallFlowTest, EmptyAccessTokenApiCallFails) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, std::string(), scopes);
  SetupAccessTokenFetcher(scopes);
  TestURLFetcher* url_fetcher = SetupApiCall(false, net::HTTP_BAD_GATEWAY);
  EXPECT_CALL(*flow_, ProcessApiCallFailure(url_fetcher));
  flow_->Start();
  flow_->OnGetTokenSuccess(
      at,
      base::Time::Now() + base::TimeDelta::FromMinutes(3600));
  flow_->OnURLFetchComplete(url_fetcher);
}

TEST_F(OAuth2ApiCallFlowTest, EmptyAccessTokenNewTokenGenerationFails) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());

  CreateFlow(rt, std::string(), scopes);
  SetupAccessTokenFetcher(scopes);
  GoogleServiceAuthError error(
      GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
  EXPECT_CALL(*flow_, ProcessMintAccessTokenFailure(error));
  flow_->Start();
  flow_->OnGetTokenFailure(error);
}

TEST_F(OAuth2ApiCallFlowTest, CreateURLFetcher) {
  std::string rt = "refresh_token";
  std::string at = "access_token";
  std::vector<std::string> scopes(CreateTestScopes());
  std::string body = CreateBody();
  GURL url(CreateApiUrl());

  CreateFlow(rt, at, scopes);
  scoped_ptr<TestURLFetcher> url_fetcher(SetupApiCall(true, net::HTTP_OK));
  flow_->CreateURLFetcher();
  HttpRequestHeaders headers;
  url_fetcher->GetExtraRequestHeaders(&headers);
  std::string auth_header;
  EXPECT_TRUE(headers.GetHeader("Authorization", &auth_header));
  EXPECT_EQ("Bearer access_token", auth_header);
  EXPECT_EQ(url, url_fetcher->GetOriginalURL());
  EXPECT_EQ(body, url_fetcher->upload_data());
}