def test_doesnt_create_directory_if_clips_error(mocker: MockFixture,
fs: FakeFilesystem) -> None:
mocker.patch("abridge.processor.abridge_clip")
mocker.spy(abridge.cli, "sys")
sys.argv = ["", "-o", "outputdir", "noexist.mp4"]
main()
os.path.isdir("outputdir")
async def test_transaction_cm(self, async_context_manager, mocker: MockFixture):
exc_type, exc_val, exc_tb = None, None, None
fake_transaction_cm = async_context_manager(mocker.Mock())
fake_connection = mocker.Mock(begin=mocker.Mock(return_value=fake_transaction_cm))
fake_conn_cm = async_context_manager(fake_connection)
fake_model_mgr = mocker.Mock(
transaction_connection=None,
engine=mocker.Mock(acquire=mocker.Mock(return_value=fake_conn_cm))
)
mocker.spy(fake_conn_cm, '__aenter__')
mocker.spy(fake_conn_cm, '__aexit__')
mocker.spy(fake_transaction_cm, '__aenter__')
mocker.spy(fake_transaction_cm, '__aexit__')
transaction = _TransactionContextManager(fake_model_mgr)
async with transaction as model_objects:
assert model_objects == fake_model_mgr
fake_model_mgr.engine.acquire.assert_called_once_with()
fake_conn_cm.__aenter__.assert_called_once_with()
fake_transaction_cm.__aenter__.assert_called_once_with()
fake_connection.begin.assert_called_once_with()
assert fake_model_mgr.transaction_connection == fake_connection
fake_transaction_cm.__aexit__.assert_called_once_with(exc_type, exc_val, exc_tb)
fake_conn_cm.__aexit__.assert_called_once_with(exc_type, exc_val, exc_tb)
assert fake_model_mgr.transaction_connection is None
def test_db_verbosity(
cli_runner: testing.CliRunner,
mocker: ptm.MockFixture,
invoke_arg: t.List[str],
) -> None:
from loguru import logger
enable_spy = mocker.spy(logger, name='enable')
disable_spy = mocker.spy(logger, name='disable')
add_spy = mocker.spy(logger, name='add')
_ = mocker.patch('asyncpg_migrate.loader.load_configuration')
from asyncpg_migrate import main
@main.db.command(name='test', short_help='test command')
def test() -> None:
click.echo(1)
result = cli_runner.invoke(main.db, invoke_arg)
assert result.exit_code == 0
if invoke_arg[0] == '-v' or invoke_arg[0] == '--verbose':
assert enable_spy.called
assert not disable_spy.called
assert add_spy.mock_calls[0].kwargs == {
'format': '{time} {message}',
'filter': 'asyncpg-migrate',
'level': 'INFO',
}
elif invoke_arg[0] == '-vv':
assert enable_spy.called
assert not disable_spy.called
assert add_spy.mock_calls[0].kwargs == {
'format': '{time} {message}',
'filter': 'asyncpg-migrate',
'level': 'DEBUG',
}
elif invoke_arg[0] == '-vvv':
assert enable_spy.called
assert not disable_spy.called
assert add_spy.mock_calls[0].kwargs == {
'format': '{time} {message}',
'filter': 'asyncpg-migrate',
'level': 'TRACE',
}
else:
assert not enable_spy.called
assert disable_spy.called
assert not add_spy.called
def test_run_configuration_should_filter_message_where_receiver_is_not_working(
db: MockFixture,
mocker: MockFixture,
setup: tuple[User, User, list[ExternalMessage]],
) -> None:
user1, user2, messages_should_be_consumed = setup
user_not_working = UserFactory(
on_leave=True,
working_time_start=datetime.time(8, 0, 0),
working_time_end=datetime.time(17, 0, 0),
)
fake_messages = messages_should_be_consumed + [
ExternalMessage(user2.username, user_not_working.username,
'message to not working user'),
]
mocker.patch.object(SampleProducer,
'produce_external_messages',
return_value=fake_messages)
consume_messages_spy = mocker.spy(SampleConsumer, 'consume_messages')
configuration = ConfigurationFactory(
consumers=(ConsumerModelFactory(), ),
producers=(ProducerModelFactory(), ),
users=(user1, user2, user_not_working),
message_filters=(MessageFilterModelFactory(
object_type=ReceiverWorkingMessageFilter.__name__), ),
)
configuration.run()
assert consume_messages_spy.call_args.args[
1] == messages_should_be_consumed
def test_extend_by_cancellation_with_future_date(client_subscription_factory,
event_factory,
mocker: MockFixture):
start_date = date(2019, 2, 25)
event = event_factory(event_class__date_from=start_date,
canceled_at=date(2019, 2, 26))
cs: models.ClientSubscriptions = client_subscription_factory(
subscription__event_class__events=event.event_class,
subscription__rounding=False,
subscription__duration=7,
subscription__duration_type=GRANULARITY.DAY,
start_date=start_date)
new_end_date = date(2019, 2, 27)
mocker.patch('crm.models.ClientSubscriptions.nearest_extended_end_date',
return_value=new_end_date)
spy = mocker.spy(models.ExtensionHistory.objects, 'create')
old_end_date = cs.end_date
cs.extend_by_cancellation(event)
cs.refresh_from_db()
assert_that(cs, has_properties(end_date=new_end_date))
spy.assert_called_once_with(
client_subscription=cs,
reason=f'В связи с отменой тренировки {event}',
added_visits=0,
related_event=event,
extended_to=new_end_date,
extended_from=old_end_date,
)
def test_extend_duration_without_new_end_date_and_zero(
client_subscription_factory, mocker: MockFixture):
start_date = date(2019, 2, 25)
cs: models.ClientSubscriptions = client_subscription_factory(
subscription__event_class__events=[],
subscription__rounding=False,
subscription__duration=7,
subscription__duration_type=GRANULARITY.DAY,
start_date=start_date)
old_end_date = cs.end_date
mocker.patch('crm.models.ClientSubscriptions.nearest_extended_end_date',
return_value=cs.end_date)
old_visits = cs.visits_left
spy = mocker.spy(models.ExtensionHistory.objects, 'create')
cs.extend_duration(0, reason='TEST')
cs.refresh_from_db()
assert_that(cs,
has_properties(visits_left=old_visits, end_date=old_end_date))
spy.assert_not_called()
def test_extend_by_cancellation_no_future_date(client_subscription_factory,
event_factory,
mocker: MockFixture):
start_date = date(2019, 2, 25)
event = event_factory(event_class__date_from=start_date,
canceled_at=date(2019, 2, 26))
cs: models.ClientSubscriptions = client_subscription_factory(
subscription__event_class__events=event.event_class,
subscription__rounding=False,
subscription__duration=7,
subscription__duration_type=GRANULARITY.DAY,
start_date=start_date)
old_end_date = cs.end_date
mocker.patch('crm.models.ClientSubscriptions.nearest_extended_end_date',
return_value=cs.end_date)
spy = mocker.spy(models.ExtensionHistory.objects, 'create')
cs.extend_by_cancellation(event)
cs.refresh_from_db()
assert_that(cs, has_properties(end_date=old_end_date))
spy.assert_not_called()
def test_spec_load_from_path(
spec_path: Path,
mocker: ptm.MockFixture,
) -> None:
parse_spec = mocker.spy(parser, 'parse_spec')
assert loader.load_spec(spec_path) is not None
parse_spec.assert_called_once()
def test_run_configuration_should_filter_message_with_skip_keywords(
db: MockFixture,
mocker: MockFixture,
setup: tuple[User, User, list[ExternalMessage]],
) -> None:
user1, user2, messages_should_be_consumed = setup
fake_messages = messages_should_be_consumed + [
ExternalMessage(user2.username, user1.username,
'message with skip_keyword1'),
]
mocker.patch.object(SampleProducer,
'produce_external_messages',
return_value=fake_messages)
consume_messages_spy = mocker.spy(SampleConsumer, 'consume_messages')
configuration = ConfigurationFactory(
consumers=(ConsumerModelFactory(), ),
producers=(ProducerModelFactory(), ),
users=(user1, user2),
message_filters=(MessageFilterModelFactory(
object_type=SkipKeywordsMessageFilter.__name__,
parameters={'skip_keywords': ['skip_keyword1']},
), ),
)
configuration.run()
assert consume_messages_spy.call_args.args[
1] == messages_should_be_consumed
def test_preview_pipeline(mocker: MockFixture, pipeline_executor):
df_to_json_spy = mocker.spy(pd.DataFrame, 'to_json')
result = json.loads(
pipeline_executor.preview_pipeline(
Pipeline(steps=[
{
'name': 'domain',
'domain': 'domain_a'
},
])))
assert 'data' in result
assert len(result['data']) == 3 # rows
assert len(result['data'][0]) == 3 # columns
assert result['schema']['fields'] == [
{
'name': 'colA',
'type': 'string'
},
{
'name': 'colB',
'type': 'integer'
},
{
'name': 'colC',
'type': 'integer'
},
]
assert result['offset'] == 0
assert result['limit'] == 50
assert result['total'] == 3
# DataFrames must be exported with pandas' method to ensure NaN and dates are correctly converted
df_to_json_spy.assert_called_once()
def test_configuration_with_multiplie_producers_and_consumers(
db: MockFixture,
mocker: MockFixture,
setup: tuple[User, User, list[ExternalMessage]],
) -> None:
user1, user2, messages_should_be_consumed = setup
fake_messages = messages_should_be_consumed + [
ExternalMessage('unknown_user', user1.username,
'message from unknown user'),
]
mocker.patch.object(SampleProducer,
'produce_external_messages',
return_value=fake_messages)
consume_messages_spy = mocker.spy(SampleConsumer, 'consume_messages')
configuration = ConfigurationFactory(
consumers=(ConsumerModelFactory(), ConsumerModelFactory()),
producers=(ProducerModelFactory(), ProducerModelFactory()),
users=(user1, user2),
)
configuration.run()
assert consume_messages_spy.call_count == 2
assert consume_messages_spy.call_args.args[
1] == messages_should_be_consumed * 2
def test_extend_duration_with_new_end_date(client_subscription_factory,
mocker: MockFixture):
start_date = date(2019, 2, 25)
new_end_date = start_date + timedelta(days=14)
mocker.patch('crm.models.ClientSubscriptions.nearest_extended_end_date',
return_value=new_end_date)
cs: models.ClientSubscriptions = client_subscription_factory(
subscription__event_class__events=[],
subscription__rounding=False,
subscription__duration=7,
subscription__duration_type=GRANULARITY.DAY,
start_date=start_date)
old_visits = cs.visits_left
spy = mocker.spy(models.ExtensionHistory.objects, 'create')
old_end_date = cs.end_date
cs.extend_duration(10, reason='TEST')
cs.refresh_from_db()
assert_that(
cs, has_properties(visits_left=old_visits + 10, end_date=new_end_date))
spy.assert_called_once_with(
client_subscription=cs,
reason='TEST',
added_visits=10,
extended_to=new_end_date,
extended_from=old_end_date,
)
async def test_control_sent_on_adjust(
servo_runner: servo.runner.ServoRunner,
fakeapi_url: str,
fastapi_app: "tests.OpsaniAPI",
mocker: pytest_mock.MockFixture,
) -> None:
sequenced_optimizer = tests.fake.SequencedOptimizer(
id="dev.opsani.com/big-in-japan", token="31337"
)
control = servo.Control(settlement="10s")
await sequenced_optimizer.recommend_adjustments(adjustments=[], control=control),
sequenced_optimizer.sequence(sequenced_optimizer.done())
fastapi_app.optimizer = sequenced_optimizer
servo_runner.servo.optimizer.base_url = fakeapi_url
adjust_connector = servo_runner.servo.get_connector("adjust")
event_handler = adjust_connector.get_event_handlers(
"adjust", servo.events.Preposition.on
)[0]
spy = mocker.spy(event_handler, "handler")
async def wait_for_optimizer_done():
while fastapi_app.optimizer.state.name != "done":
await asyncio.sleep(0.01)
await servo_runner.run()
await asyncio.wait_for(wait_for_optimizer_done(), timeout=2)
await servo_runner.shutdown()
spy.assert_called_once_with(adjust_connector, [], control)
async def test_on_authenticate(com: WebsocketCommunicator,
consumer: AsyncConsumer, mocker: MockFixture,
auth_request, access_token, user: User):
on_auth = mocker.spy(consumer, 'on_authenticate_success')
await com.send_json_to(auth_request(access_token(user)))
await com.receive_json_from()
on_auth.assert_called_once()
def test_exits_when_one_clip_doesnt_exist(mocker: MockFixture,
fs: FakeFilesystem) -> None:
fs.create_file("exists.mp4")
mocker.patch("abridge.processor.abridge_clip")
sys_spy = mocker.spy(abridge.cli, "sys")
sys.argv = ["", "exists.mp4", "something.mp4"]
main()
sys_spy.exit.assert_called_with("something.mp4: No such file or directory")
def test_get_calendar_all_absent(
event_class_factory,
mocker: MockFixture
):
start = date(2019, 1, 1)
ec = event_class_factory(date_from=start)
spy = mocker.spy(models, 'Event')
ec.get_calendar(start, date(2019, 1, 31))
assert_that(
spy.call_count, is_(31)
)
def test_game_correctly_ends(mocker: MockFixture):
mock_socket_cls = mocker.patch("socket.socket")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"HELO boring Hawking".encode("utf-8"))
game = init_game(sock, 1, "happy Pascal")
sendall_spy = mocker.spy(sock, "sendall")
set_stdin_value(mocker, "A 1")
make_step(sock, game)
sock.close()
assert game.check_winner() == "X"
sendall_spy.assert_called_once_with("MOVE A 1 STOP X".encode("utf-8"))
def test_send_personalized_multiple(client_factory, mocker: MockFixture):
client = client_factory.create_batch(3, vk_user_id=1)
mocker.patch('bot.api.messages.base.Message.prepare_generalized_message',
return_value='Test')
msg_sender = Message(client, personalized=True)
spy = mocker.spy(msg_sender, 'personalize')
sm = mocker.patch('bot.api.messages.base.send_message')
msg_sender.send_message()
assert_that(spy.call_count, is_(3))
assert_that(sm.call_count, is_(3))
def test_send_personalized(client_factory, mocker: MockFixture):
client = client_factory(vk_user_id=1)
mocker.patch('bot.api.messages.base.Message.prepare_generalized_message',
return_value='Test')
msg_sender = Message(client, personalized=True)
spy = mocker.spy(msg_sender, 'personalize')
sm = mocker.patch('bot.api.messages.base.send_message')
msg_sender.send_message()
spy.assert_called_once_with('Test', client)
sm.assert_called_once_with(1, mocker.ANY, mocker.ANY)
def test_apply_specification_subapp(
spec_path: Path,
mocker: ptm.MockFixture,
) -> None:
the_spec = loader.load_spec(spec_path)
the_app = app.AioHttpPlugin(configuration=mocker.ANY)
add_route_spy = mocker.spy(the_app.root_app.router, 'add_route')
add_subapp_spy = mocker.spy(the_app.root_app, 'add_subapp')
resolve_handler = mocker.patch('axion.handler.resolve')
the_app.add_api(
spec=the_spec,
base_path='/api',
)
assert resolve_handler.call_count == len(the_spec.operations)
assert add_route_spy.call_count == 0
assert add_subapp_spy.call_count == 1
assert len(the_app.root_app.router.resources()) == 1
subapp = the_app.root_app._subapps[0]
assert len(subapp.router.resources()) == len(the_spec.operations)
def test_get_calendar_partial_events_exists(
event_class_factory,
event_factory,
mocker: MockFixture
):
start = date(2019, 1, 1)
ec = event_class_factory(date_from=start)
for day in range_days(start, date(2019, 1, 4)):
event_factory(
company=ec.company,
event_class=ec,
date=day
)
spy = mocker.spy(models, 'Event')
ec.get_calendar(start, date(2019, 1, 10))
assert_that(spy.call_count, is_(7))
def test_run_configuration_should_filter_message_where_receiver_doesnt_have_consumer_username(
db: MockFixture,
mocker: MockFixture,
setup: tuple[User, User, list[ExternalMessage]],
) -> None:
user1, user2, messages_should_be_consumed = setup
user_without_consumer_username = UserFactory(
on_leave=False,
working_time_start=datetime.time(8, 0, 0),
working_time_end=datetime.time(17, 0, 0),
)
user_without_consumer_username.additional_info.pop(
SampleConsumer.USERNAME_KEY)
user_without_consumer_username.save()
messages_should_be_consumed = [
ExternalMessage(user1.username, user2.username, 'message1'),
ExternalMessage(user2.username, user1.username, 'message2'),
]
fake_messages = messages_should_be_consumed + [
ExternalMessage(
user1.username,
user_without_consumer_username.username,
'message to user without consumer username',
),
]
mocker.patch.object(SampleProducer,
'produce_external_messages',
return_value=fake_messages)
consume_messages_spy = mocker.spy(SampleConsumer, 'consume_messages')
configuration = ConfigurationFactory(
consumers=(ConsumerModelFactory(), ),
producers=(ProducerModelFactory(), ),
users=(user1, user2, user_without_consumer_username),
)
configuration.run()
assert consume_messages_spy.call_args.args[
1] == messages_should_be_consumed
def test_mod_with_pgd_tester(loader: AssetLoader, testmod_assetpath: str,
mocker: MockFixture):
d = Discoverer(loader)
tester = PGDTester()
d.register_asset_tester(tester)
fast_spy = mocker.spy(tester, 'is_a_fast_match')
full_spy = mocker.spy(tester, 'is_a_full_match')
results = d.run(testmod_assetpath)
assert results and 'pgd' in results
assert results['pgd'] == [
'/Game/Mods/PurloviaTEST/PrimalGameData_BP_PurloviaTEST'
]
assert fast_spy.call_count > 1
assert full_spy.call_count == 1
def given_request_none_stored(monkeypatch: pytest.MonkeyPatch, mocker: MockFixture, request_json: Tuple[dict, str]):
""" Handle request
"""
# mock anything that uses aiohttp.ClientSession::get
monkeypatch.setattr(ClientSession, 'get', default_mock_client_get)
# mock out database calls:
mock_station_crud(monkeypatch)
store_spy = mocker.spy(app.routers.hfi_calc, 'store_hfi_request')
client = TestClient(app.main.app)
headers = {'Content-Type': 'application/json',
'Authorization': 'Bearer token'}
return {
'response': client.post('/api/hfi-calc/', headers=headers, json=request_json[0]),
'filename': request_json[1],
'saved': store_spy.call_count == 1
}
def test_revoke_extending_no_chain(subscriptions_type_factory, event_factory,
extension_history_factory,
client_subscription_factory,
mocker: MockFixture):
event = event_factory(date=date(2019, 2, 25),
event_class__date_from=date(2019, 1, 1),
canceled_at=date(2019, 2, 24),
canceled_with_extending=False)
subs = subscriptions_type_factory(company=event.company,
duration=1,
duration_type=GRANULARITY.DAY,
rounding=False,
event_class__events=event.event_class)
cs = client_subscription_factory(company=event.company,
subscription=subs,
purchase_date=date(2019, 2, 24),
start_date=date(2019, 2, 25))
ex_his = extension_history_factory(company=event.company,
client_subscription=cs,
added_visits=0,
date_extended=datetime(2019,
2,
25,
tzinfo=pytz.utc),
extended_from=date(2019, 2, 25),
extended_to=date(2019, 2, 26),
related_event=event)
# Update client subscription end date, as it was changed by extension
cs.end_date = date(2019, 2, 26)
cs.save()
spy = mocker.spy(models.ExtensionHistory, 'delete')
cs.revoke_extending(event)
cs.refresh_from_db()
assert_that(cs.end_date, is_(date(2019, 2, 25)))
assert_that(calling(ex_his.refresh_from_db),
raises(models.ExtensionHistory.DoesNotExist))
spy.assert_called_once()
def test_game_continues_after_step(mocker: MockFixture):
mock_socket_cls = mocker.patch("socket.socket")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"HELO boring Hawking".encode("utf-8"))
game = init_game(sock, 2, "happy Pascal")
sock.close()
set_stdin_value(mocker, "A 1")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"MOVE B 1".encode("utf-8"))
game_over = make_step(sock, game)
sock.close()
assert not game_over
set_stdin_value(mocker, "A 2")
sock = mock_socket_cls()
sendall_spy = mocker.spy(sock, "sendall")
game_over = make_step(sock, game)
sock.close()
assert game_over
sendall_spy.assert_called_once_with("MOVE A 2 STOP X".encode("utf-8"))
def test_revoke_extending_no_extension_history(subscriptions_type_factory,
event_factory,
client_subscription_factory,
mocker: MockFixture):
event = event_factory(date=date(2019, 2, 25),
event_class__date_from=date(2019, 1, 1),
canceled_at=date(2019, 2, 24),
canceled_with_extending=False)
subs = subscriptions_type_factory(company=event.company,
duration=1,
duration_type=GRANULARITY.DAY,
rounding=False,
event_class__events=event.event_class)
cs = client_subscription_factory(company=event.company,
subscription=subs,
purchase_date=date(2019, 2, 24),
start_date=date(2019, 2, 25))
spy = mocker.spy(models.ExtensionHistory, 'delete')
# Update client subscription end date, as it was changed by extension
cs.revoke_extending(event)
spy.assert_not_called()
def test_enemy_wins(mocker: MockFixture):
mock_socket_cls = mocker.patch("socket.socket")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"HELO boring Hawking".encode("utf-8"))
game = init_game(sock, 3, "happy Pascal")
set_stdin_value(mocker, "A 2")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"MOVE A 1".encode("utf-8"))
make_step(sock, game)
set_stdin_value(mocker, "B 1")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"MOVE B 2".encode("utf-8"))
make_step(sock, game)
set_stdin_value(mocker, "C 2")
sock = get_socket_with_mocked_recv(mock_socket_cls,
"MOVE C 3".encode("utf-8"))
sendall_spy = mocker.spy(sock, "sendall")
make_step(sock, game)
sendall_spy.assert_called_with("STOP O".encode("utf-8"))
def test_spec_load_from_unsupported_type(mocker: ptm.MockFixture) -> None:
parse_spec = mocker.spy(parser, 'parse_spec')
with pytest.raises(ValueError):
loader.load_spec(1) # type: ignore
assert not parse_spec.called