class TestChangeHookConfiguredWithSecret(unittest.TestCase):
_SECRET = 'thesecret'
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitlab': {
'secret': self._SECRET
}},
master=fakeMasterForHooks(self))
@defer.inlineCallbacks
def test_missing_secret(self):
self.request = FakeRequest(content=gitJsonPayloadTag)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
yield self.request.test_render(self.changeHook)
expected = b'Invalid secret'
self.assertEqual(self.request.written, expected)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
0)
@defer.inlineCallbacks
def test_valid_secret(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.received_headers[_HEADER_GITLAB_TOKEN] = self._SECRET
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
2)
class TestChangeHookGiteaSecretPhrase(unittest.TestCase, TestReactorMixin):
def setUp(self):
self.setUpTestReactor()
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitea': {
"secret": "test"
}},
master=fakeMasterForHooks(self))
@defer.inlineCallbacks
def testValidSecret(self):
self.request = FakeRequest(content=giteaJsonPushPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"push"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPushPayload_Signature
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
2)
@defer.inlineCallbacks
def testInvalidSecret(self):
self.request = FakeRequest(content=giteaInvalidSecretPush)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"push"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPushPayload_Signature
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
0)
class TestChangeHookConfiguredWithSecret(unittest.TestCase):
_SECRET = 'thesecret'
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitlab': {'secret': self._SECRET}},
master=fakeMasterForHooks())
@defer.inlineCallbacks
def test_missing_secret(self):
self.request = FakeRequest(content=gitJsonPayloadTag)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
yield self.request.test_render(self.changeHook)
expected = b'Invalid secret'
self.assertEqual(self.request.written, expected)
self.assertEqual(len(self.changeHook.master.addedChanges), 0)
@defer.inlineCallbacks
def test_valid_secret(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.received_headers[_HEADER_GITLAB_TOKEN] = self._SECRET
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.addedChanges), 2)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(dialects={'gitlab': True})
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testGitWithChange(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = "/change_hook/gitlab"
self.request.method = "POST"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 2)
change = self.request.addedChanges[0]
self.assertEquals(change["repository"], "git@localhost:diaspora.git")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1323692851
)
self.assertEquals(change["author"], "Jordi Mallach <*****@*****.**>")
self.assertEquals(change["revision"], 'b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327')
self.assertEquals(change["comments"], "Update Catalan translation to e38cb41.")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://localhost/diaspora/commits/b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327")
change = self.request.addedChanges[1]
self.assertEquals(change["repository"], "git@localhost:diaspora.git")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1325626589
)
self.assertEquals(change["author"], "GitLab dev user <gitlabdev@dv6700.(none)>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"], 'da1560886d4f094c3e6c9ef40349f7d38b5d27d7')
self.assertEquals(change["comments"], "fixed readme")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://localhost/diaspora/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7")
d.addCallback(check_changes)
return d
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/gitlab"
self.request.method = "POST"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "No JSON object could be decoded"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check_changes)
return d
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
dialects = {'gitorious': True}
self.changeHook = change_hook.ChangeHookResource(
dialects=dialects, master=fakeMasterForHooks())
# Test 'base' hook with attributes. We should get a json string
# representing a Change object as a dictionary. All values show be set.
def testGitWithChange(self):
changeDict = {"payload": [gitJsonPayload]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/gitorious"
self.request.method = "POST"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.changeHook.master.addedChanges), 1)
change = self.changeHook.master.addedChanges[0]
# Gitorious doesn't send changed files
self.assertEquals(change['files'], [])
self.assertEquals(change["repository"],
"http://gitorious.org/q/mainline")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1326218547
)
self.assertEquals(change["author"], "jason <*****@*****.**>")
self.assertEquals(change["revision"],
'df5744f7bc8663b39717f87742dc94f52ccbf4dd')
self.assertEquals(change["comments"],
"added a place to put the docstring for Book")
self.assertEquals(change["branch"], "new_look")
revlink = ("http://gitorious.org/q/mainline/commit/"
"df5744f7bc8663b39717f87742dc94f52ccbf4dd")
self.assertEquals(change["revlink"], revlink)
d.addCallback(check_changes)
return d
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/gitorious"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "Error processing changes."
self.assertEquals(len(self.changeHook.master.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors()), 1)
d.addCallback(check_changes)
return d
class TestChangeHookGiteaClass(unittest.TestCase, TestReactorMixin):
class GiteaTestHandler(GiteaHandler):
fakeCategory = 'definitely-not-a-real-category'
def process_push(self, _, __, ___):
return [{'category': self.fakeCategory}]
def process_release(self, _, __, ___):
return [{'category': self.fakeCategory}]
def setUp(self):
self.setUpTestReactor()
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitea': {
'class': self.GiteaTestHandler
}},
master=fakeMasterForHooks(self))
def checkChanges(self):
# There should only be one change because our fake handlers throw the
# payloads away and returns their own single change with a single field.
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
1)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(change['category'],
self.GiteaTestHandler.fakeCategory)
@defer.inlineCallbacks
def testOverrideHandlerIsUsed(self):
self.request = FakeRequest(content=giteaJsonPushPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b'push'
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPushPayload_Signature
yield self.request.test_render(self.changeHook)
self.checkChanges()
@defer.inlineCallbacks
def testNewHandler(self):
self.request = FakeRequest(content=giteaJsonPushPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b'release'
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPushPayload_Signature
yield self.request.test_render(self.changeHook)
self.checkChanges()
class TestGithubChangeHookIncludeTags(TestGithubChangeHookDefaults):
def setUp(self):
self.changeHook = github_resource.GithubResource(
dialects={
'coreos_github' : {
'include_tags': True,
}
})
def testGitWithNewTag(self):
changeDict={"payload" : [gitJsonPayloadNewTag]}
self.request = FakeRequest(changeDict)
self.request.uri = "/coreos/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change['files'], ['filepath.rb'])
self.assertEquals(change["branch"], "tags/v1.2.3")
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
d.addCallback(check_changes)
return d
def testMercurialWithChange(self):
change_dict = {'payload': [mercurialJsonPayload]}
request = FakeRequest(change_dict)
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 1)
commit = request.addedChanges[0]
self.assertEqual(commit['files'], ['somefile.py'])
self.assertEqual(
commit['repository'], 'https://bitbucket.org/marcus/project-x/')
self.assertEqual(
calendar.timegm(commit['when_timestamp'].utctimetuple()),
1338350336
)
self.assertEqual(
commit['author'], 'Marcus Bertrand <*****@*****.**>')
self.assertEqual(
commit['revision'], '620ade18607ac42d872b568bb92acaa9a28620e9')
self.assertEqual(
commit['comments'], 'Added some more things to somefile.py')
self.assertEqual(commit['branch'], 'master')
self.assertEqual(
commit['revlink'],
'https://bitbucket.org/marcus/project-x/commits/'
'620ade18607ac42d872b568bb92acaa9a28620e9'
)
class TestChangeHookGiteaPushOnlySingle(unittest.TestCase, TestReactorMixin):
def setUp(self):
self.setUpTestReactor()
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitea': {
"onlyIncludePushCommit": True
}},
master=fakeMasterForHooks(self))
def checkChangesFromPush(self, codebase=None):
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
1)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(change['repository'],
'ssh://[email protected]/max/webhook_test.git')
self.assertEqual(change["author"], "Max Mustermann <*****@*****.**>")
self.assertEqual(change["revision"],
'9d7157cc4a137b3e1dfe92750ccfb1bbad239f99')
self.assertEqual(change["when_timestamp"], 1536063014)
self.assertEqual(change["comments"], "TestBranch\n")
self.assertEqual(change["branch"], "feature-branch")
self.assertEqual(
change["revlink"],
"https://git.example.com/max/webhook_test/commit/9d7157cc4a137b3e1dfe92750ccfb1bbad239f99"
)
@defer.inlineCallbacks
def testPushEvent(self):
self.request = FakeRequest(content=giteaJsonPushPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"push"
res = yield self.request.test_render(self.changeHook)
self.checkChangesFromPush(res)
def testMercurialWithChange(self):
change_dict = {b'payload': [mercurialJsonPayload]}
request = FakeRequest(change_dict)
request.received_headers[_HEADER_EVENT] = b"repo:push"
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(
len(self.change_hook.master.data.updates.changesAdded), 1)
commit = self.change_hook.master.data.updates.changesAdded[0]
self.assertEqual(commit['files'], ['somefile.py'])
self.assertEqual(commit['repository'],
'https://bitbucket.org/marcus/project-x/')
self.assertEqual(commit['when_timestamp'], 1338350336)
self.assertEqual(commit['author'],
'Marcus Bertrand <*****@*****.**>')
self.assertEqual(commit['revision'],
'620ade18607ac42d872b568bb92acaa9a28620e9')
self.assertEqual(commit['comments'],
'Added some more things to somefile.py')
self.assertEqual(commit['branch'], 'master')
self.assertEqual(
commit['revlink'],
'https://bitbucket.org/marcus/project-x/commits/'
'620ade18607ac42d872b568bb92acaa9a28620e9')
self.assertEqual(commit['properties']['event'], 'repo:push')
def testMercurialWithChange(self):
change_dict = {'payload': [mercurialJsonPayload]}
request = FakeRequest(change_dict)
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 1)
commit = self.change_hook.master.addedChanges[0]
self.assertEqual(commit['files'], ['somefile.py'])
self.assertEqual(commit['repository'],
'https://bitbucket.org/marcus/project-x/')
self.assertEqual(
calendar.timegm(commit['when_timestamp'].utctimetuple()),
1338350336)
self.assertEqual(commit['author'],
'Marcus Bertrand <*****@*****.**>')
self.assertEqual(commit['revision'],
'620ade18607ac42d872b568bb92acaa9a28620e9')
self.assertEqual(commit['comments'],
'Added some more things to somefile.py')
self.assertEqual(commit['branch'], 'master')
self.assertEqual(
commit['revlink'],
'https://bitbucket.org/marcus/project-x/commits/'
'620ade18607ac42d872b568bb92acaa9a28620e9')
def testGitWithChange(self):
change_dict = {b'payload': [gitJsonPayload]}
request = FakeRequest(change_dict)
request.received_headers[_HEADER_EVENT] = b"repo:push"
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 1)
commit = self.change_hook.master.addedChanges[0]
self.assertEqual(commit['files'], ['somefile.py'])
self.assertEqual(
commit['repository'], 'https://bitbucket.org/marcus/project-x/')
self.assertEqual(
calendar.timegm(commit['when_timestamp'].utctimetuple()),
1338350336
)
self.assertEqual(
commit['author'], 'Marcus Bertrand <*****@*****.**>')
self.assertEqual(
commit['revision'], '620ade18607ac42d872b568bb92acaa9a28620e9')
self.assertEqual(
commit['comments'], 'Added some more things to somefile.py')
self.assertEqual(commit['branch'], 'master')
self.assertEqual(
commit['revlink'],
'https://bitbucket.org/marcus/project-x/commits/'
'620ade18607ac42d872b568bb92acaa9a28620e9'
)
self.assertEqual(
commit['properties']['event'],
'repo:push')
def test_render_new_style_logs(self): # bug 2930
self.setupStep(NewStyleStep())
bs = yield self.runStep()
# now try to render it in the WebStatus
log_rsrc = logs.TextLog(bs.getSteps()[0].getLogs()[0])
request = FakeRequest()
yield request.test_render(log_rsrc)
class TestChangeHookUnconfigured(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
self.changeHook = change_hook.ChangeHookResource()
# A bad URI should cause an exception inside check_hook.
# After writing the test, it became apparent this can't happen.
# I'll leave the test anyway
def testDialectReMatchFail(self):
self.request.uri = "/garbage/garbage"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "URI doesn't match change_hook regex: /garbage/garbage"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
def testUnkownDialect(self):
self.request.uri = "/change_hook/garbage"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "The dialect specified, 'garbage', wasn't whitelisted in change_hook"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
def testDefaultDialect(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "The dialect specified, 'base', wasn't whitelisted in change_hook"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
class TestChangeHookConfiguredWithSecret(unittest.TestCase, TestReactorMixin):
_SECRET = 'thesecret'
def setUp(self):
self.setUpTestReactor()
self.master = fakeMasterForHooks(self)
fakeStorageService = FakeSecretStorage()
fakeStorageService.reconfigService(
secretdict={"secret_key": self._SECRET})
self.secretService = SecretManager()
self.secretService.services = [fakeStorageService]
self.master.addService(self.secretService)
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitlab': {
'secret': util.Secret("secret_key")
}},
master=self.master)
@defer.inlineCallbacks
def test_missing_secret(self):
self.request = FakeRequest(content=gitJsonPayloadTag)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
yield self.request.test_render(self.changeHook)
expected = b'Invalid secret'
self.assertEqual(self.request.written, expected)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
0)
@defer.inlineCallbacks
def test_valid_secret(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.received_headers[_HEADER_GITLAB_TOKEN] = self._SECRET
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
2)
class TestChangeHookUnconfigured(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
self.changeHook = change_hook.ChangeHookResource()
# A bad URI should cause an exception inside check_hook.
# After writing the test, it became apparent this can't happen.
# I'll leave the test anyway
def testDialectReMatchFail(self):
self.request.uri = "/garbage/garbage"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "URI doesn't match change_hook regex: /garbage/garbage"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
def testUnkownDialect(self):
self.request.uri = "/change_hook/garbage"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "The dialect specified, 'garbage', wasn't whitelisted in change_hook"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
def testDefaultDialect(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "The dialect specified, 'base', wasn't whitelisted in change_hook"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
d.addCallback(check)
return d
class TestPngStatusResource(unittest.TestCase):
"""Simple unit tests to check Png Status resource
"""
def setUp(self):
self.request_data = {
'builder': ['TestBuilder'],
'size': 'normal',
}
self.request = FakeRequest(self.request_data)
self.request.uri = '/png'
self.request.method = 'GET'
def assertPngFile(self, png, expectedFilename):
gotFilename = png_files_by_contents.get(png, png)
self.assertEqual(gotFilename, expectedFilename)
@inlineCallbacks
def testReturnedUnknownPngOnUnkwnownBuilder(self):
status = FakeStatus()
self.request = FakeRequest({'builder': [':)'], 'size': 'normal'})
self.request.uri = '/png'
self.request.method = 'GET'
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, 'unknown_normal')
@inlineCallbacks
def testReturnedSuccesPngOnSuccesBuild(self):
status = FakeStatus()
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, 'success_normal')
@inlineCallbacks
def do_test(self, size, status_code, exp):
status = FakeStatus(status_code)
if size:
self.request_data['size'] = [size]
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, exp)
def testWithNoJson(self):
request = FakeRequest()
request.uri = "/change_hook/bitbucket"
request.method = "POST"
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 0)
self.assertEqual(request.written, "Error processing changes.")
request.setResponseCode.assert_called_with(500, "Error processing changes.")
self.assertEqual(len(self.flushLoggedErrors()), 1)
class TestChangeHookConfiguredWithGoogleCodeChange(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
# Google Code simply transmit the payload as an UTF-8 JSON body
self.request.content = StringIO.StringIO(googleCodeJsonBody)
self.request.received_headers = {
'Google-Code-Project-Hosting-Hook-Hmac':
'85910bf93ba5c266402d9328b0c7a856',
'Content-Length': '509',
'Accept-Encoding': 'gzip',
'User-Agent':
'Google Code Project Hosting (+http://code.google.com/p/support/wiki/PostCommitWebHooks)',
'Host': 'buildbot6-lopter.dotcloud.com:19457',
'Content-Type': 'application/json; charset=UTF-8'
}
self.changeHook = change_hook.ChangeHookResource(
dialects={
'googlecode': {
'secret_key': 'FSP3p-Ghdn4T0oqX',
'branch': 'test'
}
},
master=fakeMasterForHooks())
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testGoogleCodeWithHgChange(self):
self.request.uri = "/change_hook/googlecode"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
# Only one changeset has been submitted.
self.assertEqual(len(self.changeHook.master.addedChanges), 1)
# First changeset.
change = self.changeHook.master.addedChanges[0]
self.assertEqual(change['files'], ['/CMakeLists.txt'])
self.assertEqual(change["repository"],
"https://code.google.com/p/webhook-test/")
self.assertEqual(change["when"], 1324082130)
self.assertEqual(change["author"],
"Louis Opter <*****@*****.**>")
self.assertEqual(change["revision"],
'68e5df283a8e751cdbf95516b20357b2c46f93d4')
self.assertEqual(change["comments"], "Print a message")
self.assertEqual(change["branch"], "test")
self.assertEqual(
change["revlink"],
"http://webhook-test.googlecode.com/hg-history/68e5df283a8e751cdbf95516b20357b2c46f93d4/"
)
d.addCallback(check_changes)
return d
class TestPngStatusResource(unittest.TestCase):
"""Simple unit tests to check Png Status resource
"""
def setUp(self):
self.request_data = {
'builder': ['TestBuilder'],
'size': 'normal',
}
self.request = FakeRequest(self.request_data)
self.request.uri = '/png'
self.request.method = 'GET'
def assertPngFile(self, png, expectedFilename):
gotFilename = png_files_by_contents.get(png, png)
self.assertEqual(gotFilename, expectedFilename)
@inlineCallbacks
def testReturnedUnknownPngOnUnkwnownBuilder(self):
status = FakeStatus()
self.request = FakeRequest({'builder': [':)'], 'size': 'normal'})
self.request.uri = '/png'
self.request.method = 'GET'
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, 'unknown_normal')
@inlineCallbacks
def testReturnedSuccesPngOnSuccesBuild(self):
status = FakeStatus()
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, 'success_normal')
@inlineCallbacks
def do_test(self, size, status_code, exp):
status = FakeStatus(status_code)
if size:
self.request_data['size'] = [size]
yield self.request.test_render(pngstatus.PngStatusResource(status))
self.assertPngFile(self.request.written, exp)
def testWithNoJson(self):
request = FakeRequest()
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 0)
self.assertEqual(request.written, b'Error processing changes.')
request.setResponseCode.assert_called_with(
500, b'Error processing changes.')
self.assertEqual(len(self.flushLoggedErrors()), 1)
def testMercurialWithNoCommitsPayload(self):
change_dict = {'payload': [mercurialJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 0)
self.assertEqual(request.written, 'no changes found')
def testGitWithNoCommitsPayload(self):
change_dict = {"payload": [gitJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = "/change_hook/bitbucket"
request.method = "POST"
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 0)
self.assertEqual(request.written, "no changes found")
def testMercurialWithNoCommitsPayload(self):
change_dict = {'payload': [mercurialJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 0)
self.assertEqual(request.written, 'no changes found')
def testWithNoJson(self):
request = FakeRequest()
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 0)
self.assertEqual(request.written, 'Error processing changes.')
request.setResponseCode.assert_called_with(
500, 'Error processing changes.')
self.assertEqual(len(self.flushLoggedErrors()), 1)
def testGitWithNoCommitsPayload(self):
change_dict = {b'payload': [gitJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.data.updates.changesAdded), 0)
self.assertEqual(request.written, b'no change found')
def testMercurialWithNoCommitsPayload(self):
change_dict = {b'payload': [mercurialJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.data.updates.changesAdded), 0)
self.assertEqual(request.written, b'no change found')
def testGitWithNoCommitsPayload(self):
change_dict = {b'payload': [gitJsonNoCommitsPayload]}
request = FakeRequest(change_dict)
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.addedChanges), 0)
self.assertEqual(request.written, b'no change found')
class TestChangeHookConfiguredWithSecret(unittest.TestCase):
_SECRET = 'thesecret'
def setUp(self):
self.master = fakeMasterForHooks(self)
fakeStorageService = FakeSecretStorage()
fakeStorageService.reconfigService(secretdict={"secret_key": self._SECRET})
self.secretService = SecretManager()
self.secretService.services = [fakeStorageService]
self.master.addService(self.secretService)
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitlab': {'secret': util.Secret("secret_key")}},
master=self.master)
@defer.inlineCallbacks
def test_missing_secret(self):
self.request = FakeRequest(content=gitJsonPayloadTag)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
yield self.request.test_render(self.changeHook)
expected = b'Invalid secret'
self.assertEqual(self.request.written, expected)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded), 0)
@defer.inlineCallbacks
def test_valid_secret(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.received_headers[_HEADER_GITLAB_TOKEN] = self._SECRET
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded), 2)
def testGitWithChangeAndProject(self):
change_dict = {"payload": [gitJsonPayload], "project": ["project-name"]}
request = FakeRequest(change_dict)
request.uri = "/change_hook/bitbucket"
request.method = "POST"
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 1)
commit = request.addedChanges[0]
self.assertEqual(commit["project"], "project-name")
class TestChangeHookConfiguredWithGoogleCodeChange(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
# Google Code simply transmit the payload as an UTF-8 JSON body
self.request.content = StringIO.StringIO(googleCodeJsonBody)
self.request.received_headers = {
'Google-Code-Project-Hosting-Hook-Hmac': '85910bf93ba5c266402d9328b0c7a856',
'Content-Length': '509',
'Accept-Encoding': 'gzip',
'User-Agent': 'Google Code Project Hosting (+http://code.google.com/p/support/wiki/PostCommitWebHooks)',
'Host': 'buildbot6-lopter.dotcloud.com:19457',
'Content-Type': 'application/json; charset=UTF-8'
}
self.changeHook = change_hook.ChangeHookResource(dialects={
'googlecode': {
'secret_key': 'FSP3p-Ghdn4T0oqX',
'branch': 'test'
}
}, master=fakeMasterForHooks())
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testGoogleCodeWithHgChange(self):
self.request.uri = "/change_hook/googlecode"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
# Only one changeset has been submitted.
self.assertEquals(len(self.changeHook.master.addedChanges), 1)
# First changeset.
change = self.changeHook.master.addedChanges[0]
self.assertEquals(change['files'], ['/CMakeLists.txt'])
self.assertEquals(
change["repository"], "https://code.google.com/p/webhook-test/")
self.assertEquals(change["when"], 1324082130)
self.assertEquals(
change["author"], "Louis Opter <*****@*****.**>")
self.assertEquals(
change["revision"], '68e5df283a8e751cdbf95516b20357b2c46f93d4')
self.assertEquals(change["comments"], "Print a message")
self.assertEquals(change["branch"], "test")
self.assertEquals(change[
"revlink"], "http://webhook-test.googlecode.com/hg-history/68e5df283a8e751cdbf95516b20357b2c46f93d4/")
d.addCallback(check_changes)
return d
def testGitWithChangeAndProject(self):
change_dict = {
b'payload': [gitJsonPayload],
b'project': [b'project-name']}
request = FakeRequest(change_dict)
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.data.updates.changesAdded), 1)
commit = self.change_hook.master.data.updates.changesAdded[0]
self.assertEqual(commit['project'], 'project-name')
def testGitWithChangeAndProject(self):
change_dict = {
'payload': [gitJsonPayload],
'project': ['project-name']}
request = FakeRequest(change_dict)
request.uri = '/change_hook/bitbucket'
request.method = 'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 1)
commit = request.addedChanges[0]
self.assertEqual(commit['project'], 'project-name')
def testGitWithChangeAndProject(self):
change_dict = {
b'payload': [gitJsonPayload],
b'project': [b'project-name']}
request = FakeRequest(change_dict)
request.uri = b'/change_hook/bitbucket'
request.method = b'POST'
yield request.test_render(self.change_hook)
self.assertEqual(len(self.change_hook.master.data.updates.changesAdded), 1)
commit = self.change_hook.master.data.updates.changesAdded[0]
self.assertEqual(commit['project'], 'project-name')
class TestChangeHookConfiguredBogus(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
self.changeHook = change_hook.ChangeHookResource(dialects={'garbage' : True})
@compat.usesFlushLoggedErrors
def testBogusDialect(self):
self.request.uri = "/change_hook/garbage"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check(ret):
expected = "Error processing changes."
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors()), 1)
d.addCallback(check)
return d
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
register_extendable_change_hook()
self.changeHook = change_hook.ChangeHookResource(
dialects={'planio': {'method': planio.getChanges,
'codebase': 'myCode'}})
def check_changes(self, r, project='', codebase=None):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(
change["repository"],
"[email protected]:acsone-sample_project.buildout.git")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1452859243
)
self.assertEquals(change["author"],
"Laurent Mignon <*****@*****.**>")
self.assertEquals(change["revision"],
'1b253c6b9ccb348b5098a4954b143c2317ea8b68')
self.assertEquals(change["comments"], "test.txt")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"],
"https://acsone.plan.io/projects/sample_project/repository/228/"
"revisions/1b253c6b9ccb348b5098a4954b143c2317ea8b68")
self.assertEquals(change.get("project"), project)
self.assertEquals(change.get("codebase"), codebase)
# Test 'base' hook with attributes. We should get a json string
# representing a Change object as a dictionary. All values show be set.
@defer.inlineCallbacks
def testGitWithChange(self):
self.request = FakeRequest()
self.request.content = StringIO(gitJsonPayload)
self.request.received_headers[_HEADER_CT] = _CT_JSON
self.request.uri = "/change_hook/planio"
self.request.method = "POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes(
res, project="sample_project.buildout", codebase="myCode")
class TestGithubChangeHookIncludeTags(TestGithubChangeHookDefaults):
def setUp(self):
self.changeHook = github_resource.GithubResource(dialects={"coreos_github": {"include_tags": True}})
def testGitWithNewTag(self):
changeDict = {"payload": [gitJsonPayloadNewTag]}
self.request = FakeRequest(changeDict)
self.request.uri = "/coreos/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["files"], ["filepath.rb"])
self.assertEquals(change["branch"], "tags/v1.2.3")
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
d.addCallback(check_changes)
return d
def testMercurialWithChange(self):
change_dict = {"payload": [mercurialJsonPayload]}
request = FakeRequest(change_dict)
request.uri = "/change_hook/bitbucket"
request.method = "POST"
yield request.test_render(self.change_hook)
self.assertEqual(len(request.addedChanges), 1)
commit = request.addedChanges[0]
self.assertEqual(commit["files"], ["somefile.py"])
self.assertEqual(commit["repository"], "https://bitbucket.org/marcus/project-x/")
self.assertEqual(calendar.timegm(commit["when_timestamp"].utctimetuple()), 1338350336)
self.assertEqual(commit["author"], "Marcus Bertrand <*****@*****.**>")
self.assertEqual(commit["revision"], "620ade18607ac42d872b568bb92acaa9a28620e9")
self.assertEqual(commit["comments"], "Added some more things to somefile.py")
self.assertEqual(commit["branch"], "master")
self.assertEqual(
commit["revlink"], "https://bitbucket.org/marcus/project-x/" "620ade18607ac42d872b568bb92acaa9a28620e9"
)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
changeDict={"payload" : [gitJsonPayload]}
self.request = FakeRequest(changeDict)
self.changeHook = change_hook.ChangeHookResource(dialects={'github' : True})
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testGitWithChange(self):
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 2)
change = self.request.addedChanges[0]
self.assertEquals(change['files'], ['filepath.rb'])
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
self.assertEquals(change["when"], 1203116237)
self.assertEquals(change["who"], "Fred Flinstone <*****@*****.**>")
self.assertEquals(change["revision"], '41a212ee83ca127e3c8cf465891ab7216a705f59')
self.assertEquals(change["comments"], "okay i give in")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://github.com/defunkt/github/commit/41a212ee83ca127e3c8cf465891ab7216a705f59")
change = self.request.addedChanges[1]
self.assertEquals(change['files'], [ 'modfile', 'removedFile' ])
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
self.assertEquals(change["when"], 1203114994)
self.assertEquals(change["who"], "Fred Flinstone <*****@*****.**>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"], 'de8251ff97ee194a289832576287d6f8ad74e3d0')
self.assertEquals(change["comments"], "update pricing a tad")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://github.com/defunkt/github/commit/de8251ff97ee194a289832576287d6f8ad74e3d0")
d.addCallback(check_changes)
return d
class TestPollingChangeHook(unittest.TestCase):
class Subclass(base.PollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
@defer.inlineCallbacks
def setUpRequest(self, args, options=True, activate=True):
self.changeHook = change_hook.ChangeHookResource(dialects={'poller': options}, master=mock.Mock())
self.request = FakeRequest(args=args)
self.request.uri = "/change_hook/poller"
self.request.method = "GET"
master = self.request.site.master
master.change_svc = ChangeManager()
master.change_svc.setServiceParent(master)
self.changesrc = self.Subclass("example", 21)
self.changesrc.setServiceParent(master.change_svc)
if activate:
self.changesrc.activate()
self.otherpoller = self.Subclass("otherpoller", 22)
self.otherpoller.setServiceParent(master.change_svc)
if activate:
self.otherpoller.activate()
anotherchangesrc = base.ChangeSource(name='notapoller')
anotherchangesrc.setName("notapoller")
anotherchangesrc.setServiceParent(master.change_svc)
yield self.request.test_render(self.changeHook)
yield util.asyncSleep(0)
def tearDown(self):
return defer.gatherResults([
self.changesrc.deactivate(),
self.otherpoller.deactivate(),
])
@defer.inlineCallbacks
def test_no_args(self):
yield self.setUpRequest({})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, True)
@defer.inlineCallbacks
def test_not_active(self):
yield self.setUpRequest({}, activate=False)
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_no_poller(self):
yield self.setUpRequest({"poller": ["nosuchpoller"]})
expected = "Could not find pollers: nosuchpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_invalid_poller(self):
yield self.setUpRequest({"poller": ["notapoller"]})
expected = "Could not find pollers: notapoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_trigger_poll(self):
yield self.setUpRequest({"poller": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_deny(self):
yield self.setUpRequest({"poller": ["otherpoller"]}, options={"allowed": ["example"]})
expected = "Could not find pollers: otherpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_allow(self):
yield self.setUpRequest({"poller": ["example"]}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_all(self):
yield self.setUpRequest({}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(dialects={"github": True})
# Test 'base' hook with attributes. We should get a json string
# representing a Change object as a dictionary. All values show be set.
def testGitWithChange(self):
changeDict = {"payload": [gitJsonPayload]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 2)
change = self.request.addedChanges[0]
self.assertEquals(change["files"], ["filepath.rb"])
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
self.assertEquals(calendar.timegm(change["when_timestamp"].utctimetuple()), 1203116237)
self.assertEquals(change["author"], "Fred Flinstone <*****@*****.**>")
self.assertEquals(change["revision"], "41a212ee83ca127e3c8cf465891ab7216a705f59")
self.assertEquals(change["comments"], "okay i give in")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"], "http://github.com/defunkt/github/commit/" "41a212ee83ca127e3c8cf465891ab7216a705f59"
)
change = self.request.addedChanges[1]
self.assertEquals(change["files"], ["modfile", "removedFile"])
self.assertEquals(change["repository"], "http://github.com/defunkt/github")
self.assertEquals(calendar.timegm(change["when_timestamp"].utctimetuple()), 1203114994)
self.assertEquals(change["author"], "Fred Flinstone <*****@*****.**>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"], "de8251ff97ee194a289832576287d6f8ad74e3d0")
self.assertEquals(change["comments"], "update pricing a tad")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"], "http://github.com/defunkt/github/commit/" "de8251ff97ee194a289832576287d6f8ad74e3d0"
)
d.addCallback(check_changes)
return d
def testGitWithDistinctFalse(self):
changeDict = {"payload": [gitJsonPayload.replace('"distinct": true,', '"distinct": false,')]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEqual(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEqual(change["files"], ["modfile", "removedFile"])
self.assertEqual(change["repository"], "http://github.com/defunkt/github")
self.assertEqual(calendar.timegm(change["when_timestamp"].utctimetuple()), 1203114994)
self.assertEqual(change["author"], "Fred Flinstone <*****@*****.**>")
self.assertEqual(change["src"], "git")
self.assertEqual(change["revision"], "de8251ff97ee194a289832576287d6f8ad74e3d0")
self.assertEqual(change["comments"], "update pricing a tad")
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"], "http://github.com/defunkt/github/commit/" "de8251ff97ee194a289832576287d6f8ad74e3d0"
)
d.addCallback(check_changes)
return d
@compat.usesFlushLoggedErrors
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "Error processing changes."
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors()), 1)
d.addCallback(check_changes)
return d
def testGitWithNoChanges(self):
changeDict = {"payload": [gitJsonPayloadEmpty]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
d.addCallback(check_changes)
return d
def testGitWithNonBranchChanges(self):
changeDict = {"payload": [gitJsonPayloadNonBranch]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
d.addCallback(check_changes)
return d
class TestPollingChangeHook(unittest.TestCase):
class Subclass(base.PollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
@defer.inlineCallbacks
def setUpRequest(self, args, options=True, activate=True):
self.request = FakeRequest(args=args)
self.request.uri = "/change_hook/poller"
self.request.method = "GET"
www = self.request.site.master.www
self.master = master = self.request.site.master = fakemaster.make_master(
testcase=self, wantData=True)
master.www = www
yield self.master.startService()
self.changeHook = change_hook.ChangeHookResource(
dialects={'poller': options}, master=master)
master.change_svc = ChangeManager()
yield master.change_svc.setServiceParent(master)
self.changesrc = self.Subclass("example", 21)
yield self.changesrc.setServiceParent(master.change_svc)
self.otherpoller = self.Subclass("otherpoller", 22)
yield self.otherpoller.setServiceParent(master.change_svc)
anotherchangesrc = base.ChangeSource(name='notapoller')
anotherchangesrc.setName(u"notapoller")
yield anotherchangesrc.setServiceParent(master.change_svc)
yield self.request.test_render(self.changeHook)
yield util.asyncSleep(0.1)
def tearDown(self):
return self.master.stopService()
@defer.inlineCallbacks
def test_no_args(self):
yield self.setUpRequest({})
self.assertEqual(self.request.written, b"no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, True)
@defer.inlineCallbacks
def test_no_poller(self):
yield self.setUpRequest({"poller": ["nosuchpoller"]})
expected = b"Could not find pollers: nosuchpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_invalid_poller(self):
yield self.setUpRequest({"poller": ["notapoller"]})
expected = b"Could not find pollers: notapoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_trigger_poll(self):
yield self.setUpRequest({"poller": ["example"]})
self.assertEqual(self.request.written, b"no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_deny(self):
yield self.setUpRequest({"poller": ["otherpoller"]}, options={"allowed": ["example"]})
expected = b"Could not find pollers: otherpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_allow(self):
yield self.setUpRequest({"poller": ["example"]}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, b"no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_all(self):
yield self.setUpRequest({}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, b"no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(dialects={'gitlab': True}, master=fakeMasterForHooks())
def check_changes(self, r, project='', codebase=None):
self.assertEquals(len(self.changeHook.master.addedChanges), 2)
change = self.changeHook.master.addedChanges[0]
self.assertEquals(change["repository"], "git@localhost:diaspora.git")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1323692851
)
self.assertEquals(change["author"], "Jordi Mallach <*****@*****.**>")
self.assertEquals(change["revision"], 'b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327')
self.assertEquals(change["comments"], "Update Catalan translation to e38cb41.")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://localhost/diaspora/commits/b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327")
change = self.changeHook.master.addedChanges[1]
self.assertEquals(change["repository"], "git@localhost:diaspora.git")
self.assertEquals(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1325626589
)
self.assertEquals(change["author"], "GitLab dev user <gitlabdev@dv6700.(none)>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"], 'da1560886d4f094c3e6c9ef40349f7d38b5d27d7')
self.assertEquals(change["comments"], "fixed readme")
self.assertEquals(change["branch"], "master")
self.assertEquals(change["revlink"], "http://localhost/diaspora/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7")
self.assertEquals(change.get("project"), project)
self.assertEquals(change.get("codebase"), codebase)
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
@defer.inlineCallbacks
def testGitWithChange(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = "/change_hook/gitlab"
self.request.method = "POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes(res)
@defer.inlineCallbacks
def testGitWithChange_WithProjectToo(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = "/change_hook/gitlab"
self.request.args = {'project': ['MyProject']}
self.request.method = "POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes(res, project="MyProject")
@defer.inlineCallbacks
def testGitWithChange_WithCodebaseToo(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = "/change_hook/gitlab"
self.request.args = {'codebase': ['MyCodebase']}
self.request.method = "POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes(res, codebase="MyCodebase")
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/gitlab"
self.request.method = "POST"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.changeHook.master.addedChanges), 0)
self.assertIn("Error loading JSON:", self.request.written)
self.request.setResponseCode.assert_called_with(400, mock.ANY)
d.addCallback(check_changes)
return d
class TestPollingChangeHook(unittest.TestCase):
class Subclass(base.PollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
@defer.inlineCallbacks
def setUpRequest(self, args, options=True, activate=True):
self.request = FakeRequest(args=args)
self.request.uri = b"/change_hook/poller"
self.request.method = b"GET"
www = self.request.site.master.www
self.master = master = self.request.site.master = fakemaster.make_master(
testcase=self, wantData=True)
master.www = www
yield self.master.startService()
self.changeHook = change_hook.ChangeHookResource(
dialects={'poller': options}, master=master)
master.change_svc = ChangeManager()
yield master.change_svc.setServiceParent(master)
self.changesrc = self.Subclass(21, name='example')
yield self.changesrc.setServiceParent(master.change_svc)
self.otherpoller = self.Subclass(22, name="otherpoller")
yield self.otherpoller.setServiceParent(master.change_svc)
anotherchangesrc = base.ChangeSource(name='notapoller')
anotherchangesrc.setName(u"notapoller")
yield anotherchangesrc.setServiceParent(master.change_svc)
yield self.request.test_render(self.changeHook)
yield util.asyncSleep(0.1)
def tearDown(self):
return self.master.stopService()
@defer.inlineCallbacks
def test_no_args(self):
yield self.setUpRequest({})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, True)
@defer.inlineCallbacks
def test_no_poller(self):
yield self.setUpRequest({"poller": ["nosuchpoller"]})
expected = b"Could not find pollers: nosuchpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_invalid_poller(self):
yield self.setUpRequest({"poller": ["notapoller"]})
expected = b"Could not find pollers: notapoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_trigger_poll(self):
yield self.setUpRequest({"poller": ["example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_deny(self):
yield self.setUpRequest({"poller": ["otherpoller"]}, options={"allowed": ["example"]})
expected = b"Could not find pollers: otherpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_allow(self):
yield self.setUpRequest({"poller": ["example"]}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_all(self):
yield self.setUpRequest({}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(
dialects={'github': True})
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testGitWithChange(self):
changeDict = {"payload": [gitJsonPayload]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 2)
change = self.request.addedChanges[0]
self.assertEquals(change['files'], ['filepath.rb'])
self.assertEquals(change["repository"],
"http://github.com/defunkt/github")
self.assertEquals(change["when"], 1203116237)
self.assertEquals(change["who"],
"Fred Flinstone <*****@*****.**>")
self.assertEquals(change["revision"],
'41a212ee83ca127e3c8cf465891ab7216a705f59')
self.assertEquals(change["comments"], "okay i give in")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"],
"http://github.com/defunkt/github/commit/41a212ee83ca127e3c8cf465891ab7216a705f59"
)
change = self.request.addedChanges[1]
self.assertEquals(change['files'], ['modfile', 'removedFile'])
self.assertEquals(change["repository"],
"http://github.com/defunkt/github")
self.assertEquals(change["when"], 1203114994)
self.assertEquals(change["who"],
"Fred Flinstone <*****@*****.**>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"],
'de8251ff97ee194a289832576287d6f8ad74e3d0')
self.assertEquals(change["comments"], "update pricing a tad")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"],
"http://github.com/defunkt/github/commit/de8251ff97ee194a289832576287d6f8ad74e3d0"
)
d.addCallback(check_changes)
return d
@compat.usesFlushLoggedErrors
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "Error processing changes."
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors()), 1)
d.addCallback(check_changes)
return d
def testGitWithNoChanges(self):
changeDict = {"payload": [gitJsonPayloadEmpty]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
d.addCallback(check_changes)
return d
def testGitWithNonBranchChanges(self):
changeDict = {"payload": [gitJsonPayloadNonBranch]}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
d.addCallback(check_changes)
return d
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = _prepare_github_change_hook(strict=False)
@compat.usesFlushLoggedErrors
@defer.inlineCallbacks
def test_unknown_event(self):
bad_event = 'whatever'
self.request = _prepare_request(bad_event, gitJsonPayload)
yield self.request.test_render(self.changeHook)
expected = 'Unknown event: %r' % (bad_event, )
self.assertEqual(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
@compat.usesFlushLoggedErrors
@defer.inlineCallbacks
def test_unknown_content_type(self):
bad_content_type = 'application/x-useful'
self.request = _prepare_request('push',
gitJsonPayload,
headers={_HEADER_CT: bad_content_type})
yield self.request.test_render(self.changeHook)
expected = 'Unknown content type: %r' % (bad_content_type, )
self.assertEqual(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
@defer.inlineCallbacks
def _check_ping(self, payload):
self.request = _prepare_request('ping', payload)
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.request.addedChanges), 0)
def test_ping_encoded(self):
self._check_ping(['{}'])
def test_ping_json(self):
self._check_ping('{}')
# Test 'base' hook with attributes. We should get a json string
# representing a Change object as a dictionary. All values show be set.
@defer.inlineCallbacks
def _check_git_with_change(self, payload):
self.request = _prepare_request('push', payload)
yield self.request.test_render(self.changeHook)
self.assertEquals(len(self.request.addedChanges), 2)
change = self.request.addedChanges[0]
self.assertEquals(change['files'], ['filepath.rb'])
self.assertEquals(change["repository"],
"http://github.com/defunkt/github")
self.assertEquals(timegm(change["when_timestamp"].utctimetuple()),
1203116237)
self.assertEquals(change["author"],
"Fred Flinstone <*****@*****.**>")
self.assertEquals(change["revision"],
'41a212ee83ca127e3c8cf465891ab7216a705f59')
self.assertEquals(change["comments"], "okay i give in")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"], "http://github.com/defunkt/github/commit/"
"41a212ee83ca127e3c8cf465891ab7216a705f59")
change = self.request.addedChanges[1]
self.assertEquals(change['files'], ['modfile', 'removedFile'])
self.assertEquals(change["repository"],
"http://github.com/defunkt/github")
self.assertEquals(timegm(change["when_timestamp"].utctimetuple()),
1203114994)
self.assertEquals(change["author"],
"Fred Flinstone <*****@*****.**>")
self.assertEquals(change["src"], "git")
self.assertEquals(change["revision"],
'de8251ff97ee194a289832576287d6f8ad74e3d0')
self.assertEquals(change["comments"], "update pricing a tad")
self.assertEquals(change["branch"], "master")
self.assertEquals(
change["revlink"], "http://github.com/defunkt/github/commit/"
"de8251ff97ee194a289832576287d6f8ad74e3d0")
def test_git_with_change_encoded(self):
self._check_git_with_change([gitJsonPayload])
def test_git_with_change_json(self):
self._check_git_with_change(gitJsonPayload)
@defer.inlineCallbacks
def testGitWithDistinctFalse(self):
changeDict = {
"payload": [
gitJsonPayload.replace('"distinct": true,',
'"distinct": false,')
]
}
self.request = FakeRequest(changeDict)
self.request.uri = "/change_hook/github"
self.request.method = "GET"
self.request.received_headers = {
_HEADER_CT: _CT_ENCODED,
_HEADER_EVENT: 'push'
}
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEqual(change['files'], ['modfile', 'removedFile'])
self.assertEqual(change["repository"],
"http://github.com/defunkt/github")
self.assertEqual(timegm(change["when_timestamp"].utctimetuple()),
1203114994)
self.assertEqual(change["author"],
"Fred Flinstone <*****@*****.**>")
self.assertEqual(change["src"], "git")
self.assertEqual(change["revision"],
'de8251ff97ee194a289832576287d6f8ad74e3d0')
self.assertEqual(change["comments"], "update pricing a tad")
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"], "http://github.com/defunkt/github/commit/"
"de8251ff97ee194a289832576287d6f8ad74e3d0")
@compat.usesFlushLoggedErrors
@defer.inlineCallbacks
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/github"
self.request.method = "GET"
self.request.received_headers = {
_HEADER_CT: _CT_ENCODED,
_HEADER_EVENT: 'push'
}
yield self.request.test_render(self.changeHook)
expected = "Error processing changes."
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors()), 1)
@defer.inlineCallbacks
def _check_git_with_no_changes(self, payload):
self.request = _prepare_request('push', payload)
yield self.request.test_render(self.changeHook)
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
def test_git_with_no_changes_encoded(self):
self._check_git_with_no_changes([gitJsonPayloadEmpty])
def test_git_with_no_changes_json(self):
self._check_git_with_no_changes(gitJsonPayloadEmpty)
@defer.inlineCallbacks
def _check_git_with_non_branch_changes(self, payload):
self.request = _prepare_request('push', payload)
yield self.request.test_render(self.changeHook)
expected = "no changes found"
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
def test_git_with_non_branch_changes_encoded(self):
self._check_git_with_non_branch_changes([gitJsonPayloadNonBranch])
def test_git_with_non_branch_changes_json(self):
self._check_git_with_non_branch_changes(gitJsonPayloadNonBranch)
@defer.inlineCallbacks
def _check_git_with_pull(self, payload):
self.request = _prepare_request('pull_request', payload)
yield self.request.test_render(self.changeHook)
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["repository"],
"https://github.com/defunkt/github.git")
self.assertEquals(timegm(change["when_timestamp"].utctimetuple()),
1412899790)
self.assertEquals(change["author"], "defunkt")
self.assertEquals(change["revision"],
'05c588ba8cd510ecbe112d020f215facb17817a7')
self.assertEquals(change["comments"],
"GitHub Pull Request #50 (1 commit)")
self.assertEquals(change["branch"], "refs/pull/50/head")
self.assertEquals(change["revlink"],
"https://github.com/defunkt/github/pull/50")
def test_git_with_pull_encoded(self):
self._check_git_with_pull([gitJsonPayloadPullRequest])
def test_git_with_pull_json(self):
self._check_git_with_pull(gitJsonPayloadPullRequest)
class TestChangeHookConfigured(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
self.changeHook = change_hook.ChangeHookResource(dialects={'base': True})
def testDefaultDialectGetNullChange(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["category"], None)
self.assertEquals(len(change["files"]), 0)
self.assertEquals(change["repository"], None)
self.assertEquals(change["when"], None)
self.assertEquals(change["author"], None)
self.assertEquals(change["revision"], None)
self.assertEquals(change["comments"], None)
self.assertEquals(change["project"], None)
self.assertEquals(change["branch"], None)
self.assertEquals(change["revlink"], None)
self.assertEquals(len(change["properties"]), 0)
self.assertEquals(change["revision"], None)
d.addCallback(check_changes)
return d
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testDefaultDialectWithChange(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
self.request.args = {"category": ["mycat"],
"files": [json.dumps(['file1', 'file2'])],
"repository": ["myrepo"],
"when": ["1234"],
"author": ["Santa Claus"],
"number": ["2"],
"comments": ["a comment"],
"project": ["a project"],
"at": ["sometime"],
"branch": ["a branch"],
"revlink": ["a revlink"],
"properties": [json.dumps({"prop1": "val1", "prop2": "val2"})],
"revision": ["99"]}
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["category"], "mycat")
self.assertEquals(change["repository"], "myrepo")
self.assertEquals(change["when"], 1234)
self.assertEquals(change["author"], "Santa Claus")
self.assertEquals(change["src"], None)
self.assertEquals(change["revision"], "99")
self.assertEquals(change["comments"], "a comment")
self.assertEquals(change["project"], "a project")
self.assertEquals(change["branch"], "a branch")
self.assertEquals(change["revlink"], "a revlink")
self.assertEquals(change['properties'], dict(prop1='val1', prop2='val2'))
self.assertEquals(change['files'], ['file1', 'file2'])
d.addCallback(check_changes)
return d
@compat.usesFlushLoggedErrors
def testDefaultWithNoChange(self):
self.request = FakeRequest()
self.request.uri = "/change_hook/"
self.request.method = "GET"
def namedModuleMock(name):
if name == 'buildbot.status.web.hooks.base':
class mock_hook_module(object):
def getChanges(self, request, options):
raise AssertionError
return mock_hook_module()
self.patch(change_hook, "namedModule", namedModuleMock)
d = self.request.test_render(self.changeHook)
def check_changes(r):
expected = "Error processing changes."
self.assertEquals(len(self.request.addedChanges), 0)
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(500, expected)
self.assertEqual(len(self.flushLoggedErrors(AssertionError)), 1)
d.addCallback(check_changes)
return d
class TestPollingChangeHook(TestReactorMixin, unittest.TestCase):
# New sources should derive from ReconfigurablePollingChangeSource,
# but older sources will be using PollingChangeSource.
# Both must work.
class Subclass(base.ReconfigurablePollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
class OldstyleSubclass(base.PollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
def setUp(self):
self.setup_test_reactor()
@defer.inlineCallbacks
def setUpRequest(self,
args,
options=True,
activate=True,
poller_cls=Subclass):
self.request = FakeRequest(args=args)
self.request.uri = b"/change_hook/poller"
self.request.method = b"GET"
www = self.request.site.master.www
self.master = master = self.request.site.master = \
fakemaster.make_master(self, wantData=True)
master.www = www
yield self.master.startService()
self.changeHook = change_hook.ChangeHookResource(
dialects={'poller': options}, master=master)
master.change_svc = ChangeManager()
yield master.change_svc.setServiceParent(master)
self.changesrc = poller_cls(21, name=b'example')
yield self.changesrc.setServiceParent(master.change_svc)
self.otherpoller = poller_cls(22, name=b"otherpoller")
yield self.otherpoller.setServiceParent(master.change_svc)
anotherchangesrc = base.ChangeSource(name=b'notapoller')
anotherchangesrc.setName("notapoller")
yield anotherchangesrc.setServiceParent(master.change_svc)
yield self.request.test_render(self.changeHook)
yield util.asyncSleep(0.1)
def tearDown(self):
return self.master.stopService()
@defer.inlineCallbacks
def test_no_args(self):
yield self.setUpRequest({})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, True)
@defer.inlineCallbacks
def test_no_poller(self):
yield self.setUpRequest({b"poller": [b"nosuchpoller"]})
expected = b"Could not find pollers: nosuchpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_invalid_poller(self):
yield self.setUpRequest({b"poller": [b"notapoller"]})
expected = b"Could not find pollers: notapoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_trigger_poll(self):
yield self.setUpRequest({b"poller": [b"example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_deny(self):
yield self.setUpRequest({b"poller": [b"otherpoller"]},
options={b"allowed": [b"example"]})
expected = b"Could not find pollers: otherpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_allow(self):
yield self.setUpRequest({b"poller": [b"example"]},
options={b"allowed": [b"example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_allowlist_all(self):
yield self.setUpRequest({}, options={b"allowed": [b"example"]})
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
@defer.inlineCallbacks
def test_trigger_old_poller(self):
with assertProducesWarnings(
DeprecatedApiWarning,
num_warnings=2,
message_pattern="use ReconfigurablePollingChangeSource"):
yield self.setUpRequest({b"poller": [b"example"]},
poller_cls=self.OldstyleSubclass)
self.assertEqual(self.request.written, b"no change found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.otherpoller.called, False)
class TestPngStatusResource(unittest.TestCase):
"""Simple unit tests to check Png Status resource
"""
def setUp(self):
self.request_data = {
'builder': ['TestBuilder'],
'size': 'normal',
}
self.request = FakeRequest(self.request_data)
self.request.uri = '/png'
self.request.method = 'GET'
@inlineCallbacks
def testReturnedUnknownPngOnunkwnownBuilder(self):
status = FakeStatus()
self.request = FakeRequest({'builder': ':)', 'size': 'normal'})
self.request.uri = '/png'
self.request.method = 'GET'
yield self.request.test_render(pngstatus.PngStatusResource(status))
png_file = open(
'%s/../../status/web/files/unknown_normal.png' % (
os.path.dirname(__file__),), 'rb'
)
png = png_file.read()
png_file.close()
self.assertEqual(self.request.written, png)
@inlineCallbacks
def testReturnedSuccesPngOnSuccesBuild(self):
status = FakeStatus()
yield self.request.test_render(pngstatus.PngStatusResource(status))
png_file = open(
'%s/../../status/web/files/success_normal.png' % (
os.path.dirname(__file__),), 'rb'
)
png = png_file.read()
png_file.close()
self.assertEqual(self.request.written, png)
@inlineCallbacks
def testReturnedSuccesPngOnWheteverStatusBuild(self):
i = random.randint(0, 5)
status = FakeStatus()
FakeBuilder.status_code = i
yield self.request.test_render(pngstatus.PngStatusResource(status))
png_file = open(
'%s/../../status/web/files/%s_normal.png' % (
os.path.dirname(__file__), results.Results[i]), 'rb'
)
png = png_file.read()
png_file.close()
self.assertEqual(self.request.written, png)
@inlineCallbacks
def testReturnedWheteverStatusAndWhateverSize(self):
sizes = [['small'], ['normal'], ['large']]
i = random.randint(0, 5)
x = sizes[random.randint(0, 2)]
status = FakeStatus()
FakeBuilder.status_code = i
request_data = self.request_data.copy()
request_data['size'] = x
self.request = FakeRequest(request_data)
self.request.uri = '/png'
self.request.method = 'GET'
yield self.request.test_render(pngstatus.PngStatusResource(status))
png_file = open(
'%s/../../status/web/files/%s_%s.png' % (
os.path.dirname(__file__), results.Results[i], x[0]), 'rb'
)
png = png_file.read()
png_file.close()
self.assertEqual(self.request.written, png)
class TestChangeHookGiteaPush(unittest.TestCase, TestReactorMixin):
def setUp(self):
self.setUpTestReactor()
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitea': {}}, master=fakeMasterForHooks(self))
def checkChangesFromPush(self, codebase=None):
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
2)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(change['repository'],
'ssh://[email protected]/max/webhook_test.git')
self.assertEqual(change["author"], "Max Mustermann <*****@*****.**>")
self.assertEqual(change["revision"],
'ad7157cc4a137b3e1dfe92750ccfb1bbad239f9a')
self.assertEqual(change["when_timestamp"], 1536063014)
self.assertEqual(change["comments"], "TestBranch2\n")
self.assertEqual(change["branch"], "feature-branch")
self.assertEqual(
change["revlink"],
"https://git.example.com/max/webhook_test/commit/ad7157cc4a137b3e1dfe92750ccfb1bbad239f9a"
)
change = self.changeHook.master.data.updates.changesAdded[1]
self.assertEqual(change['repository'],
'ssh://[email protected]/max/webhook_test.git')
self.assertEqual(change["author"], "Max Mustermann <*****@*****.**>")
self.assertEqual(change["revision"],
'9d7157cc4a137b3e1dfe92750ccfb1bbad239f99')
self.assertEqual(change["when_timestamp"], 1536063014)
self.assertEqual(change["comments"], "TestBranch\n")
self.assertEqual(change["branch"], "feature-branch")
self.assertEqual(
change["revlink"],
"https://git.example.com/max/webhook_test/commit/9d7157cc4a137b3e1dfe92750ccfb1bbad239f99"
)
def checkFileChanges(self, codebase=None):
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
1)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(change['repository'],
'ssh://[email protected]/Test/test.git')
self.assertEqual(change["author"], "Test User <*****@*****.**>")
self.assertEqual(change["revision"],
'ea07c3148db428876add8b312256239275c395fb')
self.assertEqual(change["comments"], "test123\n")
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"],
"https://git.example.com/Test/test/commit/ea07c3148db428876add8b312256239275c395fb"
)
self.assertEqual(change["files"],
["testfile2", "testfile1", "testfile3"])
def checkChangesFromPullRequest(self, codebase=None):
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
1)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(change['repository'],
'ssh://[email protected]/max/webhook_test.git')
self.assertEqual(change["author"], "Max Mustermann <*****@*****.**>")
self.assertEqual(change["revision"],
'7c5de0796c409e7802abe759113d7fc37e0d6578')
self.assertEqual(change["when_timestamp"], 1536063289)
self.assertEqual(change["comments"], "PR#1: TestPR\n\n")
self.assertEqual(change["branch"], "master")
self.assertEqual(change["revlink"],
"https://git.example.com/max/webhook_test/pulls/1")
properties = change["properties"]
self.assertEqual(properties["base_branch"], "master")
self.assertEqual(properties["base_sha"],
"7c5de0796c409e7802abe759113d7fc37e0d6578")
self.assertEqual(properties["base_repository"],
"https://git.example.com/max/webhook_test.git")
self.assertEqual(properties["base_git_ssh_url"],
"ssh://[email protected]/max/webhook_test.git")
self.assertEqual(properties["head_branch"], "feature-branch")
self.assertEqual(properties["head_sha"],
"9d7157cc4a137b3e1dfe92750ccfb1bbad239f99")
self.assertEqual(properties["head_repository"],
"https://git.example.com/max/webhook_test.git")
self.assertEqual(properties["head_git_ssh_url"],
"ssh://[email protected]/max/webhook_test.git")
self.assertEqual(properties["pr_id"], 8)
self.assertEqual(properties["pr_number"], 1)
def checkChangesFromPullRequestFork(self, codebase=None):
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
1)
change = self.changeHook.master.data.updates.changesAdded[0]
self.assertEqual(
change['repository'],
'ssh://[email protected]/testuser/webhook_test.git')
self.assertEqual(change["author"],
"testuser name <*****@*****.**>")
self.assertEqual(change["revision"],
'449a5a8ca05607106b5ba41988c1a658a8949a18')
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"],
"https://git.example.com/testuser/webhook_test/pulls/4")
properties = change["properties"]
self.assertEqual(properties["base_branch"], "master")
self.assertEqual(properties["base_sha"],
"449a5a8ca05607106b5ba41988c1a658a8949a18")
self.assertEqual(properties["base_repository"],
"https://git.example.com/testuser/webhook_test.git")
self.assertEqual(
properties["base_git_ssh_url"],
"ssh://[email protected]/testuser/webhook_test.git")
self.assertEqual(properties["head_branch"], "feature_branch")
self.assertEqual(properties["head_sha"],
"53e3075cbe468f14c2801d186d703e64b2adee12")
self.assertEqual(
properties["head_repository"],
"https://git.example.com/test_org/webhook_test_fork.git")
self.assertEqual(
properties["head_git_ssh_url"],
"ssh://[email protected]/test_org/webhook_test_fork.git")
self.assertEqual(properties["pr_id"], 36)
self.assertEqual(properties["pr_number"], 4)
@defer.inlineCallbacks
def testPushEvent(self):
self.request = FakeRequest(content=giteaJsonPushPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"push"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPushPayload_Signature
res = yield self.request.test_render(self.changeHook)
self.checkChangesFromPush(res)
@defer.inlineCallbacks
def testChangedFiles(self):
self.request = FakeRequest(content=giteaJsonPushModifiedFiles)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"push"
res = yield self.request.test_render(self.changeHook)
self.checkFileChanges(res)
@defer.inlineCallbacks
def testPullRequestEvent(self):
self.request = FakeRequest(content=giteaJsonPullRequestPayload)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"pull_request"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPullRequestPayload_Signature
res = yield self.request.test_render(self.changeHook)
self.checkChangesFromPullRequest(res)
@defer.inlineCallbacks
def testPullRequestForkEvent(self):
self.request = FakeRequest(content=giteaJsonPullRequestFork)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"pull_request"
res = yield self.request.test_render(self.changeHook)
self.checkChangesFromPullRequestFork(res)
@defer.inlineCallbacks
def testPullRequestNotMergeableEvent(self):
self.request = FakeRequest(
content=giteaJsonPullRequestPayloadNotMergeable)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"pull_request"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPullRequestPayloadNotMergeable_Signature
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
0)
@defer.inlineCallbacks
def testPullRequestMergedEvent(self):
self.request = FakeRequest(content=giteaJsonPullRequestPayloadMerged)
self.request.uri = b'/change_hook/gitea'
self.request.method = b'POST'
self.request.received_headers[_HEADER_EVENT_TYPE] = b"pull_request"
self.request.received_headers[
_HEADER_SIGNATURE] = giteaJsonPullRequestPayloadMerged_Signature
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.data.updates.changesAdded),
0)
class TestPollingChangeHook(unittest.TestCase):
class Subclass(base.PollingChangeSource):
pollInterval = None
called = False
def poll(self):
self.called = True
def setUpRequest(self, args, options=True):
self.changeHook = change_hook.ChangeHookResource(dialects={'poller' : options})
self.request = FakeRequest(args=args)
self.request.uri = "/change_hook/poller"
self.request.method = "GET"
master = self.request.site.buildbot_service.master
master.change_svc = ChangeManager(master)
self.changesrc = self.Subclass("example", None)
self.changesrc.setServiceParent(master.change_svc)
self.disabledChangesrc = self.Subclass("disabled", None)
self.disabledChangesrc.setServiceParent(master.change_svc)
anotherchangesrc = base.ChangeSource()
anotherchangesrc.setName("notapoller")
anotherchangesrc.setServiceParent(master.change_svc)
return self.request.test_render(self.changeHook)
@defer.inlineCallbacks
def test_no_args(self):
yield self.setUpRequest({})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.disabledChangesrc.called, True)
@defer.inlineCallbacks
def test_no_poller(self):
yield self.setUpRequest({"poller": ["nosuchpoller"]})
expected = "Could not find pollers: nosuchpoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.disabledChangesrc.called, False)
@defer.inlineCallbacks
def test_invalid_poller(self):
yield self.setUpRequest({"poller": ["notapoller"]})
expected = "Could not find pollers: notapoller"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.disabledChangesrc.called, False)
@defer.inlineCallbacks
def test_trigger_poll(self):
yield self.setUpRequest({"poller": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.disabledChangesrc.called, False)
@defer.inlineCallbacks
def test_allowlist_deny(self):
yield self.setUpRequest({"poller": ["disabled"]}, options={"allowed": ["example"]})
expected = "Could not find pollers: disabled"
self.assertEqual(self.request.written, expected)
self.request.setResponseCode.assert_called_with(400, expected)
self.assertEqual(self.changesrc.called, False)
self.assertEqual(self.disabledChangesrc.called, False)
@defer.inlineCallbacks
def test_allowlist_allow(self):
yield self.setUpRequest({"poller": ["example"]}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.disabledChangesrc.called, False)
@defer.inlineCallbacks
def test_allowlist_all(self):
yield self.setUpRequest({}, options={"allowed": ["example"]})
self.assertEqual(self.request.written, "no changes found")
self.assertEqual(self.changesrc.called, True)
self.assertEqual(self.disabledChangesrc.called, False)
class TestChangeHookConfiguredWithGitChange(unittest.TestCase):
def setUp(self):
self.changeHook = change_hook.ChangeHookResource(
dialects={'gitlab': True}, master=fakeMasterForHooks())
def check_changes_tag_event(self, r, project='', codebase=None):
self.assertEqual(len(self.changeHook.master.addedChanges), 2)
change = self.changeHook.master.addedChanges[0]
self.assertEqual(change["repository"], "git@localhost:diaspora.git")
self.assertEqual(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1323692851)
self.assertEqual(change["branch"], "v1.0.0")
def check_changes_mr_event(self, r, project='', codebase=None):
self.assertEqual(len(self.changeHook.master.addedChanges), 1)
change = self.changeHook.master.addedChanges[0]
self.assertEqual(
change["repository"],
"http://example.com/awesome_user/awesome_project.git")
self.assertEqual(
change['properties']["target_repository"],
"http://example.com/awesome_space/awesome_project.git")
self.assertEqual(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1325626589)
self.assertEqual(change["branch"], "ms-viewport")
self.assertEqual(change['properties']["target_branch"], 'master')
self.assertEqual(change["category"], "merge_request")
def check_changes_push_event(self, r, project='', codebase=None):
self.assertEqual(len(self.changeHook.master.addedChanges), 2)
change = self.changeHook.master.addedChanges[0]
self.assertEqual(change["repository"], "git@localhost:diaspora.git")
self.assertEqual(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1323692851)
self.assertEqual(change["author"],
"Jordi Mallach <*****@*****.**>")
self.assertEqual(change["revision"],
'b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327')
self.assertEqual(change["comments"],
"Update Catalan translation to e38cb41.")
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"],
"http://localhost/diaspora/commits/b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327"
)
change = self.changeHook.master.addedChanges[1]
self.assertEqual(change["repository"], "git@localhost:diaspora.git")
self.assertEqual(
calendar.timegm(change["when_timestamp"].utctimetuple()),
1325626589)
self.assertEqual(change["author"],
"GitLab dev user <gitlabdev@dv6700.(none)>")
self.assertEqual(change["src"], "git")
self.assertEqual(change["revision"],
'da1560886d4f094c3e6c9ef40349f7d38b5d27d7')
self.assertEqual(change["comments"], "fixed readme")
self.assertEqual(change["branch"], "master")
self.assertEqual(
change["revlink"],
"http://localhost/diaspora/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7"
)
self.assertEqual(change.get("project"), project)
self.assertEqual(change.get("codebase"), codebase)
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
@defer.inlineCallbacks
def testGitWithChange(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
res = yield self.request.test_render(self.changeHook)
self.check_changes_push_event(res)
@defer.inlineCallbacks
def testGitWithChange_WithProjectToo(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'project': [b'MyProject']}
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.method = b"POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes_push_event(res, project="MyProject")
@defer.inlineCallbacks
def testGitWithChange_WithCodebaseToo(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.method = b"POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes_push_event(res, codebase="MyCodebase")
@defer.inlineCallbacks
def testGitWithChange_WithPushTag(self):
self.request = FakeRequest(content=gitJsonPayloadTag)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.method = b"POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes_tag_event(res, codebase="MyCodebase")
def testGitWithNoJson(self):
self.request = FakeRequest()
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEqual(len(self.changeHook.master.addedChanges), 0)
self.assertIn(b"Error loading JSON:", self.request.written)
self.request.setResponseCode.assert_called_with(400, mock.ANY)
d.addCallback(check_changes)
return d
@defer.inlineCallbacks
def test_event_property(self):
self.request = FakeRequest(content=gitJsonPayload)
self.request.received_headers[_HEADER_EVENT] = b"Push Hook"
self.request.uri = b"/change_hook/gitlab"
self.request.method = b"POST"
yield self.request.test_render(self.changeHook)
self.assertEqual(len(self.changeHook.master.addedChanges), 2)
change = self.changeHook.master.addedChanges[0]
self.assertEqual(change["properties"]["event"], "Push Hook")
self.assertEqual(change["category"], "Push Hook")
@defer.inlineCallbacks
def testGitWithChange_WithMR(self):
self.request = FakeRequest(content=gitJsonPayloadMR)
self.request.uri = b"/change_hook/gitlab"
self.request.args = {b'codebase': [b'MyCodebase']}
self.request.received_headers[_HEADER_EVENT] = b"Merge Request Hook"
self.request.method = b"POST"
res = yield self.request.test_render(self.changeHook)
self.check_changes_mr_event(res, codebase="MyCodebase")
change = self.changeHook.master.addedChanges[0]
self.assertEqual(change["category"], "merge_request")
class TestChangeHookConfigured(unittest.TestCase):
def setUp(self):
self.request = FakeRequest()
self.changeHook = change_hook.ChangeHookResource(dialects={'base' : True})
def testDefaultDialectGetNullChange(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["category"], None)
self.assertEquals(len(change["files"]), 0)
self.assertEquals(change["repository"], None)
self.assertEquals(change["when"], None)
self.assertEquals(change["author"], None)
self.assertEquals(change["revision"], None)
self.assertEquals(change["comments"], None)
self.assertEquals(change["project"], None)
self.assertEquals(change["branch"], None)
self.assertEquals(change["revlink"], None)
self.assertEquals(len(change["properties"]), 0)
self.assertEquals(change["revision"], None)
d.addCallback(check_changes)
return d
# Test 'base' hook with attributes. We should get a json string representing
# a Change object as a dictionary. All values show be set.
def testDefaultDialectWithChange(self):
self.request.uri = "/change_hook/"
self.request.method = "GET"
self.request.args = { "category" : ["mycat"],
"files" : [json.dumps(['file1', 'file2'])],
"repository" : ["myrepo"],
"when" : [1234],
"author" : ["Santa Claus"],
"number" : [2],
"comments" : ["a comment"],
"project" : ["a project"],
"at" : ["sometime"],
"branch" : ["a branch"],
"revlink" : ["a revlink"],
"properties" : [json.dumps( { "prop1" : "val1", "prop2" : "val2" })],
"revision" : [99] }
d = self.request.test_render(self.changeHook)
def check_changes(r):
self.assertEquals(len(self.request.addedChanges), 1)
change = self.request.addedChanges[0]
self.assertEquals(change["category"], "mycat")
self.assertEquals(change["repository"], "myrepo")
self.assertEquals(change["when"], 1234)
self.assertEquals(change["author"], "Santa Claus")
self.assertEquals(change["src"], None)
self.assertEquals(change["revision"], 99)
self.assertEquals(change["comments"], "a comment")
self.assertEquals(change["project"], "a project")
self.assertEquals(change["branch"], "a branch")
self.assertEquals(change["revlink"], "a revlink")
self.assertEquals(change['properties'], dict(prop1='val1', prop2='val2'))
self.assertEquals(change['files'], ['file1', 'file2'])
d.addCallback(check_changes)
return d
