src/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/UploadTest.java

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.cronet_test_apk;
   6
   7 import android.test.suitebuilder.annotation.SmallTest;
   8
   9 import org.chromium.base.test.util.Feature;
  10 import org.chromium.net.HttpUrlRequest;
  11 import org.chromium.net.HttpUrlRequestListener;
  12
  13 import java.io.ByteArrayInputStream;
  14 import java.io.InputStream;
  15 import java.nio.channels.Channels;
  16 import java.nio.channels.ReadableByteChannel;
  17 import java.util.HashMap;
  18
  19 /**
  20  * Test fixture to test upload APIs.  Uses an in-process test server.
  21  */
  22 public class UploadTest extends CronetTestBase {
  23     private static final String UPLOAD_DATA = "Nifty upload data!";
  24     private static final String UPLOAD_CHANNEL_DATA = "Upload channel data";
  25
  26     private CronetTestActivity mActivity;
  27
  28     // @Override
  29     protected void setUp() throws Exception {
  30         super.setUp();
  31         mActivity = launchCronetTestApp();
  32         assertNotNull(mActivity);
  33         assertTrue(UploadTestServer.startUploadTestServer());
  34     }
  35
  36     private HttpUrlRequest createRequest(
  37             String url, HttpUrlRequestListener listener) {
  38         HashMap<String, String> headers = new HashMap<String, String>();
  39         return mActivity.mRequestFactory.createRequest(
  40                 url, HttpUrlRequest.REQUEST_PRIORITY_MEDIUM, headers, listener);
  41     }
  42
  43     /**
  44      * Sets request to have an upload channel containing the given data.
  45      * uploadDataLength should generally be uploadData.length(), unless a test
  46      * needs to get a read error.
  47      */
  48     private void setUploadChannel(HttpUrlRequest request,
  49                                   String contentType,
  50                                   String uploadData,
  51                                   int uploadDataLength) {
  52         InputStream uploadDataStream = new ByteArrayInputStream(
  53                 uploadData.getBytes());
  54         ReadableByteChannel uploadDataChannel =
  55                 Channels.newChannel(uploadDataStream);
  56         request.setUploadChannel(
  57                 contentType, uploadDataChannel, uploadDataLength);
  58     }
  59
  60     /**
  61      * Tests uploading an in-memory string.
  62      */
  63     @SmallTest
  64     @Feature({"Cronet"})
  65     public void testUploadData() throws Exception {
  66         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
  67         HttpUrlRequest request = createRequest(
  68                 UploadTestServer.getEchoBodyURL(), listener);
  69         request.setUploadData("text/plain", UPLOAD_DATA.getBytes("UTF8"));
  70         request.start();
  71         listener.blockForComplete();
  72
  73         assertEquals(200, listener.mHttpStatusCode);
  74         assertEquals(UPLOAD_DATA, listener.mResponseAsString);
  75     }
  76
  77     /**
  78      * Tests uploading an in-memory string with a redirect that preserves the
  79      * POST body.  This makes sure the body is correctly sent again.
  80      */
  81     @SmallTest
  82     @Feature({"Cronet"})
  83     public void testUploadDataWithRedirect() throws Exception {
  84         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
  85         HttpUrlRequest request = createRequest(
  86                 UploadTestServer.getRedirectToEchoBody(), listener);
  87         request.setUploadData("text/plain", UPLOAD_DATA.getBytes("UTF8"));
  88         request.start();
  89         listener.blockForComplete();
  90
  91         assertEquals(200, listener.mHttpStatusCode);
  92         assertEquals(UPLOAD_DATA, listener.mResponseAsString);
  93     }
  94
  95     /**
  96      * Tests Content-Type can be set when uploading an in-memory string.
  97      */
  98     @SmallTest
  99     @Feature({"Cronet"})
 100     public void testUploadDataContentType() throws Exception {
 101         String contentTypes[] = {"text/plain", "chicken/spicy"};
 102         for (String contentType : contentTypes) {
 103             TestHttpUrlRequestListener listener =
 104                     new TestHttpUrlRequestListener();
 105             HttpUrlRequest request = createRequest(
 106                     UploadTestServer.getEchoHeaderURL("Content-Type"),
 107                     listener);
 108             request.setUploadData(contentType, UPLOAD_DATA.getBytes("UTF8"));
 109             request.start();
 110             listener.blockForComplete();
 111
 112             assertEquals(200, listener.mHttpStatusCode);
 113             assertEquals(contentType, listener.mResponseAsString);
 114         }
 115     }
 116
 117     /**
 118      * Tests the default method when uploading.
 119      */
 120     @SmallTest
 121     @Feature({"Cronet"})
 122     public void testDefaultUploadMethod() throws Exception {
 123         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
 124         HttpUrlRequest request = createRequest(
 125                 UploadTestServer.getEchoMethodURL(), listener);
 126         request.setUploadData("text/plain", UPLOAD_DATA.getBytes("UTF8"));
 127         request.start();
 128         listener.blockForComplete();
 129
 130         assertEquals(200, listener.mHttpStatusCode);
 131         assertEquals("POST", listener.mResponseAsString);
 132     }
 133
 134     /**
 135      * Tests methods can be set when uploading.
 136      */
 137     @SmallTest
 138     @Feature({"Cronet"})
 139     public void testUploadMethods() throws Exception {
 140         String uploadMethods[] = {"POST", "PUT"};
 141         for (String uploadMethod : uploadMethods) {
 142             TestHttpUrlRequestListener listener =
 143                     new TestHttpUrlRequestListener();
 144             HttpUrlRequest request = createRequest(
 145                     UploadTestServer.getEchoMethodURL(), listener);
 146             request.setHttpMethod(uploadMethod);
 147             request.setUploadData("text/plain", UPLOAD_DATA.getBytes("UTF8"));
 148             request.start();
 149             listener.blockForComplete();
 150
 151             assertEquals(200, listener.mHttpStatusCode);
 152             assertEquals(uploadMethod, listener.mResponseAsString);
 153         }
 154     }
 155
 156     /**
 157      * Tests uploading from a channel.
 158      */
 159     @SmallTest
 160     @Feature({"Cronet"})
 161     public void testUploadChannel() throws Exception {
 162         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
 163         HttpUrlRequest request = createRequest(
 164                 UploadTestServer.getEchoBodyURL(), listener);
 165         setUploadChannel(request, "text/plain", UPLOAD_CHANNEL_DATA,
 166                          UPLOAD_CHANNEL_DATA.length());
 167         request.start();
 168         listener.blockForComplete();
 169
 170         assertEquals(200, listener.mHttpStatusCode);
 171         assertEquals(UPLOAD_CHANNEL_DATA, listener.mResponseAsString);
 172     }
 173
 174     /**
 175      * Tests uploading from a channel in the case a redirect preserves the post
 176      * body.  Since channels can't be rewound, the request fails when we try to
 177      * rewind it to send the second request.
 178      */
 179     @SmallTest
 180     @Feature({"Cronet"})
 181     public void testUploadChannelWithRedirect() throws Exception {
 182         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
 183         HttpUrlRequest request = createRequest(
 184                 UploadTestServer.getRedirectToEchoBody(), listener);
 185         setUploadChannel(request, "text/plain", UPLOAD_CHANNEL_DATA,
 186                          UPLOAD_CHANNEL_DATA.length());
 187         request.start();
 188         listener.blockForComplete();
 189
 190         assertEquals(0, listener.mHttpStatusCode);
 191         assertEquals(
 192                 "System error: net::ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED(-25)",
 193                 listener.mException.getMessage());
 194     }
 195
 196     /**
 197      * Tests uploading from a channel when there's a read error.  The body
 198      * should be 0-padded.
 199      */
 200     @SmallTest
 201     @Feature({"Cronet"})
 202     public void testUploadChannelWithReadError() throws Exception {
 203         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
 204         HttpUrlRequest request = createRequest(
 205                 UploadTestServer.getEchoBodyURL(), listener);
 206         setUploadChannel(request, "text/plain", UPLOAD_CHANNEL_DATA,
 207                          UPLOAD_CHANNEL_DATA.length() + 2);
 208         request.start();
 209         listener.blockForComplete();
 210
 211         assertEquals(200, listener.mHttpStatusCode);
 212         assertEquals(UPLOAD_CHANNEL_DATA + "\0\0", listener.mResponseAsString);
 213     }
 214
 215     /**
 216      * Tests Content-Type can be set when uploading from a channel.
 217      */
 218     @SmallTest
 219     @Feature({"Cronet"})
 220     public void testUploadChannelContentType() throws Exception {
 221         String contentTypes[] = {"text/plain", "chicken/spicy"};
 222         for (String contentType : contentTypes) {
 223             TestHttpUrlRequestListener listener =
 224                     new TestHttpUrlRequestListener();
 225             HttpUrlRequest request = createRequest(
 226                     UploadTestServer.getEchoHeaderURL("Content-Type"),
 227                                                       listener);
 228             setUploadChannel(request, contentType, UPLOAD_CHANNEL_DATA,
 229                              UPLOAD_CHANNEL_DATA.length());
 230             request.start();
 231             listener.blockForComplete();
 232
 233             assertEquals(200, listener.mHttpStatusCode);
 234             assertEquals(contentType, listener.mResponseAsString);
 235         }
 236     }
 237 }