class TestGitHubStatus2(TestGitHubStatus):
"""
Unit tests for `GitHubStatus` using the repo parameter.
"""
def setUp(self):
super(TestGitHubStatus2, self).setUp()
self.status = GitHubStatus(token='token', repo='owner/name')
def test_getGitHubRepoProperties_skip_no_owner(self):
self.status._repo = Interpolate('/name')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_skip_no_name(self):
self.status._repo = Interpolate('owner/')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
class TestGitHubStatus2(TestGitHubStatus):
"""
Unit tests for `GitHubStatus` using the repo parameter.
"""
def setUp(self):
super(TestGitHubStatus2, self).setUp()
self.status = GitHubStatus(
token='token', repo='owner/name')
def test_getGitHubRepoProperties_skip_no_owner(self):
self.status._repo = Interpolate('/name')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_skip_no_name(self):
self.status._repo = Interpolate('owner/')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def setUp(self):
super(TestGitHubStatus, self).setUp()
if not txgithub:
raise unittest.SkipTest("txgithub not found.")
self.setUpLogging()
self.build = FakeBuild()
self.status = GitHubStatus(
token='token', repoOwner='owner', repoName='name')
def test_repoUnderDefined(self):
"""
GitHubStatus will fail to init if not both repoOwner and repoName
are defined.
"""
self.assertRaisesConfigError(
'Specify both or none of repoOwner and repoName',
lambda: GitHubStatus(token='token', repoOwner='owner'))
self.assertRaisesConfigError(
'Specify both or none of repoOwner and repoName',
lambda: GitHubStatus(token='token', repoName='name'))
def setUp(self):
super(TestGitHubStatus, self).setUp()
if not txgithub:
raise unittest.SkipTest("txgithub not found.")
self.setUpLogging()
self.build = FakeBuild()
self.status = GitHubStatus(token="token", repoOwner="owner", repoName="name")
def test_repoOverDefined(self):
"""
GitHubStatus will fail to init if all of repoOwner, repoName, and repo
are defined.
"""
self.assertRaisesConfigError(
'Specify repoOwner and repoName or repo, but not both',
lambda: GitHubStatus(token='token',
repoOwner='owner',
repoName='name',
repo='owner/name'))
def get_github_status():
from buildbot.process.properties import Interpolate
from buildbot.status.github import GitHubStatus
return GitHubStatus(
token='<token redacted>',
repoOwner='SFML',
repoName='SFML',
sha=Interpolate("%(prop:got_revision)s"),
startDescription=Interpolate("Build #%(prop:buildnumber)s started."),
endDescription=Interpolate("Build #%(prop:buildnumber)s done."),
)
def test_custom_github_url(self):
"""
Check that the custom URL is passed as it should be
"""
with patch('buildbot.status.github.GitHubAPI') as mock:
token = 'GitHub-API-Token'
owner = Interpolate('owner')
name = Interpolate('name')
GitHubStatus(token, owner, name)
mock.assert_called_once_with(oauth2_token=token, baseURL=None)
with patch('buildbot.status.github.GitHubAPI') as mock:
token = 'GitHub-API-Token'
owner = Interpolate('owner')
name = Interpolate('name')
url = 'https://my.example.com/api'
GitHubStatus(token, owner, name, baseURL=url)
mock.assert_called_once_with(oauth2_token=token, baseURL=url)
def _getGitHubRepoProperties(self, build):
"""
Extend the status with a context revealing the origin of the information
(ie, this buildbot build).
"""
d = GitHubStatus._getGitHubRepoProperties(self, build)
def extend_status(status):
status.update({
"context": "buildbot/" + build.builder.name,
})
return status
d.addCallback(extend_status)
return d
def _getGithHubStatus(self):
"""
Return a list with configuration for github for empty list if github
is not enabled.
"""
configuration = self._raw.get('github', {})
result = []
if not configuration:
return []
result.append(
GitHubStatus(
token=configuration['token'],
repoOwner=Interpolate("%(prop:github_repo_owner)s"),
repoName=Interpolate("%(prop:github_repo_name)s"),
))
return result
def test_initialization_required_arguments(self):
"""
Status can be initialized by only specifying GitHub API token
and interpolation for repository's owner and name.
All other arguments are initialized with default values.
"""
token = 'GitHub-API-Token'
repoOwner = Interpolate('owner')
repoName = Interpolate('name')
status = GitHubStatus(
token=token, repoOwner=repoOwner, repoName=repoName)
self.assertEqual(repoOwner, status._repoOwner)
self.assertEqual(repoName, status._repoName)
# Check default values.
self.assertEqual(status._sha, Interpolate("%(src::revision)s"))
self.assertEqual(status._startDescription, "Build started.")
self.assertEqual(status._endDescription, "Build done.")
"ssl:port=8443:privateKey=/etc/ssl/server.key:certKey=/etc/ssl/server.crt:extraCertChain=/etc/ssl/server.ca-bundle",
authz=authz_cfg,
change_hook_auth=["file:changehook.passwd"],
change_hook_dialects={'github': {}},
order_console_by_time=True))
# IRC bot
ircbot = json.load(open("ircbot.json"))
status.append(
words.IRC(host=ircbot['server'],
nick=ircbot['nickname'],
password=ircbot['password'],
channels=ircbot['channels'],
notify_events={
'successToException': 1,
'successToFailure': 1,
'failureToSuccess': 1,
'exceptionToSuccess': 1
}))
# GitHub Status
tokens = json.load(open("tokens.json"))
for repo in tokens:
gs = GitHubStatus(token=tokens[repo]["token"],
repoOwner=tokens[repo]["owner"],
repoName=repo,
sha=Interpolate("%(src:" + repo + ":revision)s"),
startDescription='DEV build started.',
endDescription='DEV build done.')
status.append(gs)
class TestGitHubStatus(unittest.TestCase, logging.LoggingMixin):
"""
Unit tests for `GitHubStatus`.
"""
def setUp(self):
super(TestGitHubStatus, self).setUp()
if not txgithub:
raise unittest.SkipTest("txgithub not found.")
self.setUpLogging()
self.build = FakeBuild()
self.status = GitHubStatus(token="token", repoOwner="owner", repoName="name")
def tearDown(self):
self.assertEqual(0, len(self._logEvents), "There are still logs not validated:\n%s" % self._logEvents)
pending_errors = self.flushLoggedErrors()
self.assertEqual(0, len(pending_errors), "There are still errors not validated:\n%s" % pending_errors)
super(TestGitHubStatus, self).tearDown()
def assertLog(self, message):
"""
Check that top of the log queue has message.
"""
log_event = self._popLog()
self.assertFalse(log_event["isError"], "Log is an error.")
self.assertEqual((message,), log_event["message"], "Wrong log message")
def assertLogError(self, error, message):
"""
Pop log queue and validate error and error message.
"""
log_event = self._popLog()
self.assertTrue(log_event["isError"], "Log is not an error.")
self.assertEqual(message, log_event["why"], "Wrong error message.")
# The error is also checked in Twisted logged errors queue.
errors = self.flushLoggedErrors(type(error))
self.assertEqual(error, errors[0].value)
def _popLog(self):
try:
return self._logEvents.pop()
except IndexError:
raise AssertionError("Log queue is empty.")
def test_initialization_required_arguments(self):
"""
Status can be initialized by only specifying GitHub API token
and interpolation for repository's owner and name.
All other arguments are initialized with default values.
"""
token = "GitHub-API-Token"
repoOwner = Interpolate("owner")
repoName = Interpolate("name")
status = GitHubStatus(token=token, repoOwner=repoOwner, repoName=repoName)
self.assertEqual(repoOwner, status._repoOwner)
self.assertEqual(repoName, status._repoName)
# Check default values.
self.assertEqual(status._sha, Interpolate("%(src::revision)s"))
self.assertEqual(status._startDescription, "Build started.")
self.assertEqual(status._endDescription, "Build done.")
def test_custom_github_url(self):
"""
Check that the custom URL is passed as it should be
"""
with patch("buildbot.status.github.GitHubAPI") as mock:
token = "GitHub-API-Token"
owner = Interpolate("owner")
name = Interpolate("name")
GitHubStatus(token, owner, name)
mock.assert_called_once_with(oauth2_token=token, baseURL=None)
with patch("buildbot.status.github.GitHubAPI") as mock:
token = "GitHub-API-Token"
owner = Interpolate("owner")
name = Interpolate("name")
url = "https://my.example.com/api"
GitHubStatus(token, owner, name, baseURL=url)
mock.assert_called_once_with(oauth2_token=token, baseURL=url)
def test_startService(self):
"""
When started, it will set parent as '_status' and subscribe to parent.
"""
self.status.parent = Mock()
self.status.startService()
self.status._status.subscribe.assert_called_with(self.status)
def test_builderAdded(self):
"""
Status is attached to every builder.
"""
result = self.status.builderAdded("builder-name", None)
self.assertEqual(self.status, result)
def test_buildStarted_success(self):
"""
Will call _sendStartStatus and return `None`.
"""
builder_name = "builder-name"
build = object()
self.status._sendStartStatus = Mock()
result = self.status.buildStarted(builder_name, build)
self.assertIdentical(result, None)
self.status._sendStartStatus.assert_called_once_with(builder_name, build)
def test_buildStarted_failure(self):
"""
On failure will return `None` and log the error.
"""
builder_name = "builder-name"
error = MarkerError("start-errors")
self.status._sendStartStatus = Mock(return_value=defer.fail(error))
result = self.status.buildStarted(builder_name, None)
self.assertIdentical(result, None)
self.assertLogError(error, "While sending start status to GitHub for builder-name.")
def test_buildFinished_success(self):
"""
Will call _sendFinishStatus and return `None`.
"""
builder_name = "builder-name"
build = object()
results = object()
self.status._sendFinishStatus = Mock()
result = self.status.buildFinished(builder_name, build, results)
self.assertIdentical(result, None)
self.status._sendFinishStatus.assert_called_once_with(builder_name, build, results)
def test_buildFinished_failure(self):
"""
On failure returns `None` and log the error.
"""
builder_name = "builder-name"
error = MarkerError("finish-errors")
self.status._sendFinishStatus = Mock(return_value=defer.fail(error))
result = self.status.buildFinished(builder_name, None, None)
self.assertIdentical(result, None)
self.assertLogError(error, "While sending finish status to GitHub for builder-name.")
def test_sendStartStatus_no_properties(self):
"""
Status sending for _sendStartStatus is skipped if no GitHub specific
properties are obtained from _getGitHubRepoProperties.
"""
self.status._getGitHubRepoProperties = lambda build: {}
d = self.status._sendStartStatus("builder-name", None)
result = self.successResultOf(d)
self.assertIdentical(result, None)
def test_sendStartStatus_failure(self):
"""
On failure returns the failed deferred.
"""
error = MarkerError("send-start-status-error")
self.status._getGitHubRepoProperties = lambda build: defer.fail(error)
d = self.status._sendStartStatus("builder-name", None)
failure = self.failureResultOf(d)
self.assertEqual(error, failure.value)
def test_sendStartStatus_ok(self):
"""
When _getGitHubRepoProperties return a dict with properties
for this build, _sendStartStatus will augment with details for
start state and send a GitHub API request.
"""
self.status._getGitHubRepoProperties = lambda build: {
"repoOwner": "repo-owner",
"repoName": "repo-name",
"sha": "123",
"targetURL": "http://example.tld",
"buildNumber": "1",
}
self.status._sendGitHubStatus = Mock(return_value=defer.succeed(None))
self.build.getTimes = lambda: (1, None)
startDateTime = datetime.datetime.fromtimestamp(1).isoformat(" ")
d = self.status._sendStartStatus("builder-name", self.build)
result = self.successResultOf(d)
self.assertIdentical(result, None)
self.status._sendGitHubStatus.assert_called_with(
{
"repoOwner": "repo-owner",
"repoName": "repo-name",
"sha": "123",
"targetURL": "http://example.tld",
"buildNumber": "1",
# Augmented arguments.
"state": "pending",
"description": "Build started.",
"builderName": "builder-name",
"startDateTime": startDateTime,
"endDateTime": "In progress",
"duration": "In progress",
}
)
def test_sendFinishStatus_no_properties(self):
"""
Status sending for _sendFinishStatus is skipped if no GitHub specific
properties are obtained from _getGitHubRepoProperties.
"""
error = MarkerError("send-start-status-error")
self.status._getGitHubRepoProperties = lambda build: defer.fail(error)
d = self.status._sendFinishStatus("builder-name", None, None)
failure = self.failureResultOf(d)
self.assertEqual(error, failure.value)
def test_sendFinishStatus_failure(self):
"""
On failure returns the failed deferred.
"""
self.status._getGitHubRepoProperties = lambda build: {}
d = self.status._sendFinishStatus("builder-name", None, None)
result = self.successResultOf(d)
self.assertIdentical(result, None)
def test_sendFinishStatus_ok(self):
"""
When _getGitHubRepoProperties return a dict _sendFinishStatus will
augment it with build result and sent status to GitHub API.
"""
self.status._getGitHubRepoProperties = lambda build: {
"repoOwner": "repo-owner",
"repoName": "repo-name",
"sha": "123",
"targetURL": "http://example.tld",
"buildNumber": "1",
}
self.status._sendGitHubStatus = Mock(return_value=defer.succeed(None))
self.build.getTimes = lambda: (1, 3)
startDateTime = datetime.datetime.fromtimestamp(1).isoformat(" ")
endDateTime = datetime.datetime.fromtimestamp(3).isoformat(" ")
d = self.status._sendFinishStatus("builder-name", self.build, SUCCESS)
result = self.successResultOf(d)
self.assertIdentical(result, None)
self.status._sendGitHubStatus.assert_called_with(
{
"repoOwner": "repo-owner",
"repoName": "repo-name",
"sha": "123",
"targetURL": "http://example.tld",
"buildNumber": "1",
# Augmented arguments.
"state": "success",
"description": "Build done.",
"builderName": "builder-name",
"startDateTime": startDateTime,
"endDateTime": endDateTime,
"duration": "2 seconds",
}
)
def test_getGitHubRepoProperties_skip_no_sha(self):
"""
An empty dict is returned when any of the repo name, owner and sha
interpolation returns an empty string or None.
"""
self.build._repoOwner = Interpolate("owner")
self.build._repoName = Interpolate("name")
self.build._sha = Interpolate("")
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
self.assertLog("GitHubStatus: No revision found.")
def test_getGitHubRepoProperties_skip_no_owner(self):
self.status._repoOwner = Interpolate("")
self.status._repoName = Interpolate("name")
self.status._sha = Interpolate("sha")
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_skip_no_name(self):
self.status._repoOwner = Interpolate("owner")
self.status._repoName = Interpolate("")
self.status._sha = Interpolate("sha")
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_ok(self):
"""
A dictionary with build status properties is returned when
required properties were rendered.
"""
self.status._repoOwner = Interpolate("owner")
self.status._repoName = Interpolate("name")
self.status._sha = Interpolate("sha")
self.status._status = Mock()
self.status._status.getURLForThing = lambda build: "http://example.org"
self.build.getNumber = lambda: 1
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual(
{
"buildNumber": "1",
"repoName": "name",
"repoOwner": "owner",
"sha": "sha",
"targetURL": "http://example.org",
},
result,
)
def test_getGitHubState(self):
"""
_getGitHubState will try to translate BuildBot status into GitHub
status. For unknown values will fallback to 'error'.
"""
self.assertEqual("success", _getGitHubState(SUCCESS))
self.assertEqual("failure", _getGitHubState(FAILURE))
self.assertEqual("error", _getGitHubState("anything-else"))
def test_sendGitHubStatus_success(self):
"""
sendGitHubStatus will call the txgithub createStatus and encode
all data.
"""
status = {
"repoOwner": u"owner-resum\xe9",
"repoName": u"name-resum\xe9",
"sha": u"sha-resum\xe9",
"state": u"state-resum\xe9",
"targetURL": u"targetURL-resum\xe9",
"description": u"description-resum\xe9",
}
self.status._github.repos.createStatus = Mock(return_value=defer.succeed(None))
d = self.status._sendGitHubStatus(status)
result = self.successResultOf(d)
self.assertEqual(None, result)
self.status._github.repos.createStatus.assert_called_with(
repo_name="name-resum\xc3\xa9",
repo_user="******",
sha="sha-resum\xc3\xa9",
state="state-resum\xc3\xa9",
target_url="targetURL-resum\xc3\xa9",
description="description-resum\xc3\xa9",
)
self.assertLog(u'Status "state-resum\xe9" sent for ' u"owner-resum\xe9/name-resum\xe9 at sha-resum\xe9.")
def test_sendGitHubStatus_error(self):
"""
sendGitHubStatus will log an error if txgithub sendGitHubStatus fails.
"""
status = {
"repoOwner": u"owner",
"repoName": u"name",
"sha": u"sha",
"state": u"state",
"targetURL": u"targetURL",
"description": u"description",
}
error = MarkerError("fail-send-status")
self.status._github.repos.createStatus = Mock(return_value=defer.fail(error))
self.status._sendGitHubStatus(status)
self.assertLogError(error, u'Fail to send status "state" for owner/name at sha.')
channels=[{
"channel": "#nimbuild"
}],
nick=irc_credentials['username'],
password=irc_credentials['password'],
useColors=False,
notify_events={
'finished': 1,
'failure': 1,
'exception': 1,
})
# Github Status
gs = GitHubStatus(token=github_token,
repoOwner="nim-lang",
repoName="Nim",
startDescription='Build started.',
endDescription='Build done.')
c['status'] = [irc, gs]
class BuilderResource(HtmlResource):
"""
Helper class for per-builder resources
"""
def content(self, request, ctx):
"""Display a build status image like Travis does."""
status = self.getStatus(request)
# Get the parameters.
def builderAdded(self, name_, builder_):
if builder_.matchesAnyTag(self._required_tags):
return GitHubStatus.builderAdded(self, name_, builder_)
return None
def __init__(self, tags, *a, **kw):
self._required_tags = tags
GitHubStatus.__init__(self, *a, **kw)
def setUp(self):
super(TestGitHubStatus, self).setUp()
self.setUpLogging()
self.build = FakeBuild()
self.status = GitHubStatus(
token='token', repoOwner='owner', repoName='name')
class TestGitHubStatus(unittest.TestCase, logging.LoggingMixin):
"""
Unit tests for `GitHubStatus`.
"""
def setUp(self):
super(TestGitHubStatus, self).setUp()
if not txgithub:
raise unittest.SkipTest("txgithub not found.")
self.setUpLogging()
self.build = FakeBuild()
self.status = GitHubStatus(
token='token', repoOwner='owner', repoName='name')
def tearDown(self):
self.assertEqual(
0,
len(self._logEvents),
'There are still logs not validated:\n%s' % self._logEvents,
)
pending_errors = self.flushLoggedErrors()
self.assertEqual(
0,
len(pending_errors),
'There are still errors not validated:\n%s' % pending_errors,
)
super(TestGitHubStatus, self).tearDown()
def assertLog(self, message):
"""
Check that top of the log queue has message.
"""
log_event = self._popLog()
self.assertFalse(log_event['isError'], 'Log is an error.')
self.assertEqual(
(message, ), log_event['message'], 'Wrong log message')
def assertLogError(self, error, message):
"""
Pop log queue and validate error and error message.
"""
log_event = self._popLog()
self.assertTrue(log_event['isError'], 'Log is not an error.')
self.assertEqual(message, log_event['why'], 'Wrong error message.')
# The error is also checked in Twisted logged errors queue.
errors = self.flushLoggedErrors(type(error))
self.assertEqual(error, errors[0].value)
def _popLog(self):
try:
return self._logEvents.pop()
except IndexError:
raise AssertionError('Log queue is empty.')
def test_initialization_required_arguments(self):
"""
Status can be initialized by only specifying GitHub API token
and interpolation for repository's owner and name.
All other arguments are initialized with default values.
"""
token = 'GitHub-API-Token'
repoOwner = Interpolate('owner')
repoName = Interpolate('name')
status = GitHubStatus(
token=token, repoOwner=repoOwner, repoName=repoName)
self.assertEqual(token, status._token)
self.assertEqual(repoOwner, status._repoOwner)
self.assertEqual(repoName, status._repoName)
# Check default values.
self.assertEqual(status._sha, Interpolate("%(src::revision)s"))
self.assertEqual(status._startDescription, "Build started.")
self.assertEqual(status._endDescription, "Build done.")
def test_startService(self):
"""
When started, it will set parent as '_status' and subscribe to parent.
"""
self.status.parent = Mock()
self.status.startService()
self.status._status.subscribe.assert_called_with(self.status)
def test_builderAdded(self):
"""
Status is attached to every builder.
"""
result = self.status.builderAdded('builder-name', None)
self.assertEqual(self.status, result)
def test_buildStarted_success(self):
"""
Will call _sendStartStatus and return `None`.
"""
builder_name = 'builder-name'
build = object()
self.status._sendStartStatus = Mock()
result = self.status.buildStarted(builder_name, build)
self.assertIdentical(result, None)
self.status._sendStartStatus.assert_called_once_with(
builder_name, build)
def test_buildStarted_failure(self):
"""
On failure will return `None` and log the error.
"""
builder_name = 'builder-name'
error = MarkerError('start-errors')
self.status._sendStartStatus = Mock(
return_value=defer.fail(error))
result = self.status.buildStarted(builder_name, None)
self.assertIdentical(result, None)
self.assertLogError(
error,
'While sending start status to GitHub for builder-name.')
def test_buildFinished_success(self):
"""
Will call _sendFinishStatus and return `None`.
"""
builder_name = 'builder-name'
build = object()
results = object()
self.status._sendFinishStatus = Mock()
result = self.status.buildFinished(builder_name, build, results)
self.assertIdentical(result, None)
self.status._sendFinishStatus.assert_called_once_with(
builder_name, build, results)
def test_buildFinished_failure(self):
"""
On failure returns `None` and log the error.
"""
builder_name = 'builder-name'
error = MarkerError('finish-errors')
self.status._sendFinishStatus = Mock(
return_value=defer.fail(error))
result = self.status.buildFinished(builder_name, None, None)
self.assertIdentical(result, None)
self.assertLogError(
error,
'While sending finish status to GitHub for builder-name.')
def test_sendStartStatus_no_properties(self):
"""
Status sending for _sendStartStatus is skipped if no GitHub specific
properties are obtained from _getGitHubRepoProperties.
"""
self.status._getGitHubRepoProperties = lambda build: {}
d = self.status._sendStartStatus('builder-name', None)
result = self.successResultOf(d)
self.assertIdentical(result, None)
def test_sendStartStatus_failure(self):
"""
On failure returns the failed deferred.
"""
error = MarkerError('send-start-status-error')
self.status._getGitHubRepoProperties = lambda build: defer.fail(error)
d = self.status._sendStartStatus('builder-name', None)
failure = self.failureResultOf(d)
self.assertEqual(error, failure.value)
def test_sendStartStatus_ok(self):
"""
When _getGitHubRepoProperties return a dict with properties
for this build, _sendStartStatus will augment with details for
start state and send a GitHub API request.
"""
self.status._getGitHubRepoProperties = lambda build: {
'repoOwner': 'repo-owner',
'repoName': 'repo-name',
'sha': '123',
'targetURL': 'http://domain.tld',
'buildNumber': '1',
}
self.status._sendGitHubStatus = Mock(return_value=defer.succeed(None))
self.build.getTimes = lambda: (1, None)
startDateTime = datetime.datetime.fromtimestamp(1).isoformat(' ')
d = self.status._sendStartStatus('builder-name', self.build)
result = self.successResultOf(d)
self.assertIdentical(result, None)
self.status._sendGitHubStatus.assert_called_with({
'repoOwner': 'repo-owner',
'repoName': 'repo-name',
'sha': '123',
'targetURL': 'http://domain.tld',
'buildNumber': '1',
# Augmented arguments.
'state': 'pending',
'description': 'Build started.',
'builderName': 'builder-name',
'startDateTime': startDateTime,
'endDateTime': 'In progress',
'duration': 'In progress',
})
def test_sendFinishStatus_no_properties(self):
"""
Status sending for _sendFinishStatus is skipped if no GitHub specific
properties are obtained from _getGitHubRepoProperties.
"""
error = MarkerError('send-start-status-error')
self.status._getGitHubRepoProperties = lambda build: defer.fail(error)
d = self.status._sendFinishStatus('builder-name', None, None)
failure = self.failureResultOf(d)
self.assertEqual(error, failure.value)
def test_sendFinishStatus_failure(self):
"""
On failure returns the failed deferred.
"""
self.status._getGitHubRepoProperties = lambda build: {}
d = self.status._sendFinishStatus('builder-name', None, None)
result = self.successResultOf(d)
self.assertIdentical(result, None)
def test_sendFinishStatus_ok(self):
"""
When _getGitHubRepoProperties return a dict _sendFinishStatus will
augment it with build result and sent status to GitHub API.
"""
self.status._getGitHubRepoProperties = lambda build: {
'repoOwner': 'repo-owner',
'repoName': 'repo-name',
'sha': '123',
'targetURL': 'http://domain.tld',
'buildNumber': '1',
}
self.status._sendGitHubStatus = Mock(return_value=defer.succeed(None))
self.build.getTimes = lambda: (1, 3)
startDateTime = datetime.datetime.fromtimestamp(1).isoformat(' ')
endDateTime = datetime.datetime.fromtimestamp(3).isoformat(' ')
d = self.status._sendFinishStatus('builder-name', self.build, SUCCESS)
result = self.successResultOf(d)
self.assertIdentical(result, None)
self.status._sendGitHubStatus.assert_called_with({
'repoOwner': 'repo-owner',
'repoName': 'repo-name',
'sha': '123',
'targetURL': 'http://domain.tld',
'buildNumber': '1',
# Augmented arguments.
'state': 'success',
'description': 'Build done.',
'builderName': 'builder-name',
'startDateTime': startDateTime,
'endDateTime': endDateTime,
'duration': '2 seconds',
})
def test_timeDeltaToHumanReadable(self):
"""
It will return a human readable time difference.
"""
result = self.status._timeDeltaToHumanReadable(1, 1)
self.assertEqual('super fast', result)
result = self.status._timeDeltaToHumanReadable(1, 2)
self.assertEqual('1 seconds', result)
result = self.status._timeDeltaToHumanReadable(1, 61)
self.assertEqual('1 minutes', result)
result = self.status._timeDeltaToHumanReadable(1, 62)
self.assertEqual('1 minutes, 1 seconds', result)
result = self.status._timeDeltaToHumanReadable(1, 60 * 60 + 1)
self.assertEqual('1 hours', result)
result = self.status._timeDeltaToHumanReadable(1, 60 * 60 + 61)
self.assertEqual('1 hours, 1 minutes', result)
result = self.status._timeDeltaToHumanReadable(1, 60 * 60 + 62)
self.assertEqual('1 hours, 1 minutes, 1 seconds', result)
result = self.status._timeDeltaToHumanReadable(1, 24 * 60 * 60 + 1)
self.assertEqual('1 days', result)
result = self.status._timeDeltaToHumanReadable(1, 24 * 60 * 60 + 2)
self.assertEqual('1 days, 1 seconds', result)
def test_getGitHubRepoProperties_skip_no_sha(self):
"""
An empty dict is returned when any of the repo name, owner and sha
interpolation returns an empty string or None.
"""
self.build._repoOwner = Interpolate('owner')
self.build._repoName = Interpolate('name')
self.build._sha = Interpolate('')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
self.assertLog('GitHubStatus: No revision found.')
def test_getGitHubRepoProperties_skip_no_owner(self):
self.status._repoOwner = Interpolate('')
self.status._repoName = Interpolate('name')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_skip_no_name(self):
self.status._repoOwner = Interpolate('owner')
self.status._repoName = Interpolate('')
self.status._sha = Interpolate('sha')
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({}, result)
def test_getGitHubRepoProperties_ok(self):
"""
A dictionary with build status properties is returned when
required properties were rendered.
"""
self.status._repoOwner = Interpolate('owner')
self.status._repoName = Interpolate('name')
self.status._sha = Interpolate('sha')
self.status._status = Mock()
self.status._status.getURLForThing = lambda build: 'http://thing'
self.build.getNumber = lambda: 1
d = self.status._getGitHubRepoProperties(self.build)
result = self.successResultOf(d)
self.assertEqual({
'buildNumber': '1',
'repoName': 'name',
'repoOwner': 'owner',
'sha': 'sha',
'targetURL': 'http://thing',
},
result)
def test_getGitHubState(self):
"""
_getGitHubState will try to translate BuildBot status into GitHub
status. For unknown values will fallback to 'error'.
"""
self.assertEqual(
'success', self.status._getGitHubState(SUCCESS))
self.assertEqual(
'failure', self.status._getGitHubState(FAILURE))
self.assertEqual(
'error', self.status._getGitHubState('anything-else'))
def test_sendGitHubStatus_success(self):
"""
sendGitHubStatus will call the txgithub createStatus and encode
all data.
"""
status = {
'repoOwner': u'owner-resum\xe9',
'repoName': u'name-resum\xe9',
'sha': u'sha-resum\xe9',
'state': u'state-resum\xe9',
'targetURL': u'targetURL-resum\xe9',
'description': u'description-resum\xe9',
}
self.status._github.repos.createStatus = Mock(
return_value=defer.succeed(None))
d = self.status._sendGitHubStatus(status)
result = self.successResultOf(d)
self.assertEqual(None, result)
self.status._github.repos.createStatus.assert_called_with(
repo_name='name-resum\xc3\xa9',
repo_user='******',
sha='sha-resum\xc3\xa9',
state='state-resum\xc3\xa9',
target_url='targetURL-resum\xc3\xa9',
description='description-resum\xc3\xa9',
)
self.assertLog(
u'Status "state-resum\xe9" sent for '
u'owner-resum\xe9/name-resum\xe9 at sha-resum\xe9.'
)
def test_sendGitHubStatus_error(self):
"""
sendGitHubStatus will log an error if txgithub sendGitHubStatus fails.
"""
status = {
'repoOwner': u'owner',
'repoName': u'name',
'sha': u'sha',
'state': u'state',
'targetURL': u'targetURL',
'description': u'description',
}
error = MarkerError('fail-send-status')
self.status._github.repos.createStatus = Mock(
return_value=defer.fail(error))
self.status._sendGitHubStatus(status)
self.assertLogError(
error,
u'Fail to send status "state" for owner/name at sha.')
def setUp(self):
super(TestGitHubStatus2, self).setUp()
self.status = GitHubStatus(
token='token', repo='owner/name')
def setUp(self):
super(TestGitHubStatus2, self).setUp()
self.status = GitHubStatus(token='token', repo='owner/name')