OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/memory/scoped_ptr.h" | 5 #include "base/memory/scoped_ptr.h" |
6 #include "net/base/net_errors.h" | 6 #include "net/base/net_errors.h" |
7 #include "net/dns/mock_host_resolver.h" | 7 #include "net/dns/mock_host_resolver.h" |
8 #include "net/http/http_auth_handler.h" | 8 #include "net/http/http_auth_handler.h" |
9 #include "net/http/http_auth_handler_factory.h" | 9 #include "net/http/http_auth_handler_factory.h" |
10 #include "net/http/http_auth_scheme.h" | 10 #include "net/http/http_auth_scheme.h" |
11 #include "net/http/mock_allow_http_auth_preferences.h" | 11 #include "net/http/mock_allow_http_auth_preferences.h" |
12 #include "net/http/url_security_manager.h" | 12 #include "net/http/url_security_manager.h" |
| 13 #include "net/ssl/ssl_info.h" |
13 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
14 | 15 |
15 namespace net { | 16 namespace net { |
16 | 17 |
17 namespace { | 18 namespace { |
18 | 19 |
19 class MockHttpAuthHandlerFactory : public HttpAuthHandlerFactory { | 20 class MockHttpAuthHandlerFactory : public HttpAuthHandlerFactory { |
20 public: | 21 public: |
21 explicit MockHttpAuthHandlerFactory(int return_code) : | 22 explicit MockHttpAuthHandlerFactory(int return_code) : |
22 return_code_(return_code) {} | 23 return_code_(return_code) {} |
23 ~MockHttpAuthHandlerFactory() override {} | 24 ~MockHttpAuthHandlerFactory() override {} |
24 | 25 |
25 int CreateAuthHandler(HttpAuthChallengeTokenizer* challenge, | 26 int CreateAuthHandler(HttpAuthChallengeTokenizer* challenge, |
26 HttpAuth::Target target, | 27 HttpAuth::Target target, |
| 28 const SSLInfo& ssl_info, |
27 const GURL& origin, | 29 const GURL& origin, |
28 CreateReason reason, | 30 CreateReason reason, |
29 int nonce_count, | 31 int nonce_count, |
30 const BoundNetLog& net_log, | 32 const BoundNetLog& net_log, |
31 scoped_ptr<HttpAuthHandler>* handler) override { | 33 scoped_ptr<HttpAuthHandler>* handler) override { |
32 handler->reset(); | 34 handler->reset(); |
33 return return_code_; | 35 return return_code_; |
34 } | 36 } |
35 | 37 |
36 private: | 38 private: |
37 int return_code_; | 39 int return_code_; |
38 }; | 40 }; |
39 | 41 |
40 } // namespace | 42 } // namespace |
41 | 43 |
42 TEST(HttpAuthHandlerFactoryTest, RegistryFactory) { | 44 TEST(HttpAuthHandlerFactoryTest, RegistryFactory) { |
| 45 SSLInfo null_ssl_info; |
43 HttpAuthHandlerRegistryFactory registry_factory; | 46 HttpAuthHandlerRegistryFactory registry_factory; |
44 GURL gurl("www.google.com"); | 47 GURL gurl("www.google.com"); |
45 const int kBasicReturnCode = ERR_INVALID_SPDY_STREAM; | 48 const int kBasicReturnCode = ERR_INVALID_SPDY_STREAM; |
46 MockHttpAuthHandlerFactory* mock_factory_basic = | 49 MockHttpAuthHandlerFactory* mock_factory_basic = |
47 new MockHttpAuthHandlerFactory(kBasicReturnCode); | 50 new MockHttpAuthHandlerFactory(kBasicReturnCode); |
48 | 51 |
49 const int kDigestReturnCode = ERR_PAC_SCRIPT_FAILED; | 52 const int kDigestReturnCode = ERR_PAC_SCRIPT_FAILED; |
50 MockHttpAuthHandlerFactory* mock_factory_digest = | 53 MockHttpAuthHandlerFactory* mock_factory_digest = |
51 new MockHttpAuthHandlerFactory(kDigestReturnCode); | 54 new MockHttpAuthHandlerFactory(kDigestReturnCode); |
52 | 55 |
53 const int kDigestReturnCodeReplace = ERR_SYN_REPLY_NOT_RECEIVED; | 56 const int kDigestReturnCodeReplace = ERR_SYN_REPLY_NOT_RECEIVED; |
54 MockHttpAuthHandlerFactory* mock_factory_digest_replace = | 57 MockHttpAuthHandlerFactory* mock_factory_digest_replace = |
55 new MockHttpAuthHandlerFactory(kDigestReturnCodeReplace); | 58 new MockHttpAuthHandlerFactory(kDigestReturnCodeReplace); |
56 | 59 |
57 scoped_ptr<HttpAuthHandler> handler; | 60 scoped_ptr<HttpAuthHandler> handler; |
58 | 61 |
59 // No schemes should be supported in the beginning. | 62 // No schemes should be supported in the beginning. |
60 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, | 63 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, |
61 registry_factory.CreateAuthHandlerFromString( | 64 registry_factory.CreateAuthHandlerFromString( |
62 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 65 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
| 66 BoundNetLog(), &handler)); |
63 | 67 |
64 // Test what happens with a single scheme. | 68 // Test what happens with a single scheme. |
65 registry_factory.RegisterSchemeFactory("Basic", mock_factory_basic); | 69 registry_factory.RegisterSchemeFactory("Basic", mock_factory_basic); |
66 EXPECT_EQ(kBasicReturnCode, | 70 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
67 registry_factory.CreateAuthHandlerFromString( | 71 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
68 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 72 gurl, BoundNetLog(), &handler)); |
69 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, | 73 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, |
70 registry_factory.CreateAuthHandlerFromString( | 74 registry_factory.CreateAuthHandlerFromString( |
71 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 75 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
72 &handler)); | 76 BoundNetLog(), &handler)); |
73 | 77 |
74 // Test multiple schemes | 78 // Test multiple schemes |
75 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); | 79 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); |
76 EXPECT_EQ(kBasicReturnCode, | 80 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
77 registry_factory.CreateAuthHandlerFromString( | 81 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
78 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 82 gurl, BoundNetLog(), &handler)); |
79 EXPECT_EQ(kDigestReturnCode, | 83 EXPECT_EQ(kDigestReturnCode, |
80 registry_factory.CreateAuthHandlerFromString( | 84 registry_factory.CreateAuthHandlerFromString( |
81 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 85 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
82 &handler)); | 86 BoundNetLog(), &handler)); |
83 | 87 |
84 // Test case-insensitivity | 88 // Test case-insensitivity |
85 EXPECT_EQ(kBasicReturnCode, | 89 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
86 registry_factory.CreateAuthHandlerFromString( | 90 "basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
87 "basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 91 gurl, BoundNetLog(), &handler)); |
88 | 92 |
89 // Test replacement of existing auth scheme | 93 // Test replacement of existing auth scheme |
90 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); | 94 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); |
91 EXPECT_EQ(kBasicReturnCode, | 95 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
92 registry_factory.CreateAuthHandlerFromString( | 96 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
93 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 97 gurl, BoundNetLog(), &handler)); |
94 EXPECT_EQ(kDigestReturnCodeReplace, | 98 EXPECT_EQ(kDigestReturnCodeReplace, |
95 registry_factory.CreateAuthHandlerFromString( | 99 registry_factory.CreateAuthHandlerFromString( |
96 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 100 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
97 &handler)); | 101 BoundNetLog(), &handler)); |
98 } | 102 } |
99 | 103 |
100 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { | 104 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { |
101 scoped_ptr<HostResolver> host_resolver(new MockHostResolver()); | 105 scoped_ptr<HostResolver> host_resolver(new MockHostResolver()); |
102 MockAllowHttpAuthPreferences http_auth_preferences; | 106 MockAllowHttpAuthPreferences http_auth_preferences; |
103 scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( | 107 scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( |
104 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); | 108 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); |
105 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, | 109 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, |
106 &http_auth_preferences); | 110 &http_auth_preferences); |
107 GURL server_origin("http://www.example.com"); | 111 GURL server_origin("http://www.example.com"); |
108 GURL proxy_origin("http://cache.example.com:3128"); | 112 GURL proxy_origin("http://cache.example.com:3128"); |
| 113 SSLInfo null_ssl_info; |
109 { | 114 { |
110 scoped_ptr<HttpAuthHandler> handler; | 115 scoped_ptr<HttpAuthHandler> handler; |
111 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 116 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
112 "Basic realm=\"FooBar\"", | 117 "Basic realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, |
113 HttpAuth::AUTH_SERVER, | 118 server_origin, BoundNetLog(), &handler); |
114 server_origin, | |
115 BoundNetLog(), | |
116 &handler); | |
117 EXPECT_EQ(OK, rv); | 119 EXPECT_EQ(OK, rv); |
118 ASSERT_FALSE(handler.get() == NULL); | 120 ASSERT_FALSE(handler.get() == NULL); |
119 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); | 121 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); |
120 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 122 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
121 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 123 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
122 EXPECT_FALSE(handler->encrypts_identity()); | 124 EXPECT_FALSE(handler->encrypts_identity()); |
123 EXPECT_FALSE(handler->is_connection_based()); | 125 EXPECT_FALSE(handler->is_connection_based()); |
124 } | 126 } |
125 { | 127 { |
126 scoped_ptr<HttpAuthHandler> handler; | 128 scoped_ptr<HttpAuthHandler> handler; |
127 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 129 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
128 "UNSUPPORTED realm=\"FooBar\"", | 130 "UNSUPPORTED realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, |
129 HttpAuth::AUTH_SERVER, | 131 server_origin, BoundNetLog(), &handler); |
130 server_origin, | |
131 BoundNetLog(), | |
132 &handler); | |
133 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); | 132 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); |
134 EXPECT_TRUE(handler.get() == NULL); | 133 EXPECT_TRUE(handler.get() == NULL); |
135 } | 134 } |
136 { | 135 { |
137 scoped_ptr<HttpAuthHandler> handler; | 136 scoped_ptr<HttpAuthHandler> handler; |
138 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 137 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
139 "Digest realm=\"FooBar\", nonce=\"xyz\"", | 138 "Digest realm=\"FooBar\", nonce=\"xyz\"", HttpAuth::AUTH_PROXY, |
140 HttpAuth::AUTH_PROXY, | 139 null_ssl_info, proxy_origin, BoundNetLog(), &handler); |
141 proxy_origin, | |
142 BoundNetLog(), | |
143 &handler); | |
144 EXPECT_EQ(OK, rv); | 140 EXPECT_EQ(OK, rv); |
145 ASSERT_FALSE(handler.get() == NULL); | 141 ASSERT_FALSE(handler.get() == NULL); |
146 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); | 142 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); |
147 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 143 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
148 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); | 144 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); |
149 EXPECT_TRUE(handler->encrypts_identity()); | 145 EXPECT_TRUE(handler->encrypts_identity()); |
150 EXPECT_FALSE(handler->is_connection_based()); | 146 EXPECT_FALSE(handler->is_connection_based()); |
151 } | 147 } |
152 { | 148 { |
153 scoped_ptr<HttpAuthHandler> handler; | 149 scoped_ptr<HttpAuthHandler> handler; |
154 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 150 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
155 "NTLM", | 151 "NTLM", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, |
156 HttpAuth::AUTH_SERVER, | 152 BoundNetLog(), &handler); |
157 server_origin, | |
158 BoundNetLog(), | |
159 &handler); | |
160 EXPECT_EQ(OK, rv); | 153 EXPECT_EQ(OK, rv); |
161 ASSERT_FALSE(handler.get() == NULL); | 154 ASSERT_FALSE(handler.get() == NULL); |
162 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); | 155 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); |
163 EXPECT_STREQ("", handler->realm().c_str()); | 156 EXPECT_STREQ("", handler->realm().c_str()); |
164 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 157 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
165 EXPECT_TRUE(handler->encrypts_identity()); | 158 EXPECT_TRUE(handler->encrypts_identity()); |
166 EXPECT_TRUE(handler->is_connection_based()); | 159 EXPECT_TRUE(handler->is_connection_based()); |
167 } | 160 } |
168 { | 161 { |
169 scoped_ptr<HttpAuthHandler> handler; | 162 scoped_ptr<HttpAuthHandler> handler; |
170 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 163 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
171 "Negotiate", | 164 "Negotiate", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, |
172 HttpAuth::AUTH_SERVER, | 165 BoundNetLog(), &handler); |
173 server_origin, | |
174 BoundNetLog(), | |
175 &handler); | |
176 // Note the default factory doesn't support Kerberos on Android | 166 // Note the default factory doesn't support Kerberos on Android |
177 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) | 167 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) |
178 EXPECT_EQ(OK, rv); | 168 EXPECT_EQ(OK, rv); |
179 ASSERT_FALSE(handler.get() == NULL); | 169 ASSERT_FALSE(handler.get() == NULL); |
180 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); | 170 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); |
181 EXPECT_STREQ("", handler->realm().c_str()); | 171 EXPECT_STREQ("", handler->realm().c_str()); |
182 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 172 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
183 EXPECT_TRUE(handler->encrypts_identity()); | 173 EXPECT_TRUE(handler->encrypts_identity()); |
184 EXPECT_TRUE(handler->is_connection_based()); | 174 EXPECT_TRUE(handler->is_connection_based()); |
185 #else | 175 #else |
186 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); | 176 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); |
187 EXPECT_TRUE(handler.get() == NULL); | 177 EXPECT_TRUE(handler.get() == NULL); |
188 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) | 178 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) |
189 } | 179 } |
190 } | 180 } |
191 | 181 |
192 } // namespace net | 182 } // namespace net |
OLD | NEW |