Craig Citro | 15744b1 | 2015-03-02 13:34:32 -0800 | [diff] [blame] | 1 | #!/usr/bin/env python |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 2 | # |
Craig Citro | 751b7fb | 2014-09-23 11:20:38 -0700 | [diff] [blame] | 3 | # Copyright 2014 Google Inc. All Rights Reserved. |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | |
| 17 | """Http tests |
| 18 | |
John Asmuth | 864311d | 2014-04-24 15:46:08 -0400 | [diff] [blame] | 19 | Unit tests for the googleapiclient.http. |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 20 | """ |
INADA Naoki | d898a37 | 2015-03-04 03:52:46 +0900 | [diff] [blame] | 21 | from __future__ import absolute_import |
| 22 | from six.moves import range |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 23 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 24 | __author__ = "jcgregorio@google.com (Joe Gregorio)" |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 25 | |
Pat Ferate | c605087 | 2015-03-03 18:24:59 -0800 | [diff] [blame] | 26 | from six import PY3 |
Pat Ferate | ed9affd | 2015-03-03 16:03:15 -0800 | [diff] [blame] | 27 | from six import BytesIO, StringIO |
| 28 | from io import FileIO |
Pat Ferate | d5b61bd | 2015-03-03 16:04:11 -0800 | [diff] [blame] | 29 | from six.moves.urllib.parse import urlencode |
Pat Ferate | ed9affd | 2015-03-03 16:03:15 -0800 | [diff] [blame] | 30 | |
Joe Gregorio | 7cbceab | 2011-06-27 10:46:54 -0400 | [diff] [blame] | 31 | # Do not remove the httplib2 import |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 32 | import json |
Joe Gregorio | 7cbceab | 2011-06-27 10:46:54 -0400 | [diff] [blame] | 33 | import httplib2 |
Xiaofei Wang | 20b6758 | 2019-07-17 11:16:53 -0700 | [diff] [blame] | 34 | import io |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 35 | import logging |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 36 | import mock |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 37 | import os |
Pat Ferate | 497a90f | 2015-03-09 09:52:54 -0700 | [diff] [blame] | 38 | import unittest2 as unittest |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 39 | import random |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 40 | import socket |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 41 | import ssl |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 42 | import time |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 43 | |
John Asmuth | 864311d | 2014-04-24 15:46:08 -0400 | [diff] [blame] | 44 | from googleapiclient.discovery import build |
| 45 | from googleapiclient.errors import BatchError |
| 46 | from googleapiclient.errors import HttpError |
| 47 | from googleapiclient.errors import InvalidChunkSizeError |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 48 | from googleapiclient.http import build_http |
John Asmuth | 864311d | 2014-04-24 15:46:08 -0400 | [diff] [blame] | 49 | from googleapiclient.http import BatchHttpRequest |
| 50 | from googleapiclient.http import HttpMock |
| 51 | from googleapiclient.http import HttpMockSequence |
| 52 | from googleapiclient.http import HttpRequest |
| 53 | from googleapiclient.http import MAX_URI_LENGTH |
| 54 | from googleapiclient.http import MediaFileUpload |
| 55 | from googleapiclient.http import MediaInMemoryUpload |
| 56 | from googleapiclient.http import MediaIoBaseDownload |
| 57 | from googleapiclient.http import MediaIoBaseUpload |
| 58 | from googleapiclient.http import MediaUpload |
| 59 | from googleapiclient.http import _StreamSlice |
| 60 | from googleapiclient.http import set_user_agent |
| 61 | from googleapiclient.model import JsonModel |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 62 | from oauth2client.client import Credentials |
| 63 | |
| 64 | |
| 65 | class MockCredentials(Credentials): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 66 | """Mock class for all Credentials objects.""" |
Jon Wayne Parrott | d3a5cf4 | 2017-06-19 17:55:04 -0700 | [diff] [blame] | 67 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 68 | def __init__(self, bearer_token, expired=False): |
| 69 | super(MockCredentials, self).__init__() |
| 70 | self._authorized = 0 |
| 71 | self._refreshed = 0 |
| 72 | self._applied = 0 |
| 73 | self._bearer_token = bearer_token |
| 74 | self._access_token_expired = expired |
Jon Wayne Parrott | 20e6135 | 2018-01-18 09:16:37 -0800 | [diff] [blame] | 75 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 76 | @property |
| 77 | def access_token(self): |
| 78 | return self._bearer_token |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 79 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 80 | @property |
| 81 | def access_token_expired(self): |
| 82 | return self._access_token_expired |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 83 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 84 | def authorize(self, http): |
| 85 | self._authorized += 1 |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 86 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 87 | request_orig = http.request |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 88 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 89 | # The closure that will replace 'httplib2.Http.request'. |
| 90 | def new_request( |
| 91 | uri, |
| 92 | method="GET", |
| 93 | body=None, |
| 94 | headers=None, |
| 95 | redirections=httplib2.DEFAULT_MAX_REDIRECTS, |
| 96 | connection_type=None, |
| 97 | ): |
| 98 | # Modify the request headers to add the appropriate |
| 99 | # Authorization header. |
| 100 | if headers is None: |
| 101 | headers = {} |
| 102 | self.apply(headers) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 103 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 104 | resp, content = request_orig( |
| 105 | uri, method, body, headers, redirections, connection_type |
| 106 | ) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 107 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 108 | return resp, content |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 109 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 110 | # Replace the request method with our own closure. |
| 111 | http.request = new_request |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 112 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 113 | # Set credentials as a property of the request method. |
| 114 | setattr(http.request, "credentials", self) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 115 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 116 | return http |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 117 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 118 | def refresh(self, http): |
| 119 | self._refreshed += 1 |
| 120 | |
| 121 | def apply(self, headers): |
| 122 | self._applied += 1 |
| 123 | headers["authorization"] = self._bearer_token + " " + str(self._refreshed) |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 124 | |
| 125 | |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 126 | class HttpMockWithErrors(object): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 127 | def __init__(self, num_errors, success_json, success_data): |
| 128 | self.num_errors = num_errors |
| 129 | self.success_json = success_json |
| 130 | self.success_data = success_data |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 131 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 132 | def request(self, *args, **kwargs): |
| 133 | if not self.num_errors: |
| 134 | return httplib2.Response(self.success_json), self.success_data |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 135 | elif self.num_errors == 5 and PY3: |
| 136 | ex = ConnectionResetError # noqa: F821 |
| 137 | elif self.num_errors == 4: |
| 138 | ex = httplib2.ServerNotFoundError() |
| 139 | elif self.num_errors == 3: |
| 140 | ex = socket.error() |
| 141 | ex.errno = socket.errno.EPIPE |
| 142 | elif self.num_errors == 2: |
| 143 | ex = ssl.SSLError() |
Thomas Bonfort | 88ab76b | 2016-04-19 08:48:53 +0200 | [diff] [blame] | 144 | else: |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 145 | # Initialize the timeout error code to the platform's error code. |
| 146 | try: |
| 147 | # For Windows: |
| 148 | ex = socket.error() |
| 149 | ex.errno = socket.errno.WSAETIMEDOUT |
| 150 | except AttributeError: |
| 151 | # For Linux/Mac: |
| 152 | if PY3: |
| 153 | ex = socket.timeout() |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 154 | else: |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 155 | ex = socket.error() |
| 156 | ex.errno = socket.errno.ETIMEDOUT |
| 157 | |
| 158 | self.num_errors -= 1 |
| 159 | raise ex |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 160 | |
| 161 | |
| 162 | class HttpMockWithNonRetriableErrors(object): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 163 | def __init__(self, num_errors, success_json, success_data): |
| 164 | self.num_errors = num_errors |
| 165 | self.success_json = success_json |
| 166 | self.success_data = success_data |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 167 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 168 | def request(self, *args, **kwargs): |
| 169 | if not self.num_errors: |
| 170 | return httplib2.Response(self.success_json), self.success_data |
| 171 | else: |
| 172 | self.num_errors -= 1 |
| 173 | ex = socket.error() |
| 174 | # set errno to a non-retriable value |
| 175 | try: |
| 176 | # For Windows: |
Aaron Niskode-Dossett | ae9cd99 | 2021-01-13 04:58:15 -0600 | [diff] [blame^] | 177 | ex.errno = socket.errno.WSAEHOSTUNREACH |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 178 | except AttributeError: |
| 179 | # For Linux/Mac: |
Aaron Niskode-Dossett | ae9cd99 | 2021-01-13 04:58:15 -0600 | [diff] [blame^] | 180 | ex.errno = socket.errno.EHOSTUNREACH |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 181 | # Now raise the correct timeout error. |
| 182 | raise ex |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 183 | |
| 184 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 185 | DATA_DIR = os.path.join(os.path.dirname(__file__), "data") |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 186 | |
| 187 | |
| 188 | def datafile(filename): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 189 | return os.path.join(DATA_DIR, filename) |
| 190 | |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 191 | |
Ondrej Medek | b86bfc9 | 2018-01-19 18:53:50 +0100 | [diff] [blame] | 192 | def _postproc_none(*kwargs): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 193 | pass |
Ondrej Medek | b86bfc9 | 2018-01-19 18:53:50 +0100 | [diff] [blame] | 194 | |
| 195 | |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 196 | class TestUserAgent(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 197 | def test_set_user_agent(self): |
| 198 | http = HttpMockSequence([({"status": "200"}, "echo_request_headers")]) |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 199 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 200 | http = set_user_agent(http, "my_app/5.5") |
| 201 | resp, content = http.request("http://example.com") |
| 202 | self.assertEqual("my_app/5.5", content["user-agent"]) |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 203 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 204 | def test_set_user_agent_nested(self): |
| 205 | http = HttpMockSequence([({"status": "200"}, "echo_request_headers")]) |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 206 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 207 | http = set_user_agent(http, "my_app/5.5") |
| 208 | http = set_user_agent(http, "my_library/0.1") |
| 209 | resp, content = http.request("http://example.com") |
| 210 | self.assertEqual("my_app/5.5 my_library/0.1", content["user-agent"]) |
Joe Gregorio | 6bcbcea | 2011-03-10 15:26:05 -0500 | [diff] [blame] | 211 | |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 212 | |
| 213 | class TestMediaUpload(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 214 | def test_media_file_upload_closes_fd_in___del__(self): |
| 215 | file_desc = mock.Mock(spec=io.TextIOWrapper) |
| 216 | opener = mock.mock_open(file_desc) |
| 217 | if PY3: |
| 218 | with mock.patch("builtins.open", return_value=opener): |
| 219 | upload = MediaFileUpload(datafile("test_close"), mimetype="text/plain") |
| 220 | else: |
| 221 | with mock.patch("__builtin__.open", return_value=opener): |
| 222 | upload = MediaFileUpload(datafile("test_close"), mimetype="text/plain") |
| 223 | self.assertIs(upload.stream(), file_desc) |
| 224 | del upload |
| 225 | file_desc.close.assert_called_once_with() |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 226 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 227 | def test_media_file_upload_mimetype_detection(self): |
| 228 | upload = MediaFileUpload(datafile("small.png")) |
| 229 | self.assertEqual("image/png", upload.mimetype()) |
Xiaofei Wang | 20b6758 | 2019-07-17 11:16:53 -0700 | [diff] [blame] | 230 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 231 | upload = MediaFileUpload(datafile("empty")) |
| 232 | self.assertEqual("application/octet-stream", upload.mimetype()) |
Nam T. Nguyen | dc13631 | 2015-12-01 10:18:56 -0800 | [diff] [blame] | 233 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 234 | def test_media_file_upload_to_from_json(self): |
| 235 | upload = MediaFileUpload(datafile("small.png"), chunksize=500, resumable=True) |
| 236 | self.assertEqual("image/png", upload.mimetype()) |
| 237 | self.assertEqual(190, upload.size()) |
| 238 | self.assertEqual(True, upload.resumable()) |
| 239 | self.assertEqual(500, upload.chunksize()) |
| 240 | self.assertEqual(b"PNG", upload.getbytes(1, 3)) |
Nam T. Nguyen | dc13631 | 2015-12-01 10:18:56 -0800 | [diff] [blame] | 241 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 242 | json = upload.to_json() |
| 243 | new_upload = MediaUpload.new_from_json(json) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 244 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 245 | self.assertEqual("image/png", new_upload.mimetype()) |
| 246 | self.assertEqual(190, new_upload.size()) |
| 247 | self.assertEqual(True, new_upload.resumable()) |
| 248 | self.assertEqual(500, new_upload.chunksize()) |
| 249 | self.assertEqual(b"PNG", new_upload.getbytes(1, 3)) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 250 | |
Anthonios Partheniou | 2c6d029 | 2020-12-09 18:56:01 -0500 | [diff] [blame] | 251 | def test_media_file_upload_raises_on_file_not_found(self): |
| 252 | with self.assertRaises(FileNotFoundError): |
| 253 | MediaFileUpload(datafile("missing.png")) |
| 254 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 255 | def test_media_file_upload_raises_on_invalid_chunksize(self): |
| 256 | self.assertRaises( |
| 257 | InvalidChunkSizeError, |
| 258 | MediaFileUpload, |
| 259 | datafile("small.png"), |
| 260 | mimetype="image/png", |
| 261 | chunksize=-2, |
| 262 | resumable=True, |
| 263 | ) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 264 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 265 | def test_media_inmemory_upload(self): |
| 266 | media = MediaInMemoryUpload( |
| 267 | b"abcdef", mimetype="text/plain", chunksize=10, resumable=True |
| 268 | ) |
| 269 | self.assertEqual("text/plain", media.mimetype()) |
| 270 | self.assertEqual(10, media.chunksize()) |
| 271 | self.assertTrue(media.resumable()) |
| 272 | self.assertEqual(b"bc", media.getbytes(1, 2)) |
| 273 | self.assertEqual(6, media.size()) |
Joe Gregorio | c80ac9d | 2012-08-21 14:09:09 -0400 | [diff] [blame] | 274 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 275 | def test_http_request_to_from_json(self): |
| 276 | http = build_http() |
| 277 | media_upload = MediaFileUpload( |
| 278 | datafile("small.png"), chunksize=500, resumable=True |
| 279 | ) |
| 280 | req = HttpRequest( |
| 281 | http, |
| 282 | _postproc_none, |
| 283 | "http://example.com", |
| 284 | method="POST", |
| 285 | body="{}", |
| 286 | headers={"content-type": 'multipart/related; boundary="---flubber"'}, |
| 287 | methodId="foo", |
| 288 | resumable=media_upload, |
| 289 | ) |
Ali Afshar | 1cb6b67 | 2012-03-12 08:46:14 -0400 | [diff] [blame] | 290 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 291 | json = req.to_json() |
| 292 | new_req = HttpRequest.from_json(json, http, _postproc_none) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 293 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 294 | self.assertEqual( |
| 295 | {"content-type": 'multipart/related; boundary="---flubber"'}, |
| 296 | new_req.headers, |
| 297 | ) |
| 298 | self.assertEqual("http://example.com", new_req.uri) |
| 299 | self.assertEqual("{}", new_req.body) |
| 300 | self.assertEqual(http, new_req.http) |
| 301 | self.assertEqual(media_upload.to_json(), new_req.resumable.to_json()) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 302 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 303 | self.assertEqual(random.random, new_req._rand) |
| 304 | self.assertEqual(time.sleep, new_req._sleep) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 305 | |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 306 | |
| 307 | class TestMediaIoBaseUpload(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 308 | def test_media_io_base_upload_from_file_io(self): |
| 309 | fd = FileIO(datafile("small.png"), "r") |
| 310 | upload = MediaIoBaseUpload( |
| 311 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 312 | ) |
| 313 | self.assertEqual("image/png", upload.mimetype()) |
| 314 | self.assertEqual(190, upload.size()) |
| 315 | self.assertEqual(True, upload.resumable()) |
| 316 | self.assertEqual(500, upload.chunksize()) |
| 317 | self.assertEqual(b"PNG", upload.getbytes(1, 3)) |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 318 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 319 | def test_media_io_base_upload_from_file_object(self): |
| 320 | f = open(datafile("small.png"), "rb") |
| 321 | upload = MediaIoBaseUpload( |
| 322 | fd=f, mimetype="image/png", chunksize=500, resumable=True |
| 323 | ) |
| 324 | self.assertEqual("image/png", upload.mimetype()) |
| 325 | self.assertEqual(190, upload.size()) |
| 326 | self.assertEqual(True, upload.resumable()) |
| 327 | self.assertEqual(500, upload.chunksize()) |
| 328 | self.assertEqual(b"PNG", upload.getbytes(1, 3)) |
| 329 | f.close() |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 330 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 331 | def test_media_io_base_upload_serializable(self): |
| 332 | f = open(datafile("small.png"), "rb") |
| 333 | upload = MediaIoBaseUpload(fd=f, mimetype="image/png") |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 334 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 335 | try: |
| 336 | json = upload.to_json() |
| 337 | self.fail("MediaIoBaseUpload should not be serializable.") |
| 338 | except NotImplementedError: |
| 339 | pass |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 340 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 341 | @unittest.skipIf(PY3, "Strings and Bytes are different types") |
| 342 | def test_media_io_base_upload_from_string_io(self): |
| 343 | f = open(datafile("small.png"), "rb") |
| 344 | fd = StringIO(f.read()) |
| 345 | f.close() |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 346 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 347 | upload = MediaIoBaseUpload( |
| 348 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 349 | ) |
| 350 | self.assertEqual("image/png", upload.mimetype()) |
| 351 | self.assertEqual(190, upload.size()) |
| 352 | self.assertEqual(True, upload.resumable()) |
| 353 | self.assertEqual(500, upload.chunksize()) |
| 354 | self.assertEqual(b"PNG", upload.getbytes(1, 3)) |
| 355 | f.close() |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 356 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 357 | def test_media_io_base_upload_from_bytes(self): |
| 358 | f = open(datafile("small.png"), "rb") |
| 359 | fd = BytesIO(f.read()) |
| 360 | upload = MediaIoBaseUpload( |
| 361 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 362 | ) |
| 363 | self.assertEqual("image/png", upload.mimetype()) |
| 364 | self.assertEqual(190, upload.size()) |
| 365 | self.assertEqual(True, upload.resumable()) |
| 366 | self.assertEqual(500, upload.chunksize()) |
| 367 | self.assertEqual(b"PNG", upload.getbytes(1, 3)) |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 368 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 369 | def test_media_io_base_upload_raises_on_invalid_chunksize(self): |
| 370 | f = open(datafile("small.png"), "rb") |
| 371 | fd = BytesIO(f.read()) |
| 372 | self.assertRaises( |
| 373 | InvalidChunkSizeError, |
| 374 | MediaIoBaseUpload, |
| 375 | fd, |
| 376 | "image/png", |
| 377 | chunksize=-2, |
| 378 | resumable=True, |
| 379 | ) |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 380 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 381 | def test_media_io_base_upload_streamable(self): |
| 382 | fd = BytesIO(b"stuff") |
| 383 | upload = MediaIoBaseUpload( |
| 384 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 385 | ) |
| 386 | self.assertEqual(True, upload.has_stream()) |
| 387 | self.assertEqual(fd, upload.stream()) |
Joe Gregorio | c80ac9d | 2012-08-21 14:09:09 -0400 | [diff] [blame] | 388 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 389 | def test_media_io_base_next_chunk_retries(self): |
| 390 | f = open(datafile("small.png"), "rb") |
| 391 | fd = BytesIO(f.read()) |
| 392 | upload = MediaIoBaseUpload( |
| 393 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 394 | ) |
Joe Gregorio | c80ac9d | 2012-08-21 14:09:09 -0400 | [diff] [blame] | 395 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 396 | # Simulate errors for both the request that creates the resumable upload |
| 397 | # and the upload itself. |
| 398 | http = HttpMockSequence( |
| 399 | [ |
| 400 | ({"status": "500"}, ""), |
| 401 | ({"status": "500"}, ""), |
| 402 | ({"status": "503"}, ""), |
| 403 | ({"status": "200", "location": "location"}, ""), |
| 404 | ({"status": "403"}, USER_RATE_LIMIT_EXCEEDED_RESPONSE), |
| 405 | ({"status": "403"}, RATE_LIMIT_EXCEEDED_RESPONSE), |
| 406 | ({"status": "429"}, ""), |
| 407 | ({"status": "200"}, "{}"), |
| 408 | ] |
| 409 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 410 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 411 | model = JsonModel() |
| 412 | uri = u"https://www.googleapis.com/someapi/v1/upload/?foo=bar" |
| 413 | method = u"POST" |
| 414 | request = HttpRequest( |
| 415 | http, model.response, uri, method=method, headers={}, resumable=upload |
| 416 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 417 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 418 | sleeptimes = [] |
| 419 | request._sleep = lambda x: sleeptimes.append(x) |
| 420 | request._rand = lambda: 10 |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 421 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 422 | request.execute(num_retries=3) |
| 423 | self.assertEqual([20, 40, 80, 20, 40, 80], sleeptimes) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 424 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 425 | def test_media_io_base_next_chunk_no_retry_403_not_configured(self): |
| 426 | fd = BytesIO(b"i am png") |
| 427 | upload = MediaIoBaseUpload( |
| 428 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 429 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 430 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 431 | http = HttpMockSequence( |
| 432 | [({"status": "403"}, NOT_CONFIGURED_RESPONSE), ({"status": "200"}, "{}")] |
| 433 | ) |
Zhihao Yuan | cc6d398 | 2016-07-27 11:40:45 -0500 | [diff] [blame] | 434 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 435 | model = JsonModel() |
| 436 | uri = u"https://www.googleapis.com/someapi/v1/upload/?foo=bar" |
| 437 | method = u"POST" |
| 438 | request = HttpRequest( |
| 439 | http, model.response, uri, method=method, headers={}, resumable=upload |
| 440 | ) |
Zhihao Yuan | cc6d398 | 2016-07-27 11:40:45 -0500 | [diff] [blame] | 441 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 442 | request._rand = lambda: 1.0 |
| 443 | request._sleep = mock.MagicMock() |
Zhihao Yuan | cc6d398 | 2016-07-27 11:40:45 -0500 | [diff] [blame] | 444 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 445 | with self.assertRaises(HttpError): |
| 446 | request.execute(num_retries=3) |
| 447 | request._sleep.assert_not_called() |
Zhihao Yuan | cc6d398 | 2016-07-27 11:40:45 -0500 | [diff] [blame] | 448 | |
Joe Gregorio | 910b9b1 | 2012-06-12 09:36:30 -0400 | [diff] [blame] | 449 | |
Bu Sun Kim | af6035f | 2020-10-20 16:36:04 -0600 | [diff] [blame] | 450 | def test_media_io_base_empty_file(self): |
| 451 | fd = BytesIO() |
| 452 | upload = MediaIoBaseUpload( |
| 453 | fd=fd, mimetype="image/png", chunksize=500, resumable=True |
| 454 | ) |
| 455 | |
| 456 | http = HttpMockSequence( |
| 457 | [ |
| 458 | ({"status": "200", "location": "https://www.googleapis.com/someapi/v1/upload?foo=bar"}, "{}"), |
| 459 | ({"status": "200", "location": "https://www.googleapis.com/someapi/v1/upload?foo=bar"}, "{}") |
| 460 | ] |
| 461 | ) |
| 462 | |
| 463 | model = JsonModel() |
| 464 | uri = u"https://www.googleapis.com/someapi/v1/upload/?foo=bar" |
| 465 | method = u"POST" |
| 466 | request = HttpRequest( |
| 467 | http, model.response, uri, method=method, headers={}, resumable=upload |
| 468 | ) |
| 469 | |
| 470 | request.execute() |
| 471 | |
| 472 | # Check that "Content-Range" header is not set in the PUT request |
| 473 | self.assertTrue("Content-Range" not in http.request_sequence[-1][-1]) |
| 474 | self.assertEqual("0", http.request_sequence[-1][-1]["Content-Length"]) |
| 475 | |
| 476 | |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 477 | class TestMediaIoBaseDownload(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 478 | def setUp(self): |
| 479 | http = HttpMock(datafile("zoo.json"), {"status": "200"}) |
| 480 | zoo = build("zoo", "v1", http=http) |
| 481 | self.request = zoo.animals().get_media(name="Lion") |
| 482 | self.fd = BytesIO() |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 483 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 484 | def test_media_io_base_download(self): |
| 485 | self.request.http = HttpMockSequence( |
| 486 | [ |
| 487 | ({"status": "200", "content-range": "0-2/5"}, b"123"), |
| 488 | ({"status": "200", "content-range": "3-4/5"}, b"45"), |
| 489 | ] |
| 490 | ) |
| 491 | self.assertEqual(True, self.request.http.follow_redirects) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 492 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 493 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 494 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 495 | self.assertEqual(self.fd, download._fd) |
| 496 | self.assertEqual(3, download._chunksize) |
| 497 | self.assertEqual(0, download._progress) |
| 498 | self.assertEqual(None, download._total_size) |
| 499 | self.assertEqual(False, download._done) |
| 500 | self.assertEqual(self.request.uri, download._uri) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 501 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 502 | status, done = download.next_chunk() |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 503 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 504 | self.assertEqual(self.fd.getvalue(), b"123") |
| 505 | self.assertEqual(False, done) |
| 506 | self.assertEqual(3, download._progress) |
| 507 | self.assertEqual(5, download._total_size) |
| 508 | self.assertEqual(3, status.resumable_progress) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 509 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 510 | status, done = download.next_chunk() |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 511 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 512 | self.assertEqual(self.fd.getvalue(), b"12345") |
| 513 | self.assertEqual(True, done) |
| 514 | self.assertEqual(5, download._progress) |
| 515 | self.assertEqual(5, download._total_size) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 516 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 517 | def test_media_io_base_download_custom_request_headers(self): |
| 518 | self.request.http = HttpMockSequence( |
| 519 | [ |
| 520 | ( |
| 521 | {"status": "200", "content-range": "0-2/5"}, |
| 522 | "echo_request_headers_as_json", |
| 523 | ), |
| 524 | ( |
| 525 | {"status": "200", "content-range": "3-4/5"}, |
| 526 | "echo_request_headers_as_json", |
| 527 | ), |
| 528 | ] |
| 529 | ) |
| 530 | self.assertEqual(True, self.request.http.follow_redirects) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 531 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 532 | self.request.headers["Cache-Control"] = "no-store" |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 533 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 534 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 535 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 536 | self.assertEqual(download._headers.get("Cache-Control"), "no-store") |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 537 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 538 | status, done = download.next_chunk() |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 539 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 540 | result = json.loads(self.fd.getvalue().decode("utf-8")) |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 541 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 542 | # assert that that the header we added to the original request is |
| 543 | # sent up to the server on each call to next_chunk |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 544 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 545 | self.assertEqual(result.get("Cache-Control"), "no-store") |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 546 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 547 | download._fd = self.fd = BytesIO() |
| 548 | status, done = download.next_chunk() |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 549 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 550 | result = json.loads(self.fd.getvalue().decode("utf-8")) |
| 551 | self.assertEqual(result.get("Cache-Control"), "no-store") |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 552 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 553 | def test_media_io_base_download_handle_redirects(self): |
| 554 | self.request.http = HttpMockSequence( |
| 555 | [ |
| 556 | ( |
| 557 | { |
| 558 | "status": "200", |
| 559 | "content-location": "https://secure.example.net/lion", |
| 560 | }, |
| 561 | b"", |
| 562 | ), |
| 563 | ({"status": "200", "content-range": "0-2/5"}, b"abc"), |
| 564 | ] |
| 565 | ) |
Chris McDonough | 0dc81bf | 2018-07-19 11:19:58 -0400 | [diff] [blame] | 566 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 567 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 568 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 569 | status, done = download.next_chunk() |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 570 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 571 | self.assertEqual("https://secure.example.net/lion", download._uri) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 572 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 573 | def test_media_io_base_download_handle_4xx(self): |
| 574 | self.request.http = HttpMockSequence([({"status": "400"}, "")]) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 575 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 576 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 577 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 578 | try: |
| 579 | status, done = download.next_chunk() |
| 580 | self.fail("Should raise an exception") |
| 581 | except HttpError: |
| 582 | pass |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 583 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 584 | # Even after raising an exception we can pick up where we left off. |
| 585 | self.request.http = HttpMockSequence( |
| 586 | [({"status": "200", "content-range": "0-2/5"}, b"123")] |
| 587 | ) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 588 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 589 | status, done = download.next_chunk() |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 590 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 591 | self.assertEqual(self.fd.getvalue(), b"123") |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 592 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 593 | def test_media_io_base_download_retries_connection_errors(self): |
| 594 | self.request.http = HttpMockWithErrors( |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 595 | 5, {"status": "200", "content-range": "0-2/3"}, b"123" |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 596 | ) |
Joe Gregorio | 708388c | 2012-06-15 13:43:04 -0400 | [diff] [blame] | 597 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 598 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
| 599 | download._sleep = lambda _x: 0 # do nothing |
| 600 | download._rand = lambda: 10 |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 601 | |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 602 | status, done = download.next_chunk(num_retries=5) |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 603 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 604 | self.assertEqual(self.fd.getvalue(), b"123") |
| 605 | self.assertEqual(True, done) |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 606 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 607 | def test_media_io_base_download_retries_5xx(self): |
| 608 | self.request.http = HttpMockSequence( |
| 609 | [ |
| 610 | ({"status": "500"}, ""), |
| 611 | ({"status": "500"}, ""), |
| 612 | ({"status": "500"}, ""), |
| 613 | ({"status": "200", "content-range": "0-2/5"}, b"123"), |
| 614 | ({"status": "503"}, ""), |
| 615 | ({"status": "503"}, ""), |
| 616 | ({"status": "503"}, ""), |
| 617 | ({"status": "200", "content-range": "3-4/5"}, b"45"), |
| 618 | ] |
| 619 | ) |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 620 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 621 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 622 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 623 | self.assertEqual(self.fd, download._fd) |
| 624 | self.assertEqual(3, download._chunksize) |
| 625 | self.assertEqual(0, download._progress) |
| 626 | self.assertEqual(None, download._total_size) |
| 627 | self.assertEqual(False, download._done) |
| 628 | self.assertEqual(self.request.uri, download._uri) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 629 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 630 | # Set time.sleep and random.random stubs. |
| 631 | sleeptimes = [] |
| 632 | download._sleep = lambda x: sleeptimes.append(x) |
| 633 | download._rand = lambda: 10 |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 634 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 635 | status, done = download.next_chunk(num_retries=3) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 636 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 637 | # Check for exponential backoff using the rand function above. |
| 638 | self.assertEqual([20, 40, 80], sleeptimes) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 639 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 640 | self.assertEqual(self.fd.getvalue(), b"123") |
| 641 | self.assertEqual(False, done) |
| 642 | self.assertEqual(3, download._progress) |
| 643 | self.assertEqual(5, download._total_size) |
| 644 | self.assertEqual(3, status.resumable_progress) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 645 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 646 | # Reset time.sleep stub. |
| 647 | del sleeptimes[0 : len(sleeptimes)] |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 648 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 649 | status, done = download.next_chunk(num_retries=3) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 650 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 651 | # Check for exponential backoff using the rand function above. |
| 652 | self.assertEqual([20, 40, 80], sleeptimes) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 653 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 654 | self.assertEqual(self.fd.getvalue(), b"12345") |
| 655 | self.assertEqual(True, done) |
| 656 | self.assertEqual(5, download._progress) |
| 657 | self.assertEqual(5, download._total_size) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 658 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 659 | def test_media_io_base_download_empty_file(self): |
| 660 | self.request.http = HttpMockSequence( |
| 661 | [({"status": "200", "content-range": "0-0/0"}, b"")] |
| 662 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 663 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 664 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
andrewnester | a4a44cf | 2017-03-31 16:09:31 +0300 | [diff] [blame] | 665 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 666 | self.assertEqual(self.fd, download._fd) |
| 667 | self.assertEqual(0, download._progress) |
| 668 | self.assertEqual(None, download._total_size) |
| 669 | self.assertEqual(False, download._done) |
| 670 | self.assertEqual(self.request.uri, download._uri) |
andrewnester | a4a44cf | 2017-03-31 16:09:31 +0300 | [diff] [blame] | 671 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 672 | status, done = download.next_chunk() |
andrewnester | a4a44cf | 2017-03-31 16:09:31 +0300 | [diff] [blame] | 673 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 674 | self.assertEqual(True, done) |
| 675 | self.assertEqual(0, download._progress) |
| 676 | self.assertEqual(0, download._total_size) |
| 677 | self.assertEqual(0, status.progress()) |
andrewnester | a4a44cf | 2017-03-31 16:09:31 +0300 | [diff] [blame] | 678 | |
Bu Sun Kim | 86d8788 | 2020-10-22 08:51:16 -0600 | [diff] [blame] | 679 | def test_media_io_base_download_empty_file_416_response(self): |
| 680 | self.request.http = HttpMockSequence( |
| 681 | [({"status": "416", "content-range": "0-0/0"}, b"")] |
| 682 | ) |
| 683 | |
| 684 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
| 685 | |
| 686 | self.assertEqual(self.fd, download._fd) |
| 687 | self.assertEqual(0, download._progress) |
| 688 | self.assertEqual(None, download._total_size) |
| 689 | self.assertEqual(False, download._done) |
| 690 | self.assertEqual(self.request.uri, download._uri) |
| 691 | |
| 692 | status, done = download.next_chunk() |
| 693 | |
| 694 | self.assertEqual(True, done) |
| 695 | self.assertEqual(0, download._progress) |
| 696 | self.assertEqual(0, download._total_size) |
| 697 | self.assertEqual(0, status.progress()) |
| 698 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 699 | def test_media_io_base_download_unknown_media_size(self): |
| 700 | self.request.http = HttpMockSequence([({"status": "200"}, b"123")]) |
andrewnester | a4a44cf | 2017-03-31 16:09:31 +0300 | [diff] [blame] | 701 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 702 | download = MediaIoBaseDownload(fd=self.fd, request=self.request, chunksize=3) |
Daniel | 4406778 | 2018-01-16 23:17:56 +0100 | [diff] [blame] | 703 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 704 | self.assertEqual(self.fd, download._fd) |
| 705 | self.assertEqual(0, download._progress) |
| 706 | self.assertEqual(None, download._total_size) |
| 707 | self.assertEqual(False, download._done) |
| 708 | self.assertEqual(self.request.uri, download._uri) |
Daniel | 4406778 | 2018-01-16 23:17:56 +0100 | [diff] [blame] | 709 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 710 | status, done = download.next_chunk() |
Daniel | 4406778 | 2018-01-16 23:17:56 +0100 | [diff] [blame] | 711 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 712 | self.assertEqual(self.fd.getvalue(), b"123") |
| 713 | self.assertEqual(True, done) |
| 714 | self.assertEqual(3, download._progress) |
| 715 | self.assertEqual(None, download._total_size) |
| 716 | self.assertEqual(0, status.progress()) |
Daniel | 4406778 | 2018-01-16 23:17:56 +0100 | [diff] [blame] | 717 | |
| 718 | |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 719 | EXPECTED = """POST /someapi/v1/collection/?foo=bar HTTP/1.1 |
| 720 | Content-Type: application/json |
| 721 | MIME-Version: 1.0 |
Joe Gregorio | 5d1171b | 2012-01-05 10:48:24 -0500 | [diff] [blame] | 722 | Host: www.googleapis.com |
| 723 | content-length: 2\r\n\r\n{}""" |
| 724 | |
| 725 | |
| 726 | NO_BODY_EXPECTED = """POST /someapi/v1/collection/?foo=bar HTTP/1.1 |
| 727 | Content-Type: application/json |
| 728 | MIME-Version: 1.0 |
| 729 | Host: www.googleapis.com |
| 730 | content-length: 0\r\n\r\n""" |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 731 | |
Pepper Lebeck-Jobe | 30ecbd4 | 2015-06-12 11:45:57 -0400 | [diff] [blame] | 732 | NO_BODY_EXPECTED_GET = """GET /someapi/v1/collection/?foo=bar HTTP/1.1 |
| 733 | Content-Type: application/json |
| 734 | MIME-Version: 1.0 |
| 735 | Host: www.googleapis.com\r\n\r\n""" |
| 736 | |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 737 | |
| 738 | RESPONSE = """HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 739 | Content-Type: application/json |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 740 | Content-Length: 14 |
| 741 | ETag: "etag/pony"\r\n\r\n{"answer": 42}""" |
| 742 | |
| 743 | |
INADA Naoki | 0915761 | 2015-03-25 01:51:03 +0900 | [diff] [blame] | 744 | BATCH_RESPONSE = b"""--batch_foobarbaz |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 745 | Content-Type: application/http |
| 746 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 747 | Content-ID: <randomness + 1> |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 748 | |
| 749 | HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 750 | Content-Type: application/json |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 751 | Content-Length: 14 |
| 752 | ETag: "etag/pony"\r\n\r\n{"foo": 42} |
| 753 | |
| 754 | --batch_foobarbaz |
| 755 | Content-Type: application/http |
| 756 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 757 | Content-ID: <randomness + 2> |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 758 | |
| 759 | HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 760 | Content-Type: application/json |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 761 | Content-Length: 14 |
| 762 | ETag: "etag/sheep"\r\n\r\n{"baz": "qux"} |
| 763 | --batch_foobarbaz--""" |
| 764 | |
Joe Gregorio | 5d1171b | 2012-01-05 10:48:24 -0500 | [diff] [blame] | 765 | |
INADA Naoki | 0915761 | 2015-03-25 01:51:03 +0900 | [diff] [blame] | 766 | BATCH_ERROR_RESPONSE = b"""--batch_foobarbaz |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 767 | Content-Type: application/http |
| 768 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 769 | Content-ID: <randomness + 1> |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 770 | |
| 771 | HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 772 | Content-Type: application/json |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 773 | Content-Length: 14 |
| 774 | ETag: "etag/pony"\r\n\r\n{"foo": 42} |
| 775 | |
| 776 | --batch_foobarbaz |
| 777 | Content-Type: application/http |
| 778 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 779 | Content-ID: <randomness + 2> |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 780 | |
| 781 | HTTP/1.1 403 Access Not Configured |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 782 | Content-Type: application/json |
| 783 | Content-Length: 245 |
| 784 | ETag: "etag/sheep"\r\n\r\n{ |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 785 | "error": { |
| 786 | "errors": [ |
| 787 | { |
| 788 | "domain": "usageLimits", |
| 789 | "reason": "accessNotConfigured", |
| 790 | "message": "Access Not Configured", |
| 791 | "debugInfo": "QuotaState: BLOCKED" |
| 792 | } |
| 793 | ], |
| 794 | "code": 403, |
| 795 | "message": "Access Not Configured" |
| 796 | } |
| 797 | } |
| 798 | |
| 799 | --batch_foobarbaz--""" |
| 800 | |
| 801 | |
INADA Naoki | 0915761 | 2015-03-25 01:51:03 +0900 | [diff] [blame] | 802 | BATCH_RESPONSE_WITH_401 = b"""--batch_foobarbaz |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 803 | Content-Type: application/http |
| 804 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 805 | Content-ID: <randomness + 1> |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 806 | |
Joe Gregorio | c752e33 | 2012-07-11 14:43:52 -0400 | [diff] [blame] | 807 | HTTP/1.1 401 Authorization Required |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 808 | Content-Type: application/json |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 809 | Content-Length: 14 |
| 810 | ETag: "etag/pony"\r\n\r\n{"error": {"message": |
| 811 | "Authorizaton failed."}} |
| 812 | |
| 813 | --batch_foobarbaz |
| 814 | Content-Type: application/http |
| 815 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 816 | Content-ID: <randomness + 2> |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 817 | |
| 818 | HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 819 | Content-Type: application/json |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 820 | Content-Length: 14 |
| 821 | ETag: "etag/sheep"\r\n\r\n{"baz": "qux"} |
| 822 | --batch_foobarbaz--""" |
| 823 | |
| 824 | |
INADA Naoki | 0915761 | 2015-03-25 01:51:03 +0900 | [diff] [blame] | 825 | BATCH_SINGLE_RESPONSE = b"""--batch_foobarbaz |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 826 | Content-Type: application/http |
| 827 | Content-Transfer-Encoding: binary |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 828 | Content-ID: <randomness + 1> |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 829 | |
| 830 | HTTP/1.1 200 OK |
Joe Gregorio | 20b54fb | 2012-07-26 09:59:35 -0400 | [diff] [blame] | 831 | Content-Type: application/json |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 832 | Content-Length: 14 |
| 833 | ETag: "etag/pony"\r\n\r\n{"foo": 42} |
| 834 | --batch_foobarbaz--""" |
| 835 | |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 836 | |
| 837 | USER_RATE_LIMIT_EXCEEDED_RESPONSE = """{ |
| 838 | "error": { |
| 839 | "errors": [ |
| 840 | { |
| 841 | "domain": "usageLimits", |
| 842 | "reason": "userRateLimitExceeded", |
| 843 | "message": "User Rate Limit Exceeded" |
| 844 | } |
| 845 | ], |
| 846 | "code": 403, |
| 847 | "message": "User Rate Limit Exceeded" |
| 848 | } |
| 849 | }""" |
| 850 | |
| 851 | |
| 852 | RATE_LIMIT_EXCEEDED_RESPONSE = """{ |
| 853 | "error": { |
| 854 | "errors": [ |
| 855 | { |
| 856 | "domain": "usageLimits", |
| 857 | "reason": "rateLimitExceeded", |
| 858 | "message": "Rate Limit Exceeded" |
| 859 | } |
| 860 | ], |
| 861 | "code": 403, |
| 862 | "message": "Rate Limit Exceeded" |
| 863 | } |
| 864 | }""" |
| 865 | |
| 866 | |
| 867 | NOT_CONFIGURED_RESPONSE = """{ |
| 868 | "error": { |
| 869 | "errors": [ |
| 870 | { |
| 871 | "domain": "usageLimits", |
| 872 | "reason": "accessNotConfigured", |
| 873 | "message": "Access Not Configured" |
| 874 | } |
| 875 | ], |
| 876 | "code": 403, |
| 877 | "message": "Access Not Configured" |
| 878 | } |
| 879 | }""" |
| 880 | |
Nilayan Bhattacharya | 90ffb85 | 2017-12-05 15:30:32 -0800 | [diff] [blame] | 881 | LIST_NOT_CONFIGURED_RESPONSE = """[ |
| 882 | "error": { |
| 883 | "errors": [ |
| 884 | { |
| 885 | "domain": "usageLimits", |
| 886 | "reason": "accessNotConfigured", |
| 887 | "message": "Access Not Configured" |
| 888 | } |
| 889 | ], |
| 890 | "code": 403, |
| 891 | "message": "Access Not Configured" |
| 892 | } |
| 893 | ]""" |
| 894 | |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 895 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 896 | class Callbacks(object): |
| 897 | def __init__(self): |
| 898 | self.responses = {} |
| 899 | self.exceptions = {} |
| 900 | |
| 901 | def f(self, request_id, response, exception): |
| 902 | self.responses[request_id] = response |
| 903 | self.exceptions[request_id] = exception |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 904 | |
| 905 | |
Joe Gregorio | 83f2ee6 | 2012-12-06 15:25:54 -0500 | [diff] [blame] | 906 | class TestHttpRequest(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 907 | def test_unicode(self): |
| 908 | http = HttpMock(datafile("zoo.json"), headers={"status": "200"}) |
| 909 | model = JsonModel() |
| 910 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 911 | method = u"POST" |
| 912 | request = HttpRequest( |
| 913 | http, |
| 914 | model.response, |
| 915 | uri, |
| 916 | method=method, |
| 917 | body=u"{}", |
| 918 | headers={"content-type": "application/json"}, |
| 919 | ) |
| 920 | request.execute() |
| 921 | self.assertEqual(uri, http.uri) |
| 922 | self.assertEqual(str, type(http.uri)) |
| 923 | self.assertEqual(method, http.method) |
| 924 | self.assertEqual(str, type(http.method)) |
Joe Gregorio | 83f2ee6 | 2012-12-06 15:25:54 -0500 | [diff] [blame] | 925 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 926 | def test_empty_content_type(self): |
| 927 | """Test for #284""" |
| 928 | http = HttpMock(None, headers={"status": 200}) |
| 929 | uri = u"https://www.googleapis.com/someapi/v1/upload/?foo=bar" |
| 930 | method = u"POST" |
| 931 | request = HttpRequest( |
| 932 | http, _postproc_none, uri, method=method, headers={"content-type": ""} |
| 933 | ) |
| 934 | request.execute() |
| 935 | self.assertEqual("", http.headers.get("content-type")) |
Xiaofei Wang | 20b6758 | 2019-07-17 11:16:53 -0700 | [diff] [blame] | 936 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 937 | def test_no_retry_connection_errors(self): |
| 938 | model = JsonModel() |
| 939 | request = HttpRequest( |
| 940 | HttpMockWithNonRetriableErrors(1, {"status": "200"}, '{"foo": "bar"}'), |
| 941 | model.response, |
| 942 | u"https://www.example.com/json_api_endpoint", |
| 943 | ) |
| 944 | request._sleep = lambda _x: 0 # do nothing |
| 945 | request._rand = lambda: 10 |
| 946 | with self.assertRaises(socket.error): |
| 947 | response = request.execute(num_retries=3) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 948 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 949 | def test_retry_connection_errors_non_resumable(self): |
| 950 | model = JsonModel() |
| 951 | request = HttpRequest( |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 952 | HttpMockWithErrors(5, {"status": "200"}, '{"foo": "bar"}'), |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 953 | model.response, |
| 954 | u"https://www.example.com/json_api_endpoint", |
| 955 | ) |
| 956 | request._sleep = lambda _x: 0 # do nothing |
| 957 | request._rand = lambda: 10 |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 958 | response = request.execute(num_retries=5) |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 959 | self.assertEqual({u"foo": u"bar"}, response) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 960 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 961 | def test_retry_connection_errors_resumable(self): |
| 962 | with open(datafile("small.png"), "rb") as small_png_file: |
| 963 | small_png_fd = BytesIO(small_png_file.read()) |
| 964 | upload = MediaIoBaseUpload( |
| 965 | fd=small_png_fd, mimetype="image/png", chunksize=500, resumable=True |
| 966 | ) |
| 967 | model = JsonModel() |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 968 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 969 | request = HttpRequest( |
| 970 | HttpMockWithErrors( |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 971 | 5, {"status": "200", "location": "location"}, '{"foo": "bar"}' |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 972 | ), |
| 973 | model.response, |
| 974 | u"https://www.example.com/file_upload", |
| 975 | method="POST", |
| 976 | resumable=upload, |
| 977 | ) |
| 978 | request._sleep = lambda _x: 0 # do nothing |
| 979 | request._rand = lambda: 10 |
Damian Gadomski | c7516a2 | 2020-03-23 20:39:21 +0100 | [diff] [blame] | 980 | response = request.execute(num_retries=5) |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 981 | self.assertEqual({u"foo": u"bar"}, response) |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 982 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 983 | def test_retry(self): |
| 984 | num_retries = 5 |
| 985 | resp_seq = [({"status": "500"}, "")] * (num_retries - 3) |
| 986 | resp_seq.append(({"status": "403"}, RATE_LIMIT_EXCEEDED_RESPONSE)) |
| 987 | resp_seq.append(({"status": "403"}, USER_RATE_LIMIT_EXCEEDED_RESPONSE)) |
| 988 | resp_seq.append(({"status": "429"}, "")) |
| 989 | resp_seq.append(({"status": "200"}, "{}")) |
Sergiy Byelozyorov | 703c92c | 2015-12-21 23:27:48 +0100 | [diff] [blame] | 990 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 991 | http = HttpMockSequence(resp_seq) |
| 992 | model = JsonModel() |
| 993 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 994 | method = u"POST" |
| 995 | request = HttpRequest( |
| 996 | http, |
| 997 | model.response, |
| 998 | uri, |
| 999 | method=method, |
| 1000 | body=u"{}", |
| 1001 | headers={"content-type": "application/json"}, |
| 1002 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1003 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1004 | sleeptimes = [] |
| 1005 | request._sleep = lambda x: sleeptimes.append(x) |
| 1006 | request._rand = lambda: 10 |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1007 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1008 | request.execute(num_retries=num_retries) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1009 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1010 | self.assertEqual(num_retries, len(sleeptimes)) |
| 1011 | for retry_num in range(num_retries): |
| 1012 | self.assertEqual(10 * 2 ** (retry_num + 1), sleeptimes[retry_num]) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1013 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1014 | def test_no_retry_succeeds(self): |
| 1015 | num_retries = 5 |
| 1016 | resp_seq = [({"status": "200"}, "{}")] * (num_retries) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1017 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1018 | http = HttpMockSequence(resp_seq) |
| 1019 | model = JsonModel() |
| 1020 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1021 | method = u"POST" |
| 1022 | request = HttpRequest( |
| 1023 | http, |
| 1024 | model.response, |
| 1025 | uri, |
| 1026 | method=method, |
| 1027 | body=u"{}", |
| 1028 | headers={"content-type": "application/json"}, |
| 1029 | ) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1030 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1031 | sleeptimes = [] |
| 1032 | request._sleep = lambda x: sleeptimes.append(x) |
| 1033 | request._rand = lambda: 10 |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1034 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1035 | request.execute(num_retries=num_retries) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1036 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1037 | self.assertEqual(0, len(sleeptimes)) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1038 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1039 | def test_no_retry_fails_fast(self): |
| 1040 | http = HttpMockSequence([({"status": "500"}, ""), ({"status": "200"}, "{}")]) |
| 1041 | model = JsonModel() |
| 1042 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1043 | method = u"POST" |
| 1044 | request = HttpRequest( |
| 1045 | http, |
| 1046 | model.response, |
| 1047 | uri, |
| 1048 | method=method, |
| 1049 | body=u"{}", |
| 1050 | headers={"content-type": "application/json"}, |
| 1051 | ) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1052 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1053 | request._rand = lambda: 1.0 |
| 1054 | request._sleep = mock.MagicMock() |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1055 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1056 | with self.assertRaises(HttpError): |
| 1057 | request.execute() |
| 1058 | request._sleep.assert_not_called() |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1059 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1060 | def test_no_retry_403_not_configured_fails_fast(self): |
| 1061 | http = HttpMockSequence( |
| 1062 | [({"status": "403"}, NOT_CONFIGURED_RESPONSE), ({"status": "200"}, "{}")] |
| 1063 | ) |
| 1064 | model = JsonModel() |
| 1065 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1066 | method = u"POST" |
| 1067 | request = HttpRequest( |
| 1068 | http, |
| 1069 | model.response, |
| 1070 | uri, |
| 1071 | method=method, |
| 1072 | body=u"{}", |
| 1073 | headers={"content-type": "application/json"}, |
| 1074 | ) |
Joe Gregorio | 9086bd3 | 2013-06-14 16:32:05 -0400 | [diff] [blame] | 1075 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1076 | request._rand = lambda: 1.0 |
| 1077 | request._sleep = mock.MagicMock() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1078 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1079 | with self.assertRaises(HttpError): |
| 1080 | request.execute() |
| 1081 | request._sleep.assert_not_called() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1082 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1083 | def test_no_retry_403_fails_fast(self): |
| 1084 | http = HttpMockSequence([({"status": "403"}, ""), ({"status": "200"}, "{}")]) |
| 1085 | model = JsonModel() |
| 1086 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1087 | method = u"POST" |
| 1088 | request = HttpRequest( |
| 1089 | http, |
| 1090 | model.response, |
| 1091 | uri, |
| 1092 | method=method, |
| 1093 | body=u"{}", |
| 1094 | headers={"content-type": "application/json"}, |
| 1095 | ) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1096 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1097 | request._rand = lambda: 1.0 |
| 1098 | request._sleep = mock.MagicMock() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1099 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1100 | with self.assertRaises(HttpError): |
| 1101 | request.execute() |
| 1102 | request._sleep.assert_not_called() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1103 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1104 | def test_no_retry_401_fails_fast(self): |
| 1105 | http = HttpMockSequence([({"status": "401"}, ""), ({"status": "200"}, "{}")]) |
| 1106 | model = JsonModel() |
| 1107 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1108 | method = u"POST" |
| 1109 | request = HttpRequest( |
| 1110 | http, |
| 1111 | model.response, |
| 1112 | uri, |
| 1113 | method=method, |
| 1114 | body=u"{}", |
| 1115 | headers={"content-type": "application/json"}, |
| 1116 | ) |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1117 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1118 | request._rand = lambda: 1.0 |
| 1119 | request._sleep = mock.MagicMock() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1120 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1121 | with self.assertRaises(HttpError): |
| 1122 | request.execute() |
| 1123 | request._sleep.assert_not_called() |
eesheesh | c6425a0 | 2016-02-12 15:07:06 +0000 | [diff] [blame] | 1124 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1125 | def test_no_retry_403_list_fails(self): |
| 1126 | http = HttpMockSequence( |
| 1127 | [ |
| 1128 | ({"status": "403"}, LIST_NOT_CONFIGURED_RESPONSE), |
| 1129 | ({"status": "200"}, "{}"), |
| 1130 | ] |
| 1131 | ) |
| 1132 | model = JsonModel() |
| 1133 | uri = u"https://www.googleapis.com/someapi/v1/collection/?foo=bar" |
| 1134 | method = u"POST" |
| 1135 | request = HttpRequest( |
| 1136 | http, |
| 1137 | model.response, |
| 1138 | uri, |
| 1139 | method=method, |
| 1140 | body=u"{}", |
| 1141 | headers={"content-type": "application/json"}, |
| 1142 | ) |
Joe Gregorio | 83f2ee6 | 2012-12-06 15:25:54 -0500 | [diff] [blame] | 1143 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1144 | request._rand = lambda: 1.0 |
| 1145 | request._sleep = mock.MagicMock() |
Nilayan Bhattacharya | 90ffb85 | 2017-12-05 15:30:32 -0800 | [diff] [blame] | 1146 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1147 | with self.assertRaises(HttpError): |
| 1148 | request.execute() |
| 1149 | request._sleep.assert_not_called() |
Nilayan Bhattacharya | 90ffb85 | 2017-12-05 15:30:32 -0800 | [diff] [blame] | 1150 | |
Dmitry Frenkel | f3348f9 | 2020-07-15 13:05:58 -0700 | [diff] [blame] | 1151 | def test_null_postproc(self): |
| 1152 | resp, content = HttpRequest.null_postproc("foo", "bar") |
| 1153 | self.assertEqual(resp, "foo") |
| 1154 | self.assertEqual(content, "bar") |
| 1155 | |
Nilayan Bhattacharya | 90ffb85 | 2017-12-05 15:30:32 -0800 | [diff] [blame] | 1156 | |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1157 | class TestBatch(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1158 | def setUp(self): |
| 1159 | model = JsonModel() |
| 1160 | self.request1 = HttpRequest( |
| 1161 | None, |
| 1162 | model.response, |
| 1163 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1164 | method="POST", |
| 1165 | body="{}", |
| 1166 | headers={"content-type": "application/json"}, |
| 1167 | ) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1168 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1169 | self.request2 = HttpRequest( |
| 1170 | None, |
| 1171 | model.response, |
| 1172 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1173 | method="GET", |
| 1174 | body="", |
| 1175 | headers={"content-type": "application/json"}, |
| 1176 | ) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1177 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1178 | def test_id_to_from_content_id_header(self): |
| 1179 | batch = BatchHttpRequest() |
Bu Sun Kim | 1cf3cbc | 2020-03-12 12:38:23 -0700 | [diff] [blame] | 1180 | self.assertEqual("12", batch._header_to_id(batch._id_to_header("12"))) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1181 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1182 | def test_invalid_content_id_header(self): |
| 1183 | batch = BatchHttpRequest() |
| 1184 | self.assertRaises(BatchError, batch._header_to_id, "[foo+x]") |
| 1185 | self.assertRaises(BatchError, batch._header_to_id, "foo+1") |
| 1186 | self.assertRaises(BatchError, batch._header_to_id, "<foo>") |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1187 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1188 | def test_serialize_request(self): |
| 1189 | batch = BatchHttpRequest() |
| 1190 | request = HttpRequest( |
| 1191 | None, |
| 1192 | None, |
| 1193 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1194 | method="POST", |
| 1195 | body=u"{}", |
| 1196 | headers={"content-type": "application/json"}, |
| 1197 | methodId=None, |
| 1198 | resumable=None, |
| 1199 | ) |
| 1200 | s = batch._serialize_request(request).splitlines() |
| 1201 | self.assertEqual(EXPECTED.splitlines(), s) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1202 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1203 | def test_serialize_request_media_body(self): |
| 1204 | batch = BatchHttpRequest() |
| 1205 | f = open(datafile("small.png"), "rb") |
| 1206 | body = f.read() |
| 1207 | f.close() |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1208 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1209 | request = HttpRequest( |
| 1210 | None, |
| 1211 | None, |
| 1212 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1213 | method="POST", |
| 1214 | body=body, |
| 1215 | headers={"content-type": "application/json"}, |
| 1216 | methodId=None, |
| 1217 | resumable=None, |
| 1218 | ) |
| 1219 | # Just testing it shouldn't raise an exception. |
| 1220 | s = batch._serialize_request(request).splitlines() |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1221 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1222 | def test_serialize_request_no_body(self): |
| 1223 | batch = BatchHttpRequest() |
| 1224 | request = HttpRequest( |
| 1225 | None, |
| 1226 | None, |
| 1227 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1228 | method="POST", |
| 1229 | body=b"", |
| 1230 | headers={"content-type": "application/json"}, |
| 1231 | methodId=None, |
| 1232 | resumable=None, |
| 1233 | ) |
| 1234 | s = batch._serialize_request(request).splitlines() |
| 1235 | self.assertEqual(NO_BODY_EXPECTED.splitlines(), s) |
Joe Gregorio | dd81382 | 2012-01-25 10:32:47 -0500 | [diff] [blame] | 1236 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1237 | def test_serialize_get_request_no_body(self): |
| 1238 | batch = BatchHttpRequest() |
| 1239 | request = HttpRequest( |
| 1240 | None, |
| 1241 | None, |
| 1242 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1243 | method="GET", |
| 1244 | body=None, |
| 1245 | headers={"content-type": "application/json"}, |
| 1246 | methodId=None, |
| 1247 | resumable=None, |
| 1248 | ) |
| 1249 | s = batch._serialize_request(request).splitlines() |
| 1250 | self.assertEqual(NO_BODY_EXPECTED_GET.splitlines(), s) |
Joe Gregorio | dd81382 | 2012-01-25 10:32:47 -0500 | [diff] [blame] | 1251 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1252 | def test_deserialize_response(self): |
| 1253 | batch = BatchHttpRequest() |
| 1254 | resp, content = batch._deserialize_response(RESPONSE) |
Joe Gregorio | 5d1171b | 2012-01-05 10:48:24 -0500 | [diff] [blame] | 1255 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1256 | self.assertEqual(200, resp.status) |
| 1257 | self.assertEqual("OK", resp.reason) |
| 1258 | self.assertEqual(11, resp.version) |
| 1259 | self.assertEqual('{"answer": 42}', content) |
Pepper Lebeck-Jobe | 30ecbd4 | 2015-06-12 11:45:57 -0400 | [diff] [blame] | 1260 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1261 | def test_new_id(self): |
| 1262 | batch = BatchHttpRequest() |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1263 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1264 | id_ = batch._new_id() |
| 1265 | self.assertEqual("1", id_) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1266 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1267 | id_ = batch._new_id() |
| 1268 | self.assertEqual("2", id_) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1269 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1270 | batch.add(self.request1, request_id="3") |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1271 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1272 | id_ = batch._new_id() |
| 1273 | self.assertEqual("4", id_) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1274 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1275 | def test_add(self): |
| 1276 | batch = BatchHttpRequest() |
| 1277 | batch.add(self.request1, request_id="1") |
| 1278 | self.assertRaises(KeyError, batch.add, self.request1, request_id="1") |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1279 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1280 | def test_add_fail_for_over_limit(self): |
| 1281 | from googleapiclient.http import MAX_BATCH_LIMIT |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1282 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1283 | batch = BatchHttpRequest() |
| 1284 | for i in range(0, MAX_BATCH_LIMIT): |
| 1285 | batch.add( |
| 1286 | HttpRequest( |
| 1287 | None, |
| 1288 | None, |
| 1289 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1290 | method="POST", |
| 1291 | body="{}", |
| 1292 | headers={"content-type": "application/json"}, |
| 1293 | ) |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 1294 | ) |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1295 | self.assertRaises(BatchError, batch.add, self.request1) |
Chris McDonough | 3cf5e60 | 2018-07-18 16:18:38 -0400 | [diff] [blame] | 1296 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1297 | def test_add_fail_for_resumable(self): |
| 1298 | batch = BatchHttpRequest() |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1299 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1300 | upload = MediaFileUpload(datafile("small.png"), chunksize=500, resumable=True) |
| 1301 | self.request1.resumable = upload |
| 1302 | with self.assertRaises(BatchError) as batch_error: |
| 1303 | batch.add(self.request1, request_id="1") |
| 1304 | str(batch_error.exception) |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1305 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1306 | def test_execute_empty_batch_no_http(self): |
| 1307 | batch = BatchHttpRequest() |
| 1308 | ret = batch.execute() |
| 1309 | self.assertEqual(None, ret) |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1310 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1311 | def test_execute(self): |
| 1312 | batch = BatchHttpRequest() |
| 1313 | callbacks = Callbacks() |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1314 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1315 | batch.add(self.request1, callback=callbacks.f) |
| 1316 | batch.add(self.request2, callback=callbacks.f) |
| 1317 | http = HttpMockSequence( |
| 1318 | [ |
| 1319 | ( |
| 1320 | { |
| 1321 | "status": "200", |
| 1322 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1323 | }, |
| 1324 | BATCH_RESPONSE, |
| 1325 | ) |
| 1326 | ] |
| 1327 | ) |
| 1328 | batch.execute(http=http) |
| 1329 | self.assertEqual({"foo": 42}, callbacks.responses["1"]) |
| 1330 | self.assertEqual(None, callbacks.exceptions["1"]) |
| 1331 | self.assertEqual({"baz": "qux"}, callbacks.responses["2"]) |
| 1332 | self.assertEqual(None, callbacks.exceptions["2"]) |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1333 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1334 | def test_execute_request_body(self): |
| 1335 | batch = BatchHttpRequest() |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1336 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1337 | batch.add(self.request1) |
| 1338 | batch.add(self.request2) |
| 1339 | http = HttpMockSequence( |
| 1340 | [ |
| 1341 | ( |
| 1342 | { |
| 1343 | "status": "200", |
| 1344 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1345 | }, |
| 1346 | "echo_request_body", |
| 1347 | ) |
| 1348 | ] |
| 1349 | ) |
| 1350 | try: |
| 1351 | batch.execute(http=http) |
| 1352 | self.fail("Should raise exception") |
| 1353 | except BatchError as e: |
| 1354 | boundary, _ = e.content.split(None, 1) |
| 1355 | self.assertEqual("--", boundary[:2]) |
| 1356 | parts = e.content.split(boundary) |
| 1357 | self.assertEqual(4, len(parts)) |
| 1358 | self.assertEqual("", parts[0]) |
| 1359 | self.assertEqual("--", parts[3].rstrip()) |
| 1360 | header = parts[1].splitlines()[1] |
| 1361 | self.assertEqual("Content-Type: application/http", header) |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1362 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1363 | def test_execute_request_body_with_custom_long_request_ids(self): |
| 1364 | batch = BatchHttpRequest() |
Gabriel Garcia | 23174be | 2016-05-25 17:28:07 +0200 | [diff] [blame] | 1365 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1366 | batch.add(self.request1, request_id="abc" * 20) |
| 1367 | batch.add(self.request2, request_id="def" * 20) |
| 1368 | http = HttpMockSequence( |
| 1369 | [ |
| 1370 | ( |
| 1371 | { |
| 1372 | "status": "200", |
| 1373 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1374 | }, |
| 1375 | "echo_request_body", |
| 1376 | ) |
| 1377 | ] |
| 1378 | ) |
| 1379 | try: |
| 1380 | batch.execute(http=http) |
| 1381 | self.fail("Should raise exception") |
| 1382 | except BatchError as e: |
| 1383 | boundary, _ = e.content.split(None, 1) |
| 1384 | self.assertEqual("--", boundary[:2]) |
| 1385 | parts = e.content.split(boundary) |
| 1386 | self.assertEqual(4, len(parts)) |
| 1387 | self.assertEqual("", parts[0]) |
| 1388 | self.assertEqual("--", parts[3].rstrip()) |
| 1389 | for partindex, request_id in ((1, "abc" * 20), (2, "def" * 20)): |
| 1390 | lines = parts[partindex].splitlines() |
| 1391 | for n, line in enumerate(lines): |
| 1392 | if line.startswith("Content-ID:"): |
| 1393 | # assert correct header folding |
| 1394 | self.assertTrue(line.endswith("+"), line) |
| 1395 | header_continuation = lines[n + 1] |
| 1396 | self.assertEqual( |
| 1397 | header_continuation, |
| 1398 | " %s>" % request_id, |
| 1399 | header_continuation, |
| 1400 | ) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1401 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1402 | def test_execute_initial_refresh_oauth2(self): |
| 1403 | batch = BatchHttpRequest() |
| 1404 | callbacks = Callbacks() |
| 1405 | cred = MockCredentials("Foo", expired=True) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1406 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1407 | http = HttpMockSequence( |
| 1408 | [ |
| 1409 | ( |
| 1410 | { |
| 1411 | "status": "200", |
| 1412 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1413 | }, |
| 1414 | BATCH_SINGLE_RESPONSE, |
| 1415 | ) |
| 1416 | ] |
| 1417 | ) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1418 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1419 | cred.authorize(http) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1420 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1421 | batch.add(self.request1, callback=callbacks.f) |
| 1422 | batch.execute(http=http) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1423 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1424 | self.assertEqual({"foo": 42}, callbacks.responses["1"]) |
| 1425 | self.assertIsNone(callbacks.exceptions["1"]) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1426 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1427 | self.assertEqual(1, cred._refreshed) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1428 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1429 | self.assertEqual(1, cred._authorized) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1430 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1431 | self.assertEqual(1, cred._applied) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1432 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1433 | def test_execute_refresh_and_retry_on_401(self): |
| 1434 | batch = BatchHttpRequest() |
| 1435 | callbacks = Callbacks() |
| 1436 | cred_1 = MockCredentials("Foo") |
| 1437 | cred_2 = MockCredentials("Bar") |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1438 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1439 | http = HttpMockSequence( |
| 1440 | [ |
| 1441 | ( |
| 1442 | { |
| 1443 | "status": "200", |
| 1444 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1445 | }, |
| 1446 | BATCH_RESPONSE_WITH_401, |
| 1447 | ), |
| 1448 | ( |
| 1449 | { |
| 1450 | "status": "200", |
| 1451 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1452 | }, |
| 1453 | BATCH_SINGLE_RESPONSE, |
| 1454 | ), |
| 1455 | ] |
| 1456 | ) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1457 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1458 | creds_http_1 = HttpMockSequence([]) |
| 1459 | cred_1.authorize(creds_http_1) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1460 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1461 | creds_http_2 = HttpMockSequence([]) |
| 1462 | cred_2.authorize(creds_http_2) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1463 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1464 | self.request1.http = creds_http_1 |
| 1465 | self.request2.http = creds_http_2 |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1466 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1467 | batch.add(self.request1, callback=callbacks.f) |
| 1468 | batch.add(self.request2, callback=callbacks.f) |
| 1469 | batch.execute(http=http) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1470 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1471 | self.assertEqual({"foo": 42}, callbacks.responses["1"]) |
| 1472 | self.assertEqual(None, callbacks.exceptions["1"]) |
| 1473 | self.assertEqual({"baz": "qux"}, callbacks.responses["2"]) |
| 1474 | self.assertEqual(None, callbacks.exceptions["2"]) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1475 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1476 | self.assertEqual(1, cred_1._refreshed) |
| 1477 | self.assertEqual(0, cred_2._refreshed) |
Joe Gregorio | 654f4a2 | 2012-02-09 14:15:44 -0500 | [diff] [blame] | 1478 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1479 | self.assertEqual(1, cred_1._authorized) |
| 1480 | self.assertEqual(1, cred_2._authorized) |
Joe Gregorio | 66f5752 | 2011-11-30 11:00:00 -0500 | [diff] [blame] | 1481 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1482 | self.assertEqual(1, cred_2._applied) |
| 1483 | self.assertEqual(2, cred_1._applied) |
Joe Gregorio | d0bd388 | 2011-11-22 09:49:47 -0500 | [diff] [blame] | 1484 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1485 | def test_http_errors_passed_to_callback(self): |
| 1486 | batch = BatchHttpRequest() |
| 1487 | callbacks = Callbacks() |
| 1488 | cred_1 = MockCredentials("Foo") |
| 1489 | cred_2 = MockCredentials("Bar") |
Joe Gregorio | 3fb9367 | 2012-07-25 11:31:11 -0400 | [diff] [blame] | 1490 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1491 | http = HttpMockSequence( |
| 1492 | [ |
| 1493 | ( |
| 1494 | { |
| 1495 | "status": "200", |
| 1496 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1497 | }, |
| 1498 | BATCH_RESPONSE_WITH_401, |
| 1499 | ), |
| 1500 | ( |
| 1501 | { |
| 1502 | "status": "200", |
| 1503 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1504 | }, |
| 1505 | BATCH_RESPONSE_WITH_401, |
| 1506 | ), |
| 1507 | ] |
| 1508 | ) |
| 1509 | |
| 1510 | creds_http_1 = HttpMockSequence([]) |
| 1511 | cred_1.authorize(creds_http_1) |
| 1512 | |
| 1513 | creds_http_2 = HttpMockSequence([]) |
| 1514 | cred_2.authorize(creds_http_2) |
| 1515 | |
| 1516 | self.request1.http = creds_http_1 |
| 1517 | self.request2.http = creds_http_2 |
| 1518 | |
| 1519 | batch.add(self.request1, callback=callbacks.f) |
| 1520 | batch.add(self.request2, callback=callbacks.f) |
| 1521 | batch.execute(http=http) |
| 1522 | |
| 1523 | self.assertEqual(None, callbacks.responses["1"]) |
| 1524 | self.assertEqual(401, callbacks.exceptions["1"].resp.status) |
| 1525 | self.assertEqual( |
| 1526 | "Authorization Required", callbacks.exceptions["1"].resp.reason |
| 1527 | ) |
| 1528 | self.assertEqual({u"baz": u"qux"}, callbacks.responses["2"]) |
| 1529 | self.assertEqual(None, callbacks.exceptions["2"]) |
| 1530 | |
| 1531 | def test_execute_global_callback(self): |
| 1532 | callbacks = Callbacks() |
| 1533 | batch = BatchHttpRequest(callback=callbacks.f) |
| 1534 | |
| 1535 | batch.add(self.request1) |
| 1536 | batch.add(self.request2) |
| 1537 | http = HttpMockSequence( |
| 1538 | [ |
| 1539 | ( |
| 1540 | { |
| 1541 | "status": "200", |
| 1542 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1543 | }, |
| 1544 | BATCH_RESPONSE, |
| 1545 | ) |
| 1546 | ] |
| 1547 | ) |
| 1548 | batch.execute(http=http) |
| 1549 | self.assertEqual({"foo": 42}, callbacks.responses["1"]) |
| 1550 | self.assertEqual({"baz": "qux"}, callbacks.responses["2"]) |
| 1551 | |
| 1552 | def test_execute_batch_http_error(self): |
| 1553 | callbacks = Callbacks() |
| 1554 | batch = BatchHttpRequest(callback=callbacks.f) |
| 1555 | |
| 1556 | batch.add(self.request1) |
| 1557 | batch.add(self.request2) |
| 1558 | http = HttpMockSequence( |
| 1559 | [ |
| 1560 | ( |
| 1561 | { |
| 1562 | "status": "200", |
| 1563 | "content-type": 'multipart/mixed; boundary="batch_foobarbaz"', |
| 1564 | }, |
| 1565 | BATCH_ERROR_RESPONSE, |
| 1566 | ) |
| 1567 | ] |
| 1568 | ) |
| 1569 | batch.execute(http=http) |
| 1570 | self.assertEqual({"foo": 42}, callbacks.responses["1"]) |
| 1571 | expected = ( |
| 1572 | "<HttpError 403 when requesting " |
| 1573 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar returned " |
Muad Mohamed | a341c5a | 2020-11-08 20:30:02 +0000 | [diff] [blame] | 1574 | '"Access Not Configured". ' |
| 1575 | 'Details: "Access Not Configured">' |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1576 | ) |
| 1577 | self.assertEqual(expected, str(callbacks.exceptions["2"])) |
Ali Afshar | 6f11ea1 | 2012-02-07 10:32:14 -0500 | [diff] [blame] | 1578 | |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1579 | |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1580 | class TestRequestUriTooLong(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1581 | def test_turn_get_into_post(self): |
| 1582 | def _postproc(resp, content): |
| 1583 | return content |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1584 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1585 | http = HttpMockSequence( |
| 1586 | [ |
| 1587 | ({"status": "200"}, "echo_request_body"), |
| 1588 | ({"status": "200"}, "echo_request_headers"), |
| 1589 | ] |
| 1590 | ) |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1591 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1592 | # Send a long query parameter. |
| 1593 | query = {"q": "a" * MAX_URI_LENGTH + "?&"} |
| 1594 | req = HttpRequest( |
| 1595 | http, |
| 1596 | _postproc, |
| 1597 | "http://example.com?" + urlencode(query), |
| 1598 | method="GET", |
| 1599 | body=None, |
| 1600 | headers={}, |
| 1601 | methodId="foo", |
| 1602 | resumable=None, |
| 1603 | ) |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1604 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1605 | # Query parameters should be sent in the body. |
| 1606 | response = req.execute() |
| 1607 | self.assertEqual(b"q=" + b"a" * MAX_URI_LENGTH + b"%3F%26", response) |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1608 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1609 | # Extra headers should be set. |
| 1610 | response = req.execute() |
| 1611 | self.assertEqual("GET", response["x-http-method-override"]) |
| 1612 | self.assertEqual(str(MAX_URI_LENGTH + 8), response["content-length"]) |
| 1613 | self.assertEqual("application/x-www-form-urlencoded", response["content-type"]) |
Joe Gregorio | ba5c790 | 2012-08-03 12:48:16 -0400 | [diff] [blame] | 1614 | |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1615 | |
| 1616 | class TestStreamSlice(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1617 | """Test _StreamSlice.""" |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1618 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1619 | def setUp(self): |
| 1620 | self.stream = BytesIO(b"0123456789") |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1621 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1622 | def test_read(self): |
| 1623 | s = _StreamSlice(self.stream, 0, 4) |
| 1624 | self.assertEqual(b"", s.read(0)) |
| 1625 | self.assertEqual(b"0", s.read(1)) |
| 1626 | self.assertEqual(b"123", s.read()) |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1627 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1628 | def test_read_too_much(self): |
| 1629 | s = _StreamSlice(self.stream, 1, 4) |
| 1630 | self.assertEqual(b"1234", s.read(6)) |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1631 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1632 | def test_read_all(self): |
| 1633 | s = _StreamSlice(self.stream, 2, 1) |
| 1634 | self.assertEqual(b"2", s.read(-1)) |
Joe Gregorio | 5c120db | 2012-08-23 09:13:55 -0400 | [diff] [blame] | 1635 | |
Ali Afshar | 164f37e | 2013-01-07 14:05:45 -0800 | [diff] [blame] | 1636 | |
| 1637 | class TestResponseCallback(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1638 | """Test adding callbacks to responses.""" |
Ali Afshar | 164f37e | 2013-01-07 14:05:45 -0800 | [diff] [blame] | 1639 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1640 | def test_ensure_response_callback(self): |
| 1641 | m = JsonModel() |
| 1642 | request = HttpRequest( |
| 1643 | None, |
| 1644 | m.response, |
| 1645 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1646 | method="POST", |
| 1647 | body="{}", |
| 1648 | headers={"content-type": "application/json"}, |
| 1649 | ) |
| 1650 | h = HttpMockSequence([({"status": 200}, "{}")]) |
| 1651 | responses = [] |
| 1652 | |
| 1653 | def _on_response(resp, responses=responses): |
| 1654 | responses.append(resp) |
| 1655 | |
| 1656 | request.add_response_callback(_on_response) |
| 1657 | request.execute(http=h) |
| 1658 | self.assertEqual(1, len(responses)) |
Ali Afshar | 164f37e | 2013-01-07 14:05:45 -0800 | [diff] [blame] | 1659 | |
| 1660 | |
Craig Gurnik | 8e55b76 | 2015-01-20 15:00:10 -0500 | [diff] [blame] | 1661 | class TestHttpMock(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1662 | def test_default_response_headers(self): |
| 1663 | http = HttpMock(datafile("zoo.json")) |
| 1664 | resp, content = http.request("http://example.com") |
| 1665 | self.assertEqual(resp.status, 200) |
Craig Gurnik | 8e55b76 | 2015-01-20 15:00:10 -0500 | [diff] [blame] | 1666 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1667 | def test_error_response(self): |
| 1668 | http = HttpMock(datafile("bad_request.json"), {"status": "400"}) |
| 1669 | model = JsonModel() |
| 1670 | request = HttpRequest( |
| 1671 | http, |
| 1672 | model.response, |
| 1673 | "https://www.googleapis.com/someapi/v1/collection/?foo=bar", |
| 1674 | method="GET", |
| 1675 | headers={}, |
| 1676 | ) |
| 1677 | self.assertRaises(HttpError, request.execute) |
Alan Briolat | 26b0100 | 2015-08-14 00:13:57 +0100 | [diff] [blame] | 1678 | |
Craig Gurnik | 8e55b76 | 2015-01-20 15:00:10 -0500 | [diff] [blame] | 1679 | |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1680 | class TestHttpBuild(unittest.TestCase): |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1681 | original_socket_default_timeout = None |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1682 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1683 | @classmethod |
| 1684 | def setUpClass(cls): |
| 1685 | cls.original_socket_default_timeout = socket.getdefaulttimeout() |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1686 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1687 | @classmethod |
| 1688 | def tearDownClass(cls): |
| 1689 | socket.setdefaulttimeout(cls.original_socket_default_timeout) |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1690 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1691 | def test_build_http_sets_default_timeout_if_none_specified(self): |
| 1692 | socket.setdefaulttimeout(None) |
| 1693 | http = build_http() |
| 1694 | self.assertIsInstance(http.timeout, int) |
| 1695 | self.assertGreater(http.timeout, 0) |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1696 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1697 | def test_build_http_default_timeout_can_be_overridden(self): |
| 1698 | socket.setdefaulttimeout(1.5) |
| 1699 | http = build_http() |
| 1700 | self.assertAlmostEqual(http.timeout, 1.5, delta=0.001) |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1701 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1702 | def test_build_http_default_timeout_can_be_set_to_zero(self): |
| 1703 | socket.setdefaulttimeout(0) |
| 1704 | http = build_http() |
Bu Sun Kim | 1cf3cbc | 2020-03-12 12:38:23 -0700 | [diff] [blame] | 1705 | self.assertEqual(http.timeout, 0) |
Bu Sun Kim | 790e702 | 2020-09-11 20:18:06 -0600 | [diff] [blame] | 1706 | |
Bu Sun Kim | b3b773f | 2020-03-11 12:58:16 -0700 | [diff] [blame] | 1707 | def test_build_http_default_308_is_excluded_as_redirect(self): |
| 1708 | http = build_http() |
| 1709 | self.assertTrue(308 not in http.redirect_codes) |
Igor Maravić | 2243529 | 2017-01-19 22:28:22 +0100 | [diff] [blame] | 1710 | |
| 1711 | |
Bu Sun Kim | 66bb32c | 2019-10-30 10:11:58 -0700 | [diff] [blame] | 1712 | if __name__ == "__main__": |
| 1713 | logging.getLogger().setLevel(logging.ERROR) |
| 1714 | unittest.main() |