def test_generate_for_service( services: QuerySet, mocker: MockFixture, ): """Should run the generator.""" service = services.first() start = arrow.utcnow() end = start.shift(days=1) generator = mocker.MagicMock() get_generator = mocker.MagicMock(return_value=generator) mocker.patch( "schedule.availability.utils.get_availability_generator", new=get_generator, ) generate_for_service( service=service, append_days=True, start=start, end=end, ) get_generator.assert_called_once() generator.generate.assert_called_once() request = get_generator.call_args_list[0][0][0] assert request.service == service assert request.professional == service.professional assert request.start_datetime == start assert request.end_datetime == end assert request.append_days is True
def test_run_configurations_sync_mode(mocker: MockFixture, ) -> None: f_configurations = [mocker.MagicMock() for _ in range(2)] f_configuration_admin = ConfigurationAdmin(Configuration, AdminSite()) f_configuration_admin.run_configurations( mocker.MagicMock(), f_configurations, ) for f_config in f_configurations: f_config.run.assert_called_once()
def test_order_auto_filler_fill_exception(mocker: MockFixture): """Should raise the exception.""" order = Order() filler = OrderAutoFiller(order) filler._set_status = mocker.MagicMock() # type: ignore filler._set_status.side_effect = ObjectDoesNotExist("test") # type: ignore filler._set_end_datetime = mocker.MagicMock(return_value=3) # type: ignore filler.fill() filler._set_status.assert_called_once() # type: ignore filler._set_end_datetime.assert_not_called() # type: ignore
def test_run_configurations_async_mode(mocker: MockFixture, ) -> None: f_configurations = [mocker.MagicMock() for _ in range(2)] f_configuration_admin = ConfigurationAdmin(Configuration, AdminSite()) f_run_configuration = mocker.patch('configuration.admin.run_configuration') f_configuration_admin.run_configurations( mocker.MagicMock(), f_configurations, ) f_run_configuration.delay.assert_has_calls( [mocker.call(conf.id) for conf in f_configurations], )
def test_transition_callbacks(mocker: pytest_mock.MockFixture): mock_preempt_fn = mocker.MagicMock() mock_action_fn = mocker.MagicMock() mock_snooze_fn = mocker.MagicMock() mock_completion_fn = mocker.MagicMock() zero_timedelta = timedelta(seconds=0) goal = Goal( name='goal', priority=1.0, duration=zero_timedelta, preempt_duration=zero_timedelta, snooze_duration=zero_timedelta, preempt_event=Event( 'preempt', next_=datetime.now(), callback=mock_preempt_fn, ), action_event=Event( 'action', next_=datetime.now(), callback=mock_action_fn, ), snooze_event=Event( 'snooze', next_=datetime.now(), callback=mock_snooze_fn, ), completion_event=Event('completion', next_=datetime.now(), callback=mock_completion_fn), ) assert goal.state == States.NEW assert not mock_preempt_fn.called for i in range(5): goal.preempt() assert mock_preempt_fn.call_count == i + 1 assert goal.state == States.IDLE assert not mock_action_fn.called goal.act() assert mock_action_fn.called assert goal.state == States.ACTIVE assert not mock_snooze_fn.called for i in range(5): goal.snooze() assert mock_snooze_fn.call_count == i + 1 assert goal.state == States.ACTIVE assert not mock_completion_fn.called goal.complete() assert mock_completion_fn.called assert goal.state == States.IDLE
def test_order_auto_filler_fill(mocker: MockFixture): """Should set the order contacts.""" order = Order() filler = OrderAutoFiller(order) filler._set_status = mocker.MagicMock(return_value=1) # type: ignore filler._set_contacts = mocker.MagicMock(return_value=2) # type: ignore filler._set_end_datetime = mocker.MagicMock(return_value=3) # type: ignore filler._set_price = mocker.MagicMock(return_value=4) # type: ignore filler.fill() filler._set_status.assert_called_once() # type: ignore filler._set_contacts.assert_called_once() # type: ignore filler._set_end_datetime.assert_called_once() # type: ignore filler._set_price.assert_called_once() # type: ignore
def test_router_extend(mocker: MockFixture): """Should extend the default router.""" router = DefaultRouter() router.registry = ["one"] arg1 = mocker.MagicMock() arg1.registry = ["two", "three"] arg2 = mocker.MagicMock() arg2.registry = ["four"] router.extend(arg1, arg2) assert router.registry == ["one", "two", "three", "four"]
def test_run_command(mocker: pytest_mock.MockFixture) -> None: mocked_cmd = mocker.MagicMock() registered_commands = {"test_cmd": Command.from_func(mocked_cmd, name="test_cmd")} mocker.patch("auto_cli.cli._load_app", return_value=registered_commands) cli.run_command("my_app", ["test_cmd"]) mocked_cmd.assert_called_once()
def test_validate_params_should_raise_validation_error( m_telebot: telebot.AsyncTeleBot, mocker: MockFixture, ) -> None: mocked_chat = mocker.MagicMock() m_telebot.get_chat.return_value = mocked_chat mocked_chat.wait.return_value = ( ApiException, ApiException( 'A request to the Telegram API was unsuccessful. ' 'The server returned HTTP 400 Bad Request. Response body: ' '[b\'{"ok":false,"error_code":400,"description":"Bad Request: chat not found"}\']', None, None, ), 'traceback', ) with pytest.raises( ValidationError, match=TelegramGroupChat.CHAT_NOT_FOUND, ): TelegramGroupChat.validate_params( { 'bot_token': FAKE_TOKEN, 'chat_id': 123456789, }, )
async def test_send_message( m_telebot: telebot.AsyncTeleBot, mocker: MockFixture, ) -> None: chat_id = 123456 message = ExternalMessage( sender='@sender', receiver='@receiver', content='testing message', ) mocked_send_message = mocker.MagicMock() m_telebot.send_message.return_value = mocked_send_message mocked_send_message.wait.return_value = tb_types.Message( None, None, None, None, None, [], None, ) bot = TelegramGroupChat( bot_token=FAKE_TOKEN, chat_id=chat_id, ) await bot.send_message(message) m_telebot.send_message.assert_called_once_with( chat_id, f'From {message.sender} ' f'to {message.receiver}: ' f'{message.content}', )
async def test_send_message_raises_validation_error( m_telebot: telebot.AsyncTeleBot, mocker: MockFixture, ) -> None: chat_id = 123 message = ExternalMessage( sender='@sender', receiver='@receiver', content='testing message', ) mocked_send_message = mocker.MagicMock() m_telebot.send_message.return_value = mocked_send_message mocked_send_message.wait.return_value = ( ApiException, ApiException( 'A request to the Telegram API was unsuccessful. ' 'The server returned HTTP 400 Bad Request. Response body: ' '[b\'{"ok":false,"error_code":400,"description":"Bad Request: chat not found"}\']', None, None, ), 'traceback', ) bot = TelegramGroupChat( bot_token=FAKE_TOKEN, chat_id=chat_id, ) with pytest.raises( ValidationError, match=TelegramGroupChat.CHAT_NOT_FOUND, ): await bot.send_message(message)
def test_post_to_dict(mocker: MockFixture, check_post_dict: Callable[[dict], None]) -> None: """The reddit.post_to_dict function suceeds and has the required keys.""" post = mocker.MagicMock() comment_a = mocker.MagicMock() type(comment_a).body = "lorem ipsum" type(comment_a).is_root = True # this comment should be skipped because it is non root comment_b = mocker.MagicMock() type(comment_b).is_root = False type(comment_b).body = "lorem ipsum" post.comments.__iter__.return_value = [comment_b, comment_a, comment_a] res = reddit.post_to_dict(post, include_children=False, limit=1) check_post_dict(res)
def test_order_clean(mocker: MockFixture): """Should run the filler.""" order = Order() order.validators = [] order.filler = mocker.MagicMock() order.clean() order.filler.assert_called_once()
def test_add_class_notifies_listeners( f_registry: Registry, mocker: MockFixture, ) -> None: listeners = [mocker.MagicMock() for _ in range(2)] [f_registry.subscribe(listener) for listener in listeners] f_registry.set(RegisterTestClass) assert all(listener.notify.called for listener in listeners)
def test_add_class_not_notifies_listeners_with_special_flag( f_registry: Registry, mocker: MockFixture, ) -> None: listener = mocker.MagicMock() f_registry.subscribe(listener) f_registry.set(RegisterTestClass, notify_listeners=False) assert not listener.notify.called
def test_post_to_dict_no_coments(mocker: MockFixture) -> None: """The reddit.post_to_dict function suceeds when there are no comments.""" post = mocker.MagicMock() post.comments.__iter__.return_value = [] res = reddit.post_to_dict(post) assert len(res["comments"]) == 0
def test_load_json_schema_file(mocker: MockFixture, success_arguments: tuple): schema, instance = success_arguments mock_isfile = mocker.patch("os.path.isfile") mock_isfile.side_effect = lambda x: x.name == "schema.json" mock_load_file = mocker.patch("jsonschema_cli.args.load_file", mocker.MagicMock(return_value=schema)) args = create_parser().parse_args(["validate", "schema.json", json.dumps(instance)]) args.func(args)
def test_upload_all_custom_objects_from_db_to_registry( mocker: MockFixture, ) -> None: f_objects_manager = mocker.MagicMock() ABCCustomObjectModel.objects = f_objects_manager f_custom_objects = [ ABCCustomObjectModel(name=f'custom_object_{i}') for i in range(2) ] f_objects_manager.all.return_value = f_custom_objects registry = Registry(ABCCustomObjectModel.REGISTRY_NAME) f_listeners = [mocker.MagicMock() for _ in range(2)] [registry.subscribe(listener) for listener in f_listeners] ABCCustomObjectModel.upload_all_custom_objects_from_db_to_registry() assert all( str(custom_object) in registry.keys for custom_object in f_custom_objects) [listener.notify.assert_called_once() for listener in f_listeners]
def test_order_save(user: User, services: QuerySet, mocker: MockFixture): """Should run the filler.""" order = Order() order.validators = [] order.service = services.first() order.client = user order.start_datetime = arrow.utcnow().shift(hours=2).datetime order.end_datetime = arrow.utcnow().shift(hours=4).datetime order.filler = mocker.MagicMock() order.save() order.filler.assert_called_once()
def test_s3_copy(tmp_path: Path, mocker: MockFixture): # Setup # local files to upload names = ["model.tar.gz", "trainer_checkpoint_123.pth", "log.sqlite"] for name in names: (tmp_path / name).write_text(f"This is {name}.") # trainer mock trainer = mocker.MagicMock(spec=Engine) trainer.iteration = 123 # S3 bucket mock s3 = boto3.resource("s3") bucket_name = "sample" s3.create_bucket(Bucket=bucket_name) # Excute s3_copy( trainer, pattern=f"{tmp_path}/model.tar.gz", bucket_name=bucket_name, key_prefix="{job_name}/model/iter_{trainer.iteration}", ) s3_copy( trainer, pattern=f"{tmp_path}/trainer_checkpoint_*.pth", bucket_name=bucket_name, key_prefix="{job_name}/trainer/iter_{trainer.iteration}", ) s3_copy( trainer, pattern=f"{tmp_path}/log.sqlite", bucket_name=bucket_name, ) # Check try: # res = s3.Object(bucket_name, "model/iter_123/model.tar.gz").get() bucket = s3.Bucket(bucket_name) object_summaries = bucket.objects.all() keys = tuple(sorted([obj_sum.key for obj_sum in object_summaries])) job_name = os.uname()[1] assert keys == tuple( sorted( [ f"{job_name}/model/iter_123/model.tar.gz", f"{job_name}/trainer/iter_123/trainer_checkpoint_123.pth", f"{job_name}/log.sqlite", ] ) ) except botocore.exceptions.ClientError as e: if e.response["Error"]["Code"] == "404": assert False, "The file doesn't exist." else: assert False, e
def test_notify_model_restores_all_custom_objects_from_registry( mocker: MockFixture, ) -> None: f_meta = mocker.patch.object(ABCObjectModel, '_meta') f_field = mocker.MagicMock() f_meta.get_field.return_value = f_field ABCObjectModel.notify() f_field.choices = [ ( SampleClassInDefaultRegistry.__name__, SampleClassInDefaultRegistry.__name__, ), ]
def test_save_object_add_it_to_registry(mocker: MockFixture, ) -> None: registry = Registry(ABCCustomObjectModel.REGISTRY_NAME) f_listeners = [mocker.MagicMock() for _ in range(2)] [registry.subscribe(listener) for listener in f_listeners] f_save = mocker.patch.object(Model, 'save') custom_object = ABCCustomObjectModel() custom_object.save() f_save.assert_called_once() assert str(custom_object) in registry.keys [listener.notify.assert_called_once() for listener in f_listeners]
async def test_consume_messages( m_telebot: telebot.AsyncTeleBot, mocker: MockFixture, ) -> None: chat_id = 123456 messages = [ ExternalMessage( sender='@sender2', receiver='@receiver1', content='testing message 1', ), ExternalMessage( sender='@sender1', receiver='@receiver2', content='testing message 2', ), ] mocked_send_message = mocker.MagicMock() m_telebot.send_message.return_value = mocked_send_message mocked_send_message.wait.return_value = tb_types.Message( None, None, None, None, None, [], None, ) bot = TelegramGroupChat( bot_token=FAKE_TOKEN, chat_id=chat_id, ) await bot.consume_messages(messages) m_telebot.send_message.assert_has_calls( [ mocker.call( chat_id, f'From {messages[0].sender} ' f'to {messages[0].receiver}: ' f'{messages[0].content}', ), mocker.call( chat_id, f'From {messages[1].sender} ' f'to {messages[1].receiver}: ' f'{messages[1].content}', ), ], any_order=True, )
def test_order_auto_filler_set_price(mocker: MockFixture): """Should run the calculator.""" order = Order() filler = OrderAutoFiller(order) assert isinstance(filler.calc, AbstractCalculator) filler.calc.calc = mocker.MagicMock(return_value=1) # type: ignore order.price = Money(1, "EUR") filler._set_price() filler.calc.calc.assert_not_called() # type: ignore order.price = None filler._set_price() filler.calc.calc.assert_called_once() # type: ignore
def test_validate_params( m_telebot: telebot.AsyncTeleBot, mocker: MockFixture, ) -> None: chat_id = 123456 mocked_chat = mocker.MagicMock() m_telebot.get_chat.return_value = mocked_chat mocked_chat.wait.return_value = tb_types.Chat(chat_id, None) TelegramGroupChat.validate_params( { 'bot_token': FAKE_TOKEN, 'chat_id': chat_id, }, )
def test_oms_cancel_not_pending(mocker: MockFixture): scheduler = HistoricNetworkScheduler(0, 1000) oms = OrderManagerService(scheduler) order_events = [] Do(scheduler.get_network(), oms.get_order_events(), lambda: order_events.append(oms.get_order_events().get_value())) instrument = mocker.MagicMock(ExchangeInstrument) order = MarketOrder(10, instrument, Side.BUY, 'Main') order.set_order_id(str(uuid1())) oms.pending_new(order) oms.new(order, str(uuid1())) oms.apply_cancel(order, str(uuid1())) scheduler.run() assert (isinstance(order_events[2], CancelReject)) assert (order_events[2].get_message() == 'Attempt to apply cancel when not pending')
def test_get_metrics(mocker: MockFixture) -> None: """ Tests for ``get_metrics``. """ from superset.db_engine_specs.base import MetricType from superset.db_engine_specs.sqlite import SqliteEngineSpec from superset.models.core import Database database = Database(database_name="my_database", sqlalchemy_uri="sqlite://") assert database.get_metrics("table") == [ { "expression": "COUNT(*)", "metric_name": "count", "metric_type": "count", "verbose_name": "COUNT(*)", } ] class CustomSqliteEngineSpec(SqliteEngineSpec): @classmethod def get_metrics( cls, database: Database, inspector: Inspector, table_name: str, schema: Optional[str], ) -> List[MetricType]: return [ { "expression": "COUNT(DISTINCT user_id)", "metric_name": "count_distinct_user_id", "metric_type": "count_distinct", "verbose_name": "COUNT(DISTINCT user_id)", }, ] database.get_db_engine_spec_for_backend = mocker.MagicMock( # type: ignore return_value=CustomSqliteEngineSpec ) assert database.get_metrics("table") == [ { "expression": "COUNT(DISTINCT user_id)", "metric_name": "count_distinct_user_id", "metric_type": "count_distinct", "verbose_name": "COUNT(DISTINCT user_id)", }, ]
def test_oms_late_fill(mocker: MockFixture): scheduler = HistoricNetworkScheduler(0, 1000) oms = OrderManagerService(scheduler) order_events = [] Do(scheduler.get_network(), oms.get_order_events(), lambda: order_events.append(oms.get_order_events().get_value())) instrument = mocker.MagicMock(ExchangeInstrument) order = MarketOrder(10, instrument, Side.BUY, 'Main') order.set_order_id(str(uuid1())) oms.pending_new(order) oms.new(order, str(uuid1())) oms.pending_cancel(order) oms.apply_cancel(order, str(uuid1())) oms.apply_fill(order, 1, 10_000, str(uuid1())) scheduler.run() assert (isinstance(order_events[4], Reject)) assert (order_events[4].get_message() == 'Order canceled')
def test_http_to_calendar_request_converter( professionals: QuerySet, services: QuerySet, mocker: MockFixture, ): """Should convert a HTTP request to a calendar request.""" tz_name = "America/New_York" datetime_format = "YYYY-MM-DDTHH:mm:ss" timezone.activate(tz_name) validator = mocker.MagicMock(return_value=None) professional = professionals.first() service = services.filter( professional=professional, is_base_schedule=False, ).first() request = HttpRequest() request.GET["professional"] = professional.pk request.GET["service"] = service.pk converter = HTTPToCalendarRequestConverter(Request(request)) converter.validator = validator result = converter.get() assert result.professional == professional assert result.service == service assert validator.call_count == 1 start_datetime = "2020-08-23T16:19:43" end_datetime = "2021-08-23T16:19:43" request.GET["start_datetime"] = start_datetime request.GET["end_datetime"] = end_datetime service.is_base_schedule = True service.save() request.GET["service"] = service.pk result = HTTPToCalendarRequestConverter(Request(request)).get() assert result.start_datetime assert result.end_datetime assert result.service is None assert result.start_datetime.utcoffset().total_seconds() == 0 assert result.end_datetime.utcoffset().total_seconds() == 0 assert start_datetime == result.start_datetime.to(tz_name).format( datetime_format) assert end_datetime == result.end_datetime.to(tz_name).format( datetime_format)
def test_get_calendar_generator_get( professionals: QuerySet, mocker: MockFixture, ): """Should return an instance of the calendar generator.""" request = CalendarRequest() request.professional = professionals.first() request.start_datetime = arrow.utcnow() request.end_datetime = arrow.utcnow().shift(days=7) generator = get_calendar_generator() mock = mocker.MagicMock(return_value=[]) generator._manager.get_between_dates = mock generator.get(request) mock.assert_called_once_with( professional=request.professional, service=request.service, start=request.start_datetime, end=request.end_datetime, )