def test_is_message_needed_tags(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
# force tags
build['builder']['tags'] = ['fast']
g = BuildStatusGenerator(tags=["fast"])
self.assertTrue(g.is_message_needed_by_props(build))
def test_is_message_needed_tags(self):
_, builds = yield self.setupBuildResults(SUCCESS)
build = builds[0]
# force tags
build['builder']['tags'] = ['fast']
g = BuildStatusGenerator(tags=["fast"])
self.assertTrue(g.is_message_needed(build))
def test_is_message_needed_ignores_unspecified_tags(self):
_, builds = yield self.setupBuildResults(SUCCESS)
build = builds[0]
# force tags
build['builder']['tags'] = ['slow']
g = BuildStatusGenerator(tags=["fast"])
self.assertFalse(g.is_message_needed(build))
def run_simple_test_sends_message_for_mode(self,
mode,
result,
should_send=True):
build = yield self.insert_build_finished_get_props(result)
g = BuildStatusGenerator(mode=mode)
self.assertEqual(g.is_message_needed_by_results(build), should_send)
def run_sends_message_for_problems(self, mode, results1, results2, should_send=True):
_, builds = yield self.setupBuildResults(results2)
g = BuildStatusGenerator(mode=mode)
build = builds[0]
if results1 is not None:
build['prev_build'] = copy.deepcopy(builds[0])
build['prev_build']['results'] = results1
else:
build['prev_build'] = None
self.assertEqual(g.is_message_needed(builds[0]), should_send)
def run_sends_message_for_problems(self,
mode,
results1,
results2,
should_send=True):
build = yield self.insert_build_finished_get_props(results2)
g = BuildStatusGenerator(mode=mode)
if results1 is not None:
build['prev_build'] = copy.deepcopy(build)
build['prev_build']['results'] = results1
else:
build['prev_build'] = None
self.assertEqual(g.is_message_needed_by_results(build), should_send)
def test_createEmail_message_with_patch_and_log_containing_unicode(self):
build = yield self.insert_build_finished(SUCCESS)
msgdict = create_msgdict()
patches = [{'body': '\u00E5\u00E4\u00F6'}]
logs = yield self.master.data.get(("steps", 50, 'logs'))
for l in logs:
l['stepname'] = "fakestep"
l['content'] = yield self.master.data.get(("logs", l['logid'], 'contents'))
mn = yield self.setupMailNotifier('*****@*****.**',
generators=[BuildStatusGenerator(add_logs=True)])
m = yield mn.createEmail(msgdict, 'builder-n\u00E5me',
'project-n\u00E5me', SUCCESS,
[build], patches, logs)
try:
s = m.as_string()
# python 2.6 default transfer in base64 for utf-8
if "base64" not in s:
self.assertIn("Unicode log", s)
else: # b64encode and remove '=' padding (hence [:-1])
logStr = bytes2unicode(base64.b64encode(b"Unicode log")[:-1])
self.assertIn(logStr, s)
self.assertIn(
'Content-Disposition: attachment; filename="fakestep.stdio"', s)
except UnicodeEncodeError:
self.fail('Failed to call as_string() on email message.')
def setupBuildMessage(self, **generator_kwargs):
build = yield self.insert_build_finished(SUCCESS)
formatter = Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
formatter.wantProperties = False
formatter.wantSteps = False
formatter.wantLogs = False
generator = BuildStatusGenerator(message_formatter=formatter, **generator_kwargs)
mn = yield self.setupMailNotifier('*****@*****.**', generators=[generator])
mn.findInterrestedUsersEmails = Mock(
spec=mn.findInterrestedUsersEmails)
mn.findInterrestedUsersEmails.return_value = "<recipients>"
mn.processRecipients = Mock(spec=mn.processRecipients)
mn.processRecipients.return_value = "<processedrecipients>"
mn.createEmail = Mock(spec=mn.createEmail)
mn.createEmail.return_value = "<email>"
mn.sendMail = Mock(spec=mn.sendMail)
yield mn._got_event(('builds', 10, 'finished'), build)
return (mn, build, formatter)
def do_test_sendMessage(self, **mn_kwargs):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[
5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
build = yield self.insert_build_finished(SUCCESS)
formatter = Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
formatter.wantProperties = False
formatter.wantSteps = False
formatter.wantLogs = False
generator = BuildStatusGenerator(message_formatter=formatter)
mn = yield self.setupMailNotifier('*****@*****.**', generators=[generator], **mn_kwargs)
mn.findInterrestedUsersEmails = Mock(
spec=mn.findInterrestedUsersEmails)
mn.findInterrestedUsersEmails.return_value = list("<recipients>")
mn.processRecipients = Mock(spec=mn.processRecipients)
mn.processRecipients.return_value = list("<processedrecipients>")
mn.createEmail = Mock(spec=mn.createEmail)
mn.createEmail.return_value.as_string = Mock(return_value="<email>")
yield mn._got_event(('builds', 10, 'finished'), build)
return (mn, build)
def setup_build_message(self, **kwargs):
_, builds = yield self.setupBuildResults(SUCCESS)
g = BuildStatusGenerator(**kwargs)
g.formatter = Mock(spec=g.formatter)
g.formatter.formatMessageForBuildResults.return_value = {"body": "body",
"type": "text",
"subject": "subject"}
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.build_message(self.master, reporter, "mybldr", builds, SUCCESS)
return (g, builds, report)
def setupBuildMessage(self, old_style=False, **mnKwargs):
build = yield self.insert_build_finished(FAILURE)
formatter = mock.Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
formatter.wantProperties = False
formatter.wantSteps = False
formatter.wantLogs = False
if old_style:
with assertProducesWarnings(
DeprecatedApiWarning,
message_pattern='have been deprecated'):
mn = yield self.setupNotifier(old_style=True,
messageFormatter=formatter,
**mnKwargs)
else:
generator_kwargs = {}
if 'mode' in mnKwargs:
generator_kwargs['mode'] = mnKwargs.pop('mode')
generator = BuildStatusGenerator(message_formatter=formatter,
**generator_kwargs)
mn = yield self.setupNotifier(generators=[generator], **mnKwargs)
yield mn._got_event(('builds', 20, 'finished'), build)
return (mn, build, formatter)
def _create_generators_from_old_args(self, builders, want_properties, want_steps,
want_previous_build, want_logs):
formatter = MessageFormatterEmpty(wantProperties=want_properties, wantSteps=want_steps,
wantLogs=want_logs)
return [
BuildStatusGenerator(builders=builders, message_formatter=formatter, report_new=True,
_want_previous_build=want_previous_build)
]
def masterConfig(build_set_summary):
c = {}
from buildbot.config import BuilderConfig
from buildbot.process.factory import BuildFactory
from buildbot.plugins import steps, schedulers, reporters
c['schedulers'] = [
schedulers.AnyBranchScheduler(
name="sched",
builderNames=["testy"])
]
f = BuildFactory()
f.addStep(steps.ShellCommand(command='echo hello'))
c['builders'] = [
BuilderConfig(name="testy",
workernames=["local1"],
factory=f)
]
formatter = MessageFormatter(template='This is a message.')
formatter_worker = MessageFormatterMissingWorker(template='No worker.')
if build_set_summary:
generators_mail = [
BuildSetStatusGenerator(mode='all'),
WorkerMissingGenerator(workers='all'),
]
generators_pushover = [
BuildSetStatusGenerator(mode='all', message_formatter=formatter),
WorkerMissingGenerator(workers=['local1'], message_formatter=formatter_worker),
]
else:
generators_mail = [
BuildStatusGenerator(mode='all'),
WorkerMissingGenerator(workers='all'),
]
generators_pushover = [
BuildStatusGenerator(mode='all', message_formatter=formatter),
WorkerMissingGenerator(workers=['local1'], message_formatter=formatter_worker),
]
c['services'] = [
reporters.MailNotifier("*****@*****.**", generators=generators_mail),
reporters.PushoverNotifier('1234', 'abcd', generators=generators_pushover)
]
return c
def _create_default_generators(self):
return [
BuildStatusGenerator(
add_patch=True,
message_formatter=MessageFormatter(template_type='html')),
WorkerMissingGenerator(
workers='all',
message_formatter=MessageFormatterMissingWorker(template_type='html')),
]
def setup_generator(self,
results=SUCCESS,
message=None,
db_args=None,
**kwargs):
if message is None:
message = {"body": "body", "type": "text", "subject": "subject"}
if db_args is None:
db_args = {}
build = yield self.insert_build_finished_get_props(results, **db_args)
g = BuildStatusGenerator(**kwargs)
g.formatter = Mock(spec=g.formatter)
g.formatter.format_message_for_build.return_value = message
return (g, build)
def setupBuildMessage(self, **kwargs):
build = yield self.insert_build_finished(FAILURE)
formatter = mock.Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
formatter.wantProperties = False
formatter.wantSteps = False
formatter.wantLogs = False
generator = BuildStatusGenerator(message_formatter=formatter, **kwargs)
mn = yield self.setupNotifier(generators=[generator])
yield mn._got_event(('builds', 20, 'finished'), build)
return (mn, build, formatter)
def create_generators_from_old_args(self, mode, tags, builders, build_set_summary,
message_formatter, subject, add_logs, add_patch, schedulers,
branches, watched_workers,
message_formatter_missing_worker):
generators = []
if build_set_summary:
generators.append(BuildSetStatusGenerator(mode=mode, tags=tags, builders=builders,
schedulers=schedulers, branches=branches,
subject=subject, add_logs=add_logs,
add_patch=add_patch,
message_formatter=message_formatter))
else:
generators.append(BuildStatusGenerator(mode=mode, tags=tags, builders=builders,
schedulers=schedulers, branches=branches,
subject=subject, add_logs=add_logs,
add_patch=add_patch,
message_formatter=message_formatter))
if watched_workers is not None and len(watched_workers) > 0:
generators.append(
WorkerMissingGenerator(workers=watched_workers,
message_formatter=message_formatter_missing_worker))
return generators
def test_is_message_needed_branches_doesnt_send_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = BuildStatusGenerator(branches=['some-random-branch'])
self.assertFalse(g.is_message_needed_by_props(build))
def test_is_message_needed_branches_doesnt_send_mail(self):
_, builds = yield self.setupBuildResults(SUCCESS)
build = builds[0]
g = BuildStatusGenerator(branches=['some-random-branch'])
self.assertFalse(g.is_message_needed(build))
def run_simple_test_sends_message_for_mode(self, mode, result, should_send=True):
_, builds = yield self.setupBuildResults(result)
g = BuildStatusGenerator(mode=mode)
self.assertEqual(g.is_message_needed(builds[0]), should_send)
def _create_default_generators(self):
formatter = MessageFormatter(template_type='html', template=DEFAULT_MSG_TEMPLATE)
return [BuildStatusGenerator(message_formatter=formatter)]
))
if hasattr(config, 'discord_reporter') and config.discord_reporter:
from utils import discord
from buildbot.reporters.generators.buildset import BuildSetStatusGenerator
from buildbot.reporters.generators.build import BuildStatusGenerator
services.append(discord.DiscordStatusPush(config.discord_reporter,
generators=[
BuildSetStatusGenerator(
message_formatter=discord.DiscordFormatter(),
# Only report builder aggregated in a buildset and not fetch or nightly
tags=['build'],
mode=("change", "exception")),
BuildStatusGenerator(
message_formatter=discord.DiscordFormatter(),
# Report cleanup too
tags=['cleanup'],
mode=("change", "exception"))
]))
if hasattr(config, 'enable_list_snapshots') and config.enable_list_snapshots:
serve_snapshots = hasattr(config, 'serve_snapshots') and config.serve_snapshots
import builds, platforms
from utils import list_snapshots
from utils import scummsteps
www['plugins']['wsgi_dashboards'] = [{
'name': 'snapshots',
'caption': 'Snapshots',
'app': list_snapshots.get_application(
(scummsteps.create_names, scummsteps.parse_package_name),
config.snapshots_dir, config.snapshots_url,
def _create_default_generators(self):
return [
BuildStatusGenerator(add_patch=True),
WorkerMissingGenerator(workers='all'),
]
def test_is_message_needed_schedulers_sends_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = BuildStatusGenerator(schedulers=['checkin'])
self.assertTrue(g.is_message_needed_by_props(build))
def _generators(self) -> list[BuildStatusGenerator]:
formatter = MessageFormatter(template_type="plain",
subject=subject_template)
return [BuildStatusGenerator(message_formatter=formatter)]
def test_subject_newlines_not_allowed(self):
g = BuildStatusGenerator(subject='subject\nwith\nnewline')
with self.assertRaisesConfigError('Newlines are not allowed'):
g.check()
def test_list_params_check_raises(self, arg_name, arg_value):
kwargs = {arg_name: arg_value}
g = BuildStatusGenerator(**kwargs)
with self.assertRaisesConfigError('must be a list or None'):
g.check()
def _create_default_generators(self):
return [BuildStatusGenerator()]
def _create_default_generators(self):
formatter = MessageFormatterFunction(lambda context: context['build'],
'json')
return [
BuildStatusGenerator(message_formatter=formatter, report_new=True)
]
def test_is_message_needed_branches_sends_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = BuildStatusGenerator(branches=['refs/pull/34/merge'])
self.assertTrue(g.is_message_needed_by_props(build))