1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
|
# Copyright 2015 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import inspect
try:
from unittest import mock
from unittest.mock import AsyncMock # pragma: NO COVER # noqa: F401
except ImportError: # pragma: NO COVER
import mock # type: ignore
import pytest
from google.api_core import page_iterator_async
class PageAsyncIteratorImpl(page_iterator_async.AsyncIterator):
async def _next_page(self):
return mock.create_autospec(page_iterator_async.Page, instance=True)
class TestAsyncIterator:
def test_constructor(self):
client = mock.sentinel.client
item_to_value = mock.sentinel.item_to_value
token = "ab13nceor03"
max_results = 1337
iterator = PageAsyncIteratorImpl(
client, item_to_value, page_token=token, max_results=max_results
)
assert not iterator._started
assert iterator.client is client
assert iterator.item_to_value == item_to_value
assert iterator.max_results == max_results
# Changing attributes.
assert iterator.page_number == 0
assert iterator.next_page_token == token
assert iterator.num_results == 0
@pytest.mark.asyncio
async def test_anext(self):
parent = mock.sentinel.parent
page_1 = page_iterator_async.Page(
parent,
("item 1.1", "item 1.2"),
page_iterator_async._item_to_value_identity,
)
page_2 = page_iterator_async.Page(
parent, ("item 2.1",), page_iterator_async._item_to_value_identity
)
async_iterator = PageAsyncIteratorImpl(None, None)
async_iterator._next_page = mock.AsyncMock(side_effect=[page_1, page_2, None])
# Consume items and check the state of the async_iterator.
assert async_iterator.num_results == 0
assert await async_iterator.__anext__() == "item 1.1"
assert async_iterator.num_results == 1
assert await async_iterator.__anext__() == "item 1.2"
assert async_iterator.num_results == 2
assert await async_iterator.__anext__() == "item 2.1"
assert async_iterator.num_results == 3
with pytest.raises(StopAsyncIteration):
await async_iterator.__anext__()
def test_pages_property_starts(self):
iterator = PageAsyncIteratorImpl(None, None)
assert not iterator._started
assert inspect.isasyncgen(iterator.pages)
assert iterator._started
def test_pages_property_restart(self):
iterator = PageAsyncIteratorImpl(None, None)
assert iterator.pages
# Make sure we cannot restart.
with pytest.raises(ValueError):
assert iterator.pages
@pytest.mark.asyncio
async def test__page_aiter_increment(self):
iterator = PageAsyncIteratorImpl(None, None)
page = page_iterator_async.Page(
iterator, ("item",), page_iterator_async._item_to_value_identity
)
iterator._next_page = mock.AsyncMock(side_effect=[page, None])
assert iterator.num_results == 0
page_aiter = iterator._page_aiter(increment=True)
await page_aiter.__anext__()
assert iterator.num_results == 1
await page_aiter.aclose()
@pytest.mark.asyncio
async def test__page_aiter_no_increment(self):
iterator = PageAsyncIteratorImpl(None, None)
assert iterator.num_results == 0
page_aiter = iterator._page_aiter(increment=False)
await page_aiter.__anext__()
# results should still be 0 after fetching a page.
assert iterator.num_results == 0
await page_aiter.aclose()
@pytest.mark.asyncio
async def test__items_aiter(self):
# Items to be returned.
item1 = 17
item2 = 100
item3 = 211
# Make pages from mock responses
parent = mock.sentinel.parent
page1 = page_iterator_async.Page(
parent, (item1, item2), page_iterator_async._item_to_value_identity
)
page2 = page_iterator_async.Page(
parent, (item3,), page_iterator_async._item_to_value_identity
)
iterator = PageAsyncIteratorImpl(None, None)
iterator._next_page = mock.AsyncMock(side_effect=[page1, page2, None])
items_aiter = iterator._items_aiter()
assert inspect.isasyncgen(items_aiter)
# Consume items and check the state of the iterator.
assert iterator.num_results == 0
assert await items_aiter.__anext__() == item1
assert iterator.num_results == 1
assert await items_aiter.__anext__() == item2
assert iterator.num_results == 2
assert await items_aiter.__anext__() == item3
assert iterator.num_results == 3
with pytest.raises(StopAsyncIteration):
await items_aiter.__anext__()
@pytest.mark.asyncio
async def test___aiter__(self):
async_iterator = PageAsyncIteratorImpl(None, None)
async_iterator._next_page = mock.AsyncMock(side_effect=[(1, 2), (3,), None])
assert not async_iterator._started
result = []
async for item in async_iterator:
result.append(item)
assert result == [1, 2, 3]
assert async_iterator._started
def test___aiter__restart(self):
iterator = PageAsyncIteratorImpl(None, None)
iterator.__aiter__()
# Make sure we cannot restart.
with pytest.raises(ValueError):
iterator.__aiter__()
def test___aiter___restart_after_page(self):
iterator = PageAsyncIteratorImpl(None, None)
assert iterator.pages
# Make sure we cannot restart after starting the page iterator
with pytest.raises(ValueError):
iterator.__aiter__()
class TestAsyncGRPCIterator(object):
def test_constructor(self):
client = mock.sentinel.client
items_field = "items"
iterator = page_iterator_async.AsyncGRPCIterator(
client, mock.sentinel.method, mock.sentinel.request, items_field
)
assert not iterator._started
assert iterator.client is client
assert iterator.max_results is None
assert iterator.item_to_value is page_iterator_async._item_to_value_identity
assert iterator._method == mock.sentinel.method
assert iterator._request == mock.sentinel.request
assert iterator._items_field == items_field
assert (
iterator._request_token_field
== page_iterator_async.AsyncGRPCIterator._DEFAULT_REQUEST_TOKEN_FIELD
)
assert (
iterator._response_token_field
== page_iterator_async.AsyncGRPCIterator._DEFAULT_RESPONSE_TOKEN_FIELD
)
# Changing attributes.
assert iterator.page_number == 0
assert iterator.next_page_token is None
assert iterator.num_results == 0
def test_constructor_options(self):
client = mock.sentinel.client
items_field = "items"
request_field = "request"
response_field = "response"
iterator = page_iterator_async.AsyncGRPCIterator(
client,
mock.sentinel.method,
mock.sentinel.request,
items_field,
item_to_value=mock.sentinel.item_to_value,
request_token_field=request_field,
response_token_field=response_field,
max_results=42,
)
assert iterator.client is client
assert iterator.max_results == 42
assert iterator.item_to_value is mock.sentinel.item_to_value
assert iterator._method == mock.sentinel.method
assert iterator._request == mock.sentinel.request
assert iterator._items_field == items_field
assert iterator._request_token_field == request_field
assert iterator._response_token_field == response_field
@pytest.mark.asyncio
async def test_iterate(self):
request = mock.Mock(spec=["page_token"], page_token=None)
response1 = mock.Mock(items=["a", "b"], next_page_token="1")
response2 = mock.Mock(items=["c"], next_page_token="2")
response3 = mock.Mock(items=["d"], next_page_token="")
method = mock.AsyncMock(side_effect=[response1, response2, response3])
iterator = page_iterator_async.AsyncGRPCIterator(
mock.sentinel.client, method, request, "items"
)
assert iterator.num_results == 0
items = []
async for item in iterator:
items.append(item)
assert items == ["a", "b", "c", "d"]
method.assert_called_with(request)
assert method.call_count == 3
assert request.page_token == "2"
@pytest.mark.asyncio
async def test_iterate_with_max_results(self):
request = mock.Mock(spec=["page_token"], page_token=None)
response1 = mock.Mock(items=["a", "b"], next_page_token="1")
response2 = mock.Mock(items=["c"], next_page_token="2")
response3 = mock.Mock(items=["d"], next_page_token="")
method = mock.AsyncMock(side_effect=[response1, response2, response3])
iterator = page_iterator_async.AsyncGRPCIterator(
mock.sentinel.client, method, request, "items", max_results=3
)
assert iterator.num_results == 0
items = []
async for item in iterator:
items.append(item)
assert items == ["a", "b", "c"]
assert iterator.num_results == 3
method.assert_called_with(request)
assert method.call_count == 2
assert request.page_token == "1"
|
