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