async def test_init_params_assertion(self, mocker: MockFixture, fake_data_provider: BaseDataProvider): fake_get_many = CoroutineMock() fake_include_settings_data_provider = mocker.Mock( __name__='foo', return_value=mocker.Mock(get_many=fake_get_many)) fake_item = mocker.Mock() fake_include_settings = { 'relations': [{ 'included_entity_field_name': 'foo', 'root_entity_field_name': 'bar', }], 'data_provider_init_params': [{ 'param_name': 'wrong_param_name', 'attribute_name': 'test_attribute_name', }], 'data_provider_class': fake_include_settings_data_provider } fake_include_params = {'page': mocker.Mock(), 'fields': mocker.Mock()} with pytest.raises(AssertionError): await fake_data_provider.get_item_include_data( fake_item, fake_include_settings, fake_include_params) fake_item.get.assert_called_once_with('bar') fake_include_settings_data_provider.assert_not_called() fake_get_many.assert_not_called()
async def test_resolve_request_with_single_matcher(self): handler = CoroutineMock(return_value=sentinel.response) matcher = CoroutineMock(return_value=True) self.resolver.register_matcher(matcher, handler) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, handler) matcher.assert_called_once_with(request) handler.assert_not_called()
async def test_resolve_request_priority(self): matcher = CoroutineMock(side_effect=(True, True)) handler1 = CoroutineMock(return_value=sentinel.response1) handler2 = CoroutineMock(return_value=sentinel.response2) self.resolver.register_matcher(matcher, handler1) self.resolver.register_matcher(matcher, handler2) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, handler1) handler1.assert_not_called() handler2.assert_not_called() matcher.assert_called_once_with(request)
async def test_resolve_request_with_first_falsy_matcher(self): handler = CoroutineMock(return_value=sentinel.response) matcher1 = CoroutineMock(return_value=False) matcher2 = CoroutineMock(return_value=True) self.resolver.register_matcher(matcher1, handler) self.resolver.register_matcher(matcher2, handler) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, self.default_handler) matcher1.assert_called_once_with(request) matcher2.assert_not_called() handler.assert_not_called()
async def test_resolve_request_with_multiple_handlers(self): matcher = CoroutineMock(side_effect=(False, True)) handler1 = CoroutineMock(return_value=sentinel.response1) handler2 = CoroutineMock(return_value=sentinel.response2) self.resolver.register_matcher(matcher, handler1) self.resolver.register_matcher(matcher, handler2) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, handler2) handler1.assert_not_called() handler2.assert_not_called() matcher.assert_has_calls([call(request)] * 2) self.assertEqual(matcher.call_count, 2)
async def test_can_handle_message_with_no_subscription(self): frame = Frame("MESSAGE", { "subscription": "123", "message-id": "321" }, "blah") handler = CoroutineMock() frame_handler = Mock() frame_handler.get.return_value = None stomp = StompReader(frame_handler, self.loop) await stomp._handle_message(frame) handler.assert_not_called()
async def test_can_handle_message_with_no_subscription(self): frame = Frame('MESSAGE', { 'subscription': '123', 'message-id': '321' }, 'blah') handler = CoroutineMock() frame_handler = Mock() frame_handler.get.return_value = None stomp = StompReader(frame_handler, self.loop) await stomp._handle_message(frame) handler.assert_not_called()
async def test_relations_assertion(self, mocker: MockFixture, fake_data_provider: BaseDataProvider): fake_get_many = CoroutineMock() fake_include_settings_data_provider = mocker.Mock( __name__='foo', return_value=mocker.Mock(get_many=fake_get_many)) fake_item = mocker.Mock() fake_include_settings = { 'data_provider_class': fake_include_settings_data_provider } fake_include_params = {'page': mocker.Mock(), 'fields': mocker.Mock()} with pytest.raises(AssertionError): await fake_data_provider.get_item_include_data( fake_item, fake_include_settings, fake_include_params) fake_item.get.assert_not_called() fake_include_settings_data_provider.assert_not_called() fake_get_many.assert_not_called()
class TestBarterDude(TestCase): @patch("barterdude.App") @patch("barterdude.AMQPConnection") def setUp(self, AMQPConnection, App): self.monitor = Mock() self.monitor.dispatch_before_consume = CoroutineMock() self.monitor.dispatch_on_success = CoroutineMock() self.monitor.dispatch_on_fail = CoroutineMock() self.callback = CoroutineMock() self.messages = [Mock(value=i) for i in range(10)] self.calls = [call(message) for message in self.messages] self.AMQPConnection = AMQPConnection self.connection = self.AMQPConnection.return_value self.App = App self.app = self.App.return_value self.app.startup = CoroutineMock() self.app.shutdown = CoroutineMock() self.decorator = self.app.route.return_value self.schema = load_fixture("schema.json") self.barterdude = BarterDude() def test_should_create_connection(self): self.AMQPConnection.assert_called_once_with( # nosec hostname="127.0.0.1", username="******", password="******", prefetch=10, name="default", ) self.App.assert_called_once_with(connections=[self.connection]) def test_should_call_route_when_created(self): monitor = Mock() self.barterdude.consume_amqp(["queue"], monitor=monitor)(CoroutineMock()) self.app.route.assert_called_once_with( ["queue"], type=RouteTypes.AMQP_RABBITMQ, options={ Options.BULK_SIZE: 10, Options.BULK_FLUSH_INTERVAL: 60, Options.CONNECTION_FAIL_CALLBACK: monitor.dispatch_on_connection_fail, }) def test_should_call_route_when_adding_endpoint(self): hook = Mock() self.barterdude.add_endpoint(['/my_route'], ['GET'], hook) self.app.route.assert_called_once_with(routes=['/my_route'], methods=['GET'], type=RouteTypes.HTTP) self.decorator.assert_called_once_with(hook) async def test_should_call_callback_for_each_message(self): self.barterdude.consume_amqp(["queue"], self.monitor)(self.callback) self.decorator.assert_called_once() wrapper = self.decorator.call_args[0][0] await wrapper(self.messages) messages = [] for message in self.callback.mock_calls: self.assertEqual(Message, type(message[1][0])) messages.append(message[1][0]._message) self.assertListEqual(sorted(messages, key=lambda x: x.value), sorted(self.messages, key=lambda x: x.value)) async def test_should_call_reject_when_callback_fail(self): self.callback.side_effect = Exception('Boom!') self.barterdude.consume_amqp(["queue"], self.monitor)(self.callback) wrapper = self.decorator.call_args[0][0] await wrapper(self.messages) for message in self.messages: message.reject.assert_called_once() async def test_should_call_monitor_for_each_success_message(self): self.barterdude.consume_amqp(["queue"], self.monitor)(self.callback) wrapper = self.decorator.call_args[0][0] await wrapper(self.messages) self.monitor.dispatch_before_consume.assert_has_calls(self.calls, any_order=True) self.monitor.dispatch_on_success.assert_has_calls(self.calls, any_order=True) self.monitor.dispatch_on_fail.assert_not_called() async def test_should_call_callback_for_valid_message(self): self.barterdude.consume_amqp(["queue"], self.monitor, validation_schema=self.schema)( self.callback) self.decorator.assert_called_once() wrapper = self.decorator.call_args[0][0] message = Mock(Message) message.body = {"key": 'ok'} await wrapper([message]) self.callback.assert_called_once() self.assertEqual(self.callback.await_args[0][0].body["key"], message.body["key"]) async def test_should_not_call_callback_for_valid_message(self): self.barterdude.consume_amqp(["queue"], self.monitor, validation_schema=self.schema)( self.callback) self.decorator.assert_called_once() wrapper = self.decorator.call_args[0][0] message = Mock(Message) message.body = {"wrong": 'ok'} await wrapper([message]) self.callback.assert_not_called() async def test_should_call_monitor_for_each_fail_message(self): error = Exception('Boom!') self.callback.side_effect = error self.barterdude.consume_amqp(["queue"], self.monitor)(self.callback) wrapper = self.decorator.call_args[0][0] await wrapper(self.messages) self.monitor.dispatch_before_consume.assert_has_calls(self.calls, any_order=True) error_calls = [call(message, error) for message in self.messages] self.monitor.dispatch_on_fail.assert_has_calls(error_calls, any_order=True) self.monitor.dispatch_on_success.assert_not_called() async def test_should_call_put_when_publish(self): data = Mock() self.connection.put = CoroutineMock() await self.barterdude.publish_amqp('exchange', data, vhost="vhost", routing_key="routing_key") self.connection.put.assert_called_once_with(exchange='exchange', data=data, vhost="vhost", routing_key="routing_key", properties=None) async def test_should_call_startup_and_shutdown(self): await self.barterdude.startup() self.app.startup.assert_called_once_with() await self.barterdude.shutdown() self.app.shutdown.assert_called_once_with() def test_should_call_run(self): self.barterdude.run() self.app.run.assert_called_once_with()
class Pick(CommandTestCase): def setup(self, state="A", inv=0): mock_command = Mock(spec=PickCommand, invocation="A") mock_message = Mock(spec=Message) mock_candy_value = Mock(spec=CandyValue, candy=Mock(spec=Candy), value=10) self.mock_candy_drop = Mock(spec=CandyDrop, candy_value=mock_candy_value, command=mock_command, message=mock_message) self.mock_state = {state: self.mock_candy_drop} self.patch("candybot.engine.STATE", self.mock_state) mock_get_inv = Mock(spec=database.get_inv, return_value={ "A": Mock(spec=CandyCollection, __getitem__=Mock(return_value=inv)) }) self.mock_database = Mock(spec=database, get_inv=mock_get_inv) self.patch("candybot.commands.pick.database", self.mock_database) self.mock_send = CoroutineMock() self.patch("candybot.commands.Command.send", self.mock_send) def assert_action(self, expected_candy): self.assertFalse(self.mock_state) self.mock_candy_drop.message.delete.assert_called_once_with() self.mock_database.set_inv.assert_called_once_with( "A", "A", self.mock_candy_drop.candy_value, update=True) self.mock_send.assert_called_once_with(self.mock_candy_drop.pick_str) self.assertEqual(self.mock_candy_drop.candy_value.value, expected_candy) def assert_no_action(self): self.assertTrue(self.mock_state) self.mock_candy_drop.message.delete.assert_not_called() self.mock_database.set_inv.assert_not_called() self.mock_send.assert_not_called() def test_invocation_default(self): command = PickCommand(None) self.assertEqual(command.invocation, "pick") def test_invocation_set(self): command = PickCommand(None, invocation="A") self.assertEqual(command.invocation, "A") async def test_ignore_if_no_state(self): self.setup(state="B") command = PickCommand(None, invocation="A") await command._run() self.assert_no_action() async def test_ignore_if_invocations_differ(self): self.setup() command = PickCommand(None, invocation="B") await command._run() self.assert_no_action() async def test_ignore_if_at_cap(self): self.setup(inv=20) command = PickCommand(Mock(spec=Settings, cap=20), invocation="A") await command._run() self.assert_no_action() async def test_successful_full_pick(self): self.setup() command = PickCommand(Mock(spec=Settings, cap=20), invocation="A") await command._run() self.assert_action(10) async def test_successful_partial_pick(self): self.setup(inv=15) command = PickCommand(Mock(spec=Settings, cap=20), invocation="A") await command._run() self.assert_action(5)