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,
)
