def test_argspecs_are_validated_when_called_via_mock_provider(self): class MyServiceNeeds(NeedsInterface): def a(self, a, b=10): pass class MyService(Service): deps = MyServiceNeeds() @provides def get_a(self, *args, **kwargs): return self.deps.a(*args, **kwargs) service = MyService() provider = attach_mock_provider(consumer=service, ports=['a']) provider.a.side_effect = lambda a, b=10: a + b # assert works as expected if called properly self.assertEqual(53, service.get_a(50, 3)) self.assertEqual(53, service.get_a(a=50, b=3)) self.assertEqual(53, service.get_a(b=50, a=3)) self.assertEqual(60, service.get_a(a=50)) with self.assertRaisesRegexp(TypeError, "'a' parameter lacking default value"): service.get_a() with self.assertRaisesRegexp(TypeError, "too many keyword arguments {'c': 10}"): service.get_a(100, c=10) with self.assertRaisesRegexp(TypeError, "'a' parameter lacking default value"): service.get_a(b=10)
def test_attaching_mock_provider_to_service(self): class MyService(Service): deps = Needs(['a', 'b']) @provides def get_a(self): return self.deps.a() @provides def get_b(self): return self.deps.b() service = MyService() attach_mock_provider(consumer=service, ports={'a': 100}) self.assertEqual(100, service.get_a()) self.assertRaises(DisconnectedPort, service.get_b)
def test_get_order_history__returns_empty_list_if_no_historical_data(self): # GIVEN db_store_closed_order port returns a None (room with no historical orders) provider = attach_mock_provider( consumer=self.service, ports={'db_get_closed_orders_for_room': None}) # WHEN provides port called output = self.service.get_order_history(room='room_x') # THEN empty list returned self.assertSequenceEqual([], output) provider.db_get_closed_orders_for_room.assert_called_once_with( room='room_x')
def test_archive_order__closed_order_are_written_to_db(self): # GIVEN db_store_closed_order is connected to something that returns object after saving it provider = attach_mock_provider(consumer=self.service, ports=['db_store_closed_order']) provider.db_store_closed_order.side_effect = lambda order_details: order_details order = make_order_details(order_id='id001') # WHEN archive_order is called with an order output = self.service.archive_order(order_details=order) # THEN the needs port is called and its output value is returned self.assertEqual(order, output) provider.db_store_closed_order.assert_called_once_with( order_details=order)
def test_get_order_history__returns_list_of_orders_retrieved_from_db(self): # GIVEN db_store_closed_order port returns a list of orders orders = [ make_order_details(order_id='id001'), make_order_details(order_id='id002') ] provider = attach_mock_provider( consumer=self.service, ports={'db_get_closed_orders_for_room': orders}) # WHEN provides port called output = self.service.get_order_history(room='room_x') # THEN the orders are returned self.assertSequenceEqual(orders, output) provider.db_get_closed_orders_for_room.assert_called_once_with( room='room_x')
def test_returned_mock_provider_can_be_operated_on(self): class MyService(Service): deps = Needs(['a', 'b']) @provides def get_a(self): return self.deps.a() @provides def get_b(self): return self.deps.b() service = MyService() provider = attach_mock_provider(consumer=service, ports=['a']) provider.a.side_effect = KeyError self.assertRaises(KeyError, service.get_a) self.assertRaises(DisconnectedPort, service.get_b) provider.a.assert_called_once_with()
def test_interface_restriction_transferred_to_service_with_shared_needs( self): class MyServiceNeeds(NeedsInterface): def a(self, a, b=10): pass class MyService(Service): deps = MyServiceNeeds() @provides def get_a(self, *args, **kwargs): return self.deps.a(*args, **kwargs) class AnotherService(Service): deps = Needs( ['a'] ) # no interface supplied, but inherited with shared port of domain @provides def get_another(self, *args, **kwargs): return self.deps.a(*args, **kwargs) class MyDomain(Domain): __services__ = [MyService, AnotherService] __provides__ = ['get_another'] domain = MyDomain() provider = attach_mock_provider(consumer=domain, ports=['a']) provider.a.side_effect = lambda a, b=10: a + b # assert works as expected if called properly self.assertEqual(53, domain.get_another(a=50, b=3)) with self.assertRaisesRegexp(TypeError, "too many keyword arguments {'c': 10}"): domain.get_another(100, c=10)