1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4//
5// A set of unit tests for TokenValidatorFactoryImpl
6
7#include <string>
8
9#include "base/json/json_writer.h"
10#include "base/values.h"
11#include "net/url_request/test_url_fetcher_factory.h"
12#include "net/url_request/url_request_test_util.h"
13#include "remoting/base/rsa_key_pair.h"
14#include "remoting/base/test_rsa_key_pair.h"
15#include "remoting/host/token_validator_factory_impl.h"
16#include "testing/gtest/include/gtest/gtest.h"
17#include "url/gurl.h"
18
19namespace {
20
21const char kTokenUrl[] = "https://example.com/token";
22const char kTokenValidationUrl[] = "https://example.com/validate";
23const char kLocalJid[] = "user@example.com/local";
24const char kRemoteJid[] = "user@example.com/remote";
25const char kToken[] = "xyz123456";
26const char kSharedSecret[] = "abcdefgh";
27
28// Bad scope: no nonce element.
29const char kBadScope[] =
30    "client:user@example.com/local host:user@example.com/remote";
31
32}  // namespace
33
34namespace remoting {
35
36class TokenValidatorFactoryImplTest : public testing::Test {
37 public:
38  TokenValidatorFactoryImplTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
39
40  void SuccessCallback(const std::string& shared_secret) {
41    EXPECT_FALSE(shared_secret.empty());
42    message_loop_.Quit();
43  }
44
45  void FailureCallback(const std::string& shared_secret) {
46    EXPECT_TRUE(shared_secret.empty());
47    message_loop_.Quit();
48  }
49
50  void DeleteOnFailureCallback(const std::string& shared_secret) {
51    EXPECT_TRUE(shared_secret.empty());
52    token_validator_.reset();
53    message_loop_.Quit();
54  }
55
56 protected:
57  virtual void SetUp() OVERRIDE {
58    key_pair_ = RsaKeyPair::FromString(kTestRsaKeyPair);
59    request_context_getter_ = new net::TestURLRequestContextGetter(
60        message_loop_.message_loop_proxy());
61    token_validator_factory_.reset(new TokenValidatorFactoryImpl(
62        GURL(kTokenUrl), GURL(kTokenValidationUrl), key_pair_,
63        request_context_getter_));
64  }
65
66  static std::string CreateResponse(const std::string& scope) {
67    DictionaryValue response_dict;
68    response_dict.SetString("access_token", kSharedSecret);
69    response_dict.SetString("token_type", "shared_secret");
70    response_dict.SetString("scope", scope);
71    std::string response;
72    base::JSONWriter::Write(&response_dict, &response);
73    return response;
74  }
75
76  static std::string CreateErrorResponse(const std::string& error) {
77    DictionaryValue response_dict;
78    response_dict.SetString("error", error);
79    std::string response;
80    base::JSONWriter::Write(&response_dict, &response);
81    return response;
82  }
83
84  base::MessageLoop message_loop_;
85  scoped_refptr<RsaKeyPair> key_pair_;
86  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
87  scoped_ptr<TokenValidatorFactoryImpl> token_validator_factory_;
88  scoped_ptr<protocol::ThirdPartyHostAuthenticator::TokenValidator>
89  token_validator_;
90};
91
92TEST_F(TokenValidatorFactoryImplTest, Success) {
93  net::FakeURLFetcherFactory factory(NULL);
94  token_validator_ = token_validator_factory_->CreateTokenValidator(
95      kLocalJid, kRemoteJid);
96  factory.SetFakeResponse(kTokenValidationUrl, CreateResponse(
97      token_validator_->token_scope()), true);
98  token_validator_->ValidateThirdPartyToken(
99      kToken, base::Bind(&TokenValidatorFactoryImplTest::SuccessCallback,
100                             base::Unretained(this)));
101  message_loop_.Run();
102}
103
104TEST_F(TokenValidatorFactoryImplTest, BadToken) {
105  net::FakeURLFetcherFactory factory(NULL);
106  token_validator_ = token_validator_factory_->CreateTokenValidator(
107      kLocalJid, kRemoteJid);
108  factory.SetFakeResponse(kTokenValidationUrl, std::string(), false);
109  token_validator_->ValidateThirdPartyToken(
110      kToken, base::Bind(&TokenValidatorFactoryImplTest::FailureCallback,
111                             base::Unretained(this)));
112  message_loop_.Run();
113}
114
115TEST_F(TokenValidatorFactoryImplTest, BadScope) {
116  net::FakeURLFetcherFactory factory(NULL);
117  token_validator_ = token_validator_factory_->CreateTokenValidator(
118      kLocalJid, kRemoteJid);
119  factory.SetFakeResponse(kTokenValidationUrl, CreateResponse(kBadScope), true);
120  token_validator_->ValidateThirdPartyToken(
121      kToken, base::Bind(&TokenValidatorFactoryImplTest::FailureCallback,
122                         base::Unretained(this)));
123  message_loop_.Run();
124}
125
126TEST_F(TokenValidatorFactoryImplTest, DeleteOnFailure) {
127  net::FakeURLFetcherFactory factory(NULL);
128  token_validator_ = token_validator_factory_->CreateTokenValidator(
129      kLocalJid, kRemoteJid);
130  factory.SetFakeResponse(kTokenValidationUrl, std::string(), false);
131  token_validator_->ValidateThirdPartyToken(
132      kToken, base::Bind(
133          &TokenValidatorFactoryImplTest::DeleteOnFailureCallback,
134          base::Unretained(this)));
135  message_loop_.Run();
136}
137
138}  // namespace remoting
139