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 "net/http/http_auth_handler_factory.h" | 5 #include "net/http/http_auth_handler_factory.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "net/base/net_errors.h" | 9 #include "net/base/net_errors.h" |
10 #include "net/dns/mock_host_resolver.h" | 10 #include "net/dns/mock_host_resolver.h" |
(...skipping 18 matching lines...) Expand all Loading... |
29 explicit MockHttpAuthHandlerFactory(int return_code) : | 29 explicit MockHttpAuthHandlerFactory(int return_code) : |
30 return_code_(return_code) {} | 30 return_code_(return_code) {} |
31 ~MockHttpAuthHandlerFactory() override {} | 31 ~MockHttpAuthHandlerFactory() override {} |
32 | 32 |
33 int CreateAuthHandler(HttpAuthChallengeTokenizer* challenge, | 33 int CreateAuthHandler(HttpAuthChallengeTokenizer* challenge, |
34 HttpAuth::Target target, | 34 HttpAuth::Target target, |
35 const SSLInfo& ssl_info, | 35 const SSLInfo& ssl_info, |
36 const GURL& origin, | 36 const GURL& origin, |
37 CreateReason reason, | 37 CreateReason reason, |
38 int nonce_count, | 38 int nonce_count, |
39 const BoundNetLog& net_log, | 39 const NetLogWithSource& net_log, |
40 std::unique_ptr<HttpAuthHandler>* handler) override { | 40 std::unique_ptr<HttpAuthHandler>* handler) override { |
41 handler->reset(); | 41 handler->reset(); |
42 return return_code_; | 42 return return_code_; |
43 } | 43 } |
44 | 44 |
45 private: | 45 private: |
46 int return_code_; | 46 int return_code_; |
47 }; | 47 }; |
48 | 48 |
49 } // namespace | 49 } // namespace |
(...skipping 13 matching lines...) Expand all Loading... |
63 const int kDigestReturnCodeReplace = ERR_SYN_REPLY_NOT_RECEIVED; | 63 const int kDigestReturnCodeReplace = ERR_SYN_REPLY_NOT_RECEIVED; |
64 MockHttpAuthHandlerFactory* mock_factory_digest_replace = | 64 MockHttpAuthHandlerFactory* mock_factory_digest_replace = |
65 new MockHttpAuthHandlerFactory(kDigestReturnCodeReplace); | 65 new MockHttpAuthHandlerFactory(kDigestReturnCodeReplace); |
66 | 66 |
67 std::unique_ptr<HttpAuthHandler> handler; | 67 std::unique_ptr<HttpAuthHandler> handler; |
68 | 68 |
69 // No schemes should be supported in the beginning. | 69 // No schemes should be supported in the beginning. |
70 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, | 70 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, |
71 registry_factory.CreateAuthHandlerFromString( | 71 registry_factory.CreateAuthHandlerFromString( |
72 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, | 72 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
73 BoundNetLog(), &handler)); | 73 NetLogWithSource(), &handler)); |
74 | 74 |
75 // Test what happens with a single scheme. | 75 // Test what happens with a single scheme. |
76 registry_factory.RegisterSchemeFactory("Basic", mock_factory_basic); | 76 registry_factory.RegisterSchemeFactory("Basic", mock_factory_basic); |
77 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( | 77 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
78 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, | 78 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
79 gurl, BoundNetLog(), &handler)); | 79 gurl, NetLogWithSource(), &handler)); |
80 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, | 80 EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, |
81 registry_factory.CreateAuthHandlerFromString( | 81 registry_factory.CreateAuthHandlerFromString( |
82 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, | 82 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
83 BoundNetLog(), &handler)); | 83 NetLogWithSource(), &handler)); |
84 | 84 |
85 // Test multiple schemes | 85 // Test multiple schemes |
86 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); | 86 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest); |
87 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( | 87 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
88 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, | 88 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
89 gurl, BoundNetLog(), &handler)); | 89 gurl, NetLogWithSource(), &handler)); |
90 EXPECT_EQ(kDigestReturnCode, | 90 EXPECT_EQ(kDigestReturnCode, |
91 registry_factory.CreateAuthHandlerFromString( | 91 registry_factory.CreateAuthHandlerFromString( |
92 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, | 92 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
93 BoundNetLog(), &handler)); | 93 NetLogWithSource(), &handler)); |
94 | 94 |
95 // Test case-insensitivity | 95 // Test case-insensitivity |
96 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( | 96 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
97 "basic", HttpAuth::AUTH_SERVER, null_ssl_info, | 97 "basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
98 gurl, BoundNetLog(), &handler)); | 98 gurl, NetLogWithSource(), &handler)); |
99 | 99 |
100 // Test replacement of existing auth scheme | 100 // Test replacement of existing auth scheme |
101 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); | 101 registry_factory.RegisterSchemeFactory("Digest", mock_factory_digest_replace); |
102 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( | 102 EXPECT_EQ(kBasicReturnCode, registry_factory.CreateAuthHandlerFromString( |
103 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, | 103 "Basic", HttpAuth::AUTH_SERVER, null_ssl_info, |
104 gurl, BoundNetLog(), &handler)); | 104 gurl, NetLogWithSource(), &handler)); |
105 EXPECT_EQ(kDigestReturnCodeReplace, | 105 EXPECT_EQ(kDigestReturnCodeReplace, |
106 registry_factory.CreateAuthHandlerFromString( | 106 registry_factory.CreateAuthHandlerFromString( |
107 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, | 107 "Digest", HttpAuth::AUTH_SERVER, null_ssl_info, gurl, |
108 BoundNetLog(), &handler)); | 108 NetLogWithSource(), &handler)); |
109 } | 109 } |
110 | 110 |
111 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { | 111 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) { |
112 std::unique_ptr<HostResolver> host_resolver(new MockHostResolver()); | 112 std::unique_ptr<HostResolver> host_resolver(new MockHostResolver()); |
113 MockAllowHttpAuthPreferences http_auth_preferences; | 113 MockAllowHttpAuthPreferences http_auth_preferences; |
114 std::unique_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( | 114 std::unique_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory( |
115 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); | 115 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); |
116 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, | 116 http_auth_handler_factory->SetHttpAuthPreferences(kNegotiateAuthScheme, |
117 &http_auth_preferences); | 117 &http_auth_preferences); |
118 GURL server_origin("http://www.example.com"); | 118 GURL server_origin("http://www.example.com"); |
119 GURL proxy_origin("http://cache.example.com:3128"); | 119 GURL proxy_origin("http://cache.example.com:3128"); |
120 SSLInfo null_ssl_info; | 120 SSLInfo null_ssl_info; |
121 { | 121 { |
122 std::unique_ptr<HttpAuthHandler> handler; | 122 std::unique_ptr<HttpAuthHandler> handler; |
123 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 123 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
124 "Basic realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, | 124 "Basic realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, |
125 server_origin, BoundNetLog(), &handler); | 125 server_origin, NetLogWithSource(), &handler); |
126 EXPECT_THAT(rv, IsOk()); | 126 EXPECT_THAT(rv, IsOk()); |
127 ASSERT_FALSE(handler.get() == NULL); | 127 ASSERT_FALSE(handler.get() == NULL); |
128 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); | 128 EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, handler->auth_scheme()); |
129 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 129 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
130 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 130 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
131 EXPECT_FALSE(handler->encrypts_identity()); | 131 EXPECT_FALSE(handler->encrypts_identity()); |
132 EXPECT_FALSE(handler->is_connection_based()); | 132 EXPECT_FALSE(handler->is_connection_based()); |
133 } | 133 } |
134 { | 134 { |
135 std::unique_ptr<HttpAuthHandler> handler; | 135 std::unique_ptr<HttpAuthHandler> handler; |
136 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 136 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
137 "UNSUPPORTED realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, | 137 "UNSUPPORTED realm=\"FooBar\"", HttpAuth::AUTH_SERVER, null_ssl_info, |
138 server_origin, BoundNetLog(), &handler); | 138 server_origin, NetLogWithSource(), &handler); |
139 EXPECT_THAT(rv, IsError(ERR_UNSUPPORTED_AUTH_SCHEME)); | 139 EXPECT_THAT(rv, IsError(ERR_UNSUPPORTED_AUTH_SCHEME)); |
140 EXPECT_TRUE(handler.get() == NULL); | 140 EXPECT_TRUE(handler.get() == NULL); |
141 } | 141 } |
142 { | 142 { |
143 std::unique_ptr<HttpAuthHandler> handler; | 143 std::unique_ptr<HttpAuthHandler> handler; |
144 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 144 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
145 "Digest realm=\"FooBar\", nonce=\"xyz\"", HttpAuth::AUTH_PROXY, | 145 "Digest realm=\"FooBar\", nonce=\"xyz\"", HttpAuth::AUTH_PROXY, |
146 null_ssl_info, proxy_origin, BoundNetLog(), &handler); | 146 null_ssl_info, proxy_origin, NetLogWithSource(), &handler); |
147 EXPECT_THAT(rv, IsOk()); | 147 EXPECT_THAT(rv, IsOk()); |
148 ASSERT_FALSE(handler.get() == NULL); | 148 ASSERT_FALSE(handler.get() == NULL); |
149 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); | 149 EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, handler->auth_scheme()); |
150 EXPECT_STREQ("FooBar", handler->realm().c_str()); | 150 EXPECT_STREQ("FooBar", handler->realm().c_str()); |
151 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); | 151 EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target()); |
152 EXPECT_TRUE(handler->encrypts_identity()); | 152 EXPECT_TRUE(handler->encrypts_identity()); |
153 EXPECT_FALSE(handler->is_connection_based()); | 153 EXPECT_FALSE(handler->is_connection_based()); |
154 } | 154 } |
155 { | 155 { |
156 std::unique_ptr<HttpAuthHandler> handler; | 156 std::unique_ptr<HttpAuthHandler> handler; |
157 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 157 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
158 "NTLM", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, | 158 "NTLM", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, |
159 BoundNetLog(), &handler); | 159 NetLogWithSource(), &handler); |
160 EXPECT_THAT(rv, IsOk()); | 160 EXPECT_THAT(rv, IsOk()); |
161 ASSERT_FALSE(handler.get() == NULL); | 161 ASSERT_FALSE(handler.get() == NULL); |
162 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); | 162 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NTLM, handler->auth_scheme()); |
163 EXPECT_STREQ("", handler->realm().c_str()); | 163 EXPECT_STREQ("", handler->realm().c_str()); |
164 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 164 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
165 EXPECT_TRUE(handler->encrypts_identity()); | 165 EXPECT_TRUE(handler->encrypts_identity()); |
166 EXPECT_TRUE(handler->is_connection_based()); | 166 EXPECT_TRUE(handler->is_connection_based()); |
167 } | 167 } |
168 { | 168 { |
169 std::unique_ptr<HttpAuthHandler> handler; | 169 std::unique_ptr<HttpAuthHandler> handler; |
170 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( | 170 int rv = http_auth_handler_factory->CreateAuthHandlerFromString( |
171 "Negotiate", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, | 171 "Negotiate", HttpAuth::AUTH_SERVER, null_ssl_info, server_origin, |
172 BoundNetLog(), &handler); | 172 NetLogWithSource(), &handler); |
173 // Note the default factory doesn't support Kerberos on Android | 173 // Note the default factory doesn't support Kerberos on Android |
174 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) | 174 #if defined(USE_KERBEROS) && !defined(OS_ANDROID) |
175 EXPECT_THAT(rv, IsOk()); | 175 EXPECT_THAT(rv, IsOk()); |
176 ASSERT_FALSE(handler.get() == NULL); | 176 ASSERT_FALSE(handler.get() == NULL); |
177 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); | 177 EXPECT_EQ(HttpAuth::AUTH_SCHEME_NEGOTIATE, handler->auth_scheme()); |
178 EXPECT_STREQ("", handler->realm().c_str()); | 178 EXPECT_STREQ("", handler->realm().c_str()); |
179 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); | 179 EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target()); |
180 EXPECT_TRUE(handler->encrypts_identity()); | 180 EXPECT_TRUE(handler->encrypts_identity()); |
181 EXPECT_TRUE(handler->is_connection_based()); | 181 EXPECT_TRUE(handler->is_connection_based()); |
182 #else | 182 #else |
183 EXPECT_THAT(rv, IsError(ERR_UNSUPPORTED_AUTH_SCHEME)); | 183 EXPECT_THAT(rv, IsError(ERR_UNSUPPORTED_AUTH_SCHEME)); |
184 EXPECT_TRUE(handler.get() == NULL); | 184 EXPECT_TRUE(handler.get() == NULL); |
185 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) | 185 #endif // defined(USE_KERBEROS) && !defined(OS_ANDROID) |
186 } | 186 } |
187 } | 187 } |
188 | 188 |
189 } // namespace net | 189 } // namespace net |
OLD | NEW |