KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use dynamodbstreams method in localstack
Best Python code snippet using localstack_python
test_streams.py
Source:test_streams.py 
1# Copyright 2020 ScyllaDB2#3# This file is part of Scylla.4#5# Scylla is free software: you can redistribute it and/or modify6# it under the terms of the GNU Affero General Public License as published by7# the Free Software Foundation, either version 3 of the License, or8# (at your option) any later version.9#10# Scylla is distributed in the hope that it will be useful,11# but WITHOUT ANY WARRANTY; without even the implied warranty of12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the13# GNU General Public License for more details.14#15# You should have received a copy of the GNU Affero General Public License16# along with Scylla. If not, see <http://www.gnu.org/licenses/>.17# Tests for stream operations: ListStreams, DescribeStream, GetShardIterator,18# GetRecords.19import pytest20import time21import urllib.request22from botocore.exceptions import ClientError23from util import list_tables, test_table_name, create_test_table, random_string, freeze24from contextlib import contextmanager25from urllib.error import URLError26from boto3.dynamodb.types import TypeDeserializer27stream_types = [ 'OLD_IMAGE', 'NEW_IMAGE', 'KEYS_ONLY', 'NEW_AND_OLD_IMAGES']28def disable_stream(dynamodbstreams, table):29 table.update(StreamSpecification={'StreamEnabled': False});30 # Wait for the stream to really be disabled. A table may have multiple31 # historic streams - we need all of them to become DISABLED. One of32 # them (the current one) may remain DISABLING for some time.33 exp = time.process_time() + 6034 while time.process_time() < exp:35 streams = dynamodbstreams.list_streams(TableName=table.name)36 disabled = True37 for stream in streams['Streams']:38 desc = dynamodbstreams.describe_stream(StreamArn=stream['StreamArn'])['StreamDescription']39 if desc['StreamStatus'] != 'DISABLED':40 disabled = False41 break42 if disabled:43 print('disabled stream on {}'.format(table.name))44 return45 time.sleep(0.5)46 pytest.fail("timed out")47 48# Cannot use fixtures. Because real dynamodb cannot _remove_ a stream49# once created. It can only expire 24h later. So reusing test_table for 50# example works great for scylla/local testing, but once we run against51# actual aws instances, we get lingering streams, and worse: cannot 52# create new ones to replace it, because we have overlapping types etc. 53# 54# So we have to create and delete a table per test. And not run this 55# test to often against aws. 56@contextmanager57def create_stream_test_table(dynamodb, StreamViewType=None):58 spec = { 'StreamEnabled': False }59 if StreamViewType != None:60 spec = {'StreamEnabled': True, 'StreamViewType': StreamViewType}61 table = create_test_table(dynamodb, StreamSpecification=spec,62 KeySchema=[ { 'AttributeName': 'p', 'KeyType': 'HASH' },63 { 'AttributeName': 'c', 'KeyType': 'RANGE' }64 ],65 AttributeDefinitions=[66 { 'AttributeName': 'p', 'AttributeType': 'S' },67 { 'AttributeName': 'c', 'AttributeType': 'S' },68 ])69 yield table70 while True:71 try:72 table.delete()73 return74 except ClientError as ce:75 # if the table has a stream currently being created we cannot76 # delete the table immediately. Again, only with real dynamo77 if ce.response['Error']['Code'] == 'ResourceInUseException':78 print('Could not delete table yet. Sleeping 5s.')79 time.sleep(5)80 continue;81 raise82def wait_for_active_stream(dynamodbstreams, table, timeout=60):83 exp = time.process_time() + timeout84 while time.process_time() < exp:85 streams = dynamodbstreams.list_streams(TableName=table.name)86 for stream in streams['Streams']:87 arn = stream['StreamArn']88 if arn == None:89 continue90 desc = dynamodbstreams.describe_stream(StreamArn=arn)['StreamDescription']91 if not 'StreamStatus' in desc or desc.get('StreamStatus') == 'ENABLED':92 return (arn, stream['StreamLabel']);93 # real dynamo takes some time until a stream is usable94 print("Stream not available. Sleep 5s...")95 time.sleep(5)96 assert False97# Local java dynamodb server version behaves differently from 98# the "real" one. Most importantly, it does not verify a number of 99# parameters, and consequently does not throw when called with borked 100# args. This will try to check if we are in fact running against 101# this test server, and if so, just raise the error here and be done 102# with it. All this just so we can run through the tests on 103# aws, scylla and local. 104def is_local_java(dynamodbstreams):105 # no good way to check, but local server runs on a Jetty, 106 # so check for that. 107 url = dynamodbstreams.meta.endpoint_url108 try: 109 urllib.request.urlopen(url)110 except URLError as e:111 if hasattr(e, 'info'):112 return e.info()['Server'].startswith('Jetty')113 return False114def ensure_java_server(dynamodbstreams, error='ValidationException'):115 # no good way to check, but local server has a "shell" builtin, 116 # so check for that. 117 if is_local_java(dynamodbstreams):118 if error != None:119 raise ClientError({'Error': { 'Code' : error }}, '')120 return121 assert False122def test_list_streams_create(dynamodb, dynamodbstreams):123 for type in stream_types:124 with create_stream_test_table(dynamodb, StreamViewType=type) as table:125 wait_for_active_stream(dynamodbstreams, table)126def test_list_streams_alter(dynamodb, dynamodbstreams):127 for type in stream_types:128 with create_stream_test_table(dynamodb, StreamViewType=None) as table:129 res = table.update(StreamSpecification={'StreamEnabled': True, 'StreamViewType': type});130 wait_for_active_stream(dynamodbstreams, table)131def test_list_streams_paged(dynamodb, dynamodbstreams):132 for type in stream_types:133 with create_stream_test_table(dynamodb, StreamViewType=type) as table1:134 with create_stream_test_table(dynamodb, StreamViewType=type) as table2:135 wait_for_active_stream(dynamodbstreams, table1)136 wait_for_active_stream(dynamodbstreams, table2)137 streams = dynamodbstreams.list_streams(Limit=1)138 assert streams139 assert streams.get('Streams')140 assert streams.get('LastEvaluatedStreamArn')141 tables = [ table1.name, table2.name ]142 while True:143 for s in streams['Streams']:144 name = s['TableName']145 if name in tables: tables.remove(name)146 if not tables:147 break148 streams = dynamodbstreams.list_streams(Limit=1, ExclusiveStartStreamArn=streams['LastEvaluatedStreamArn'])149@pytest.mark.skip(reason="Python driver validates Limit, so trying to test it is pointless")150def test_list_streams_zero_limit(dynamodb, dynamodbstreams):151 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:152 with pytest.raises(ClientError, match='ValidationException'):153 wait_for_active_stream(dynamodbstreams, table)154 dynamodbstreams.list_streams(Limit=0)155def test_create_streams_wrong_type(dynamodb, dynamodbstreams, test_table):156 with pytest.raises(ClientError, match='ValidationException'):157 # should throw158 test_table.update(StreamSpecification={'StreamEnabled': True, 'StreamViewType': 'Fisk'});159 # just in case the test fails, disable stream again160 test_table.update(StreamSpecification={'StreamEnabled': False});161def test_list_streams_empty(dynamodb, dynamodbstreams, test_table):162 streams = dynamodbstreams.list_streams(TableName=test_table.name)163 assert 'Streams' in streams164 assert not streams['Streams'] # empty165def test_list_streams_with_nonexistent_last_stream(dynamodb, dynamodbstreams):166 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:167 with pytest.raises(ClientError, match='ValidationException'):168 streams = dynamodbstreams.list_streams(TableName=table.name, ExclusiveStartStreamArn='kossaapaaasdafsdaasdasdasdasasdasfadfadfasdasdas')169 assert 'Streams' in streams170 assert not streams['Streams'] # empty171 # local java dynamodb does _not_ raise validation error for 172 # malformed stream arn here. verify 173 ensure_java_server(dynamodbstreams)174def test_describe_stream(dynamodb, dynamodbstreams):175 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:176 streams = dynamodbstreams.list_streams(TableName=table.name)177 arn = streams['Streams'][0]['StreamArn'];178 desc = dynamodbstreams.describe_stream(StreamArn=arn)179 assert desc;180 assert desc.get('StreamDescription')181 assert desc['StreamDescription']['StreamArn'] == arn182 assert desc['StreamDescription']['StreamStatus'] != 'DISABLED'183 assert desc['StreamDescription']['StreamViewType'] == 'KEYS_ONLY'184 assert desc['StreamDescription']['TableName'] == table.name185 assert desc['StreamDescription'].get('Shards')186 assert desc['StreamDescription']['Shards'][0].get('ShardId')187 assert desc['StreamDescription']['Shards'][0].get('SequenceNumberRange')188 assert desc['StreamDescription']['Shards'][0]['SequenceNumberRange'].get('StartingSequenceNumber')189 # We don't know what the sequence number is supposed to be, but the190 # DynamoDB documentation requires that it contains only numeric191 # characters and some libraries rely on this. Reproduces issue #7158:192 assert desc['StreamDescription']['Shards'][0]['SequenceNumberRange']['StartingSequenceNumber'].isdecimal()193@pytest.mark.xfail(reason="alternator does not have creation time on streams")194def test_describe_stream_create_time(dynamodb, dynamodbstreams):195 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:196 streams = dynamodbstreams.list_streams(TableName=table.name)197 arn = streams['Streams'][0]['StreamArn'];198 desc = dynamodbstreams.describe_stream(StreamArn=arn)199 assert desc;200 assert desc.get('StreamDescription')201 # note these are non-required attributes202 assert 'CreationRequestDateTime' in desc['StreamDescription']203def test_describe_nonexistent_stream(dynamodb, dynamodbstreams):204 with pytest.raises(ClientError, match='ResourceNotFoundException' if is_local_java(dynamodbstreams) else 'ValidationException'):205 streams = dynamodbstreams.describe_stream(StreamArn='sdfadfsdfnlfkajakfgjalksfgklasjklasdjfklasdfasdfgasf')206def test_describe_stream_with_nonexistent_last_shard(dynamodb, dynamodbstreams):207 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:208 streams = dynamodbstreams.list_streams(TableName=table.name)209 arn = streams['Streams'][0]['StreamArn'];210 try:211 desc = dynamodbstreams.describe_stream(StreamArn=arn, ExclusiveStartShardId='zzzzzzzzzzzzzzzzzzzzzzzzsfasdgagadfadfgagkjsdfsfsdjfjks')212 assert not desc['StreamDescription']['Shards']213 except:214 # local java throws here. real does not. 215 ensure_java_server(dynamodbstreams, error=None)216def test_get_shard_iterator(dynamodb, dynamodbstreams):217 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:218 streams = dynamodbstreams.list_streams(TableName=table.name)219 arn = streams['Streams'][0]['StreamArn'];220 desc = dynamodbstreams.describe_stream(StreamArn=arn)221 shard_id = desc['StreamDescription']['Shards'][0]['ShardId'];222 seq = desc['StreamDescription']['Shards'][0]['SequenceNumberRange']['StartingSequenceNumber'];223 # spec says shard_id must be 65 chars or less224 assert len(shard_id) <= 65225 for type in ['AT_SEQUENCE_NUMBER', 'AFTER_SEQUENCE_NUMBER']: 226 iter = dynamodbstreams.get_shard_iterator(227 StreamArn=arn, ShardId=shard_id, ShardIteratorType=type, SequenceNumber=seq228 )229 assert iter.get('ShardIterator')230 for type in ['TRIM_HORIZON', 'LATEST']: 231 iter = dynamodbstreams.get_shard_iterator(232 StreamArn=arn, ShardId=shard_id, ShardIteratorType=type233 )234 assert iter.get('ShardIterator')235 for type in ['AT_SEQUENCE_NUMBER', 'AFTER_SEQUENCE_NUMBER']: 236 # must have seq in these modes237 with pytest.raises(ClientError, match='ValidationException'):238 iter = dynamodbstreams.get_shard_iterator(239 StreamArn=arn, ShardId=shard_id, ShardIteratorType=type240 )241 for type in ['TRIM_HORIZON', 'LATEST']: 242 # should not set "seq" in these modes243 with pytest.raises(ClientError, match='ValidationException'):244 dynamodbstreams.get_shard_iterator(245 StreamArn=arn, ShardId=shard_id, ShardIteratorType=type, SequenceNumber=seq246 )247 # bad arn248 with pytest.raises(ClientError, match='ValidationException'):249 iter = dynamodbstreams.get_shard_iterator(250 StreamArn='sdfadsfsdfsdgdfsgsfdabadfbabdadsfsdfsdfsdfsdfsdfsdfdfdssdffbdfdf', ShardId=shard_id, ShardIteratorType=type, SequenceNumber=seq251 )252 # bad shard id 253 with pytest.raises(ClientError, match='ResourceNotFoundException'):254 dynamodbstreams.get_shard_iterator(StreamArn=arn, ShardId='semprinidfaasdasfsdvacsdcfsdsvsdvsdvsdvsdvsdv', 255 ShardIteratorType='LATEST'256 )257 # bad iter type258 with pytest.raises(ClientError, match='ValidationException'):259 dynamodbstreams.get_shard_iterator(StreamArn=arn, ShardId=shard_id, 260 ShardIteratorType='bulle', SequenceNumber=seq261 )262 # bad seq 263 with pytest.raises(ClientError, match='ValidationException'):264 dynamodbstreams.get_shard_iterator(StreamArn=arn, ShardId=shard_id, 265 ShardIteratorType='LATEST', SequenceNumber='sdfsafglldfngjdafnasdflgnaldklkafdsgklnasdlv'266 )267def test_get_shard_iterator_for_nonexistent_stream(dynamodb, dynamodbstreams):268 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:269 (arn, label) = wait_for_active_stream(dynamodbstreams, table)270 desc = dynamodbstreams.describe_stream(StreamArn=arn)271 shards = desc['StreamDescription']['Shards']272 with pytest.raises(ClientError, match='ResourceNotFoundException' if is_local_java(dynamodbstreams) else 'ValidationException'):273 dynamodbstreams.get_shard_iterator(274 StreamArn='sdfadfsddafgdafsgjnadflkgnalngalsdfnlkasnlkasdfasdfasf', ShardId=shards[0]['ShardId'], ShardIteratorType='LATEST'275 )276def test_get_shard_iterator_for_nonexistent_shard(dynamodb, dynamodbstreams):277 with create_stream_test_table(dynamodb, StreamViewType='KEYS_ONLY') as table:278 streams = dynamodbstreams.list_streams(TableName=table.name)279 arn = streams['Streams'][0]['StreamArn'];280 with pytest.raises(ClientError, match='ResourceNotFoundException'):281 dynamodbstreams.get_shard_iterator(282 StreamArn=arn, ShardId='adfasdasdasdasdasdasdasdasdasasdasd', ShardIteratorType='LATEST'283 )284def test_get_records(dynamodb, dynamodbstreams):285 # TODO: add tests for storage/transactionable variations and global/local index286 with create_stream_test_table(dynamodb, StreamViewType='NEW_AND_OLD_IMAGES') as table:287 (arn, label) = wait_for_active_stream(dynamodbstreams, table)288 p = 'piglet'289 c = 'ninja'290 val = 'lucifers'291 val2 = 'flowers'292 table.put_item(Item={'p': p, 'c': c, 'a1': val, 'a2': val2})293 nval = 'semprini'294 nval2 = 'nudge'295 table.update_item(Key={'p': p, 'c': c}, 296 AttributeUpdates={ 'a1': {'Value': nval, 'Action': 'PUT'},297 'a2': {'Value': nval2, 'Action': 'PUT'}298 })299 has_insert = False300 # in truth, we should sleep already here, since at least scylla301 # will not be able to produce any stream content until 302 # ~30s after insert/update (confidence iterval)303 # but it is useful to see a working null-iteration as well, so 304 # lets go already.305 while True:306 desc = dynamodbstreams.describe_stream(StreamArn=arn)307 iterators = []308 while True:309 shards = desc['StreamDescription']['Shards']310 for shard in shards:311 shard_id = shard['ShardId']312 start = shard['SequenceNumberRange']['StartingSequenceNumber']313 iter = dynamodbstreams.get_shard_iterator(StreamArn=arn, ShardId=shard_id, ShardIteratorType='AT_SEQUENCE_NUMBER',SequenceNumber=start)['ShardIterator']314 iterators.append(iter)315 last_shard = desc["StreamDescription"].get("LastEvaluatedShardId")316 if not last_shard:317 break318 desc = dynamodbstreams.describe_stream(StreamArn=arn, ExclusiveStartShardId=last_shard)319 next_iterators = []320 while iterators:321 iter = iterators.pop(0)322 response = dynamodbstreams.get_records(ShardIterator=iter, Limit=1000)323 if 'NextShardIterator' in response:324 next_iterators.append(response['NextShardIterator'])325 records = response.get('Records')326 # print("Query {} -> {}".format(iter, records))327 if records:328 for record in records:329 # print("Record: {}".format(record))330 type = record['eventName']331 dynamodb = record['dynamodb']332 keys = dynamodb['Keys']333 334 assert keys.get('p')335 assert keys.get('c')336 assert keys['p'].get('S')337 assert keys['p']['S'] == p338 assert keys['c'].get('S')339 assert keys['c']['S'] == c340 if type == 'MODIFY' or type == 'INSERT':341 assert dynamodb.get('NewImage')342 newimage = dynamodb['NewImage'];343 assert newimage.get('a1')344 assert newimage.get('a2')345 if type == 'INSERT' or (type == 'MODIFY' and not has_insert):346 assert newimage['a1']['S'] == val347 assert newimage['a2']['S'] == val2348 has_insert = True349 continue350 if type == 'MODIFY':351 assert has_insert352 assert newimage['a1']['S'] == nval353 assert newimage['a2']['S'] == nval2354 assert dynamodb.get('OldImage')355 oldimage = dynamodb['OldImage'];356 assert oldimage.get('a1')357 assert oldimage.get('a2')358 assert oldimage['a1']['S'] == val359 assert oldimage['a2']['S'] == val2360 return361 print("Not done. Sleep 10s...")362 time.sleep(10)363 iterators = next_iterators364def test_get_records_nonexistent_iterator(dynamodbstreams):365 with pytest.raises(ClientError, match='ValidationException'):366 dynamodbstreams.get_records(ShardIterator='sdfsdfsgagaddafgagasgasgasdfasdfasdfasdfasdgasdasdgasdg', Limit=1000)367##############################################################################368# Fixtures for creating a table with a stream enabled with one of the allowed369# StreamViewType settings (KEYS_ONLY, NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES).370# Unfortunately changing the StreamViewType setting of an existing stream is371# not allowed (see test_streams_change_type), and while removing and re-adding372# a stream is posssible, it is very slow. So we create four different fixtures373# with the four different StreamViewType settings for these four fixtures.374#375# It turns out that DynamoDB makes reusing the same table in different tests376# very difficult, because when we request a "LATEST" iterator we sometimes377# miss the immediately following write (this issue doesn't happen in378# ALternator, just in DynamoDB - presumably LATEST adds some time slack?)379# So all the fixtures we create below have scope="function", meaning that a380# separate table is created for each of the tests using these fixtures. This381# slows the tests down a bit, but not by much (about 0.05 seconds per test).382# It is still worthwhile to use a fixture rather than to create a table383# explicitly - it is convenient, safe (the table gets deleted automatically)384# and if in the future we can work around the DynamoDB problem, we can return385# these fixtures to session scope.386def create_table_ss(dynamodb, dynamodbstreams, type):387 table = create_test_table(dynamodb,388 KeySchema=[{ 'AttributeName': 'p', 'KeyType': 'HASH' }, { 'AttributeName': 'c', 'KeyType': 'RANGE' }],389 AttributeDefinitions=[{ 'AttributeName': 'p', 'AttributeType': 'S' }, { 'AttributeName': 'c', 'AttributeType': 'S' }],390 StreamSpecification={ 'StreamEnabled': True, 'StreamViewType': type })391 (arn, label) = wait_for_active_stream(dynamodbstreams, table, timeout=60)392 yield table, arn393 table.delete()394@pytest.fixture(scope="function")395def test_table_ss_keys_only(dynamodb, dynamodbstreams):396 yield from create_table_ss(dynamodb, dynamodbstreams, 'KEYS_ONLY')397@pytest.fixture(scope="function")398def test_table_ss_new_image(dynamodb, dynamodbstreams):399 yield from create_table_ss(dynamodb, dynamodbstreams, 'NEW_IMAGE')400@pytest.fixture(scope="function")401def test_table_ss_old_image(dynamodb, dynamodbstreams):402 yield from create_table_ss(dynamodb, dynamodbstreams, 'OLD_IMAGE')403@pytest.fixture(scope="function")404def test_table_ss_new_and_old_images(dynamodb, dynamodbstreams):405 yield from create_table_ss(dynamodb, dynamodbstreams, 'NEW_AND_OLD_IMAGES')406# Test that it is, sadly, not allowed to use UpdateTable on a table which407# already has a stream enabled to change that stream's StreamViewType.408# Currently, Alternator does allow this (see issue #6939), so the test is409# marked xfail.410@pytest.mark.xfail(reason="Alternator allows changing StreamViewType - see issue #6939")411def test_streams_change_type(test_table_ss_keys_only):412 table, arn = test_table_ss_keys_only413 with pytest.raises(ClientError, match='ValidationException.*already'):414 table.update(StreamSpecification={'StreamEnabled': True, 'StreamViewType': 'OLD_IMAGE'});415 # If the above change succeeded (because of issue #6939), switch it back :-)416 table.update(StreamSpecification={'StreamEnabled': True, 'StreamViewType': 'KEYS_ONLY'});417# Utility function for listing all the shards of the given stream arn.418# Implemented by multiple calls to DescribeStream, possibly several pages419# until all the shards are returned. The return of this function should be420# cached - it is potentially slow, and DynamoDB documentation even states421# DescribeStream may only be called at a maximum rate of 10 times per second.422# list_shards() only returns the shard IDs, not the information about the423# shards' sequence number range, which is also returned by DescribeStream.424def list_shards(dynamodbstreams, arn):425 # By default DescribeStream lists a limit of 100 shards. For faster426 # tests we reduced the number of shards in the testing setup to427 # 32 (16 vnodes x 2 cpus), see issue #6979, so to still exercise this428 # paging feature, lets use a limit of 10.429 limit = 10430 response = dynamodbstreams.describe_stream(StreamArn=arn, Limit=limit)['StreamDescription']431 assert len(response['Shards']) <= limit432 shards = [x['ShardId'] for x in response['Shards']]433 while 'LastEvaluatedShardId' in response:434 # 7409 kinesis ignores LastEvaluatedShardId and just looks at last shard435 assert shards[-1] == response['LastEvaluatedShardId']436 response = dynamodbstreams.describe_stream(StreamArn=arn, Limit=limit,437 ExclusiveStartShardId=response['LastEvaluatedShardId'])['StreamDescription']438 assert len(response['Shards']) <= limit439 shards.extend([x['ShardId'] for x in response['Shards']])440 print('Number of shards in stream: {}'.format(len(shards)))441 assert len(set(shards)) == len(shards)442 # 7409 - kinesis required shards to be in lexical order.443 # verify.444 assert shards == sorted(shards)445 # special test: ensure we get nothing more if we ask for starting at the last446 # of the last447 response = dynamodbstreams.describe_stream(StreamArn=arn,448 ExclusiveStartShardId=shards[-1])['StreamDescription']449 assert len(response['Shards']) == 0450 return shards451# Utility function for getting shard iterators starting at "LATEST" for452# all the shards of the given stream arn.453def latest_iterators(dynamodbstreams, arn):454 iterators = []455 for shard_id in list_shards(dynamodbstreams, arn):456 iterators.append(dynamodbstreams.get_shard_iterator(StreamArn=arn,457 ShardId=shard_id, ShardIteratorType='LATEST')['ShardIterator'])458 assert len(set(iterators)) == len(iterators)459 return iterators460# Utility function for fetching more content from the stream (given its461# array of iterators) into an "output" array. Call repeatedly to get more462# content - the function returns a new array of iterators which should be463# used to replace the input list of iterators.464# Note that the order of the updates is guaranteed for the same partition,465# but cannot be trusted for *different* partitions.466def fetch_more(dynamodbstreams, iterators, output):467 new_iterators = []468 for iter in iterators:469 response = dynamodbstreams.get_records(ShardIterator=iter)470 if 'NextShardIterator' in response:471 new_iterators.append(response['NextShardIterator'])472 output.extend(response['Records'])473 assert len(set(new_iterators)) == len(new_iterators)474 return new_iterators475# Utility function for comparing "output" as fetched by fetch_more(), to a list476# expected_events, each of which looks like:477# [type, keys, old_image, new_image]478# where type is REMOVE, INSERT or MODIFY.479# The "mode" parameter specifies which StreamViewType mode (KEYS_ONLY,480# OLD_IMAGE, NEW_IMAGE, NEW_AND_OLD_IMAGES) was supposedly used to generate481# "output". This mode dictates what we can compare - e.g., in KEYS_ONLY mode482# the compare_events() function ignores the the old and new image in483# expected_events.484# compare_events() throws an exception immediately if it sees an unexpected485# event, but if some of the expected events are just missing in the "output",486# it only returns false - suggesting maybe the caller needs to try again487# later - maybe more output is coming.488# Note that the order of events is only guaranteed (and therefore compared)489# inside a single partition.490def compare_events(expected_events, output, mode):491 # The order of expected_events is only meaningful inside a partition, so492 # let's convert it into a map indexed by partition key.493 expected_events_map = {}494 for event in expected_events:495 expected_type, expected_key, expected_old_image, expected_new_image = event496 # For simplicity, we actually use the entire key, not just the partiton497 # key. We only lose a bit of testing power we didn't plan to test anyway498 # (that events for different items in the same partition are ordered).499 key = freeze(expected_key)500 if not key in expected_events_map:501 expected_events_map[key] = []502 expected_events_map[key].append(event)503 # Iterate over the events in output. An event for a certain key needs to504 # be the *first* remaining event for this key in expected_events_map (and505 # then we remove this matched even from expected_events_map)506 for event in output:507 # In DynamoDB, eventSource is 'aws:dynamodb'. We decided to set it to508 # a *different* value - 'scylladb:alternator'. Issue #6931.509 assert 'eventSource' in event510 # Alternator is missing "awsRegion", which makes little sense for it511 # (although maybe we should have provided the DC name). Issue #6931.512 #assert 'awsRegion' in event513 # Alternator is also missing the "eventVersion" entry. Issue #6931.514 #assert 'eventVersion' in event515 # Check that eventID appears, but can't check much on what it is.516 assert 'eventID' in event517 op = event['eventName']518 record = event['dynamodb']519 # record['Keys'] is "serialized" JSON, ({'S', 'thestring'}), so we520 # want to deserialize it to match our expected_events content.521 deserializer = TypeDeserializer()522 key = {x:deserializer.deserialize(y) for (x,y) in record['Keys'].items()}523 expected_type, expected_key, expected_old_image, expected_new_image = expected_events_map[freeze(key)].pop(0)524 if expected_type != '*': # hack to allow a caller to not test op, to bypass issue #6918.525 assert op == expected_type526 assert record['StreamViewType'] == mode527 # We don't know what ApproximateCreationDateTime should be, but we do528 # know it needs to be a timestamp - there is conflicting documentation529 # in what format (ISO 8601?). In any case, boto3 parses this timestamp530 # for us, so we can't check it here, beyond checking it exists.531 assert 'ApproximateCreationDateTime' in record532 # We don't know what SequenceNumber is supposed to be, but the DynamoDB533 # documentation requires that it contains only numeric characters and534 # some libraries rely on this. This reproduces issue #7158:535 assert 'SequenceNumber' in record536 assert record['SequenceNumber'].isdecimal()537 # Alternator doesn't set the SizeBytes member. Issue #6931.538 #assert 'SizeBytes' in record539 if mode == 'KEYS_ONLY':540 assert not 'NewImage' in record541 assert not 'OldImage' in record542 elif mode == 'NEW_IMAGE':543 assert not 'OldImage' in record544 if expected_new_image == None:545 assert not 'NewImage' in record546 else:547 new_image = {x:deserializer.deserialize(y) for (x,y) in record['NewImage'].items()}548 assert expected_new_image == new_image549 elif mode == 'OLD_IMAGE':550 assert not 'NewImage' in record551 if expected_old_image == None:552 assert not 'OldImage' in record553 pass554 else:555 old_image = {x:deserializer.deserialize(y) for (x,y) in record['OldImage'].items()}556 assert expected_old_image == old_image557 elif mode == 'NEW_AND_OLD_IMAGES':558 if expected_new_image == None:559 assert not 'NewImage' in record560 else:561 new_image = {x:deserializer.deserialize(y) for (x,y) in record['NewImage'].items()}562 assert expected_new_image == new_image563 if expected_old_image == None:564 assert not 'OldImage' in record565 else:566 old_image = {x:deserializer.deserialize(y) for (x,y) in record['OldImage'].items()}567 assert expected_old_image == old_image568 else:569 pytest.fail('cannot happen')570 # After the above loop, expected_events_map should remain empty arrays.571 # If it isn't, one of the expected events did not yet happen. Return False.572 for entry in expected_events_map.values():573 if len(entry) > 0:574 return False575 return True576# Convenience funtion used to implement several tests below. It runs a given577# function "updatefunc" which is supposed to do some updates to the table578# and also return an expected_events list. do_test() then fetches the streams579# data and compares it to the expected_events using compare_events().580def do_test(test_table_ss_stream, dynamodbstreams, updatefunc, mode, p = random_string(), c = random_string()):581 table, arn = test_table_ss_stream582 iterators = latest_iterators(dynamodbstreams, arn)583 expected_events = updatefunc(table, p, c)584 # Updating the stream is asynchronous. Moreover, it may even be delayed585 # artificially (see Alternator's alternator_streams_time_window_s config).586 # So if compare_events() reports the stream data is missing some of the587 # expected events (by returning False), we need to retry it for some time.588 # Note that compare_events() throws if the stream data contains *wrong*589 # (unexpected) data, so even failing tests usually finish reasonably590 # fast - depending on the alternator_streams_time_window_s parameter.591 # This is optimization is important to keep *failing* tests reasonably592 # fast and not have to wait until the following arbitrary timeout.593 timeout = time.time() + 20594 output = []595 while time.time() < timeout:596 iterators = fetch_more(dynamodbstreams, iterators, output)597 print("after fetch_more number expected_events={}, output={}".format(len(expected_events), len(output)))598 if compare_events(expected_events, output, mode):599 # success!600 return601 time.sleep(0.5)602 # If we're still here, the last compare_events returned false.603 pytest.fail('missing events in output: {}'.format(output))604# Test a single PutItem of a new item. Should result in a single INSERT605# event. Currently fails because in Alternator, PutItem - which generates a606# tombstone to *replace* an item - generates REMOVE+MODIFY (issue #6930).607@pytest.mark.xfail(reason="Currently fails - see issue #6930")608def test_streams_putitem_keys_only(test_table_ss_keys_only, dynamodbstreams):609 def do_updates(table, p, c):610 events = []611 table.put_item(Item={'p': p, 'c': c, 'x': 2})612 events.append(['INSERT', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])613 return events614 do_test(test_table_ss_keys_only, dynamodbstreams, do_updates, 'KEYS_ONLY')615# Test a single UpdateItem. Should result in a single INSERT event.616# Currently fails because Alternator generates a MODIFY event even though617# this is a new item (issue #6918).618@pytest.mark.xfail(reason="Currently fails - see issue #6918")619def test_streams_updateitem_keys_only(test_table_ss_keys_only, dynamodbstreams):620 def do_updates(table, p, c):621 events = []622 table.update_item(Key={'p': p, 'c': c},623 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 2})624 events.append(['INSERT', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])625 return events626 do_test(test_table_ss_keys_only, dynamodbstreams, do_updates, 'KEYS_ONLY')627# This is exactly the same test as test_streams_updateitem_keys_only except628# we don't verify the type of even we find (MODIFY or INSERT). It allows us629# to have at least one good GetRecords test until solving issue #6918.630# When we do solve that issue, this test should be removed.631def test_streams_updateitem_keys_only_2(test_table_ss_keys_only, dynamodbstreams):632 def do_updates(table, p, c):633 events = []634 table.update_item(Key={'p': p, 'c': c},635 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 2})636 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])637 return events638 do_test(test_table_ss_keys_only, dynamodbstreams, do_updates, 'KEYS_ONLY')639# Test OLD_IMAGE using UpdateItem. Verify that the OLD_IMAGE indeed includes,640# as needed, the entire old item and not just the modified columns.641# Reproduces issue #6935642def test_streams_updateitem_old_image(test_table_ss_old_image, dynamodbstreams):643 def do_updates(table, p, c):644 events = []645 table.update_item(Key={'p': p, 'c': c},646 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 2})647 # We use here '*' instead of the really expected 'INSERT' to avoid648 # checking again the same Alternator bug already checked by649 # test_streams_updateitem_keys_only (issue #6918).650 # Note: The "None" as OldImage here tests that the OldImage should be651 # missing because the item didn't exist. This reproduces issue #6933.652 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])653 table.update_item(Key={'p': p, 'c': c},654 UpdateExpression='SET y = :val1', ExpressionAttributeValues={':val1': 3})655 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2}, {'p': p, 'c': c, 'x': 2, 'y': 3}])656 return events657 do_test(test_table_ss_old_image, dynamodbstreams, do_updates, 'OLD_IMAGE')658# Above we verified that if an item did not previously exist, the OLD_IMAGE659# would be missing, but if the item did previously exist, OLD_IMAGE should660# be present and must include the key. Here we confirm the special case the661# latter case - the case of a pre-existing *empty* item, which has just the662# key - in this case since the item did exist, OLD_IMAGE should be returned -663# and include just the key. This is a special case of reproducing #6935 -664# the first patch for this issue failed in this special case.665def test_streams_updateitem_old_image_empty_item(test_table_ss_old_image, dynamodbstreams):666 def do_updates(table, p, c):667 events = []668 # Create an *empty* item, with nothing except a key:669 table.update_item(Key={'p': p, 'c': c})670 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c}])671 table.update_item(Key={'p': p, 'c': c},672 UpdateExpression='SET y = :val1', ExpressionAttributeValues={':val1': 3})673 # Note that OLD_IMAGE should be present and be the empty item,674 # with just a key, not entirely missing.675 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c}, {'p': p, 'c': c, 'y': 3}])676 return events677 do_test(test_table_ss_old_image, dynamodbstreams, do_updates, 'OLD_IMAGE')678# Test that OLD_IMAGE indeed includes the entire old item and not just the679# modified attributes, in the special case of attributes which are a key of680# a secondary index.681# The unique thing about this case is that as currently implemented,682# secondary-index key attributes are real Scylla columns, contrasting with683# other attributes which are just elements of a map. And our CDC684# implementation treats those cases differently - when a map is modified685# the preimage includes the entire content of the map, but for regular686# columns they are only included in the preimage if they change.687# Currently fails in Alternator because the item's key is missing in688# OldImage (#6935) and the LSI key is also missing (#7030).689@pytest.fixture(scope="function")690def test_table_ss_old_image_and_lsi(dynamodb, dynamodbstreams):691 table = create_test_table(dynamodb,692 KeySchema=[693 {'AttributeName': 'p', 'KeyType': 'HASH'},694 {'AttributeName': 'c', 'KeyType': 'RANGE'}],695 AttributeDefinitions=[696 { 'AttributeName': 'p', 'AttributeType': 'S' },697 { 'AttributeName': 'c', 'AttributeType': 'S' },698 { 'AttributeName': 'k', 'AttributeType': 'S' }],699 LocalSecondaryIndexes=[{700 'IndexName': 'index',701 'KeySchema': [702 {'AttributeName': 'p', 'KeyType': 'HASH'},703 {'AttributeName': 'k', 'KeyType': 'RANGE'}],704 'Projection': { 'ProjectionType': 'ALL' }705 }],706 StreamSpecification={ 'StreamEnabled': True, 'StreamViewType': 'OLD_IMAGE' })707 (arn, label) = wait_for_active_stream(dynamodbstreams, table, timeout=60)708 yield table, arn709 table.delete()710def test_streams_updateitem_old_image_lsi(test_table_ss_old_image_and_lsi, dynamodbstreams):711 def do_updates(table, p, c):712 events = []713 table.update_item(Key={'p': p, 'c': c},714 UpdateExpression='SET x = :x, k = :k',715 ExpressionAttributeValues={':x': 2, ':k': 'dog'})716 # We use here '*' instead of the really expected 'INSERT' to avoid717 # checking again the same Alternator bug already checked by718 # test_streams_updateitem_keys_only (issue #6918).719 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2, 'k': 'dog'}])720 table.update_item(Key={'p': p, 'c': c},721 UpdateExpression='SET y = :y', ExpressionAttributeValues={':y': 3})722 # In issue #7030, the 'k' value was missing from the OldImage.723 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2, 'k': 'dog'}, {'p': p, 'c': c, 'x': 2, 'k': 'dog', 'y': 3}])724 return events725 do_test(test_table_ss_old_image_and_lsi, dynamodbstreams, do_updates, 'OLD_IMAGE')726# Tests similar to the above tests for OLD_IMAGE, just for NEW_IMAGE mode.727# Verify that the NEW_IMAGE includes the entire old item (including the key),728# that deleting the item results in a missing NEW_IMAGE, and that setting the729# item to be empty has a different result - a NEW_IMAGE with just a key.730# Reproduces issue #7107.731def test_streams_new_image(test_table_ss_new_image, dynamodbstreams):732 def do_updates(table, p, c):733 events = []734 table.update_item(Key={'p': p, 'c': c},735 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 2})736 # Confirm that when adding one attribute "x", the NewImage contains both737 # the new x, and the key columns (p and c).738 # We use here '*' instead of 'INSERT' to avoid testing issue #6918 here.739 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])740 # Confirm that when adding just attribute "y", the NewImage will contain741 # all the attributes, including the old "x":742 table.update_item(Key={'p': p, 'c': c},743 UpdateExpression='SET y = :val1', ExpressionAttributeValues={':val1': 3})744 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2}, {'p': p, 'c': c, 'x': 2, 'y': 3}])745 # Confirm that when deleting the columns x and y, the NewImage becomes746 # empty - but still exists and contains the key columns,747 table.update_item(Key={'p': p, 'c': c},748 UpdateExpression='REMOVE x, y')749 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2, 'y': 3}, {'p': p, 'c': c}])750 # Confirm that deleting the item results in a missing NewImage:751 table.delete_item(Key={'p': p, 'c': c})752 events.append(['REMOVE', {'p': p, 'c': c}, {'p': p, 'c': c}, None])753 return events754 do_test(test_table_ss_new_image, dynamodbstreams, do_updates, 'NEW_IMAGE')755# Test similar to the above test for NEW_IMAGE corner cases, but here for756# NEW_AND_OLD_IMAGES mode.757# Although it is likely that if both OLD_IMAGE and NEW_IMAGE work correctly then758# so will the combined NEW_AND_OLD_IMAGES mode, it is still possible that the759# implementation of the combined mode has unique bugs, so it is worth testing760# it separately.761# Reproduces issue #7107.762def test_streams_new_and_old_images(test_table_ss_new_and_old_images, dynamodbstreams):763 def do_updates(table, p, c):764 events = []765 table.update_item(Key={'p': p, 'c': c},766 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 2})767 # The item doesn't yet exist, so OldImage is missing.768 # We use here '*' instead of 'INSERT' to avoid testing issue #6918 here.769 events.append(['*', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])770 # Confirm that when adding just attribute "y", the NewImage will contain771 # all the attributes, including the old "x". Also, OldImage contains the772 # key attributes, not just "x":773 table.update_item(Key={'p': p, 'c': c},774 UpdateExpression='SET y = :val1', ExpressionAttributeValues={':val1': 3})775 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2}, {'p': p, 'c': c, 'x': 2, 'y': 3}])776 # Confirm that when deleting the attributes x and y, the NewImage becomes777 # empty - but still exists and contains the key attributes:778 table.update_item(Key={'p': p, 'c': c},779 UpdateExpression='REMOVE x, y')780 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2, 'y': 3}, {'p': p, 'c': c}])781 # Confirm that when adding an attribute z to the empty item, OldItem is782 # not missing - it just contains only the key attributes:783 table.update_item(Key={'p': p, 'c': c},784 UpdateExpression='SET z = :val1', ExpressionAttributeValues={':val1': 4})785 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c}, {'p': p, 'c': c, 'z': 4}])786 # Confirm that deleting the item results in a missing NewImage:787 table.delete_item(Key={'p': p, 'c': c})788 events.append(['REMOVE', {'p': p, 'c': c}, {'p': p, 'c': c, 'z': 4}, None])789 return events790 do_test(test_table_ss_new_and_old_images, dynamodbstreams, do_updates, 'NEW_AND_OLD_IMAGES')791# Test that when a stream shard has no data to read, GetRecords returns an792# empty Records array - not a missing one. Reproduces issue #6926.793def test_streams_no_records(test_table_ss_keys_only, dynamodbstreams):794 table, arn = test_table_ss_keys_only795 # Get just one shard - any shard - and its LATEST iterator. Because it's796 # LATEST, there will be no data to read from this iterator.797 shard = dynamodbstreams.describe_stream(StreamArn=arn, Limit=1)['StreamDescription']['Shards'][0]798 shard_id = shard['ShardId']799 iter = dynamodbstreams.get_shard_iterator(StreamArn=arn, ShardId=shard_id, ShardIteratorType='LATEST')['ShardIterator']800 response = dynamodbstreams.get_records(ShardIterator=iter)801 assert 'NextShardIterator' in response or 'EndingSequenceNumber' in shard['SequenceNumberRange']802 assert 'Records' in response803 # We expect Records to be empty - there is no data at the LATEST iterator.804 assert response['Records'] == []805# Test that after fetching the last result from a shard, we don't get it806# yet again. Reproduces issue #6942.807def test_streams_last_result(test_table_ss_keys_only, dynamodbstreams):808 table, arn = test_table_ss_keys_only809 iterators = latest_iterators(dynamodbstreams, arn)810 # Do an UpdateItem operation that is expected to leave one event in the811 # stream.812 table.update_item(Key={'p': random_string(), 'c': random_string()},813 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})814 # Eventually (we may need to retry this for a while), *one* of the815 # stream shards will return one event:816 timeout = time.time() + 15817 while time.time() < timeout:818 for iter in iterators:819 response = dynamodbstreams.get_records(ShardIterator=iter)820 if 'Records' in response and response['Records'] != []:821 # Found the shard with the data! Test that it only has822 # one event and that if we try to read again, we don't823 # get more data (this was issue #6942).824 assert len(response['Records']) == 1825 assert 'NextShardIterator' in response826 response = dynamodbstreams.get_records(ShardIterator=response['NextShardIterator'])827 assert response['Records'] == []828 return829 time.sleep(0.5)830 pytest.fail("timed out")831# In test_streams_last_result above we tested that there is no further events832# after reading the only one. In this test we verify that if we *do* perform833# another change on the same key, we do get another event and it happens on the834# *same* shard.835def test_streams_another_result(test_table_ss_keys_only, dynamodbstreams):836 table, arn = test_table_ss_keys_only837 iterators = latest_iterators(dynamodbstreams, arn)838 # Do an UpdateItem operation that is expected to leave one event in the839 # stream.840 p = random_string()841 c = random_string()842 table.update_item(Key={'p': p, 'c': c},843 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})844 # Eventually, *one* of the stream shards will return one event:845 timeout = time.time() + 15846 while time.time() < timeout:847 for iter in iterators:848 response = dynamodbstreams.get_records(ShardIterator=iter)849 if 'Records' in response and response['Records'] != []:850 # Finally found the shard reporting the changes to this key851 assert len(response['Records']) == 1852 assert response['Records'][0]['dynamodb']['Keys']== {'p': {'S': p}, 'c': {'S': c}}853 assert 'NextShardIterator' in response854 iter = response['NextShardIterator']855 # Found the shard with the data. It only has one event so if856 # we try to read again, we find nothing (this is the same as857 # what test_streams_last_result tests).858 response = dynamodbstreams.get_records(ShardIterator=iter)859 assert response['Records'] == []860 assert 'NextShardIterator' in response861 iter = response['NextShardIterator']862 # Do another UpdateItem operation to the same key, so it is863 # expected to write to the *same* shard:864 table.update_item(Key={'p': p, 'c': c},865 UpdateExpression='SET x = :val2', ExpressionAttributeValues={':val2': 7})866 # Again we may need to wait for the event to appear on the stream:867 timeout = time.time() + 15868 while time.time() < timeout:869 response = dynamodbstreams.get_records(ShardIterator=iter)870 if 'Records' in response and response['Records'] != []:871 assert len(response['Records']) == 1872 assert response['Records'][0]['dynamodb']['Keys']== {'p': {'S': p}, 'c': {'S': c}}873 assert 'NextShardIterator' in response874 # The test is done, successfully.875 return876 time.sleep(0.5)877 pytest.fail("timed out")878 time.sleep(0.5)879 pytest.fail("timed out")880# Test the SequenceNumber attribute returned for stream events, and the881# "AT_SEQUENCE_NUMBER" iterator that can be used to re-read from the same882# event again given its saved "sequence number".883def test_streams_at_sequence_number(test_table_ss_keys_only, dynamodbstreams):884 table, arn = test_table_ss_keys_only885 # List all the shards and their LATEST iterators:886 shards_and_iterators = []887 for shard_id in list_shards(dynamodbstreams, arn):888 shards_and_iterators.append((shard_id, dynamodbstreams.get_shard_iterator(StreamArn=arn,889 ShardId=shard_id, ShardIteratorType='LATEST')['ShardIterator']))890 # Do an UpdateItem operation that is expected to leave one event in the891 # stream.892 p = random_string()893 c = random_string()894 table.update_item(Key={'p': p, 'c': c},895 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})896 # Eventually, *one* of the stream shards will return the one event:897 timeout = time.time() + 15898 while time.time() < timeout:899 for (shard_id, iter) in shards_and_iterators:900 response = dynamodbstreams.get_records(ShardIterator=iter)901 if 'Records' in response and response['Records'] != []:902 # Finally found the shard reporting the changes to this key:903 assert len(response['Records']) == 1904 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}905 assert 'NextShardIterator' in response906 sequence_number = response['Records'][0]['dynamodb']['SequenceNumber']907 # Found the shard with the data. It only has one event so if908 # we try to read again, we find nothing (this is the same as909 # what test_streams_last_result tests).910 iter = response['NextShardIterator']911 response = dynamodbstreams.get_records(ShardIterator=iter)912 assert response['Records'] == []913 assert 'NextShardIterator' in response914 # If we use the SequenceNumber of the first event to create an915 # AT_SEQUENCE_NUMBER iterator, we can read the same event again.916 # We don't need a loop and a timeout, because this event is already917 # available.918 iter = dynamodbstreams.get_shard_iterator(StreamArn=arn,919 ShardId=shard_id, ShardIteratorType='AT_SEQUENCE_NUMBER',920 SequenceNumber=sequence_number)['ShardIterator']921 response = dynamodbstreams.get_records(ShardIterator=iter)922 assert 'Records' in response923 assert len(response['Records']) == 1924 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}925 assert response['Records'][0]['dynamodb']['SequenceNumber'] == sequence_number926 return927 time.sleep(0.5)928 pytest.fail("timed out")929# Test the SequenceNumber attribute returned for stream events, and the930# "AFTER_SEQUENCE_NUMBER" iterator that can be used to re-read *after* the same931# event again given its saved "sequence number".932def test_streams_after_sequence_number(test_table_ss_keys_only, dynamodbstreams):933 table, arn = test_table_ss_keys_only934 # List all the shards and their LATEST iterators:935 shards_and_iterators = []936 for shard_id in list_shards(dynamodbstreams, arn):937 shards_and_iterators.append((shard_id, dynamodbstreams.get_shard_iterator(StreamArn=arn,938 ShardId=shard_id, ShardIteratorType='LATEST')['ShardIterator']))939 # Do two UpdateItem operations to the same key, that are expected to leave940 # two events in the stream.941 p = random_string()942 c = random_string()943 table.update_item(Key={'p': p, 'c': c},944 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 3})945 table.update_item(Key={'p': p, 'c': c},946 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})947 # Eventually, *one* of the stream shards will return the two events:948 timeout = time.time() + 15949 while time.time() < timeout:950 for (shard_id, iter) in shards_and_iterators:951 response = dynamodbstreams.get_records(ShardIterator=iter)952 if 'Records' in response and len(response['Records']) == 2:953 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}954 assert response['Records'][1]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}955 sequence_number_1 = response['Records'][0]['dynamodb']['SequenceNumber']956 sequence_number_2 = response['Records'][1]['dynamodb']['SequenceNumber']957 # #7424 - AWS sdk assumes sequence numbers can be compared958 # as bigints, and are monotonically growing.959 assert int(sequence_number_1) < int(sequence_number_2)960 # If we use the SequenceNumber of the first event to create an961 # AFTER_SEQUENCE_NUMBER iterator, we can read the second event962 # (only) again. We don't need a loop and a timeout, because this963 # event is already available.964 iter = dynamodbstreams.get_shard_iterator(StreamArn=arn,965 ShardId=shard_id, ShardIteratorType='AFTER_SEQUENCE_NUMBER',966 SequenceNumber=sequence_number_1)['ShardIterator']967 response = dynamodbstreams.get_records(ShardIterator=iter)968 assert 'Records' in response969 assert len(response['Records']) == 1970 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}971 assert response['Records'][0]['dynamodb']['SequenceNumber'] == sequence_number_2972 return973 time.sleep(0.5)974 pytest.fail("timed out")975# Test the "TRIM_HORIZON" iterator, which can be used to re-read *all* the976# previously-read events of the stream shard again.977# NOTE: This test relies on the test_table_ss_keys_only fixture giving us a978# brand new stream, with no old events saved from other tests. If we ever979# change this, we should change this test to use a different fixture.980def test_streams_trim_horizon(test_table_ss_keys_only, dynamodbstreams):981 table, arn = test_table_ss_keys_only982 # List all the shards and their LATEST iterators:983 shards_and_iterators = []984 for shard_id in list_shards(dynamodbstreams, arn):985 shards_and_iterators.append((shard_id, dynamodbstreams.get_shard_iterator(StreamArn=arn,986 ShardId=shard_id, ShardIteratorType='LATEST')['ShardIterator']))987 # Do two UpdateItem operations to the same key, that are expected to leave988 # two events in the stream.989 p = random_string()990 c = random_string()991 table.update_item(Key={'p': p, 'c': c},992 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 3})993 table.update_item(Key={'p': p, 'c': c},994 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})995 # Eventually, *one* of the stream shards will return the two events:996 timeout = time.time() + 15997 while time.time() < timeout:998 for (shard_id, iter) in shards_and_iterators:999 response = dynamodbstreams.get_records(ShardIterator=iter)1000 if 'Records' in response and len(response['Records']) == 2:1001 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}1002 assert response['Records'][1]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}1003 sequence_number_1 = response['Records'][0]['dynamodb']['SequenceNumber']1004 sequence_number_2 = response['Records'][1]['dynamodb']['SequenceNumber']1005 # If we use the TRIM_HORIZON iterator, we should receive the1006 # same two events again, in the same order.1007 # Note that we assume that the fixture gave us a brand new1008 # stream, with no old events saved from other tests. If we1009 # couldn't assume this, this test would need to become much1010 # more complex, and would need to read from this shard until1011 # we find the two events we are looking for.1012 iter = dynamodbstreams.get_shard_iterator(StreamArn=arn,1013 ShardId=shard_id, ShardIteratorType='TRIM_HORIZON')['ShardIterator']1014 response = dynamodbstreams.get_records(ShardIterator=iter)1015 assert 'Records' in response1016 assert len(response['Records']) == 21017 assert response['Records'][0]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}1018 assert response['Records'][1]['dynamodb']['Keys'] == {'p': {'S': p}, 'c': {'S': c}}1019 assert response['Records'][0]['dynamodb']['SequenceNumber'] == sequence_number_11020 assert response['Records'][1]['dynamodb']['SequenceNumber'] == sequence_number_21021 return1022 time.sleep(0.5)1023 pytest.fail("timed out")1024# Above we tested some specific operations in small tests aimed to reproduce1025# a specific bug, in the following tests we do a all the different operations,1026# PutItem, DeleteItem, BatchWriteItem and UpdateItem, and check the resulting1027# stream for correctness.1028# The following tests focus on mulitple operations on the *same* item. Those1029# should appear in the stream in the correct order.1030def do_updates_1(table, p, c):1031 events = []1032 # a first put_item appears as an INSERT event. Note also empty old_image.1033 table.put_item(Item={'p': p, 'c': c, 'x': 2})1034 events.append(['INSERT', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'x': 2}])1035 # a second put_item of the *same* key and same value, doesn't appear in the log at all!1036 table.put_item(Item={'p': p, 'c': c, 'x': 2})1037 # a second put_item of the *same* key and different value, appears as a MODIFY event1038 table.put_item(Item={'p': p, 'c': c, 'y': 3})1039 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'x': 2}, {'p': p, 'c': c, 'y': 3}])1040 # deleting an item appears as a REMOVE event. Note no new_image at all, but there is an old_image.1041 table.delete_item(Key={'p': p, 'c': c})1042 events.append(['REMOVE', {'p': p, 'c': c}, {'p': p, 'c': c, 'y': 3}, None])1043 # deleting a non-existant item doesn't appear in the log at all.1044 table.delete_item(Key={'p': p, 'c': c})1045 # If update_item creates an item, the event is INSERT as well.1046 table.update_item(Key={'p': p, 'c': c},1047 UpdateExpression='SET b = :val1',1048 ExpressionAttributeValues={':val1': 4})1049 events.append(['INSERT', {'p': p, 'c': c}, None, {'p': p, 'c': c, 'b': 4}])1050 # If update_item modifies the item, note how old and new image includes both old and new columns1051 table.update_item(Key={'p': p, 'c': c},1052 UpdateExpression='SET x = :val1',1053 ExpressionAttributeValues={':val1': 5})1054 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'b': 4}, {'p': p, 'c': c, 'b': 4, 'x': 5}])1055 # TODO: incredibly, if we uncomment the "REMOVE b" update below, it will be1056 # completely missing from the DynamoDB stream - the test continues to1057 # pass even though we didn't add another expected event, and even though1058 # the preimage in the following expected event includes this "b" we will1059 # remove. I couldn't reproduce this apparant DynamoDB bug in a smaller test.1060 #table.update_item(Key={'p': p, 'c': c}, UpdateExpression='REMOVE b')1061 # Test BatchWriteItem as well. This modifies the item, so will be a MODIFY event.1062 table.meta.client.batch_write_item(RequestItems = {table.name: [{'PutRequest': {'Item': {'p': p, 'c': c, 'x': 5}}}]})1063 events.append(['MODIFY', {'p': p, 'c': c}, {'p': p, 'c': c, 'b': 4, 'x': 5}, {'p': p, 'c': c, 'x': 5}])1064 return events1065@pytest.mark.xfail(reason="Currently fails - because of multiple issues listed above")1066def test_streams_1_keys_only(test_table_ss_keys_only, dynamodbstreams):1067 do_test(test_table_ss_keys_only, dynamodbstreams, do_updates_1, 'KEYS_ONLY')1068@pytest.mark.xfail(reason="Currently fails - because of multiple issues listed above")1069def test_streams_1_new_image(test_table_ss_new_image, dynamodbstreams):1070 do_test(test_table_ss_new_image, dynamodbstreams, do_updates_1, 'NEW_IMAGE')1071@pytest.mark.xfail(reason="Currently fails - because of multiple issues listed above")1072def test_streams_1_old_image(test_table_ss_old_image, dynamodbstreams):1073 do_test(test_table_ss_old_image, dynamodbstreams, do_updates_1, 'OLD_IMAGE')1074@pytest.mark.xfail(reason="Currently fails - because of multiple issues listed above")1075def test_streams_1_new_and_old_images(test_table_ss_new_and_old_images, dynamodbstreams):1076 do_test(test_table_ss_new_and_old_images, dynamodbstreams, do_updates_1, 'NEW_AND_OLD_IMAGES')1077# A fixture which creates a test table with a stream enabled, and returns a1078# bunch of interesting information collected from the CreateTable response.1079# This fixture is session-scoped - it can be shared by multiple tests below,1080# because we are not going to actually use or change this stream, we will1081# just do multiple tests on its setup.1082@pytest.fixture(scope="session")1083def test_table_stream_with_result(dynamodb, dynamodbstreams):1084 tablename = test_table_name()1085 result = dynamodb.meta.client.create_table(TableName=tablename,1086 BillingMode='PAY_PER_REQUEST',1087 StreamSpecification={'StreamEnabled': True, 'StreamViewType': 'KEYS_ONLY'},1088 KeySchema=[ { 'AttributeName': 'p', 'KeyType': 'HASH' },1089 { 'AttributeName': 'c', 'KeyType': 'RANGE' }1090 ],1091 AttributeDefinitions=[1092 { 'AttributeName': 'p', 'AttributeType': 'S' },1093 { 'AttributeName': 'c', 'AttributeType': 'S' },1094 ])1095 waiter = dynamodb.meta.client.get_waiter('table_exists')1096 waiter.config.delay = 11097 waiter.config.max_attempts = 2001098 waiter.wait(TableName=tablename)1099 table = dynamodb.Table(tablename)1100 yield result, table1101 while True:1102 try:1103 table.delete()1104 return1105 except ClientError as ce:1106 # if the table has a stream currently being created we cannot1107 # delete the table immediately. Again, only with real dynamo1108 if ce.response['Error']['Code'] == 'ResourceInUseException':1109 print('Could not delete table yet. Sleeping 5s.')1110 time.sleep(5)1111 continue;1112 raise1113# Test that in a table with Streams enabled, LatestStreamArn is returned1114# by CreateTable, DescribeTable and UpdateTable, and is the same ARN as1115# returned by ListStreams. Reproduces issue #7157.1116def test_latest_stream_arn(test_table_stream_with_result, dynamodbstreams):1117 (result, table) = test_table_stream_with_result1118 assert 'LatestStreamArn' in result['TableDescription']1119 arn_in_create_table = result['TableDescription']['LatestStreamArn']1120 # Check that ListStreams returns the same stream ARN as returned1121 # by the original CreateTable1122 (arn_in_list_streams, label) = wait_for_active_stream(dynamodbstreams, table)1123 assert arn_in_create_table == arn_in_list_streams1124 # Check that DescribeTable also includes the same LatestStreamArn:1125 desc = table.meta.client.describe_table(TableName=table.name)['Table']1126 assert 'LatestStreamArn' in desc1127 assert desc['LatestStreamArn'] == arn_in_create_table1128 # Check that UpdateTable also includes the same LatestStreamArn.1129 # The "update" changes nothing (it just sets BillingMode to what it was).1130 desc = table.meta.client.update_table(TableName=table.name,1131 BillingMode='PAY_PER_REQUEST')['TableDescription']1132 assert desc['LatestStreamArn'] == arn_in_create_table1133# Test that in a table with Streams enabled, LatestStreamLabel is returned1134# by CreateTable, DescribeTable and UpdateTable, and is the same "label" as1135# returned by ListStreams. Reproduces issue #7162.1136def test_latest_stream_label(test_table_stream_with_result, dynamodbstreams):1137 (result, table) = test_table_stream_with_result1138 assert 'LatestStreamLabel' in result['TableDescription']1139 label_in_create_table = result['TableDescription']['LatestStreamLabel']1140 # Check that ListStreams returns the same stream label as returned1141 # by the original CreateTable1142 (arn, label) = wait_for_active_stream(dynamodbstreams, table)1143 assert label_in_create_table == label1144 # Check that DescribeTable also includes the same LatestStreamLabel:1145 desc = table.meta.client.describe_table(TableName=table.name)['Table']1146 assert 'LatestStreamLabel' in desc1147 assert desc['LatestStreamLabel'] == label_in_create_table1148 # Check that UpdateTable also includes the same LatestStreamLabel.1149 # The "update" changes nothing (it just sets BillingMode to what it was).1150 desc = table.meta.client.update_table(TableName=table.name,1151 BillingMode='PAY_PER_REQUEST')['TableDescription']1152 assert desc['LatestStreamLabel'] == label_in_create_table1153# Test that in a table with Streams enabled, StreamSpecification is returned1154# by CreateTable, DescribeTable and UpdateTable. Reproduces issue #7163.1155def test_stream_specification(test_table_stream_with_result, dynamodbstreams):1156 # StreamSpecification as set in test_table_stream_with_result:1157 stream_specification = {'StreamEnabled': True, 'StreamViewType': 'KEYS_ONLY'}1158 (result, table) = test_table_stream_with_result1159 assert 'StreamSpecification' in result['TableDescription']1160 assert stream_specification == result['TableDescription']['StreamSpecification']1161 # Check that DescribeTable also includes the same StreamSpecification:1162 desc = table.meta.client.describe_table(TableName=table.name)['Table']1163 assert 'StreamSpecification' in desc1164 assert stream_specification == desc['StreamSpecification']1165 # Check that UpdateTable also includes the same StreamSpecification.1166 # The "update" changes nothing (it just sets BillingMode to what it was).1167 desc = table.meta.client.update_table(TableName=table.name,1168 BillingMode='PAY_PER_REQUEST')['TableDescription']1169 assert stream_specification == desc['StreamSpecification']1170# The following test checks the behavior of *closed* shards.1171# We achieve a closed shard by disabling the stream - the DynamoDB1172# documentation states that "If you disable a stream, any shards that are1173# still open will be closed. The data in the stream will continue to be1174# readable for 24 hours". In the test we verify that indeed, after a shard1175# is closed, it is still readable with GetRecords (reproduces issue #7239).1176# Moreover, upon reaching the end of data in the shard, the NextShardIterator1177# attribute should say that the end was reached. The DynamoDB documentation1178# says that NextShardIterator should be "set to null" in this case - but it1179# is not clear what "null" means in this context: Should NextShardIterator1180# be missing? Or a "null" JSON type? Or an empty string? This test verifies1181# that the right answer is that NextShardIterator should be *missing*1182# (reproduces issue #7237).1183@pytest.mark.xfail(reason="disabled stream is deleted - issue #7239")1184def test_streams_closed_read(test_table_ss_keys_only, dynamodbstreams):1185 table, arn = test_table_ss_keys_only1186 iterators = latest_iterators(dynamodbstreams, arn)1187 # Do an UpdateItem operation that is expected to leave one event in the1188 # stream.1189 table.update_item(Key={'p': random_string(), 'c': random_string()},1190 UpdateExpression='SET x = :val1', ExpressionAttributeValues={':val1': 5})1191 # Disable streaming for this table. Note that the test_table_ss_keys_only1192 # fixture has "function" scope so it is fine to ruin table, it will not1193 # be used in other tests.1194 disable_stream(dynamodbstreams, table)1195 # Even after streaming is disabled for the table, we can still read1196 # from the earlier stream (it is guaranteed to work for 24 hours).1197 # The iterators we got earlier should still be fully usable, and1198 # eventually *one* of the stream shards will return one event:1199 timeout = time.time() + 151200 while time.time() < timeout:1201 for iter in iterators:1202 response = dynamodbstreams.get_records(ShardIterator=iter)1203 if 'Records' in response and response['Records'] != []:1204 # Found the shard with the data! Test that it only has1205 # one event. NextShardIterator should either be missing now,1206 # indicating that it is a closed shard (DynamoDB does this),1207 # or, it may (and currently does in Alternator) return another1208 # and reading from *that* iterator should then tell us that1209 # we reached the end of the shard (i.e., zero results and1210 # missing NextShardIterator).1211 assert len(response['Records']) == 11212 if 'NextShardIterator' in response:1213 response = dynamodbstreams.get_records(ShardIterator=response['NextShardIterator'])1214 assert len(response['Records']) == 01215 assert not 'NextShardIterator' in response1216 return1217 time.sleep(0.5)1218 pytest.fail("timed out")1219# TODO: tests on multiple partitions1220# TODO: write a test that disabling the stream and re-enabling it works, but1221# requires the user to wait for the first stream to become DISABLED before1222# creating the new one. Then ListStreams should return the two streams,1223# one DISABLED and one ENABLED? I'm not sure we want or can do this in1224# Alternator.1225# TODO: Can we test shard splitting? (shard splitting1226# requires the user to - periodically or following shards ending - to call...
__init__.py
Source:__init__.py
1from __future__ import unicode_literals2from .models import dynamodbstreams_backends3from ..core.models import base_decorator4dynamodbstreams_backend = dynamodbstreams_backends["us-east-1"]...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run localstack automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
