def testIfVerifiedVerifyZeroInteractionsStillRaises(self):
when(Dog).bark('Miau')
rex = Dog()
rex.bark('Miau')
verify(Dog).bark('Miau')
with pytest.raises(VerificationError):
verifyZeroInteractions(Dog)
def testIfVerifiedVerifyZeroInteractionsStillRaises(self):
when(Dog).bark('Miau')
rex = Dog()
rex.bark('Miau')
verify(Dog).bark('Miau')
with pytest.raises(VerificationError):
verifyZeroInteractions(Dog)
def test_market_open_does_not_trade(self):
price = None
self.exec_hanlder.accept_orders([self.order_1, self.order_4])
self._set_price_for_now(price)
self.exec_hanlder.on_market_open(...)
verifyZeroInteractions(self.portfolio, self.spied_monitor)
def test_search_transliteration_empty(query, expected, fragment_finder,
fragment_repository):
spy2(fragment_repository.query_by_transliteration)
query = TransliterationQuery(query)
test_result = fragment_finder.search_transliteration(query)
verifyZeroInteractions(fragment_repository)
assert test_result == expected
unstub()
def test_no_orders_executed_on_market_open(self):
self.exec_hanlder.on_market_open(...)
verifyZeroInteractions(self.portfolio, self.spied_monitor)
actual_orders = self.exec_hanlder.get_open_orders()
expected_orders = [
self.stop_loss_order_1, self.stop_loss_order_2,
self.stop_loss_order_3
]
assert_lists_equal(expected_orders, actual_orders)
def test_compare_and_update_no_update(self):
when(sut).check_and_update_wp(ANY(), ANY()).thenReturn(False)
when(sut).check_and_update_plugins(ANY()).thenReturn(False)
when(repush).RepositoryPusher(ANY())
self.assertFalse(sut.compare_and_update(self.dummy_repo_path, "42"))
verify(sut, times=1).check_and_update_wp(self.dummy_repo_path,
self.dummy_latest_version)
verify(sut, times=1).check_and_update_plugins(self.dummy_repo_path)
verifyZeroInteractions(repush)
def test_store_When_channel_has_no_icon_Then_do_nothing(self):
# Setup
channel = Channel({'name':'Bogus Channel', 'icon':None, 'chanid': '9', 'callsign': 'WXYZ'})
conn = Mock()
downloader = MythChannelIconResolver(conn)
# Test
downloader.store(channel, 'bogusDestDir')
# Verify
verifyZeroInteractions(conn)
def test_rpc_cast_with_consumer_exception(self):
mock_conn = mock()
when(rpc).create_connection(new=True).thenRaise(IOError("host down"))
exp_msg = RpcMsgMatcher("prepare", "memory_mb", "databases", "users", "device_path", "mount_point")
with testtools.ExpectedException(exception.GuestError, ".* host down"):
self.api.prepare("2048", "db1", "user1", "/dev/vdt", "/mnt/opt")
verify(rpc).create_connection(new=True)
verifyZeroInteractions(mock_conn)
verify(rpc, never).cast(any(), any(), exp_msg)
def test_3_orders_fill_only_at_open(self):
self.exec_hanlder.accept_orders(
[self.order_1, self.order_2, self.order_3])
self._set_price_for_now(101)
self.exec_hanlder.on_market_close(...)
verifyZeroInteractions(self.portfolio, self.spied_monitor)
actual_orders = self.exec_hanlder.get_open_orders()
expected_orders = [self.order_1, self.order_2, self.order_3]
assert_lists_equal(expected_orders, actual_orders)
def test_process_img_repo_for_no_update_required(self):
when(updater).compare_and_update(ANY(), ANY()).thenReturn(False)
when(app).wait_for_build(ANY(), ANY())
when(rpi.ReleasePipeline)
when(pipe.Pipeline)
app.process_img_repo(self.dummy_repo, self.dummy_img_repo_path, self.dummy_latest_version)
verify(updater, times=1).compare_and_update(self.dummy_img_repo_path, self.dummy_latest_version)
verify(app, times=0).wait_for_build(ANY(), ANY())
verifyZeroInteractions(rpi.ReleasePipeline, pipe.Pipeline)
def test_start_process(dummy_kwargs):
command = mock()
when(command).run(async_=True)
context = _run_context.RunContext(**dummy_kwargs)
setattr(context, '_command', command)
assert context.start_time == 0
verifyZeroInteractions()
context.start_process()
assert context.start_time != 0
verifyStubbedInvocationsAreUsed()
verifyNoUnwantedInteractions()
def test_getSeasonAndEpisode_When_found_in_cache_Then_return_cached_copy(self):
# Given
key = self.provider.createEpisodeKey('getSeasonAndEpisode', self.program)
self.provider.imagePathsByKey[key] = ('5','12')
# When
season, episode = self.provider.getSeasonAndEpisode(self.program)
# Then
self.assertEqual('5', season)
self.assertEqual('12', episode)
verifyZeroInteractions(self.nextProvider)
def test_getSeasonAndEpisode_When_found_in_cache_Then_return_cached_copy(self):
# Given
key = self.provider.createEpisodeKey('getSeasonAndEpisode', self.program)
self.provider.imagePathsByKey[key] = ('5','12')
# When
season, episode = self.provider.getSeasonAndEpisode(self.program)
# Then
self.assertEqual('5', season)
self.assertEqual('12', episode)
verifyZeroInteractions(self.nextProvider)
def test_order_not_executed_when_bar_for_today_is_incomplete(self):
self._set_bar_for_today(open=None,
high=110.0,
low=100.0,
close=105.0,
volume=100000000.0)
self.exec_hanlder.on_market_close(...)
verifyZeroInteractions(self.portfolio, self.spied_monitor)
actual_orders = self.exec_hanlder.get_open_orders()
expected_orders = [self.stop_loss_order_1, self.stop_loss_order_2]
assert_lists_equal(expected_orders, actual_orders)
def test_getPosters_When_not_struck_out_and_delegate_returns_posters_Then_return_posters(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
when(self.delegate).getPosters(any()).thenReturn(['blah.png'])
# Test
posters = provider.getPosters(self.program)
# Verify
self.assertEqual('blah.png', posters[0])
self.assertNotIn(self.program.title(), provider.struckOut.values())
verifyZeroInteractions(self.nextProvider)
def test_getPosters_When_not_struck_out_and_delegate_returns_posters_Then_return_posters(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
when(self.delegate).getPosters(any()).thenReturn(['blah.png'])
# Test
posters = provider.getPosters(self.program)
# Verify
self.assertEqual('blah.png', posters[0])
self.assertNotIn(self.program.title(), provider.struckOut.values())
verifyZeroInteractions(self.nextProvider)
def test_rpc_cast_with_consumer_exception(self):
mock_conn = mock()
when(rpc).create_connection(new=True).thenRaise(IOError('host down'))
exp_msg = RpcMsgMatcher('prepare', 'memory_mb', 'databases', 'users',
'device_path', 'mount_point')
with testtools.ExpectedException(exception.GuestError, '.* host down'):
self.api.prepare('2048', 'db1', 'user1', '/dev/vdt', '/mnt/opt')
verify(rpc).create_connection(new=True)
verifyZeroInteractions(mock_conn)
verify(rpc, never).cast(any(), any(), exp_msg)
def test_rpc_cast_with_consumer_exception(self):
mock_conn = mock()
when(rpc).create_connection(new=True).thenRaise(IOError('host down'))
exp_msg = RpcMsgMatcher('prepare', 'memory_mb', 'databases', 'users',
'device_path', 'mount_point')
with testtools.ExpectedException(exception.GuestError, '.* host down'):
self.api.prepare('2048', 'db1', 'user1', '/dev/vdt', '/mnt/opt')
verify(rpc).create_connection(new=True)
verifyZeroInteractions(mock_conn)
verify(rpc, never).cast(any(), any(), exp_msg)
def test_enterText_Should_DoNothing_When_UserCancelsOperation(self):
# Setup
xbmc.Keyboard.stubConfirmed = False
control = Mock()
validator = Mock()
updater = Mock()
# Test
enterText(control=control, validator=validator.validate, updater=updater.update)
# Verify
verifyZeroInteractions(validator)
verifyZeroInteractions(updater)
def test_getSeasonAndEpisode_When_not_struck_out_and_delegate_returns_season_and_episode_Then_return_season_and_episode(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
when(self.delegate).getSeasonAndEpisode(any()).thenReturn(('1','2',))
# Test
season, episode = provider.getSeasonAndEpisode(self.program)
# Verify
self.assertEqual('1', season)
self.assertEqual('2', episode)
self.assertNotIn(self.program.title(), provider.struckOut.values())
verifyZeroInteractions(self.nextProvider)
def test_getSeasonAndEpisode_When_not_struck_out_and_delegate_returns_season_and_episode_Then_return_season_and_episode(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
when(self.delegate).getSeasonAndEpisode(any()).thenReturn(('1','2',))
# Test
season, episode = provider.getSeasonAndEpisode(self.program)
# Verify
self.assertEqual('1', season)
self.assertEqual('2', episode)
self.assertNotIn(self.program.title(), provider.struckOut.values())
verifyZeroInteractions(self.nextProvider)
def testClearsInvocations(self):
theMock1 = mock()
theMock2 = mock()
theMock1.do_foo()
theMock2.do_bar()
self.assertRaises(VerificationError, verifyZeroInteractions, theMock1)
self.assertRaises(VerificationError, verifyZeroInteractions, theMock2)
forget_invocations(theMock1, theMock2)
verifyZeroInteractions(theMock1)
verifyZeroInteractions(theMock2)
def testClearsInvocations(self):
theMock1 = mock()
theMock2 = mock()
theMock1.do_foo()
theMock2.do_bar()
self.assertRaises(VerificationError, verifyZeroInteractions, theMock1)
self.assertRaises(VerificationError, verifyZeroInteractions, theMock2)
forget_invocations(theMock1, theMock2)
verifyZeroInteractions(theMock1)
verifyZeroInteractions(theMock2)
def test_getPosters_When_struck_out_Then_skip_delegate_and_return_nextProviders_result(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
key = provider.createKey('getPosters', self.program)
provider.strikeOut(key, self.program)
when(self.nextProvider).getPosters(any()).thenReturn(['blah.png'])
# Test
posters = provider.getPosters(self.program)
# Verify
self.assertEqual('blah.png', posters[0])
self.assertIn(self.program.title(), provider.struckOut[key].values())
verifyZeroInteractions(self.delegate)
def test_getPosters_When_struck_out_Then_skip_delegate_and_return_nextProviders_result(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
key = provider.createKey('getPosters', self.program)
provider.strikeOut(key, self.program)
when(self.nextProvider).getPosters(any()).thenReturn(['blah.png'])
# Test
posters = provider.getPosters(self.program)
# Verify
self.assertEqual('blah.png', posters[0])
self.assertIn(self.program.title(), provider.struckOut[key].values())
verifyZeroInteractions(self.delegate)
def test_notification_that_is_not_to_a_paid_state(self):
payload = mockito.Mock()
product = self.create_from_factory(ValidProductFactory, price=200)
purchase = self.create_from_factory(ValidPurchaseFactory, product=product)
payment = self.create_from_factory(ValidPaymentFactory, type='dummy', purchase=purchase, amount=100)
transition = self.create_from_factory(ValidTransitionToPendingFactory, payment=payment)
mockito.when(self.dummy).notify(purchase, payment, payload, 'notification').thenReturn(transition)
result = self.service.notify(purchase.id, payment.id, payload)
self.assertEquals(payment.status, 'pending')
self.assertEquals(result[0].status, 'pending')
self.assertEquals(result[0].outstanding_amount, 200)
mockito.verifyZeroInteractions(self.mailer)
def test_getSeasonAndEpisode_When_struck_out_Then_skip_delegate_and_return_nextProviders_result(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
key = provider.createKey('getSeasonAndEpisode', self.program)
provider.strikeOut(key, self.program)
when(self.nextProvider).getSeasonAndEpisode(any()).thenReturn(('1','2'))
# Test
season, episode = provider.getSeasonAndEpisode(self.program)
# Verify
self.assertEqual('1', season)
self.assertEqual('2', episode)
self.assertIn(self.program.title(), provider.struckOut[key].values())
verifyZeroInteractions(self.delegate)
def test_enterText_Should_DoNothing_When_UserCancelsOperation(self):
# Setup
xbmc.Keyboard.stubConfirmed = False
control = Mock()
validator = Mock()
updater = Mock()
# Test
enterText(control=control,
validator=validator.validate,
updater=updater.update)
# Verify
verifyZeroInteractions(validator)
verifyZeroInteractions(updater)
def test_enterText_Should_NotUpdateControlAndModel_When_UserEnteredTextFailsValidation(self):
# Setup
xbmc.Keyboard.stubConfirmed = True
xbmc.Keyboard.stubText = 'Bubba'
control = Mock()
updater = Mock()
validator = Mock()
when(validator).validate(any()).thenRaise(Exception('Invalid name'))
# Test
enterText(control=control, validator=validator.validate, updater=updater.update)
# Verify
verifyZeroInteractions(updater)
verify(control, 0).setLabel(any(str), any(str))
def test_getSeasonAndEpisode_When_struck_out_Then_skip_delegate_and_return_nextProviders_result(self):
# Setup
provider = OneStrikeAndYoureOutFanartProvider(self.platform, self.delegate, self.nextProvider)
key = provider.createKey('getSeasonAndEpisode', self.program)
provider.strikeOut(key, self.program)
when(self.nextProvider).getSeasonAndEpisode(any()).thenReturn(('1','2'))
# Test
season, episode = provider.getSeasonAndEpisode(self.program)
# Verify
self.assertEqual('1', season)
self.assertEqual('2', episode)
self.assertIn(self.program.title(), provider.struckOut[key].values())
verifyZeroInteractions(self.delegate)
def test_notifications_that_cannot_be_processed_throws_its_errors(self):
payload = mockito.Mock()
product = self.create_from_factory(ValidProductFactory, price=200)
purchase = self.create_from_factory(ValidPurchaseFactory, product=product)
payment = self.create_from_factory(ValidPaymentFactory, type='dummy', purchase=purchase, amount=100)
transition = self.create_from_factory(ValidTransitionToPendingFactory, payment=payment)
mockito.when(self.dummy).notify(purchase, payment, payload, 'notification').thenRaise(InvalidPaymentNotification)
with self.assertRaises(InvalidPaymentNotification):
self.service.notify(purchase.id, payment.id, payload)
mockito.when(self.dummy).notify(purchase, payment, payload, 'notification').thenRaise(PaymentVerificationFailed)
with self.assertRaises(PaymentVerificationFailed):
self.service.notify(purchase.id, payment.id, payload)
mockito.verifyZeroInteractions(self.mailer)
def test_notification_that_pays_the_balance_of_purchase(self):
payload = mockito.Mock()
product = self.create_from_factory(ValidProductFactory, price=200)
purchase = self.create_from_factory(ValidPurchaseFactory, product=product)
payment = self.create_from_factory(ValidPaymentFactory, type='dummy', purchase=purchase, amount=200)
transition = self.create_from_factory(ValidTransitionToPaidFactory, payment=payment)
mockito.when(self.dummy).notify(purchase, payment, payload, 'notification').thenReturn(transition)
mockito.when(self.mailer).notify_payment(purchase, payment)
result = self.service.notify(purchase.id, payment.id, payload)
self.assertEquals(result[0].status, 'paid')
self.assertEquals(payment.status, 'paid')
mockito.verify(self.mailer).notify_payment(purchase, payment)
mockito.verifyZeroInteractions(self.caravans)
def test_store_When_channel_has_no_icon_Then_do_nothing(self):
# Setup
channel = Channel({
'name': 'Bogus Channel',
'icon': None,
'chanid': '9',
'callsign': 'WXYZ'
})
conn = Mock()
downloader = MythChannelIconResolver(conn)
# Test
downloader.store(channel, 'bogusDestDir')
# Verify
verifyZeroInteractions(conn)
def test_determine_last_updatedate_for_public_image(self):
expected_result = "2020-03-12T10:11:56.603Z"
dummy_parent_image = "ubuntu:18.04"
when(DockerImageDetails)
when(RepoDetails)
when(ParentImage).is_public_image(ANY(str)).thenReturn(True)
when(ParentImage).determine_last_updatedate(ANY(str)).thenReturn(expected_result)
result = sut.determine_last_updatedate(dummy_parent_image, "")
self.assertEqual(expected_result, result)
verify(ParentImage, times=1).is_public_image(dummy_parent_image)
verify(ParentImage, times=1).determine_last_updatedate(dummy_parent_image)
verifyZeroInteractions(DockerImageDetails)
verifyZeroInteractions(RepoDetails)
def test_enterText_Should_NotUpdateControlAndModel_When_UserEnteredTextFailsValidation(
self):
# Setup
xbmc.Keyboard.stubConfirmed = True
xbmc.Keyboard.stubText = 'Bubba'
control = Mock()
updater = Mock()
validator = Mock()
when(validator).validate(any()).thenRaise(Exception('Invalid name'))
# Test
enterText(control=control,
validator=validator.validate,
updater=updater.update)
# Verify
verifyZeroInteractions(updater)
verify(control, 0).setLabel(any(str), any(str))
def test_determine_last_updatedate_for_private_image_with_static_version(self):
expected_result = "2020-03-12T10:11:56.603Z"
expected_json = {"lastUpdateTime": expected_result}
dummy_parent_image = "orgdummy.azurecr.io/prj-infra-dummy:7.7"
dummy_details = mock(DockerImageDetails)
when(DockerImageDetails).from_FQDIN(ANY(str)).thenReturn(dummy_details)
when(dummy_details).az_image_tag_details().thenReturn(expected_json)
when(RepoDetails)
when(ParentImage).is_public_image(ANY(str)).thenReturn(False)
when(ParentImage).determine_last_updatedate(ANY(str)).thenReturn(expected_result)
result = sut.determine_last_updatedate(dummy_parent_image, "")
self.assertEqual(expected_result, result)
verify(ParentImage, times=1).is_public_image(dummy_parent_image)
verify(ParentImage, times=0).determine_last_updatedate(ANY(str))
verify(DockerImageDetails, times=1).from_FQDIN(dummy_parent_image)
verify(dummy_details, times=1).az_image_tag_details()
verifyZeroInteractions(RepoDetails)
def test_day_order_disappears_after_a_day(self):
self._set_bar_for_today(open=105.0,
high=110.0,
low=100.0,
close=105.0,
volume=100000000.0)
expected_orders = [
self.stop_loss_order_1, self.stop_loss_order_2,
self.stop_loss_order_3
]
actual_orders = self.exec_hanlder.get_open_orders()
assert_lists_equal(expected_orders, actual_orders)
self.exec_hanlder.on_market_close(...)
verifyZeroInteractions(self.portfolio, self.spied_monitor)
actual_orders = self.exec_hanlder.get_open_orders()
expected_orders = [self.stop_loss_order_1, self.stop_loss_order_2]
assert_lists_equal(expected_orders, actual_orders)
def testVerifyZeroInteractionsWorks(self):
when(Dog).bark('Miau')
verifyZeroInteractions(Dog)
def testVerifies(self):
theMock = mock()
verifyZeroInteractions(theMock)
theMock.foo()
self.assertRaises(VerificationError, verifyNoMoreInteractions, theMock)
def testPassIfVerifiedZeroInteractions(self):
dog = mock()
when(dog).waggle(1).thenReturn('Sure')
verifyZeroInteractions(dog)
verifyStubbedInvocationsAreUsed(dog)
def assert_login_setup_service_for_user(_):
verifyZeroInteractions(self.portal)
mock_redirect.assert_called_once_with('/', self.request)
def testVerifyZeroInteractionsWorks(self):
dummy = spy(Dummy())
verifyZeroInteractions(dummy)
def testVerifyZeroInteractionsWorks(self):
when(Dog).bark('Miau')
verifyZeroInteractions(Dog)
def testVerifies(self): theMock = mock() verifyZeroInteractions(theMock) theMock.foo() self.assertRaises(VerificationError, verifyNoMoreInteractions, theMock)
def assert_login_setup_service_for_user(_):
verifyZeroInteractions(self.portal)
mock_redirect.assert_called_once_with('/', self.request)
def testVerifyZeroInteractionsWorks(self):
dummy = spy(Dummy())
verifyZeroInteractions(dummy)
