async def test_read_write_stream_new_queue(
monkeypatch,
mock_app_config,
mock_plugin_config # noqa: F811
):
payload = MockData("ok")
expected = MockResult("ok: ok")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(
MockEventHandler, 'test_track_ids', {
'track.operation_id': 'test_operation_id',
'track.request_id': 'test_request_id',
'track.request_ts': '2020-02-05T17:07:37.771396+00:00',
'track.session_id': 'test_session_id',
'stream.name': 'test_stream',
'stream.msg_id': '0000000000-0',
'stream.consumer_group': 'test_group',
'event.app': 'mock_app.test'
})
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
mock_app_config.events['mock_read_write_stream'].write_stream.queues = \
['custom']
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_read_write_stream',
test_mode=True)
assert res == expected
assert engine.stream_manager.write_stream_name == 'mock_read_write_stream.write.custom'
assert engine.stream_manager.write_stream_queue == 'custom'
assert engine.stream_manager.write_stream_payload == expected
await engine.stop()
async def test_write_stream_batch(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = "ok"
expected = MockData("stream: ok.3")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
monkeypatch.setattr(MockEventHandler, 'test_track_ids', None)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
stream_manager = MockStreamManager(address='test')
monkeypatch.setattr(engine, 'stream_manager', stream_manager)
event_info = mock_app_config.events['mock_write_stream_event']
await invoke_execute(engine=engine,
from_app=engine.app_config,
event_name='mock_spawn_event',
query_args={},
payload=payload,
expected=expected,
track_ids={
"track.request_id": "test_request_id",
"track.request_ts":
"2020-02-05T17:07:37.771396+00:00",
"track.session_id": "test_session_id"
})
assert stream_manager.write_stream_name == event_info.write_stream.name
assert stream_manager.write_stream_payload == expected
assert stream_manager.write_target_max_len == 10
await engine.stop()
async def test_read_stream_event_fail_and_process_next(
monkeypatch, mock_app_config, mock_plugin_config): # noqa: F811
setup_mocks(monkeypatch)
payload = MockData("cancel")
expected = MockResult("none")
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_stream_timeout',
test_mode=True)
assert isinstance(res, asyncio.CancelledError)
payload = MockData("fail")
expected = MockResult("none")
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_stream_timeout',
test_mode=True)
assert isinstance(res, ValueError)
payload = MockData("ok")
expected = MockResult("ok: ok")
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
res = await engine.read_stream(event_name='mock_stream_timeout',
test_mode=True)
assert res == expected
await engine.stop()
async def test_read_write_stream_multiple_queues_propagate(
monkeypatch,
mock_app_config,
mock_plugin_config # noqa: F811
):
payload = MockData("ok")
expected = MockResult("ok: ok")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(
MockEventHandler, 'test_track_ids', {
'track.operation_id': 'test_operation_id',
'track.request_id': 'test_request_id',
'track.request_ts': '2020-02-05T17:07:37.771396+00:00',
'track.session_id': 'test_session_id',
'stream.name': 'test_stream',
'stream.msg_id': '0000000000-0',
'stream.consumer_group': 'test_group',
'event.app': 'mock_app.test'
})
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
monkeypatch.setattr(MockStreamManager, 'test_queue',
None) # Will use last part of stream name
mock_app_config.events['mock_read_write_stream'].read_stream.queues = \
['q1', 'q2']
mock_app_config.events['mock_read_write_stream'].write_stream.queues = \
['q3', 'q4']
mock_app_config.events['mock_read_write_stream'].write_stream.queue_strategy = \
StreamQueueStrategy.PROPAGATE
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_read_write_stream',
test_mode=True)
assert res == expected
assert engine.stream_manager.write_stream_name == 'mock_read_write_stream.write.q4'
assert engine.stream_manager.write_stream_queue == 'q2'
assert engine.stream_manager.write_stream_payload == expected
assert MockStreamManager.last_read_stream_names[-2:] == \
['mock_read_write_stream.read.q1', 'mock_read_write_stream.read.q2']
assert MockStreamManager.last_read_queue_names[-2:] == \
['q1', 'q2']
assert MockStreamManager.last_write_stream_names[-4:] == [
'mock_read_write_stream.write.q3', 'mock_read_write_stream.write.q4',
'mock_read_write_stream.write.q3', 'mock_read_write_stream.write.q4'
]
assert MockStreamManager.last_write_queue_names[-4:] == \
['q1', 'q1', 'q2', 'q2']
await engine.stop()
async def test_read_stream_failed(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = MockData("fail")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', None)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_stream_event',
test_mode=True)
assert isinstance(res, ValueError)
await engine.stop()
async def test_read_stream_timeout_ok(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = MockData("ok")
expected = MockResult("ok: ok")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_stream_timeout',
test_mode=True)
assert res == expected
await engine.stop()
async def test_service_loop(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = "stream: service.0"
expected = MockData("stream: service.0")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
monkeypatch.setattr(MockEventHandler, 'test_track_ids', None)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.service_loop(event_name='mock_service_event',
test_mode=True)
assert res == expected
await engine.stop()
async def test_read_stream(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = MockData("ok")
expected = MockResult("ok: ok")
setup_mocks(monkeypatch)
from mock_app import mock_event_dataobject_payload
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'call_function',
mock_event_dataobject_payload.entry_point)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.read_stream(event_name='mock_stream_event',
test_mode=True)
assert res == expected
await engine.stop()
async def test_service_loop_timeout(monkeypatch, mock_app_config,
mock_plugin_config): # noqa: F811
payload = MockData("timeout")
expected = MockData("stream: service.1")
setup_mocks(monkeypatch)
monkeypatch.setattr(MockEventHandler, 'input_payload', payload)
monkeypatch.setattr(MockEventHandler, 'expected_result', expected)
monkeypatch.setattr(MockStreamManager, 'test_payload', payload)
monkeypatch.setattr(MockEventHandler, 'test_track_ids', None)
engine = await create_engine(app_config=mock_app_config,
plugin=mock_plugin_config)
monkeypatch.setattr(engine, 'stream_manager',
MockStreamManager(address='test'))
res = await engine.service_loop(event_name='mock_service_timeout',
test_mode=True)
# Result could be TimeoutError ot CancelledError depending on execution environment
assert isinstance(res, asyncio.TimeoutError) or isinstance(
res, asyncio.CancelledError)
await engine.stop()
