TestBasicAuth xref

    1   /*
    2    * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/test/org/apache/commons/httpclient/auth/TestBasicAuth.java,v 1.9 2004/11/20 17:56:40 olegk Exp $
    3    * $Revision: 480424 $
    4    * $Date: 2006-11-29 06:56:49 +0100 (Wed, 29 Nov 2006) $
    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 480424 2006-11-29 05:56:49Z bayard $
    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 }