def test_cleanup_quits_webdrivers(self): "Tests that clean up is performed on webdrivers created by WebdriverManger" config_reader = mock(ConfigReader) when(config_reader).get( WebDriverManager.SHUTDOWN_HOOK_CONFIG, True).thenReturn(True) when(config_reader).get( WebDriverManager.REUSE_BROWSER, True).thenReturn(False) when(config_reader).get( WebDriverManager.REUSE_BROWSER, True).thenReturn(False) when(config_reader).get( WebDriverManager.ENABLE_THREADING_SUPPORT, False).thenReturn(True) webdriver_mock1 = mock(WebDriver) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver( testname=None).thenReturn(webdriver_mock1) webdriver_provider = WebDriverManager(webdriver_factory=webdriverfactory_mock, config=config_reader) # Spawn thread to check if driver is unique per thread. driver = webdriver_provider.get_driver() del webdriver_provider # verify decontructor cleans up the webdriver. verify(driver).quit()
def test_CanRetrieveOrganizationListFiltered(): pertinoSdk, _, response = setupSdk() json = {"orgs": [{"name": "organization", "id": 1234}]} when(response).json().thenReturn(json) closure = mock() pertinoSdk.listOrgs(closure=closure.function) verify(closure).function(json["orgs"][0])
def test_should_return_empty_running_environment_if_nothing_is_running(self): mock_command_helper = mock() when(mock_command_helper).run_command("sudo lxc-ls -c1").thenReturn("") provider = LXCNodeProvider(None, None, mock_command_helper) environment = provider.get_running_environment("test", "test", all_credentials) self.assertIsNotNone(environment) self.assertEqual(0, len(environment.get_locations()))
def test_onlyTakeCommentsFromIssueForByFilter(self): toTracker = mock() aTestItemFilter = mock() syncCommentsFor = TrackerSyncBy.syncingItem(aTestItemFilter.calledWith) when(toTracker).items(None).thenRaise(StopIteration) syncCommentsFor(None, toTracker) verify(aTestItemFilter).calledWith(None)
def test_doNotAddCommentsWhenItemNotFound(self): toTracker = mock() item = mock() syncCommentsFor = TrackerSyncBy.syncingItem() when(toTracker).items(None).thenRaise(StopIteration) syncCommentsFor(item, toTracker) verify(toTracker, never).update(item)
def test_multithreadMode(self): """ Tests that when we call get_driver() it returns a unique driver for each thread, but for the same thread returns the same driver. """ config_reader = mock(ConfigReader) when(config_reader).get(WebDriverManager.SHUTDOWN_HOOK_CONFIG, any()).thenReturn(True) when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False) when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False) when(config_reader).get(WebDriverManager.ENABLE_THREADING_SUPPORT, any()).thenReturn(True) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver(testname=None).thenReturn(mock(WebDriver))\ .thenReturn(mock(WebDriver)).thenReturn(mock(WebDriver)) webdriver_provider = WebDriverManager(webdriver_factory=webdriverfactory_mock, config = config_reader) # Spawn thread to check if driver is unique per thread. driver1 = webdriver_provider.get_driver() t = threading.Thread(target=lambda: self.__multithreaded_7est_thread2(driver1, webdriver_provider)) t.start() t.join() self.assertFalse(self._driver_from_thread_is_same) # Check that driver is same for the same thread. driver3 = webdriver_provider.get_driver() self.assertEqual(driver1, driver3, "Same thread should return same driver.")
def test_user_can_login_with_password(self): cli = mock() user = User("username", "password", cli) when(cli).compareReceivedAgainst(any(),any(), indexOfSuccessfulResult=any()).thenReturn(0).thenReturn(1) user.login() verify(cli).send("su username") verify(cli).send("password")
def test_noDeletionsWhenNoItems(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ when(trackerInstance).GetStories(any()).thenReturn([]) tracker.deleteAllItems() verify(trackerInstance, never).DeleteStory(any()) pass
def test_CanRetrieveDevicesListFiltered(): pertinoSdk, _, response = setupSdk() json = {"devices": [{"ipv4Address": "123.456.789.10", "hostName": "host", "id": 1234}]} when(response).json().thenReturn(json) closure = mock() pertinoSdk.listDevicesIn({"id":1}, closure.function) verify(closure).function(json["devices"][0])
def test_doNotAddItemWhenNoItemToAdd(self): toTracker = mock() fromTracker = mock() when(fromTracker).items(any()).thenReturn([]) syncByAddingItems = TrackerSyncBy.addingItemsOfType(None) syncByAddingItems(fromTracker, toTracker) verify(toTracker, never).update()
def test_retryWhenTryingToGetStoriesAndException(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ when(trackerInstance).GetStories(any()).thenRaise(Exception("")).thenReturn([Story(),Story()]) when(trackerInstance).GetComments(any()).thenReturn([]) next(tracker.items()) verify(trackerInstance, times=2).GetStories(any())
def test_mode_exited(self): cli = self.makeCli() when(cli).compareReceivedAgainst(any(),any()).thenReturn(0) testMode = Mode(cli) testMode.exit() verify(cli).exitMode(testMode) verify(cli).send("exit")
def setupSync(self, syncDirection=ForwardSync): toTracker = mock() itemToSyncTo = mock() itemToSyncFrom = mock() syncCommentsFor = TrackerSyncBy.syncingItem(Direction=syncDirection) when(toTracker).items(None).thenReturn(Testing.MockIterator([itemToSyncTo])) return toTracker, itemToSyncTo, itemToSyncFrom, syncCommentsFor
def test_should_throw_exception_when_node_is_not_up_and_running(self): mock_connection_provider = mock() tags = { 'services' : """ 'apache' : 80: 80""", 'credentials_name': 'test', 'env_name' : 'test', 'env_def_name' : 'Single-AZ Deployment', } fake_boto_instance1 = mock() fake_boto_instance1.tags = tags stub_region = mock() stub_region.name = 'eu-west' fake_boto_instance1.region = stub_region fake_boto_instance1.id = 'id1234' fake_boto_instance1.ip_address = 'test_ip' fake_boto_instance1.state = 'running' fake_boto_instance1.placement='us-east-1' aws_node = AWSRunningNode(fake_boto_instance1, None, mock_connection_provider) when(mock_connection_provider).connected_to_node('test_ip', 22).thenReturn(False) with self.assertRaisesRegexp(Exception, "Node id1234 is not running"): aws_node.wait_for_ready(lambda : None, 5)
def test_should_return_empty_running_environment_if_nothing_is_running(self): fake_boto_instance = mock() tags = { 'services' : """ apache : 80: 80""", 'credentials_name': 'test', 'env_name' : 'my_environment', 'env_def_name' : 'Single-AZ Deployment', } fake_boto_instance.tags = tags stub_region = mock() stub_region.name = 'eu-west' fake_boto_instance.region = stub_region fake_boto_instance.image_id = '1234' fake_boto_instance.instance_type = 'large' mock_connection_provider = mock() when(mock_connection_provider).ec2_connection_for_region("eu-west", None, None).thenReturn(None) when(mock_connection_provider).get_all_boto_instances(None, None).thenReturn([fake_boto_instance]) provider = AWSNodeProvider(None, None, mock_connection_provider) environment = provider.get_running_environment("test","test", all_credentials) self.assertIsNotNone(environment) self.assertEqual(0, len(environment.get_locations()))
def test_multithreadMode(self): """ Tests that when we call get_driver() it returns a unique driver for each thread, but for the same thread returns the same driver. """ config_reader = mock(ConfigReader) when(config_reader).get(WebDriverManager.SHUTDOWN_HOOK_CONFIG, any()).thenReturn(True) when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False) when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False) when(config_reader).get(WebDriverManager.ENABLE_THREADING_SUPPORT, any()).thenReturn(True) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver(testname=None).thenReturn(mock(WebDriver))\ .thenReturn(mock(WebDriver)).thenReturn(mock(WebDriver)) webdriver_provider = WebDriverManager( webdriver_factory=webdriverfactory_mock, config=config_reader) # Spawn thread to check if driver is unique per thread. driver1 = webdriver_provider.get_driver() t = threading.Thread(target=lambda: self.__multithreaded_7est_thread2( driver1, webdriver_provider)) t.start() t.join() self.assertFalse(self._driver_from_thread_is_same) # Check that driver is same for the same thread. driver3 = webdriver_provider.get_driver() self.assertEqual(driver1, driver3, "Same thread should return same driver.")
def test_cleanup_quits_webdrivers(self): "Tests that clean up is performed on webdrivers created by WebdriverManger" config_reader = mock(ConfigReader) when(config_reader).get(WebDriverManager.SHUTDOWN_HOOK_CONFIG, True).thenReturn(True) when(config_reader).get(WebDriverManager.REUSE_BROWSER, True).thenReturn(False) when(config_reader).get(WebDriverManager.REUSE_BROWSER, True).thenReturn(False) when(config_reader).get(WebDriverManager.ENABLE_THREADING_SUPPORT, False).thenReturn(True) webdriver_mock1 = mock(WebDriver) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver( testname=None).thenReturn(webdriver_mock1) webdriver_provider = WebDriverManager( webdriver_factory=webdriverfactory_mock, config=config_reader) # Spawn thread to check if driver is unique per thread. driver = webdriver_provider.get_driver() del webdriver_provider # verify decontructor cleans up the webdriver. verify(driver).quit()
def test_whenJiraIdIsZeroNameIsNone(self): jiraStatus = mock() mapObject = mock() when(jiraStatus).status().thenReturn("") status = TrackerItemStatus(jiraStatus, mapObject) verify(mapObject, never).translateStatusTo(any(), any()) self.assertEqual(status.jira(), None)
def test_getJobs_ForProgram_ByJobType(self): # Setup when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs()) jobs = self.db.getJobs() if len(jobs) == 0: log.warn('No jobs in database to test with. Test skipped...') return job = jobs[-1] # last job data = [''] * self.protocol.recordSize() data[4] = job.channelId data[11] = time.mktime(job.startTime.timetuple()) program = RecordedProgram(data=data, settings=Mock(), translator=Mock(), platform=Mock(), protocol=self.protocol, conn=Mock()) # Test jobs = self.db.getJobs(program=program, jobType=job.jobType) # Verify self.assertTrue(len(jobs) > 0) for index, actual in enumerate(jobs): log.debug('job %d = %s' % (index, actual)) self.assertEquals(job.channelId, actual.channelId) self.assertEquals(job.startTime, actual.startTime) self.assertEquals(job.jobType, actual.jobType)
def test_whenNoActionAvaiableDoNotSetStatus(self): jira = JiraTracker() jiraInstance = self.getMockFor(jira) trackerItem = mock() tracerBullet = "hello" when(trackerItem).underlying().thenReturn(tracerBullet) bullet = jira._ticketWithUpdatedStatusFrom(trackerItem) self.assertEqual(tracerBullet, bullet)
def test_canUpdateStatus(self): statusId = "Match" action = TestAction(5,statusId) jira, jiraInstance, itemId, trackerItem, status = self.setupStatus() when(status).jira().thenReturn(statusId) when(jiraInstance.service).getAvailableActions(any(), any()).thenReturn([action,]) jira._ticketWithUpdatedStatusFrom(trackerItem) verify(jiraInstance.service).progressWorkflowAction(self.auth_, itemId, action.id, any())
def test_dontDeleteNotAddedItem(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ pivotalTrackerItem = mock() when(pivotalTrackerItem).Id().thenReturn(None) tracker.delete(pivotalTrackerItem) verify(trackerInstance, never).DeleteStory(any()) pass
def test_filterIsSentWhenSpecified(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ forFilter = "blah" when(trackerInstance).GetStories(any()).thenReturn([]) when(trackerInstance).GetComments(any()).thenReturn([]) self.assertRaises(StopIteration, next, tracker.items(forFilter)) verify(trackerInstance).GetStories(forFilter)
def test_retryWhenTryingToGetStoriesAndException(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ when(trackerInstance).GetStories(any()).thenRaise( Exception("")).thenReturn([Story(), Story()]) when(trackerInstance).GetComments(any()).thenReturn([]) next(tracker.items()) verify(trackerInstance, times=2).GetStories(any())
def test_CanRetrieveOrganizationListUnfiltered(): pertinoSdk, requests, response = setupSdk() json = {"orgs": [{"name": "organization", "id": 1234}]} when(response).json().thenReturn(json) assert pertinoSdk.listOrgs() == json["orgs"] verify(requests).get( 'http://api.labs.pertino.com:5000/api/v0-alpha/orgs?user_key=993e79924d5b6346fe62a5cf62183bc5', auth=('a', 'b'))
def test_whenSeedingWithUserForPivotal(self): pivotalUser = "******" jiraUser = "******" mapObject = mock() when(mapObject).translateUserTo('jira', pivotalUser).thenReturn(jiraUser) userObject = PivotalUser(pivotalUser, apiObject=mapObject) self.assertEqual(pivotalUser, userObject.pivotal()) self.assertEqual(jiraUser, userObject.jira())
def setupSync(self, syncDirection=ForwardSync): toTracker = mock() itemToSyncTo = mock() itemToSyncFrom = mock() syncCommentsFor = TrackerSyncBy.syncingItem(Direction=syncDirection) when(toTracker).items(None).thenReturn( Testing.MockIterator([itemToSyncTo])) return toTracker, itemToSyncTo, itemToSyncFrom, syncCommentsFor
def test_canntGetBugsForProject(self): jira = JiraTracker() jiraInstance = self.getMockFor(jira) jira.selectProject(["",""]) fault = Holder() fault.faultstring = "" when(jiraInstance.service).getIssuesFromJqlSearch(any(), any(), any()).thenRaise(WebFault(fault, None)) self.assertRaises(StopIteration, next, jira._getItems())
def test_load_a_program_pcb_creation_with_a_real_mmu(self): when(self.disco).getProgram("programa").thenReturn(self.program) when(self.disco).getProgram("programa").thenReturn(self.program) self.progLoader2.loadProcess("programa") self.assertEquals(self.progLoader.getNextId(), 1) self.assertEquals(self.ram.getDir(0), self.instruccion1)
def test_filterAndOmitPivotalTrackerCreateCommentsRemovesComments(self): item = mock() comments = [ "A Pivotal Tracker story", ] when(item).comments("new").thenReturn(comments) andOmitPivotalTrackerCreatedComments(item) self.assertListEqual(comments, [])
def test_whenStatusCanBeMatchedToActionThenReturnActionId(self): status = mock() potentialAction = mock() actions = [potentialAction, ] when(status).jira().thenReturn([str(potentialAction.name)]) action = JiraStatusToAction(status, actions) self.assertEqual(str(potentialAction.id), str(action.Id())) pass
def test_whenDoingPivotalOperationAuthenticationIsIncluded(self): tracker = self.makeTestTracker() pivotalApiObject = self.apiObject_ password = "******" authentication = mock() when(pivotalApiObject).HostedTrackerAuth(any(),any()).thenReturn(authentication) tracker.withCredential(password) verify(pivotalApiObject).Tracker(any(), authentication)
def test_response(self): random = mock() when(random).called().thenReturn(1).thenReturn(2).thenReturn( 4).thenReturn(5) game = MasterMind(random=[1, 2, 4, 5]) self.assertEqual((1, 0), game.guess([1, 6, 7, 8])) self.assertEqual((2, 0), game.guess([1, 6, 7, 5])) self.assertEqual((1, 1), game.guess([1, 5, 6, 7])) self.assertEqual((0, 4), game.guess([5, 4, 1, 2]))
def test_is_driver_available_withEmptyChannel_returnsFalse(self): "Test that false is returned if webdriver was not created." config_reader = mock(ConfigReader) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver(testname=None).thenReturn(None) webdriver_provider = WebDriverManager(webdriver_factory=webdriverfactory_mock, config = config_reader) self.assertFalse(webdriver_provider.is_driver_available())
def test_canOverwriteKnownReporter(self): item = JiraTrackerItem() withReporter = "reporter" load = self.create_loader(JiraTrackerItem.withRequestor) load(item, withReporter) random = mock() when(random).jira().thenReturn("blah") item.withRequestor(random) self.assertEqual(random, item.requestor())
def test_trackerCanDeleteItem(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ pivotalTrackerItem = mock() storyId = 1234 when(pivotalTrackerItem).Id().thenReturn(storyId) tracker.delete(pivotalTrackerItem) verify(trackerInstance).DeleteStory(storyId) pass
def jiraTimezoneSetupForTimeStamp(self, timeStamp, daylightTimeHappening): time = mock() when(time).timezone().thenReturn(25200) when(time).daylight().thenReturn(daylightTimeHappening) when(time).altzone().thenReturn(21600) when(time).mktime(any()).thenReturn(timeStamp) timeAsStructure = localtime(timeStamp) when(time).localtime(timeStamp).thenReturn(timeAsStructure) return time
def test_canChangeReporter(self): item = JiraTrackerItem() requestor = mock() reporter = "me" when(requestor).jira().thenReturn(reporter).thenReturn(reporter) item.withRequestor(requestor) self.assertEqual(requestor, item.requestor()) self.assertEqual(reporter, item.underlying().reporter()) self.assertEqual(item.piecesToUpdate(), [{'id':"reporter" , 'values':[reporter,]}])
def makeValidTracker(self): tracker = self.makeTestTracker() pivotalApiObject = self.apiObject_ trackerInstance = mock() when(pivotalApiObject).Tracker(any(),any()).thenReturn(trackerInstance) pivotalProjectNumber = 0 tracker.selectProject(pivotalProjectNumber) self.trackerInstance_ = trackerInstance return tracker
def test_should_capture_actions_on_returned_nodes_from_list(self): node = create_node() when(self.inner_provider).list('cred', node_predicates.all_nodes).thenReturn([node]) new_node = self.sut.list('cred')[0] new_node.run_command("do something") new_node.upload_file("file", "destination") new_node.add_service_to_tags("service_name", [DynamicDictionary({'ports' : [80]})]) self.assertEqual(3, len(self.sut.actions))
def test_canGetStoriesFromProject(self): tracker = self.makeValidTracker() trackerInstance = self.trackerInstance_ when(trackerInstance).GetStories(any()).thenReturn([Story(), Story()]) when(trackerInstance).GetComments(any()).thenReturn([]) itemIterator = tracker.items() next(itemIterator) next(itemIterator) self.assertRaises(StopIteration, next, itemIterator)
def setupStatus(self): jira = JiraTracker() jiraInstance = self.getMockFor(jira) itemId = 1234 trackerItem = mock() status = mock() when(trackerItem).Id().thenReturn(itemId) when(trackerItem).status().thenReturn(status) return jira, jiraInstance, itemId, trackerItem, status
def test_whenDoingPivotalOperationAuthenticationIsIncluded(self): tracker = self.makeTestTracker() pivotalApiObject = self.apiObject_ password = "******" authentication = mock() when(pivotalApiObject).HostedTrackerAuth( any(), any()).thenReturn(authentication) tracker.withCredential(password) verify(pivotalApiObject).Tracker(any(), authentication)
def test_handleWhenNoCommentsAreReturned(self): jira = JiraTracker() jiraInstance = self.getMockFor(jira) ticket = mock() key = "12345" when(ticket).Id().thenReturn(key) when(jiraInstance.service).getComments(any(),any()).thenReturn(None) jira.addCommentsTo(ticket) verify(jiraInstance.service,times=0).addComment(any(), any(), any())
def test_is_driver_available_withEmptyChannel_returnsFalse(self): "Test that false is returned if webdriver was not created." config_reader = mock(ConfigReader) webdriverfactory_mock = mock(WebDriverFactory) when(webdriverfactory_mock).create_webdriver( testname=None).thenReturn(None) webdriver_provider = WebDriverManager( webdriver_factory=webdriverfactory_mock, config=config_reader) self.assertFalse(webdriver_provider.is_driver_available())