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