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