1   /*
2    * $HeadURL: https://svn.apache.org/repos/asf/httpcomponents/oac.hc3x/trunk/src/test/org/apache/commons/httpclient/auth/TestBasicAuth.java $
3    * $Revision: 1425331 $
4    * $Date: 2012-12-22 19:29:41 +0100 (Sat, 22 Dec 2012) $
5    * ====================================================================
6    *
7    *  Licensed to the Apache Software Foundation (ASF) under one or more
8    *  contributor license agreements.  See the NOTICE file distributed with
9    *  this work for additional information regarding copyright ownership.
10   *  The ASF licenses this file to You under the Apache License, Version 2.0
11   *  (the "License"); you may not use this file except in compliance with
12   *  the License.  You may obtain a copy of the License at
13   *
14   *      http://www.apache.org/licenses/LICENSE-2.0
15   *
16   *  Unless required by applicable law or agreed to in writing, software
17   *  distributed under the License is distributed on an "AS IS" BASIS,
18   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19   *  See the License for the specific language governing permissions and
20   *  limitations under the License.
21   * ====================================================================
22   *
23   * This software consists of voluntary contributions made by many
24   * individuals on behalf of the Apache Software Foundation.  For more
25   * information on the Apache Software Foundation, please see
26   * <http://www.apache.org/>.
27   *
28   */
29  
30  package org.apache.commons.httpclient.auth;
31  
32  import java.io.IOException;
33  
34  import junit.framework.Test;
35  import junit.framework.TestSuite;
36  
37  import org.apache.commons.codec.binary.Base64;
38  import org.apache.commons.httpclient.EchoService;
39  import org.apache.commons.httpclient.FeedbackService;
40  import org.apache.commons.httpclient.Header;
41  import org.apache.commons.httpclient.HttpClientTestBase;
42  import org.apache.commons.httpclient.HttpState;
43  import org.apache.commons.httpclient.HttpStatus;
44  import org.apache.commons.httpclient.ProxyTestDecorator;
45  import org.apache.commons.httpclient.UsernamePasswordCredentials;
46  import org.apache.commons.httpclient.methods.GetMethod;
47  import org.apache.commons.httpclient.methods.HeadMethod;
48  import org.apache.commons.httpclient.methods.PostMethod;
49  import org.apache.commons.httpclient.methods.PutMethod;
50  import org.apache.commons.httpclient.methods.StringRequestEntity;
51  import org.apache.commons.httpclient.server.AuthRequestHandler;
52  import org.apache.commons.httpclient.server.HttpRequestHandlerChain;
53  import org.apache.commons.httpclient.server.HttpServiceHandler;
54  import org.apache.commons.httpclient.util.EncodingUtil;
55  
56  /***
57   * Basic authentication test cases.
58   *
59   * @author Oleg Kalnichevski
60   * 
61   * @version $Id: TestBasicAuth.java 608014 2008-01-02 05:48:53Z rolandw $
62   */
63  public class TestBasicAuth extends HttpClientTestBase {
64  
65      // ------------------------------------------------------------ Constructor
66      public TestBasicAuth(final String testName) throws IOException {
67          super(testName);
68      }
69  
70      // ------------------------------------------------------------------- Main
71      public static void main(String args[]) {
72          String[] testCaseName = { TestBasicAuth.class.getName() };
73          junit.textui.TestRunner.main(testCaseName);
74      }
75  
76      // ------------------------------------------------------- TestCase Methods
77  
78      public static Test suite() {
79          TestSuite suite = new TestSuite(TestBasicAuth.class);
80          ProxyTestDecorator.addTests(suite);
81          return suite;
82      }
83  
84      public void testBasicAuthenticationWithNoCreds() throws IOException {
85  
86          UsernamePasswordCredentials creds = 
87              new UsernamePasswordCredentials("testuser", "testpass");
88          
89          HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
90          handlerchain.appendHandler(new AuthRequestHandler(creds));
91          handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
92          
93          this.server.setRequestHandler(handlerchain);
94          GetMethod httpget = new GetMethod("/test/");
95          try {
96              this.client.executeMethod(httpget);
97              assertNotNull(httpget.getStatusLine());
98              assertEquals(HttpStatus.SC_UNAUTHORIZED, httpget.getStatusLine().getStatusCode());
99              AuthState authstate = httpget.getHostAuthState();
100             assertNotNull(authstate.getAuthScheme());
101             assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
102             assertEquals("test", authstate.getRealm());
103         } finally {
104             httpget.releaseConnection();
105         }
106     }
107 
108     public void testBasicAuthenticationWithNoCredsRetry() throws IOException {
109         UsernamePasswordCredentials creds = 
110             new UsernamePasswordCredentials("testuser", "testpass");
111         
112         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
113         handlerchain.appendHandler(new AuthRequestHandler(creds));
114         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
115         
116         this.server.setRequestHandler(handlerchain);
117 
118         GetMethod httpget = new GetMethod("/test/");
119         try {
120             this.client.executeMethod(httpget);
121             assertNotNull(httpget.getStatusLine());
122             assertEquals(HttpStatus.SC_UNAUTHORIZED, httpget.getStatusLine().getStatusCode());
123             AuthState authstate = httpget.getHostAuthState();
124             assertNotNull(authstate.getAuthScheme());
125             assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
126             assertEquals("test", authstate.getRealm());
127         } finally {
128             httpget.releaseConnection();
129         }
130         // now try with credentials
131         httpget = new GetMethod("/test/");
132         try {
133             this.client.getState().setCredentials(AuthScope.ANY, creds);
134             this.client.executeMethod(httpget);
135             assertNotNull(httpget.getStatusLine());
136             assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
137         } finally {
138             httpget.releaseConnection();
139         }
140     }
141     
142     public void testBasicAuthenticationWithNoRealm() {
143         String challenge = "Basic";
144         try {
145             AuthScheme authscheme = new BasicScheme();
146             authscheme.processChallenge(challenge);
147             fail("Should have thrown MalformedChallengeException");
148         } catch(MalformedChallengeException e) {
149             // expected
150         }
151     }
152 
153     public void testBasicAuthenticationWith88591Chars() throws Exception {
154         int[] germanChars = { 0xE4, 0x2D, 0xF6, 0x2D, 0xFc };
155         StringBuffer buffer = new StringBuffer();
156         for (int i = 0; i < germanChars.length; i++) {
157             buffer.append((char)germanChars[i]); 
158         }
159         
160         UsernamePasswordCredentials credentials = new UsernamePasswordCredentials("dh", buffer.toString());
161         assertEquals("Basic ZGg65C32Lfw=", 
162             BasicScheme.authenticate(credentials, "ISO-8859-1"));
163     }
164     
165     public void testBasicAuthenticationWithDefaultCreds() throws Exception {
166         UsernamePasswordCredentials creds = 
167             new UsernamePasswordCredentials("testuser", "testpass");
168         
169         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
170         handlerchain.appendHandler(new AuthRequestHandler(creds));
171         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
172 
173         HttpState state = new HttpState();
174         state.setCredentials(AuthScope.ANY, creds);
175         this.client.setState(state);
176         
177         this.server.setRequestHandler(handlerchain);
178 
179         GetMethod httpget = new GetMethod("/test/");
180         try {
181             this.client.executeMethod(httpget);
182         } finally {
183             httpget.releaseConnection();
184         }
185         assertNotNull(httpget.getStatusLine());
186         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
187         Header auth = httpget.getRequestHeader("Authorization");
188         assertNotNull(auth);
189         String expected = "Basic " + EncodingUtil.getAsciiString(
190             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
191         assertEquals(expected, auth.getValue());
192         AuthState authstate = httpget.getHostAuthState();
193         assertNotNull(authstate.getAuthScheme());
194         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
195         assertEquals("test", authstate.getRealm());
196     }
197 
198     public void testBasicAuthentication() throws Exception {
199         UsernamePasswordCredentials creds = 
200             new UsernamePasswordCredentials("testuser", "testpass");
201         
202         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
203         handlerchain.appendHandler(new AuthRequestHandler(creds));
204         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
205 
206         HttpState state = new HttpState();
207         AuthScope authscope = new AuthScope(
208             this.server.getLocalAddress(), 
209             this.server.getLocalPort(),
210             "test");
211         state.setCredentials(authscope, creds);
212         this.client.setState(state);
213 
214         this.server.setRequestHandler(handlerchain);
215 
216         GetMethod httpget = new GetMethod("/test/");
217         try {
218             this.client.executeMethod(httpget);
219         } finally {
220             httpget.releaseConnection();
221         }
222         assertNotNull(httpget.getStatusLine());
223         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
224         Header auth = httpget.getRequestHeader("Authorization");
225         assertNotNull(auth);
226         String expected = "Basic " + EncodingUtil.getAsciiString(
227             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
228         assertEquals(expected, auth.getValue());
229         AuthState authstate = httpget.getHostAuthState();
230         assertNotNull(authstate.getAuthScheme());
231         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
232         assertEquals("test", authstate.getRealm());
233     }
234 
235     public void testBasicAuthenticationWithInvalidCredentials() throws Exception {
236         UsernamePasswordCredentials creds = 
237             new UsernamePasswordCredentials("testuser", "testpass");
238         
239         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
240         handlerchain.appendHandler(new AuthRequestHandler(creds));
241         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
242 
243         HttpState state = new HttpState();
244         AuthScope authscope = new AuthScope(
245             this.server.getLocalAddress(), 
246             this.server.getLocalPort(),
247             "test");
248         state.setCredentials(authscope, new UsernamePasswordCredentials("test", "stuff"));
249         this.client.setState(state);
250 
251         this.server.setRequestHandler(handlerchain);
252         
253         GetMethod httpget = new GetMethod("/test/");
254         try {
255             this.client.executeMethod(httpget);
256         } finally {
257             httpget.releaseConnection();
258         }
259         assertNotNull(httpget.getStatusLine());
260         assertEquals(HttpStatus.SC_UNAUTHORIZED, httpget.getStatusLine().getStatusCode());
261         AuthState authstate = httpget.getHostAuthState();
262         assertNotNull(authstate.getAuthScheme());
263         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
264         assertEquals("test", authstate.getRealm());
265     }
266 
267     public void testBasicAuthenticationWithMutlipleRealms1() throws Exception {
268         UsernamePasswordCredentials creds = 
269             new UsernamePasswordCredentials("testuser", "testpass");
270         
271         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
272         handlerchain.appendHandler(new AuthRequestHandler(creds));
273         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
274 
275         HttpState state = new HttpState();
276         AuthScope realm1 = new AuthScope(
277             this.server.getLocalAddress(), 
278             this.server.getLocalPort(),
279             "test");
280         AuthScope realm2 = new AuthScope(
281             this.server.getLocalAddress(), 
282             this.server.getLocalPort(),
283             "test2");
284         state.setCredentials(realm1, new UsernamePasswordCredentials("testuser","testpass"));
285         state.setCredentials(realm2, new UsernamePasswordCredentials("testuser2","testpass2"));
286         this.client.setState(state);
287 
288         this.server.setRequestHandler(handlerchain);
289         
290         GetMethod httpget = new GetMethod("/test/");
291         try {
292             this.client.executeMethod(httpget);
293         } finally {
294             httpget.releaseConnection();
295         }
296         assertNotNull(httpget.getStatusLine());
297         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
298         Header auth = httpget.getRequestHeader("Authorization");
299         assertNotNull(auth);
300         String expected = "Basic " + EncodingUtil.getAsciiString(
301             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
302         assertEquals(expected, auth.getValue());
303         AuthState authstate = httpget.getHostAuthState();
304         assertNotNull(authstate.getAuthScheme());
305         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
306         assertEquals("test", authstate.getRealm());
307     }
308 
309     public void testBasicAuthenticationWithMutlipleRealms2() throws Exception {
310         UsernamePasswordCredentials creds = 
311             new UsernamePasswordCredentials("testuser2", "testpass2");
312         
313         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
314         handlerchain.appendHandler(new AuthRequestHandler(creds, "test2"));
315         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
316 
317         HttpState state = new HttpState();
318         AuthScope realm1 = new AuthScope(
319             this.server.getLocalAddress(), 
320             this.server.getLocalPort(),
321             "test");
322         AuthScope realm2 = new AuthScope(
323             this.server.getLocalAddress(), 
324             this.server.getLocalPort(),
325             "test2");
326         state.setCredentials(realm1, new UsernamePasswordCredentials("testuser","testpass"));
327         state.setCredentials(realm2, new UsernamePasswordCredentials("testuser2","testpass2"));
328         this.client.setState(state);
329 
330         this.server.setRequestHandler(handlerchain);
331         
332         GetMethod httpget = new GetMethod("/test2/");
333         try {
334             this.client.executeMethod(httpget);
335         } finally {
336             httpget.releaseConnection();
337         }
338         assertNotNull(httpget.getStatusLine());
339         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
340         Header auth = httpget.getRequestHeader("Authorization");
341         assertNotNull(auth);
342         String expected = "Basic " + EncodingUtil.getAsciiString(
343             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser2:testpass2")));
344         assertEquals(expected, auth.getValue());
345         AuthState authstate = httpget.getHostAuthState();
346         assertNotNull(authstate.getAuthScheme());
347         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
348         assertEquals("test2", authstate.getRealm());
349     }
350 
351     public void testPreemptiveAuthorizationTrueWithCreds() throws Exception {
352         UsernamePasswordCredentials creds = 
353             new UsernamePasswordCredentials("testuser", "testpass");
354         
355         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
356         handlerchain.appendHandler(new AuthRequestHandler(creds));
357         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
358 
359         HttpState state = new HttpState();
360         state.setCredentials(AuthScope.ANY, creds);
361         this.client.setState(state);
362         this.client.getParams().setAuthenticationPreemptive(true);
363         
364         this.server.setRequestHandler(handlerchain);
365 
366         GetMethod httpget = new GetMethod("/test/");
367         try {
368             this.client.executeMethod(httpget);
369         } finally {
370             httpget.releaseConnection();
371         }
372         assertNotNull(httpget.getStatusLine());
373         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
374         Header auth = httpget.getRequestHeader("Authorization");
375         assertNotNull(auth);
376         String expected = "Basic " + EncodingUtil.getAsciiString(
377             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
378         assertEquals(expected, auth.getValue());
379         AuthState authstate = httpget.getHostAuthState();
380         assertNotNull(authstate.getAuthScheme());
381         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
382         assertNull(authstate.getRealm());
383         assertTrue(authstate.isPreemptive());
384     }
385 
386     public void testPreemptiveAuthorizationTrueWithoutCreds() throws Exception {
387         UsernamePasswordCredentials creds = 
388             new UsernamePasswordCredentials("testuser", "testpass");
389         
390         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
391         handlerchain.appendHandler(new AuthRequestHandler(creds));
392         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
393 
394         HttpState state = new HttpState();
395         this.client.setState(state);
396         this.client.getParams().setAuthenticationPreemptive(true);
397         
398         this.server.setRequestHandler(handlerchain);
399 
400         GetMethod httpget = new GetMethod("/test/");
401         try {
402             this.client.executeMethod(httpget);
403         } finally {
404             httpget.releaseConnection();
405         }
406         assertNotNull(httpget.getStatusLine());
407         assertEquals(HttpStatus.SC_UNAUTHORIZED, httpget.getStatusLine().getStatusCode());
408         Header auth = httpget.getRequestHeader("Authorization");
409         assertNull(auth);
410         AuthState authstate = httpget.getHostAuthState();
411         assertNotNull(authstate.getAuthScheme());
412         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
413         assertNotNull(authstate.getRealm());
414         assertTrue(authstate.isPreemptive());
415     }
416 
417     public void testCustomAuthorizationHeader() throws Exception {
418         UsernamePasswordCredentials creds = 
419             new UsernamePasswordCredentials("testuser", "testpass");
420         
421         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
422         handlerchain.appendHandler(new AuthRequestHandler(creds));
423         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
424 
425         this.server.setRequestHandler(handlerchain);
426 
427         GetMethod httpget = new GetMethod("/test/");
428         String authResponse = "Basic " + EncodingUtil.getAsciiString(
429                 Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
430         httpget.addRequestHeader(new Header("Authorization", authResponse));
431         try {
432             this.client.executeMethod(httpget);
433         } finally {
434             httpget.releaseConnection();
435         }
436         assertNotNull(httpget.getStatusLine());
437         assertEquals(HttpStatus.SC_OK, httpget.getStatusLine().getStatusCode());
438     }
439     
440     public void testHeadBasicAuthentication() throws Exception {
441         UsernamePasswordCredentials creds = 
442             new UsernamePasswordCredentials("testuser", "testpass");
443         
444         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
445         handlerchain.appendHandler(new AuthRequestHandler(creds));
446         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
447 
448         HttpState state = new HttpState();
449         AuthScope authscope = new AuthScope(
450             this.server.getLocalAddress(), 
451             this.server.getLocalPort(),
452             "test");
453         state.setCredentials(authscope, creds);
454         this.client.setState(state);
455 
456         this.server.setRequestHandler(handlerchain);
457 
458         HeadMethod head = new HeadMethod("/test/");
459         try {
460             this.client.executeMethod(head);
461         } finally {
462             head.releaseConnection();
463         }
464         assertNotNull(head.getStatusLine());
465         assertEquals(HttpStatus.SC_OK, head.getStatusLine().getStatusCode());
466         Header auth = head.getRequestHeader("Authorization");
467         assertNotNull(auth);
468         String expected = "Basic " + EncodingUtil.getAsciiString(
469             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
470         assertEquals(expected, auth.getValue());
471         AuthState authstate = head.getHostAuthState();
472         assertNotNull(authstate.getAuthScheme());
473         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
474         assertEquals("test", authstate.getRealm());
475     }
476 
477     public void testPostBasicAuthentication() throws Exception {
478         UsernamePasswordCredentials creds = 
479             new UsernamePasswordCredentials("testuser", "testpass");
480         
481         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
482         handlerchain.appendHandler(new AuthRequestHandler(creds));
483         handlerchain.appendHandler(new HttpServiceHandler(new EchoService()));
484 
485         HttpState state = new HttpState();
486         AuthScope authscope = new AuthScope(
487             this.server.getLocalAddress(), 
488             this.server.getLocalPort(),
489             "test");
490         state.setCredentials(authscope, creds);
491         this.client.setState(state);
492 
493         this.server.setRequestHandler(handlerchain);
494 
495         PostMethod post = new PostMethod("/test/");
496         post.setRequestEntity(new StringRequestEntity("Test body", null, null));
497         try {
498             this.client.executeMethod(post);
499             assertEquals("Test body", post.getResponseBodyAsString());
500         } finally {
501             post.releaseConnection();
502         }
503         assertNotNull(post.getStatusLine());
504         assertEquals(HttpStatus.SC_OK, post.getStatusLine().getStatusCode());
505         Header auth = post.getRequestHeader("Authorization");
506         assertNotNull(auth);
507         String expected = "Basic " + EncodingUtil.getAsciiString(
508             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
509         assertEquals(expected, auth.getValue());
510         AuthState authstate = post.getHostAuthState();
511         assertNotNull(authstate.getAuthScheme());
512         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
513         assertEquals("test", authstate.getRealm());
514     }
515     
516     public void testPutBasicAuthentication() throws Exception {
517         UsernamePasswordCredentials creds = 
518             new UsernamePasswordCredentials("testuser", "testpass");
519         
520         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
521         handlerchain.appendHandler(new AuthRequestHandler(creds));
522         handlerchain.appendHandler(new HttpServiceHandler(new EchoService()));
523 
524         HttpState state = new HttpState();
525         AuthScope authscope = new AuthScope(
526             this.server.getLocalAddress(), 
527             this.server.getLocalPort(),
528             "test");
529         state.setCredentials(authscope, creds);
530         this.client.setState(state);
531 
532         this.server.setRequestHandler(handlerchain);
533 
534         PutMethod put = new PutMethod("/test/");
535         put.setRequestEntity(new StringRequestEntity("Test body", null, null));
536         try {
537             this.client.executeMethod(put);
538             assertEquals("Test body", put.getResponseBodyAsString());
539         } finally {
540             put.releaseConnection();
541         }
542         assertNotNull(put.getStatusLine());
543         assertEquals(HttpStatus.SC_OK, put.getStatusLine().getStatusCode());
544         Header auth = put.getRequestHeader("Authorization");
545         assertNotNull(auth);
546         String expected = "Basic " + EncodingUtil.getAsciiString(
547             Base64.encodeBase64(EncodingUtil.getAsciiBytes("testuser:testpass")));
548         assertEquals(expected, auth.getValue());
549         AuthState authstate = put.getHostAuthState();
550         assertNotNull(authstate.getAuthScheme());
551         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
552         assertEquals("test", authstate.getRealm());
553     }
554 
555     public void testPreemptiveAuthorizationFailure() throws Exception {
556         UsernamePasswordCredentials creds = 
557             new UsernamePasswordCredentials("testuser", "testpass");
558         UsernamePasswordCredentials wrongcreds = 
559             new UsernamePasswordCredentials("testuser", "garbage");
560         
561         HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
562         handlerchain.appendHandler(new AuthRequestHandler(creds));
563         handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
564 
565         HttpState state = new HttpState();
566         state.setCredentials(AuthScope.ANY, wrongcreds);
567         this.client.setState(state);
568         this.client.getParams().setAuthenticationPreemptive(true);
569         
570         this.server.setRequestHandler(handlerchain);
571 
572         GetMethod httpget = new GetMethod("/test/");
573         try {
574             this.client.executeMethod(httpget);
575         } finally {
576             httpget.releaseConnection();
577         }
578         assertNotNull(httpget.getStatusLine());
579         assertEquals(HttpStatus.SC_UNAUTHORIZED, httpget.getStatusLine().getStatusCode());
580         AuthState authstate = httpget.getHostAuthState();
581         assertNotNull(authstate.getAuthScheme());
582         assertTrue(authstate.getAuthScheme() instanceof BasicScheme);
583         assertEquals("test", authstate.getRealm());
584         assertTrue(authstate.isPreemptive());
585     }
586     
587 }