def test_update_jobs___Ignore_job2_after_update___event_fired_with_new_ignore_status(self):
jobOne = Job('job1', JobStatus.OK)
jobTwo = Job('job2', JobStatus.FAILING)
self.jenkins.list_jobs().AndReturn([jobOne, jobTwo])
self.jenkins.list_jobs().AndReturn([jobOne, jobTwo])
self.event.fire([JobModel(jobOne, False), JobModel(jobTwo, False)])
self.event.fire([JobModel(jobOne, False), JobModel(jobTwo, True)])
self.mocks.ReplayAll()
model = Model(self.jenkins, self.logger, self.event)
model.update_jobs()
model.ignore_job('job2')
mox.Verify(self.event)
def test_put_no_content(self):
"""
Don't try to update from a no-content response.
"""
class BasicMost(self.cls):
name = fields.Field()
value = fields.Field()
request = {
'uri': 'http://example.com/bwuh',
'headers': {
'accept': 'application/json'
},
}
content = """{"name": "Molly", "value": 80}"""
h = utils.mock_http(request, content)
b = BasicMost.get('http://example.com/bwuh', http=h)
self.assertEquals(b.name, 'Molly')
mox.Verify(h)
headers = {
'accept': 'application/json',
'content-type': 'application/json',
'if-match': '7',
}
request = dict(uri='http://example.com/bwuh',
method='PUT',
headers=headers,
body=content)
response = dict(content="", status=204)
h = utils.mock_http(request, response)
b.put(http=h)
mox.Verify(h)
self.assertEquals(b.name, 'Molly')
def testIsDone(self):
print "testing isDone"
self.path = array([[0, 1, 1, 1], [1, 2, 2, 2], [2, 9, 9, 9],
[3, 28, 28, 28]])
self.path = self.path.transpose()
self.mock_leg_model.getFootPos().AndReturn([0, 0, 0])
self.mock_leg_model.jointAnglesFromFootPos(ReturnTrue(self.path))
mox.Replay(self.mock_leg_model)
ifm = InterpolatedFootMove(self.mock_leg_model, self.path)
ifm.update()
self.assertFalse(ifm.isDone())
global_time.updateDelta(4)
ifm.update()
self.assertTrue(ifm.isDone())
mox.Verify(self.mock_leg_model)
def testOk(self):
self.mox.StubOutWithMock(os, 'makedirs')
os.makedirs(self.dir, 0700)
self.mox.StubOutWithMock(os, 'mknod')
os.mknod(self.path, 0600 | stat.S_IFREG)
result = object()
open_ = self.mox.CreateMockAnything()
open_(self.path, 'r').AndReturn(result)
mox.Replay(open_)
self.mox.ReplayAll()
self.assertEqual(util.SafeOpen(self.path, 'r', open_=open_), result)
self.mox.VerifyAll()
mox.Verify(open_)
def test_index(self):
class Toybox(self.cls):
pass
url = 'http://example.com/whahay'
headers = {"accept": "application/json"}
request = dict(uri=url, headers=headers)
content = """{"entries":[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}"""
h = utils.mock_http(request, content)
mox.Replay(h)
b = Toybox.get('http://example.com/whahay', http=h)
self.assertEqual(b[7], 7)
mox.Verify(h)
def testRunStateChanged(self):
projects = self.Projects(2)
# 0 is STOP so it'll be looked for
self.to_be_found = projects[0]
self.looked_for = False
projects[1].runstate = launcher.Project.STATE_RUN
frame_mock = mox.MockObject(launcher.MainFrame)
tc = launcher.TaskController(FakeAppController())
tc._FindThreadForProject = self._FindThreadForProject
tc.SetModelsViews(frame=frame_mock)
mox.Replay(frame_mock)
for project in projects:
tc.RunStateChanged(project)
mox.Verify(frame_mock)
self.assertTrue(self.looked_for)
def test_post(self):
class BasicMost(self.cls):
name = fields.Field()
value = fields.Field()
class ContainerMost(self.cls):
name = fields.Field()
request = {
'uri': 'http://example.com/asfdasf',
'headers': {'accept': 'application/json'},
}
content = """{"name": "CBS"}"""
h = utils.mock_http(request, content)
c = ContainerMost.get('http://example.com/asfdasf', http=h)
self.assertEquals(c.name, 'CBS')
mox.Verify(h)
b = BasicMost(name='Fred Friendly', value=True)
headers = {
'accept': 'application/json',
'content-type': 'application/json',
}
content = """{"name": "Fred Friendly", "value": true}"""
request = dict(uri='http://example.com/asfdasf', method='POST',
body=content, headers=headers)
response = dict(content=content, status=201, etag='xyz',
location='http://example.com/fred')
h = utils.mock_http(request, response)
c.post(b, http=h)
mox.Verify(h)
self.assertEquals(b._location, 'http://example.com/fred')
self.assertEquals(b._etag, 'xyz')
def testResizeListener(self):
rl = self.mox.CreateMock(window.IResizeListener)
# Expectations
rl.windowResized(mox.IsA(window.ResizeEvent))
# Start actual test
mox.Replay(rl)
# Add listener and send a resize event -> should end up
# in listener once
self._window.addListener(rl, window.IResizeListener)
self.sendResize(self._window)
# Ensure listener was called once
mox.Verify(rl)
# Remove the listener and send close event -> should not
# end up in listener
self._window.removeListener(rl, window.IResizeListener)
self.sendResize(self._window)
# Ensure listener still has been called only once
mox.Verify(rl)
def testTwoTries(self):
"""Test a two try cache."""
original = mox.MockAnything()
original.getHostByName('google.com').AndReturn(
defer.fail(
failure.Failure(error.DNSLookupError('Fake DNS failure'))))
original.getHostByName('google.com').AndReturn(
defer.succeed('1.2.3.4'))
mox.Replay(original)
cache = dnsRetry.RetryingDNS(original,
tries=2,
sleep=time.SleepManager(0, 0, 0))
result = cache.getHostByName('google.com')
self.assertEquals(result, '1.2.3.4')
mox.Verify(original)
def testDashboard(self):
projects = self.Projects(5)
tc = launcher.TaskController(FakeAppController())
frame_mock = mox.MockObject(launcher.MainFrame)
frame_mock.SelectedProjects().MultipleTimes().AndReturn(projects)
mox.Replay(frame_mock)
tc.SetModelsViews(frame=frame_mock)
browsed = []
def Browse(project):
browsed.append(project)
tc._BrowseDashboardForProject = Browse
tc.Dashboard(None)
self.assertEqual(sorted(projects), sorted(browsed))
mox.Verify(frame_mock)
def test_not_found(self):
self.assert_(self.cls.NotFound)
class Huh(self.cls):
name = fields.Field()
self.assert_(Huh.NotFound)
request = {
'uri': 'http://example.com/bwuh',
'headers': {'accept': 'application/json'},
}
response = {'content': '', 'status': 404}
http = utils.mock_http(request, response)
self.assertRaises(Huh.NotFound, lambda: Huh.get('http://example.com/bwuh', http=http).name)
mox.Verify(http)
def testFallbackFailsFirstTime(self):
"""Test a cache with fallback."""
original = mox.MockAnything()
original.getHostByName('google.com').AndReturn(
defer.fail(failure.Failure(error.DNSLookupError('Fake DNS failure'))))
original.getHostByName('google.com').AndReturn(
defer.succeed('1.2.3.4'))
mox.Replay(original)
cache = dnsCache.CachingDNS(original, timeout = 1)
result = cache.getHostByName('google.com')
self.assertTrue(isinstance(result.result, failure.Failure))
result.addErrback(lambda _: None) # Consume the error.
result = cache.getHostByName('google.com')
self.assertEquals(result.result, '1.2.3.4')
mox.Verify(original)
def test_schedule_consecutive_rep_2_grade(self):
date_from = date.today() + timedelta(4)
date_to = date.today() + timedelta(9)
self._global_data.get_workloads(date_from, date_to, None).AndReturn(
[63, 40, 33, 20, 18, 50])
self._global_data.get_avg_difficulties(date_from, date_to).AndReturn(
[6.0, 2.2, 1.5, 1.6, 3.5, 5.1])
mox.Replay(self._global_data)
alg_data = dict(num_reviews=3, avg_grade=3.7, difficulty=1.70)
next_review, alg_data = self._algorithm.schedule(alg_data=alg_data,
priority=PRIORITY_LOW,
grade=2)
mox.Verify(self._global_data)
assert_equals(date.today() + timedelta(8), next_review.date())
self._assert_new_alg_data(4, 3.28, 3.56, FINAL_DRILL, alg_data)
def testOneTry(self):
"""Test a single try cache."""
original = mox.MockAnything()
original.getHostByName('google.com').AndReturn(
defer.fail(
failure.Failure(error.DNSLookupError('Fake DNS failure'))))
original.getHostByName('google.com').AndReturn(
defer.succeed('1.2.3.4'))
mox.Replay(original)
cache = dnsRetry.RetryingDNS(original, tries=1)
self.assertRaises(error.DNSLookupError, cache.getHostByName,
'google.com')
result = cache.getHostByName('google.com')
self.assertEquals(result, '1.2.3.4')
mox.Verify(original)
def test_get(self):
class BasicMost(self.cls):
name = fields.Field()
value = fields.Field()
request = {
'uri': 'http://example.com/ohhai',
'headers': {'accept': 'application/json', 'x-test': 'boo'},
}
content = """{"name": "Fred", "value": 7}"""
h = utils.mock_http(request, content)
b = BasicMost.get('http://example.com/ohhai', http=h,
headers={"x-test": "boo"})
self.assertEquals(b.name, 'Fred')
self.assertEquals(b.value, 7)
mox.Verify(h)
def test_get_bad_encoding(self):
class BasicMost(self.cls):
name = fields.Field()
value = fields.Field()
request = {
'uri': 'http://example.com/ohhai',
'headers': {'accept': 'application/json'},
}
content = """{"name": "Fred\xf1", "value": "image by \xefndrew Example"}"""
h = utils.mock_http(request, content)
b = BasicMost.get('http://example.com/ohhai', http=h)
self.assertEquals(b.name, u"Fred\ufffd")
# Bad characters are replaced with the unicode Replacement Character 0xFFFD.
self.assertEquals(b.value, u"image by \ufffdndrew Example")
mox.Verify(h)
def test_Constructor_ModelFiresStatusChangedEvent_ViewSetStatusCalled(
self):
mocks = mox.Mox()
model = mocks.CreateMock(IModel)
view = mocks.CreateMock(IView)
event = Event()
model.status_changed_event().AndReturn(event)
view.set_status('some status string', 'status message')
mocks.ReplayAll()
presenter = Presenter(model, view) # @UnusedVariable
event.fire('some status string', 'status message')
mox.Verify(view)
def testOK(self):
"""Dialog comes up and a change is made."""
dialog_mock = mox.MockObject(launcher.PreferenceView)
dialog_mock.ShowModal().AndReturn(wx.ID_OK)
python_pref = launcher.Preferences.PREF_PYTHON
appengine_pref = launcher.Preferences.PREF_APPENGINE
deploy_pref = launcher.Preferences.PREF_DEPLOY_SERVER
editor_pref = launcher.Preferences.PREF_EDITOR
dialog_mock.Get(python_pref).InAnyOrder().AndReturn('python-2')
dialog_mock.Get(appengine_pref).InAnyOrder().AndReturn(None)
dialog_mock.Get(deploy_pref).InAnyOrder().AndReturn(None)
dialog_mock.Get(editor_pref).InAnyOrder().AndReturn(None)
dialog_mock.Destroy()
mox.Replay(dialog_mock)
pc = FakeController(self.prefs, dialog_mock)
pc.ShowModal()
mox.Verify(dialog_mock)
self.assertEqual('python-2', self.prefs[python_pref])
def testCubic(self):
print "testing cubic interpolation"
self.path = array([[0, 1, 1, 1], [1, 2, 2, 2], [2, 9, 9, 9],
[3, 28, 28, 28]])
self.path = self.path.transpose()
self.mock_leg_model.getFootPos().AndReturn([0, 0, 0])
self.mock_leg_model.jointAnglesFromFootPos(
ArraysEqual(array([.0, .0, .0])))
self.mock_leg_model.jointAnglesFromFootPos(
ArraysEqual(array([.001, .001, .001])))
self.mock_leg_model.jointAnglesFromFootPos(
ArraysEqual(array([.008, .008, .008])))
self.mock_leg_model.jointAnglesFromFootPos(
ArraysEqual(array([.027, .027, .027])))
self.mock_leg_model.jointAnglesFromFootPos(
ArraysEqual(array([.064, .064, .064])))
mox.Replay(self.mock_leg_model)
ifm = InterpolatedFootMove(self.mock_leg_model, self.path)
print "TEST 1"
#target_foot_pos = array([ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3])
print "expected target_foot_pos = ", array([.0, .0, .0])
self.assertFalse(ifm.isDone())
ifm.update()
global_time.updateDelta(0.1)
print "TEST 2"
#target_foot_pos = array([ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3])
print "expected target_foot_pos = ", array([.001, .001, .001])
ifm.update()
global_time.updateDelta(0.1)
print "TEST 3"
#target_foot_pos = array([ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3])
print "expected target_foot_pos = ", array([.008, .008, .008])
ifm.update()
global_time.updateDelta(0.1)
print "TEST 4"
#target_foot_pos = array([ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3])
print "expected target_foot_pos = ", array([.027, .027, .027])
ifm.update()
global_time.updateDelta(0.1)
print "TEST 5"
#target_foot_pos = array([ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3, ifm.stop_watch.getTime()**3])
print "expected target_foot_pos = ", array([.064, .064, .064])
ifm.update()
mox.Verify(self.mock_leg_model)
def testAdd(self):
"""Tests both Add() and AddNew()."""
for attr in ('Add', 'AddNew'):
p = launcher.Project('/tmp/himom', 8123)
# Avoid UI with a NoAskController
controller = NoAskController(self.app, p)
# Mock table to confirm AddProject() gets called
table_mock = mox.MockObject(launcher.MainTable)
table_mock.AddProject(p)
table_mock._projects = None
mox.Replay(table_mock)
controller.SetModelsViews(table=table_mock)
# UI should be noop, and table.AddProject() should be called in here
getattr(controller, attr)(None)
mox.Verify(table_mock)
# Make sure the path makes it to the controller.
c = NoAskController(self.app, None)
c.Add(None, '/Path/To/Oblivion')
self.assertEqual('/Path/To/Oblivion', c._path)
def testFallback(self):
"""Test a cache with fallback."""
original = mox.MockAnything()
original.getHostByName('google.com').AndReturn(
defer.succeed('1.2.3.4'))
original.getHostByName('google.com').AndReturn(
defer.fail(failure.Failure(error.DNSLookupError('Fake DNS failure'))))
original.getHostByName('google.com').AndReturn(
defer.succeed('9.8.7.6'))
mox.Replay(original)
cache = dnsCache.CachingDNS(original, timeout = 0)
result = cache.getHostByName('google.com')
self.assertEquals(result.result, '1.2.3.4')
result = cache.getHostByName('google.com')
self.assertEquals(result.result, '1.2.3.4')
result = cache.getHostByName('google.com')
self.assertEquals(result.result, '9.8.7.6')
mox.Verify(original)
def test_create___Job_status_is_unknown___No_enable_or_disable_added(self):
job_model = JobModel(Job('name', JobStatus.UNKNOWN), False)
self.qtgui.QAction(mox.IgnoreArg(),
mox.IgnoreArg(),
triggered='ignore callback').InAnyOrder().AndReturn(
'ignore/unignore action')
self.qtgui.QAction(
mox.IgnoreArg(), mox.IgnoreArg(),
triggered='unignore callback').InAnyOrder().AndReturn(
'ignore/unignore action')
self.menu.addAction('ignore/unignore action')
self.mocks.ReplayAll()
factory = gui.jobs.ContextMenuFactory(self.parent, self.qtgui)
factory.create(job_model, 'ignore callback', 'unignore callback',
'enable callback', 'disable callback')
mox.Verify(self.menu)
def test_create_JobIsDisabled_AddEnableAction(self):
job_model = JobModel(Job('name', JobStatus.DISABLED), True)
self.qtgui.QAction(mox.IgnoreArg(),
mox.IgnoreArg(),
triggered=mox.IgnoreArg()).InAnyOrder().AndReturn(
'ignore/unignore action')
self.qtgui.QAction('Enable', self.parent,
triggered='enable callback').InAnyOrder().AndReturn(
'enable action')
self.menu.addAction(mox.IgnoreArg()).InAnyOrder()
self.menu.addAction('enable action').InAnyOrder()
self.mocks.ReplayAll()
factory = gui.jobs.ContextMenuFactory(self.parent, self.qtgui)
factory.create(job_model, 'ignore callback', 'unignore callback',
'enable callback', 'disable callback')
mox.Verify(self.menu)
def test_updateStatus_JobsModelFiresFirstUpdateEventStatusUnknownAndMessageNone_StatusChangedEventNotFired(
self):
self.jobs_filter.filter_jobs(self.job_models).AndReturn(
self.job_models)
self.messageComposer.message(self.jobs).AndReturn(None)
self.statusReader.status(self.jobs).AndReturn(JobStatus.UNKNOWN)
self.mocks.ReplayAll()
model = Model(
self.jobsModel, # @UnusedVariable
self.jobs_filter,
self.messageComposer,
self.statusReader,
self.statusEvent)
self.jobsEvent.fire(self.job_models)
mox.Verify(self.statusEvent)
def test_delete_failure(self):
class BasicMost(self.cls):
name = fields.Field()
value = fields.Field()
b = BasicMost(name='Molly', value=80)
b._location = 'http://example.com/bwuh'
b._etag = 'asfdasf'
headers = {
'accept': 'application/json',
'if-match': 'asfdasf',
}
request = dict(uri='http://example.com/bwuh', method='DELETE', headers=headers)
response = dict(status=412) # Precondition Failed
h = utils.mock_http(request, response)
self.assertRaises(BasicMost.PreconditionFailed, lambda: b.delete(http=h))
mox.Verify(h)
def test___set_jobs___Ignored_job___Ignored_job_gets_ignored_icon(self):
jobs = [
JobModel(Job('john', pyjenkins.job.JobStatus.FAILING), False),
JobModel(Job('terry', pyjenkins.job.JobStatus.OK), True)
]
self.qtgui.QListWidgetItem('failing icon',
'john').AndReturn('item for john')
self.qtgui.QListWidgetItem('ignored icon',
'terry').AndReturn('item for terry')
self.view.right_click_event().InAnyOrder().AndReturn(Event())
self.view.set_list(['item for john', 'item for terry'])
self.mocks.ReplayAll()
adapter = gui.jobs.ListViewAdapter(self.view, self.media,
self.menu_factory, self.qtgui)
adapter.set_jobs(jobs)
mox.Verify(self.view)
def test_updateStatus_JobsModelFiresFirstUpdateEvent_StatusChangedEventFired(
self):
self.jobs_filter.filter_jobs(self.job_models).AndReturn(
self.job_models)
self.messageComposer.message(self.jobs).AndReturn('message')
self.statusReader.status(self.jobs).AndReturn(JobStatus.FAILING)
self.statusEvent.fire(JobStatus.FAILING, 'message')
self.mocks.ReplayAll()
model = Model(
self.jobsModel, # @UnusedVariable
self.jobs_filter,
self.messageComposer,
self.statusReader,
self.statusEvent)
self.jobsEvent.fire(self.job_models)
mox.Verify(self.statusEvent)
def testSDKConsole(self):
projects = self.Projects(5)
tc = launcher.TaskController(FakeAppController())
frame_mock = mox.MockObject(launcher.MainFrame)
frame_mock.SelectedProjects().MultipleTimes().AndReturn(projects)
mox.Replay(frame_mock)
tc.SetModelsViews(frame=frame_mock)
browsed_projects = []
def FakeBrowse(project):
browsed_projects.append(project)
tc._BrowseAdminConsoleForProject = FakeBrowse
# none are running so we expect no browsing
tc.SdkConsole(None)
self.assertFalse(browsed_projects)
for i in (1, 3, 4):
projects[i].runstate = launcher.Project.STATE_RUN
tc.SdkConsole(None)
self.assertEqual(3, len(browsed_projects))
mox.Verify(frame_mock)
def test_Constructor___View_fires_job_ignored_event___Model_ignore_job_called(self):
mocks = mox.Mox()
model = mocks.CreateMock(IModel)
view = mocks.CreateMock(IView)
job_ignored_event = Event()
model.jobs_updated_event().AndReturn(Event())
view.job_ignored_event().InAnyOrder().AndReturn(job_ignored_event)
view.job_unignored_event().InAnyOrder().AndReturn(Event())
view.job_enabled_event().InAnyOrder().AndReturn(Event())
view.job_disabled_event().InAnyOrder().AndReturn(Event())
model.ignore_job('spam')
mocks.ReplayAll()
presenter = Presenter(model, view) # @UnusedVariable
job_ignored_event.fire('spam')
mox.Verify(model)
def test_not_found_discrete(self):
"""Checks that the NotFound exceptions for different HttpObjects are
really different classes, so you can catch them discretely and treat
different unfound objects differently, like:
>>> try:
... h = Huh.get(huh_url)
... w = What.get(what_url)
... except Huh.NotFound:
... # oops, no Huh
... except What.NotFound:
... # oops, no What
This feature is not implemented.
"""
class Huh(self.cls):
pass
class What(self.cls):
pass
def try_that(http):
try:
What.get('http://example.com/bwuh', http=http)
# Let through What.NotFound only if it's not equivalent to Huh.NotFound.
except Huh.NotFound:
pass
request = {
'uri': 'http://example.com/bwuh',
'headers': {
'accept': 'application/json'
},
}
response = dict(status=404)
http = utils.MockedHttp(request, response)
self.assertRaises(What.NotFound, lambda: try_that(http))
mox.Verify(http)
