def test_roger_push_env_from_ROGER_ENV_VAR(self):
settings = mock(Settings)
appConfig = mock(AppConfig)
roger_push = RogerPush()
marathon = mock(Marathon)
mockedHooks = mock(Hooks)
roger_env = self.roger_env
config = self.config
frameworkUtils = mock(FrameworkUtils)
when(settings).getConfigDir().thenReturn(self.configs_dir)
when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0)
when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env)
when(appConfig).getConfig(any(), any()).thenReturn(config)
args = self.args
args.env = None
args.secrets_file = ""
args.skip_push = True
args.app_name = 'grafana_test_app'
args.config_file = 'test.json'
roger_env = appConfig.getRogerEnv(self.configs_dir)
roger_env["default_environment"] = None
# Setting ROGER_ENV to specific value
os.environ["ROGER_ENV"] = "test_env"
with self.assertRaises(ValueError):
roger_push.main(settings, appConfig, frameworkUtils, mockedHooks,
args)
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_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_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 test_filterIsSentWhenSpecified(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
forFilter = "blah"
self.setMocksForGettingItems(jiraInstance)
self.assertRaises(StopIteration, next, jira._getItems(forFilter))
verify(jiraInstance.service).getIssuesFromJqlSearch(any(),forFilter,any())
def test_newDriver_ReturnsNewInstance(self):
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)
webdriver_mock1 = mock(WebDriver)
webdriver_mock2 = mock(WebDriver)
webdriverfactory_mock = mock(WebDriverFactory)
when(webdriverfactory_mock).create_webdriver(testname=None).thenReturn(
webdriver_mock1).thenReturn(webdriver_mock2)
webdriver_provider = WebDriverManager(
webdriver_factory=webdriverfactory_mock, config=config_reader)
driver1 = webdriver_provider.new_driver()
driver2 = webdriver_provider.new_driver()
self.assertFalse(
driver1 is driver2,
"new_driver() should create fresh instance if reusebrowser if false."
)
def test_get_children_default_watcher(self):
watcher = mock()
z = pookeeper.allocate(self.hosts, watcher=watcher)
z.create('/pookie', CREATOR_ALL_ACL, Persistent(), data=_random_data())
z.get_children('/pookie', watch=True)
z.create('/pookie/bear', CREATOR_ALL_ACL, Persistent(), data=_random_data())
z.get_children('/pookie', watch=True)
z.set_data('/pookie', _random_data())
z.set_data('/pookie/bear', _random_data())
# One is for when we do and the other is for when we don't chroot
z.get_children('/pookie', watch=True)
z.get_children('/pookie/bear', watch=True)
z.delete('/pookie/bear')
z.delete('/pookie')
z.close()
mockito.verify(watcher).session_connected(matchers.any(long), matchers.any(str), False)
mockito.verify(watcher, times=2).children_changed('/pookie')
mockito.verify(watcher).node_deleted('/pookie/bear')
mockito.verify(watcher).connection_closed()
verifyNoMoreInteractions(watcher)
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_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_noDeletionsWhenNoItems(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
when(trackerInstance).GetStories(any()).thenReturn([])
tracker.deleteAllItems()
verify(trackerInstance, never).DeleteStory(any())
pass
def test_roger_push_env_from_ROGER_ENV_VAR(self):
settings = mock(Settings)
appConfig = mock(AppConfig)
roger_push = RogerPush()
marathon = mock(Marathon)
mockedHooks = mock(Hooks)
roger_env = self.roger_env
config = self.config
frameworkUtils = mock(FrameworkUtils)
when(settings).getConfigDir().thenReturn(self.configs_dir)
when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0)
when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env)
when(appConfig).getConfig(any(), any()).thenReturn(config)
args = self.args
args.env = None
args.secrets_file = ""
args.skip_push = True
args.app_name = 'grafana_test_app'
args.config_file = 'test.json'
roger_env = appConfig.getRogerEnv(self.configs_dir)
roger_env["default_environment"] = None
# Setting ROGER_ENV to specific value
os.environ["ROGER_ENV"] = "test_env"
with self.assertRaises(ValueError):
roger_push.main(settings, appConfig,
frameworkUtils, mockedHooks, args)
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_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_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_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_authSentWhenGettingBugs(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
self.setMocksForGettingItems(jiraInstance)
itemIterator = jira._getItems()
self.assertRaises(StopIteration, next, itemIterator)
verify(jiraInstance.service).getIssuesFromJqlSearch(self.auth_, any(), 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_doNotAddCommentsGreaterThan20000Characters(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
testing = Testing()
item = self.itemWithComments(testing)
item.addComment(Testing.stringOfAsOfSize(20002))
tracker.updateCommentsFor(item)
verify(trackerInstance, times=2).AddComment(any(), any())
def test_run_hook_returns_zero_when_hook_succeeds(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(), any()).thenReturn(any())
assert self.hooks.run_hook("pre-build", self.appdata, os.getcwd(), "roger-tools.pre-build-test") == 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_noDeletionsWhenNoItems(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
jira.selectProject(["",""])
self.setMocksForGettingItems(jiraInstance)
jira.deleteAllItems()
verify(jiraInstance.service, never).deleteIssue(any(), any())
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_doNotAddCommentsGreaterThan20000Characters(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
testing = Testing()
item = self.itemWithComments(testing)
item.addComment(Testing.stringOfAsOfSize(20002))
tracker.updateCommentsFor(item)
verify(trackerInstance, times=2).AddComment(any(), any())
def test_updateAddsNewComments(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
testing = Testing()
item = self.itemWithComments(testing)
jira.update(item)
verify(jiraInstance.service, times=2).addComment(any(), any(), any())
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_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 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_trackerValidAfterLogin(self):
tracker = self.makeTestTracker()
pivotalApiObject = self.apiObject_
trackerInstance = mock()
when(pivotalApiObject).Tracker(any(),any()).thenReturn(trackerInstance)
user = "******"
password = "******"
tracker.loginAs(user).withCredential(password)
self.assertTrue(tracker.valid())
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 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_run_hook_returns_non_zero_when_hook_fails(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(), any()).thenReturn(any())
assert self.hooks.run_hook(
"bad-hook-cmd", self.appdata, os.getcwd(), "roger-tools.bad-hook-cmd-test") != 0
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_jiraItemsAreReturnedWithUrlPopulated(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
url = "http://www.jira.com/garbage/not/to/be/included/"
jira.setLocationTo(url)
item = RemoteIssue()
item.key = "TEST-jt12345"
when(jiraInstance.service).getIssuesFromJqlSearch(any(), any(), any()).thenReturn([item])
when(jiraInstance.service).getComments(any(),any()).thenReturn([])
self.assertEqual(next(jira.items()).jiraUrl(), "https://www.jira.com/browse/TEST-jt12345")
def test_run_hook_returns_zero_when_hook_is_absent(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(),
any()).thenReturn(any())
assert self.hooks.run_hook("absent-hook", self.appdata, os.getcwd(),
"roger-tools.absent-hook-test") == 0
def test_doNotAddItemWhenItemInTracker(self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(Testing.MockIterator([detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, never).update()
def test_whenMultipleItemsMatchFilterAndItemsCanNotBeSyncedWithThenAddNewItem(self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(Testing.MockIterator([detectedItem,detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(False).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, never).update()
def test_canAddCommentsToTicket(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
testing = Testing()
item = self.itemWithComments(testing)
jira.updateCommentsFor(item)
inorder.verify(jiraInstance.service).login(any(),any())
inorder.verify(jiraInstance.service).addComment(self.auth_, testing.issue.key, {"body":testing.comment1.text()})
inorder.verify(jiraInstance.service).addComment(self.auth_, testing.issue.key, {"body":testing.comment2.text()})
pass
def test_trackerValidAfterLogin(self):
tracker = self.makeTestTracker()
pivotalApiObject = self.apiObject_
trackerInstance = mock()
when(pivotalApiObject).Tracker(any(),
any()).thenReturn(trackerInstance)
user = "******"
password = "******"
tracker.loginAs(user).withCredential(password)
self.assertTrue(tracker.valid())
def test_run_hook_returns_non_zero_when_hook_fails(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(),
any()).thenReturn(any())
assert self.hooks.run_hook("bad-hook-cmd", self.appdata, os.getcwd(),
"roger-tools.bad-hook-cmd-test") != 0
def test_no_assertion_when_good_result_detected(self):
resultContainGoodResult = 0
goodResult = "who cares"
cli = self.makeCli()
when(cli).compareReceivedAgainst(any(),any(),indexOfSuccessfulResult=any()).thenReturn(resultContainGoodResult)
assertion = assertResultEquals(goodResult)
assertion.executeOn(cli)
verify(cli).compareReceivedAgainst([goodResult, EOF, TIMEOUT], any(),indexOfSuccessfulResult=0)
def getMockFor(self, jira):
jiraApiObject = mock()
jiraInstance = Holder()
jiraInstance.service = mock()
jira.apiObject(jiraApiObject)
when(jiraApiObject).Client(any(), timeout=any()).thenReturn(jiraInstance)
self.auth_ = mock()
when(jiraInstance.service).login(any(),any()).thenReturn(self.auth_)
jira.withCredential("None")
return jiraInstance
def test_run_hook_preserves_current_directory(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(), any()).thenReturn(any())
cwd = os.getcwd()
self.hooks.run_hook("pre-build", self.appdata, "/tmp", "roger-tools.pre-build-tmp-test")
assert cwd == os.getcwd()
def test_doNotAddItemWhenItemInTracker(self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(
Testing.MockIterator([detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, never).update()
def test_canGetAvailableStatusNextStepsForATicket(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
actions = ["next step1", "next step2"]
item = mock()
itemId = 1234
when(item).Id().thenReturn(itemId)
when(jiraInstance.service).getAvailableActions(any(), any()).thenReturn(actions)
actionsReturned = jira.getNextStatusActionsFor(item)
verify(jiraInstance.service).getAvailableActions(self.auth_, itemId)
self.assertEqual(actions, actionsReturned)
def test_updateAddsNewComments(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
updatedStory = mock()
testing = Testing()
item = self.itemWithComments(testing)
when(trackerInstance).UpdateStory(any()).thenReturn(updatedStory)
when(updatedStory).GetName().thenReturn("")
tracker.update(item)
verify(trackerInstance, times=2).AddComment(any(), any())
pass
def test_canGetBugsForProject(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
project = ["test","JQL here"]
jira.selectProject(project)
when(jiraInstance.service).getIssuesFromJqlSearch(any(), project[1], any()).thenReturn([RemoteIssue(),RemoteIssue(),RemoteIssue()])
itemIterator = jira._getItems()
next(itemIterator)
next(itemIterator)
next(itemIterator)
self.assertRaises(StopIteration, next, itemIterator)
def test_invoke_webhook_when_appdata_is_invalid(self):
settings = mock(Settings)
appConfig = mock(AppConfig)
appdata = 'invalid-app-data'
hook_input_metrics = 'hook-input-metrics'
conf_file = 'roger-mesos-tools.config'
when(settings).getConfigDir().thenReturn(self.configs_dir)
when(appConfig).getRogerEnv(any()).thenReturn(self.roger_env)
when(appConfig).getConfig(any(), any()).thenReturn(conf_file)
with self.assertRaises(ValueError):
self.webhook.invoke_webhook(appdata, hook_input_metrics, conf_file)
def test_run_hook_preserves_current_directory(self):
when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
sc = mock(StatsClient)
when(sc).timing(any(), any()).thenReturn(any())
when(self.hooks.utils).getStatsClient().thenReturn(sc)
when(self.hooks.utils).get_identifier(any(), any(),
any()).thenReturn(any())
cwd = os.getcwd()
self.hooks.run_hook("pre-build", self.appdata, "/tmp",
"roger-tools.pre-build-tmp-test")
assert cwd == os.getcwd()
