def testVerifyNoMoreInteractionsWorks(self, verification):
rex = Dog()
expect(rex, **verification).bark('Miau').thenReturn('Wuff')
rex.bark('Miau')
rex.bark('Miau')
verifyNoMoreInteractions(rex)
def test_should_compute_tags_similarity(self):
text_processor = mock()
similarity_measure_factory = mock()
when(similarity_measure_factory).jaccard().thenReturn(
JaccardCoefficient())
authored_document = AuthoredDocument(
"1", {
"title": "this is a title",
"body": "this is my second blog, which is much better",
"tags": ["second", "blog"]
},
text_processor=text_processor,
similarity_measure_factory=similarity_measure_factory)
other_authored_document = AuthoredDocument("2", {
"title":
"this is a another title blog",
"body":
"We are surrounded by objects in the real world. These can be cars, houses, etc. This is my better second blog",
"tags": ["objects", "blog", "cars", "houses"]
},
text_processor=
text_processor,
similarity_measure_factory=
similarity_measure_factory)
score = authored_document.tags_similarity_score(
other_authored_document)
self.assertEqual(score, 0.2000)
verify(similarity_measure_factory).jaccard()
verifyNoMoreInteractions(text_processor)
verifyNoMoreInteractions(similarity_measure_factory)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).is_logged_in('some_user_uuid')
verifyNoMoreInteractions(self.services_factory)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
def test_should_compute_title_similarity(self):
text_processor = mock()
similarity_measure_factory = mock()
when(similarity_measure_factory).jaccard().thenReturn(
JaccardCoefficient())
when(text_processor).tokenize("this is a title").thenReturn(["title"])
when(text_processor).tokenize(
"this is a another title blog").thenReturn(["title", "blog"])
authored_document = AuthoredDocument(
"1", {
"title": "this is a title",
"body": "",
"tags": []
},
text_processor=text_processor,
similarity_measure_factory=similarity_measure_factory)
other_authored_document = AuthoredDocument(
"2", {
"title": "this is a another title blog",
"body": "",
"tags": []
},
text_processor=text_processor,
similarity_measure_factory=similarity_measure_factory)
score = authored_document.title_similarity_score(
other_authored_document)
self.assertEqual(score, 0.5)
verify(similarity_measure_factory).jaccard()
verify(text_processor).tokenize("this is a title")
verify(text_processor).tokenize("this is a another title blog")
verifyNoMoreInteractions(text_processor)
verifyNoMoreInteractions(similarity_measure_factory)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).is_logged_in('some_user_uuid')
verifyNoMoreInteractions(self.services_factory)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
def test_register_should_call_listener_for_existent_reference_when_there_is_one_selector(self):
reference = 'REFERENCE'
selection = [reference]
self.manager.register(self.listener_callable_mock, selection)
verify(self.listener_mock, times=1).__call__(reference)
verifyNoMoreInteractions(self.listener_mock)
def testVerifyNoMoreInteractionsWorks(self, verification):
rex = Dog()
expect(rex, **verification).bark('Miau').thenReturn('Wuff')
rex.bark('Miau')
rex.bark('Miau')
verifyNoMoreInteractions(rex)
def test_register_synched_should_call_listener_for_each_existent_combination_of_references_when_there_are_multiple_selectors(
self):
reference1a = 'X1'
reference2a = 'X2'
reference3a = 'X3'
selection_a = [reference1a, reference2a, reference3a]
reference1b = 'R1'
reference2b = 'R2'
reference3b = 'R3'
selection_b = mock()
(when(selection_b).__iter__().thenReturn(
[reference1b, reference2b, reference3b].__iter__()))
when(selection_b).intersection('{%s}' % reference1a).thenReturn(
[reference1b])
when(selection_b).intersection('{%s}' % reference2a).thenReturn(
[reference2b])
when(selection_b).intersection('{%s}' % reference3a).thenReturn(
[reference3b])
self.manager.register_synched(
self.listener_callable_mock,
[selection_a, utils.IterableMock(selection_b)])
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verify(self.listener_mock, times=1).__call__(reference3a, reference3b)
verifyNoMoreInteractions(self.listener_mock)
def testPrintsUnwantedInteraction(self):
theMock = mock()
theMock.foo(1, 'foo')
try:
verifyNoMoreInteractions(theMock)
except VerificationError, e:
self.assertEquals("\nUnwanted interaction: foo(1, 'foo')", str(e))
def testExpectWitoutVerification(self):
rex = Dog()
expect(rex).bark('Miau').thenReturn('Wuff')
verifyNoMoreInteractions(rex)
rex.bark('Miau')
with pytest.raises(VerificationError):
verifyNoMoreInteractions(rex)
def testVerifies(self): mockOne, mockTwo = mock(), mock() mockOne.foo() mockTwo.bar() verify(mockOne).foo() verify(mockTwo).bar() verifyNoMoreInteractions(mockOne, mockTwo)
def testVerifies(self):
mockOne, mockTwo = mock(), mock()
mockOne.foo()
mockTwo.bar()
verify(mockOne).foo()
verify(mockTwo).bar()
verifyNoMoreInteractions(mockOne, mockTwo)
def test_register_should_call_listener_for_existent_reference_when_there_is_one_selector(
self):
reference = 'REFERENCE'
selection = [reference]
self.manager.register(self.listener_callable_mock, selection)
verify(self.listener_mock, times=1).__call__(reference)
verifyNoMoreInteractions(self.listener_mock)
def testExpectWitoutVerification(self):
rex = Dog()
expect(rex).bark('Miau').thenReturn('Wuff')
verifyNoMoreInteractions(rex)
rex.bark('Miau')
with pytest.raises(VerificationError):
verifyNoMoreInteractions(rex)
def test_register_synched_should_call_listener_for_each_existent_reference_when_there_is_one_selector(self):
reference1 = 'REFERENCE1'
reference2 = 'REFERENCE2'
selection = [[reference1, reference2]]
self.manager.register_synched(self.listener_callable_mock, selection)
verify(self.listener_mock, times=1).__call__(reference1)
verify(self.listener_mock, times=1).__call__(reference2)
verifyNoMoreInteractions(self.listener_mock)
def test_register_synched_should_call_listener_for_each_existent_reference_when_there_is_one_selector(
self):
reference1 = 'REFERENCE1'
reference2 = 'REFERENCE2'
selection = [[reference1, reference2]]
self.manager.register_synched(self.listener_callable_mock, selection)
verify(self.listener_mock, times=1).__call__(reference1)
verify(self.listener_mock, times=1).__call__(reference2)
verifyNoMoreInteractions(self.listener_mock)
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail("send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
def test_waits_for_consensus_on_vote_before_leader_elected(self):
peer = mock()
when(peer).get(self.election.VOTE_KEY).thenReturn('a')
self.gossiper.live_peers = [peer]
when(peer).keys().thenReturn([self.election.VOTE_KEY])
when(self.gossiper).get(self.election.VOTE_KEY).thenReturn('b')
self.election.value_changed('peer-a', self.election.VOTE_KEY, 'a')
verify(self.gossiper).get(self.election.VOTE_KEY)
verify(peer).keys()
verify(peer).get(self.election.VOTE_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_waits_for_consensus_on_leader_before_proclaiming(self):
peer = mock()
when(peer).get(self.election.LEADER_KEY).thenReturn('a')
when(peer).keys().thenReturn([self.election.LEADER_KEY])
self.gossiper.live_peers = [peer]
when(self.gossiper).get(self.election.LEADER_KEY).thenReturn('b')
self.election.value_changed('peer', self.election.LEADER_KEY, 'a')
verify(self.gossiper).get(self.election.LEADER_KEY)
verify(peer).keys()
verify(peer).get(self.election.LEADER_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_waits_for_consensus_on_leader_before_proclaiming(self):
peer = mock()
when(peer).get(self.election.LEADER_KEY).thenReturn('a')
when(peer).keys().thenReturn([self.election.LEADER_KEY])
self.gossiper.live_peers = [peer]
when(self.gossiper).get(self.election.LEADER_KEY).thenReturn('b')
self.election.value_changed('peer', self.election.LEADER_KEY, 'a')
verify(self.gossiper).get(self.election.LEADER_KEY)
verify(peer).keys()
verify(peer).get(self.election.LEADER_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_assign_resources_leaves_current_assignment_state(self):
when(self.keystore).keys('assign:*').thenReturn(['assign:A'])
when(self.keystore).get('assign:A').thenReturn('a')
when(self.keystore).keys('resource:*').thenReturn(['resource:A'])
when(self.keystore).get('resource:A').thenReturn(
(0, 'please-assign', 'address'))
self.computer.assign_resources(['a'])
verify(self.keystore).keys('assign:*')
verify(self.keystore).get('assign:A')
verify(self.keystore).keys('resource:*')
verify(self.keystore).get('resource:A')
verifyNoMoreInteractions(self.keystore)
def test_get_should_use_callableFactory_to_populte_resultant_dictiornary(
self):
self.tag_mappings.update({'A': set(['a1', 'a2', 'a3'])})
when(self.callable_factory).__call__('a1').thenReturn('a1')
when(self.callable_factory).__call__('a2').thenReturn('a2')
when(self.callable_factory).__call__('a3').thenReturn('a3')
self.tagSelection.union('A').get()
verify(self.callable_factory, times=1).__call__('a1')
verify(self.callable_factory, times=1).__call__('a2')
verify(self.callable_factory, times=1).__call__('a3')
verifyNoMoreInteractions(self.callable_factory)
def test_leader_elected_when_consensus_reached_on_votes(self):
peer = mock()
when(peer).get(self.election.VOTE_KEY).thenReturn('a')
when(peer).keys().thenReturn([self.election.VOTE_KEY])
self.gossiper.live_peers = [peer]
when(self.gossiper).get(self.election.VOTE_KEY).thenReturn('a')
self.election.value_changed('peer-a', self.election.VOTE_KEY, 'a')
verify(self.gossiper).get(self.election.VOTE_KEY)
verify(self.gossiper).set(self.election.LEADER_KEY, 'a')
verify(peer).keys()
verify(peer).get(self.election.VOTE_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail(
"send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
def test_leader_elected_when_consensus_reached_on_votes(self):
peer = mock()
when(peer).get(self.election.VOTE_KEY).thenReturn('a')
when(peer).keys().thenReturn([self.election.VOTE_KEY])
self.gossiper.live_peers = [peer]
when(self.gossiper).get(self.election.VOTE_KEY).thenReturn('a')
self.election.value_changed('peer-a', self.election.VOTE_KEY, 'a')
verify(self.gossiper).get(self.election.VOTE_KEY)
verify(self.gossiper).set(self.election.LEADER_KEY, 'a')
verify(peer).keys()
verify(peer).get(self.election.VOTE_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_waits_for_consensus_on_vote_before_leader_elected(self):
peer = mock()
when(peer).get(self.election.VOTE_KEY).thenReturn('a')
self.gossiper.live_peers = [peer]
when(peer).keys().thenReturn([self.election.VOTE_KEY])
when(self.gossiper).get(self.election.VOTE_KEY).thenReturn('b')
self.election.value_changed('peer-a', self.election.VOTE_KEY,
'a')
verify(self.gossiper).get(self.election.VOTE_KEY)
verify(peer).keys()
verify(peer).get(self.election.VOTE_KEY)
verifyNoMoreInteractions(self.gossiper)
verifyNoMoreInteractions(peer)
def test_set_selenium_timeout_only_affects_open_browsers(self):
bm = _BrowserManagementKeywords()
first_browser, second_browser = mock(), mock()
bm._cache.register(first_browser)
bm._cache.close()
verify(first_browser).quit()
bm._cache.register(second_browser)
bm.set_selenium_timeout("10 seconds")
verify(second_browser).set_script_timeout(10.0)
bm._cache.close_all()
verify(second_browser).quit()
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
def test_register_should_call_listener_for_late_reference_when_there_is_one_selector(self):
reference = 'REFERENCE'
selection = mock()
when(selection).__iter__().thenReturn([].__iter__()).thenReturn([reference].__iter__())
when(selection).is_elegible(reference).thenReturn(True)
self.manager.register(self.listener_callable_mock, utils.IterableMock(selection))
verify(self.listener_mock, times=0).__call__(anyx())
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference)
verify(self.listener_mock, times=1).__call__(reference)
verifyNoMoreInteractions(self.listener_mock)
def test_set_selenium_timeout_only_affects_open_browsers(self):
bm = BrowserManagementKeywords()
first_browser, second_browser = mock(), mock()
bm._cache.register(first_browser)
bm._cache.close()
verify(first_browser).quit()
bm._cache.register(second_browser)
bm.set_selenium_timeout("10 seconds")
verify(second_browser).set_script_timeout(10.0)
bm._cache.close_all()
verify(second_browser).quit()
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
def test_get_should_use_callableFactory_to_populte_resultant_dictiornary(self):
self.tag_mappings.update({
'A': set(['a1', 'a2', 'a3'])
})
when(self.callable_factory).__call__('a1').thenReturn('a1')
when(self.callable_factory).__call__('a2').thenReturn('a2')
when(self.callable_factory).__call__('a3').thenReturn('a3')
self.tagSelection.union('A').get()
verify(self.callable_factory, times=1).__call__('a1')
verify(self.callable_factory, times=1).__call__('a2')
verify(self.callable_factory, times=1).__call__('a3')
verifyNoMoreInteractions(self.callable_factory)
def test_register_should_call_listener_for_each_existent_combination_of_references_when_there_are_multiple_selectors(self):
reference1a = 'REFERENCE1a'
reference2a = 'REFERENCE2a'
selection_a = [reference1a, reference2a]
reference1b = 'REFERENCE1b'
reference2b = 'REFERENCE2b'
selection_b = [reference1b, reference2b]
self.manager.register(self.listener_callable_mock, selection_a, selection_b)
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verify(self.listener_mock, times=1).__call__(reference1a, reference2b)
verify(self.listener_mock, times=1).__call__(reference2a, reference1b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verifyNoMoreInteractions(self.listener_mock)
def test_set_selenium_timeout_only_affects_open_browsers():
ctx = mock()
ctx.timeout = 5.0
_drivers = mock()
ctx._drivers = _drivers
first_browser, second_browser = mock(), mock()
ctx._drivers.active_drivers = [first_browser, second_browser]
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
ctx._drivers.active_drivers = []
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_drivers = mock()
ctx._drivers = _drivers
first_browser, second_browser = mock(), mock()
ctx._drivers.active_drivers = [first_browser, second_browser]
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
ctx._drivers.active_drivers = []
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
def test_secure_with_mycnf_error(self):
mock_conn = mock_sql_connection()
when(mock_conn).execute(any()).thenReturn(None)
when(utils).execute_with_timeout("sudo", any(str), "stop").thenReturn(None)
# skip writing the file for now
when(os.path).isfile(any()).thenReturn(False)
mock_status = mock()
when(mock_status).wait_for_real_status_to_change_to(any(), any(), any()).thenReturn(True)
app = MySqlApp(mock_status)
self.assertRaises(TypeError, app.secure, None)
verify(mock_conn, atleast=2).execute(any())
inorder.verify(mock_status).wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN, any(), any()
)
verifyNoMoreInteractions(mock_status)
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_browsers = mock()
ctx._browsers = _browsers
first_browser, second_browser = mock(), mock()
when(_browsers).get_open_browsers().thenReturn(
[first_browser, second_browser])
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
when(_browsers).get_open_browsers().thenReturn([])
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
def test_register_should_call_listener_for_each_existent_combination_of_references_when_there_are_multiple_selectors(
self):
reference1a = 'REFERENCE1a'
reference2a = 'REFERENCE2a'
selection_a = [reference1a, reference2a]
reference1b = 'REFERENCE1b'
reference2b = 'REFERENCE2b'
selection_b = [reference1b, reference2b]
self.manager.register(self.listener_callable_mock, selection_a,
selection_b)
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verify(self.listener_mock, times=1).__call__(reference1a, reference2b)
verify(self.listener_mock, times=1).__call__(reference2a, reference1b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verifyNoMoreInteractions(self.listener_mock)
def test_register_should_call_listener_for_late_reference_when_there_is_one_selector(
self):
reference = 'REFERENCE'
selection = mock()
when(selection).__iter__().thenReturn([].__iter__()).thenReturn(
[reference].__iter__())
when(selection).is_elegible(reference).thenReturn(True)
self.manager.register(self.listener_callable_mock,
utils.IterableMock(selection))
verify(self.listener_mock, times=0).__call__(anyx())
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference)
verify(self.listener_mock, times=1).__call__(reference)
verifyNoMoreInteractions(self.listener_mock)
def test_secure_with_mycnf_error(self):
mock_conn = mock_sql_connection()
when(mock_conn).execute(any()).thenReturn(None)
when(utils).execute_with_timeout("sudo", any(str), "stop").thenReturn(
None)
# skip writing the file for now
when(os.path).isfile(any()).thenReturn(False)
mock_status = mock()
when(mock_status).wait_for_real_status_to_change_to(
any(), any(), any()).thenReturn(True)
app = MySqlApp(mock_status)
self.assertRaises(TypeError, app.secure, None)
verify(mock_conn, atleast=2).execute(any())
inorder.verify(mock_status).wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN, any(), any())
verifyNoMoreInteractions(mock_status)
def test_should_compute_body_similarity(self):
text_processor = mock()
similarity_measure_factory = mock()
when(similarity_measure_factory).cosine().thenReturn(
CosineSimilarity())
when(text_processor).tokenize(
"this is my second blog, which is much better").thenReturn(
["second", "blog"])
when(text_processor).tokenize(
"We are surrounded by objects in the real world. These can be cars, houses, etc. This is my better second blog") \
.thenReturn(["surrounded", "objects", "real", "world", "cars", "houses", "second", "blog"])
authored_document = AuthoredDocument(
"1", {
"title": "this is a title",
"body": "this is my second blog, which is much better",
"tags": []
},
text_processor=text_processor,
similarity_measure_factory=similarity_measure_factory)
other_authored_document = AuthoredDocument("2", {
"title": "this is a another title blog",
"body":
"We are surrounded by objects in the real world. These can be cars, houses, etc. This is my better second blog",
"tags": []
},
text_processor=
text_processor,
similarity_measure_factory=
similarity_measure_factory)
score = authored_document.body_similarity_score(
other_authored_document)
verify(similarity_measure_factory).cosine()
verify(text_processor).tokenize(
"this is my second blog, which is much better")
verify(text_processor).tokenize(
"We are surrounded by objects in the real world. These can be cars, houses, etc. This is my better second blog"
)
verifyNoMoreInteractions(text_processor)
verifyNoMoreInteractions(similarity_measure_factory)
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_browsers = mock()
ctx._browsers = _browsers
first_browser, second_browser = mock(), mock()
when(_browsers).get_open_browsers().thenReturn(
[first_browser, second_browser]
)
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
when(_browsers).get_open_browsers().thenReturn(
[]
)
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
def test_register_should_call_listener_for_each_late_reference_when_there_is_one_selector(
self):
reference1 = 'REFERENCE1'
reference2 = 'REFERENCE2'
reference3 = 'REFERENCE3'
selection = mock()
(when(selection).__iter__().thenReturn(
[reference1].__iter__()).thenReturn([
reference1, reference2
].__iter__()).thenReturn([reference1, reference2,
reference3].__iter__()))
when(selection).is_elegible(reference2).thenReturn(True)
when(selection).is_elegible(reference3).thenReturn(True)
self.manager.register(self.listener_callable_mock,
utils.IterableMock(selection))
verify(self.listener_mock, times=1).__call__(reference1)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2)
verify(self.listener_mock, times=1).__call__(reference2)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference3)
verify(self.listener_mock, times=1).__call__(reference3)
verifyNoMoreInteractions(self.listener_mock)
def test_register_should_call_listener_for_each_late_combination_of_references_when_there_are_multiple_selectors(self):
reference1a = 'REFERENCE1a'
reference2a = 'REFERENCE2a'
reference1b = 'REFERENCE1b'
reference2b = 'REFERENCE2b'
selection_a = mock()
(when(selection_a).__iter__()
.thenReturn([reference1a].__iter__())
.thenReturn([reference1a, reference2a].__iter__())
.thenReturn([reference1a, reference2a].__iter__()))
when(selection_a).is_elegible(reference2a).thenReturn(True)
selection_b = mock()
(when(selection_b).__iter__()
.thenReturn([reference1b].__iter__())
.thenReturn([reference1b].__iter__())
.thenReturn([reference1b, reference2b].__iter__()))
when(selection_b).is_elegible(reference2b).thenReturn(True)
self.manager.register(self.listener_callable_mock, utils.IterableMock(selection_a), utils.IterableMock(selection_b))
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2a)
verify(self.listener_mock, times=1).__call__(reference2a, reference1b)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2b)
verify(self.listener_mock, times=1).__call__(reference1a, reference2b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verifyNoMoreInteractions(self.listener_mock)
def test_register_should_call_listener_for_each_late_combination_of_references_when_there_are_multiple_selectors(
self):
reference1a = 'REFERENCE1a'
reference2a = 'REFERENCE2a'
reference1b = 'REFERENCE1b'
reference2b = 'REFERENCE2b'
selection_a = mock()
(when(selection_a).__iter__().thenReturn(
[reference1a].__iter__()).thenReturn([
reference1a, reference2a
].__iter__()).thenReturn([reference1a, reference2a].__iter__()))
when(selection_a).is_elegible(reference2a).thenReturn(True)
selection_b = mock()
(when(selection_b).__iter__().thenReturn([
reference1b
].__iter__()).thenReturn([reference1b].__iter__()).thenReturn(
[reference1b, reference2b].__iter__()))
when(selection_b).is_elegible(reference2b).thenReturn(True)
self.manager.register(self.listener_callable_mock,
utils.IterableMock(selection_a),
utils.IterableMock(selection_b))
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2a)
verify(self.listener_mock, times=1).__call__(reference2a, reference1b)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2b)
verify(self.listener_mock, times=1).__call__(reference1a, reference2b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verifyNoMoreInteractions(self.listener_mock)
def test_register_synched_should_call_listener_for_each_existent_combination_of_references_when_there_are_multiple_selectors(self):
reference1a = 'X1'
reference2a = 'X2'
reference3a = 'X3'
selection_a = [reference1a, reference2a, reference3a]
reference1b = 'R1'
reference2b = 'R2'
reference3b = 'R3'
selection_b = mock()
(when(selection_b).__iter__()
.thenReturn([reference1b, reference2b, reference3b].__iter__()))
when(selection_b).intersection('{%s}' % reference1a).thenReturn([reference1b])
when(selection_b).intersection('{%s}' % reference2a).thenReturn([reference2b])
when(selection_b).intersection('{%s}' % reference3a).thenReturn([reference3b])
self.manager.register_synched(self.listener_callable_mock,
[selection_a, utils.IterableMock(selection_b)])
verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
verify(self.listener_mock, times=1).__call__(reference3a, reference3b)
verifyNoMoreInteractions(self.listener_mock)
def test_register_should_call_listener_for_each_late_reference_when_there_is_one_selector(self):
reference1 = 'REFERENCE1'
reference2 = 'REFERENCE2'
reference3 = 'REFERENCE3'
selection = mock()
(when(selection).__iter__().thenReturn([reference1].__iter__())
.thenReturn([reference1, reference2].__iter__())
.thenReturn([reference1, reference2, reference3].__iter__()))
when(selection).is_elegible(reference2).thenReturn(True)
when(selection).is_elegible(reference3).thenReturn(True)
self.manager.register(self.listener_callable_mock, utils.IterableMock(selection))
verify(self.listener_mock, times=1).__call__(reference1)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference2)
verify(self.listener_mock, times=1).__call__(reference2)
verifyNoMoreInteractions(self.listener_mock)
self.manager.evaluate_new_candidate(reference3)
verify(self.listener_mock, times=1).__call__(reference3)
verifyNoMoreInteractions(self.listener_mock)
def test_do_stuff(self):
''' test do stuff '''
when(self.hello_world).helloworld(7, 8).thenReturn(1000)
self.assertEqual(self.foobar.do_stuff(), "hello")
verify(self.hello_world).helloworld(7, 8)
verifyNoMoreInteractions(self.hello_world)
def testEnsureWhenGetsNotConfused(self):
m = mock()
when(m).foo(1).thenReturn()
m.foo(1)
with pytest.raises(VerificationError):
verifyNoMoreInteractions(m)
def testVerifyNoMoreInteractionsBarksIfUnsatisfied(self, verification):
rex = Dog()
expect(rex, **verification).bark('Miau').thenReturn('Wuff')
with pytest.raises(VerificationError):
verifyNoMoreInteractions(rex)
def test_register_should_not_call_listener_when_there_is_no_existent_reference(self):
selection = []
self.manager.register(self.listener_callable_mock, selection)
verifyNoMoreInteractions(self.listener_mock)
def assert_not_removed_from_drafts(_):
verifyNoMoreInteractions(self.drafts)
def test_do_stuff_2_or_whatever(self):
''' test do stuff '''
when(self.hello_world).helloworld(7, 8).thenReturn(50)
self.assertEqual(self.foobar.do_stuff(), "goodbye")
verify(self.hello_world).helloworld(7, 8)
verifyNoMoreInteractions(self.hello_world)
def testEnsureWhenGetsNotConfused(self):
m = mock()
when(m).foo(1).thenReturn()
m.foo(1)
with pytest.raises(VerificationError):
verifyNoMoreInteractions(m)
def testIfVerifiedVerifyNoMoreInteractionsPasses(self):
when(Dog).bark('Miau')
rex = Dog()
rex.bark('Miau')
verify(Dog).bark('Miau')
verifyNoMoreInteractions(Dog)
def testPrintsUnwantedInteraction(self):
theMock = mock()
theMock.foo(1, 'foo')
with pytest.raises(VerificationError) as exc:
verifyNoMoreInteractions(theMock)
assert "\nUnwanted interaction: foo(1, 'foo')" == str(exc.value)
def verify_no_exceptions_logged(self):
m.verifyNoMoreInteractions(self.logger)
def assert_not_removed_from_drafts(_):
verifyNoMoreInteractions(self.drafts)
def verify_no_exceptions_logged(self):
m.verifyNoMoreInteractions(self.logger)
def testNothingVerifiedVerifyNoMoreInteractionsRaises(self):
when(Dog).bark('Miau')
rex = Dog()
rex.bark('Miau')
with pytest.raises(VerificationError):
verifyNoMoreInteractions(Dog)
def testVerifyNoMoreInteractionsBarksIfUnsatisfied(self, verification):
rex = Dog()
expect(rex, **verification).bark('Miau').thenReturn('Wuff')
with pytest.raises(VerificationError):
verifyNoMoreInteractions(rex)
