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_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_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_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_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_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_noDeletionsWhenNoItems(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
when(trackerInstance).GetStories(any()).thenReturn([])
tracker.deleteAllItems()
verify(trackerInstance, never).DeleteStory(any())
pass
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_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_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_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_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_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_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_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 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_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_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 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())
