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/http_response_info.h" |
11 #include "net/http/mock_allow_http_auth_preferences.h" | 12 #include "net/http/mock_allow_http_auth_preferences.h" |
12 #include "net/http/url_security_manager.h" | 13 #include "net/http/url_security_manager.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 HttpResponseInfo& response_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 HttpResponseInfo null_response_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_response_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, |
67 registry_factory.CreateAuthHandlerFromString( | 71 registry_factory.CreateAuthHandlerFromString( |
68 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 72 "Basic", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
| 73 BoundNetLog(), &handler)); |
69 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, | 74 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, |
70 registry_factory.CreateAuthHandlerFromString( | 75 registry_factory.CreateAuthHandlerFromString( |
71 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 76 "Digest", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
72 &handler)); | 77 BoundNetLog(), &handler)); |
73 | 78 |
74 // Test multiple schemes | 79 // Test multiple schemes |
75 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); | 80 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); |
76 EXPECT_EQ(kBasicReturnCode, | 81 EXPECT_EQ(kBasicReturnCode, |
77 registry_factory.CreateAuthHandlerFromString( | 82 registry_factory.CreateAuthHandlerFromString( |
78 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 83 "Basic", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
| 84 BoundNetLog(), &handler)); |
79 EXPECT_EQ(kDigestReturnCode, | 85 EXPECT_EQ(kDigestReturnCode, |
80 registry_factory.CreateAuthHandlerFromString( | 86 registry_factory.CreateAuthHandlerFromString( |
81 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 87 "Digest", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
82 &handler)); | 88 BoundNetLog(), &handler)); |
83 | 89 |
84 // Test case-insensitivity | 90 // Test case-insensitivity |
85 EXPECT_EQ(kBasicReturnCode, | 91 EXPECT_EQ(kBasicReturnCode, |
86 registry_factory.CreateAuthHandlerFromString( | 92 registry_factory.CreateAuthHandlerFromString( |
87 "basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 93 "basic", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
| 94 BoundNetLog(), &handler)); |
88 | 95 |
89 // Test replacement of existing auth scheme | 96 // Test replacement of existing auth scheme |
90 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); | 97 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); |
91 EXPECT_EQ(kBasicReturnCode, | 98 EXPECT_EQ(kBasicReturnCode, |
92 registry_factory.CreateAuthHandlerFromString( | 99 registry_factory.CreateAuthHandlerFromString( |
93 "Basic", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), &handler)); | 100 "Basic", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
| 101 BoundNetLog(), &handler)); |
94 EXPECT_EQ(kDigestReturnCodeReplace, | 102 EXPECT_EQ(kDigestReturnCodeReplace, |
95 registry_factory.CreateAuthHandlerFromString( | 103 registry_factory.CreateAuthHandlerFromString( |
96 "Digest", HttpAuth::AUTH_SERVER, gurl, BoundNetLog(), | 104 "Digest", HttpAuth::AUTH_SERVER, null_response_info, gurl, |
97 &handler)); | 105 BoundNetLog(), &handler)); |
98 } | 106 } |
99 | 107 |
100 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { | 108 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { |
101 scoped_ptr<HostResolver> host_resolver(new MockHostResolver()); | 109 scoped_ptr<HostResolver> host_resolver(new MockHostResolver()); |
102 MockAllowHttpAuthPreferences http_auth_preferences; | 110 MockAllowHttpAuthPreferences http_auth_preferences; |
103 scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( | 111 scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( |
104 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); | 112 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); |
105 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, | 113 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, |
106 &http_auth_preferences); | 114 &http_auth_preferences); |
107 GURL server_origin("http://www.example.com"); | 115 GURL server_origin("http://www.example.com"); |
108 GURL proxy_origin("http://cache.example.com:3128"); | 116 GURL proxy_origin("http://cache.example.com:3128"); |
| 117 HttpResponseInfo null_response_info; |
109 { | 118 { |
110 scoped_ptr<HttpAuthHandler> handler; | 119 scoped_ptr<HttpAuthHandler> handler; |
111 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 120 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
112 "Basic realm=\"FooBar\"", | 121 "Basic realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_response_info, |
113 HttpAuth::AUTH_SERVER, | 122 server_origin, BoundNetLog(), &handler); |
114 server_origin, | |
115 BoundNetLog(), | |
116 &handler); | |
117 EXPECT_EQ(OK, rv); | 123 EXPECT_EQ(OK, rv); |
118 ASSERT_FALSE(handler.get() == NULL); | 124 ASSERT_FALSE(handler.get() == NULL); |
119 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); | 125 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); |
120 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 126 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
121 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 127 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
122 EXPECT_FALSE(handler->encrypts_identity()); | 128 EXPECT_FALSE(handler->encrypts_identity()); |
123 EXPECT_FALSE(handler->is_connection_based()); | 129 EXPECT_FALSE(handler->is_connection_based()); |
124 } | 130 } |
125 { | 131 { |
126 scoped_ptr<HttpAuthHandler> handler; | 132 scoped_ptr<HttpAuthHandler> handler; |
127 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 133 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
128 "UNSUPPORTED realm=\"FooBar\"", | 134 "UNSUPPORTED realm=\"FooBar\"", HttpAuth::AUTH_SERVER, |
129 HttpAuth::AUTH_SERVER, | 135 null_response_info, server_origin, BoundNetLog(), &handler); |
130 server_origin, | |
131 BoundNetLog(), | |
132 &handler); | |
133 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); | 136 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); |
134 EXPECT_TRUE(handler.get() == NULL); | 137 EXPECT_TRUE(handler.get() == NULL); |
135 } | 138 } |
136 { | 139 { |
137 scoped_ptr<HttpAuthHandler> handler; | 140 scoped_ptr<HttpAuthHandler> handler; |
138 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 141 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
139 "Digest realm=\"FooBar\", nonce=\"xyz\"", | 142 "Digest realm=\"FooBar\", nonce=\"xyz\"", HttpAuth::AUTH_PROXY, |
140 HttpAuth::AUTH_PROXY, | 143 null_response_info, proxy_origin, BoundNetLog(), &handler); |
141 proxy_origin, | |
142 BoundNetLog(), | |
143 &handler); | |
144 EXPECT_EQ(OK, rv); | 144 EXPECT_EQ(OK, rv); |
145 ASSERT_FALSE(handler.get() == NULL); | 145 ASSERT_FALSE(handler.get() == NULL); |
146 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); | 146 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); |
147 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 147 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
148 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); | 148 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); |
149 EXPECT_TRUE(handler->encrypts_identity()); | 149 EXPECT_TRUE(handler->encrypts_identity()); |
150 EXPECT_FALSE(handler->is_connection_based()); | 150 EXPECT_FALSE(handler->is_connection_based()); |
151 } | 151 } |
152 { | 152 { |
153 scoped_ptr<HttpAuthHandler> handler; | 153 scoped_ptr<HttpAuthHandler> handler; |
154 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 154 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
155 "NTLM", | 155 "NTLM", HttpAuth::AUTH_SERVER, null_response_info, server_origin, |
156 HttpAuth::AUTH_SERVER, | 156 BoundNetLog(), &handler); |
157 server_origin, | |
158 BoundNetLog(), | |
159 &handler); | |
160 EXPECT_EQ(OK, rv); | 157 EXPECT_EQ(OK, rv); |
161 ASSERT_FALSE(handler.get() == NULL); | 158 ASSERT_FALSE(handler.get() == NULL); |
162 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); | 159 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); |
163 EXPECT_STREQ("", handler->realm().c_str()); | 160 EXPECT_STREQ("", handler->realm().c_str()); |
164 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 161 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
165 EXPECT_TRUE(handler->encrypts_identity()); | 162 EXPECT_TRUE(handler->encrypts_identity()); |
166 EXPECT_TRUE(handler->is_connection_based()); | 163 EXPECT_TRUE(handler->is_connection_based()); |
167 } | 164 } |
168 { | 165 { |
169 scoped_ptr<HttpAuthHandler> handler; | 166 scoped_ptr<HttpAuthHandler> handler; |
170 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 167 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
171 "Negotiate", | 168 "Negotiate", HttpAuth::AUTH_SERVER, null_response_info, server_origin, |
172 HttpAuth::AUTH_SERVER, | 169 BoundNetLog(), &handler); |
173 server_origin, | |
174 BoundNetLog(), | |
175 &handler); | |
176 // Note the default factory doesn't support Kerberos on Android | 170 // Note the default factory doesn't support Kerberos on Android |
177 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) | 171 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) |
178 EXPECT_EQ(OK, rv); | 172 EXPECT_EQ(OK, rv); |
179 ASSERT_FALSE(handler.get() == NULL); | 173 ASSERT_FALSE(handler.get() == NULL); |
180 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); | 174 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); |
181 EXPECT_STREQ("", handler->realm().c_str()); | 175 EXPECT_STREQ("", handler->realm().c_str()); |
182 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 176 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
183 EXPECT_TRUE(handler->encrypts_identity()); | 177 EXPECT_TRUE(handler->encrypts_identity()); |
184 EXPECT_TRUE(handler->is_connection_based()); | 178 EXPECT_TRUE(handler->is_connection_based()); |
185 #else | 179 #else |
186 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); | 180 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv); |
187 EXPECT_TRUE(handler.get() == NULL); | 181 EXPECT_TRUE(handler.get() == NULL); |
188 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) | 182 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) |
189 } | 183 } |
190 } | 184 } |
191 | 185 |
192 } // namespace net | 186 } // namespace net |
OLD | NEW |