Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(129)

Side by Side Diff: net/http/http_auth_handler_factory_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698