class CreateOrUpdateShortcutTest(TestCase):
def setUp(self):
self.squad = Squad()
SquadApi.configure(
url="http://localhost:%s" % settings.DEFAULT_SQUAD_PORT,
token="193cd8bb41ab9217714515954e8724f651ef8601",
)
self.group_slug = 'my_group'
def assertEqualProjects(self, project1, project2):
self.assertEqual(project1.id, project2.id)
self.assertEqual(project1.name, project2.name)
self.assertEqual(project1.description, project2.description)
self.assertEqual(project1.is_public, project2.is_public)
self.assertEqual(project1.html_mail, project2.html_mail)
self.assertEqual(project1.moderate_notifications,
project2.moderate_notifications)
self.assertEqual(project1.is_archived, project2.is_archived)
self.assertEqual(project1.enabled_plugins_list,
project2.enabled_plugins_list)
self.assertEqual(project1.important_metadata_keys,
project2.important_metadata_keys)
self.assertEqual(project1.wait_before_notification,
project2.wait_before_notification)
self.assertEqual(project1.notification_timeout,
project2.notification_timeout)
self.assertEqual(project1.data_retention_days,
project2.data_retention_days)
def test_minimum_parameters(self):
project_slug = 'project-with-minimum-parameteres'
project, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
)
self.assertIsNotNone(project)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqual(check_project.id, project.id)
project.delete()
def test_all_parameters(self):
project_slug = 'project-with-all-parameteres'
project, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='project name',
description='project description',
settings='{"SETTING_KEY": "SETTING VALUE"}',
is_public=True,
html_mail=False,
moderate_notifications=False,
is_archived=False,
plugins=['linux-log-parser'],
important_metadata_keys="important-key-1,important key 2",
wait_before_notification_timeout=60,
notification_timeout=120,
data_retention=1,
)
self.assertIsNotNone(project)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqualProjects(check_project, project)
project.delete()
def test_overwrite(self):
project_slug = 'project-with-overwritten-data'
project, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name',
)
self.assertIsNotNone(project)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqual(check_project.id, project.id)
self.assertEqual(check_project.name, project.name)
project_edited, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name edited',
overwrite=True,
)
self.assertIsNotNone(project_edited)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqual(check_project.id, project_edited.id)
self.assertEqual(check_project.name, project_edited.name)
project_edited.delete()
def test_overwrite_selected_fields_only(self):
project_slug = 'project-with-overwritten-data-specific-fields-only'
description = 'project description'
settings = '{"SETTING_KEY": "SETTING VALUE"}'
is_public = True
html_mail = False
moderate_notifications = False
is_archived = False
plugins = ['linux-log-parser']
important_metadata_keys = 'important-key-1,important key 2'
wait_before_notification_timeout = 60
notification_timeout = 120
data_retention = 1
project, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name',
description=description,
settings=settings,
is_public=is_public,
html_mail=html_mail,
moderate_notifications=moderate_notifications,
is_archived=is_archived,
plugins=plugins,
important_metadata_keys=important_metadata_keys,
wait_before_notification_timeout=wait_before_notification_timeout,
notification_timeout=notification_timeout,
data_retention=data_retention,
)
self.assertIsNotNone(project)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqualProjects(check_project, project)
project_edited, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name edited',
overwrite=True,
)
self.assertIsNotNone(project_edited)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqualProjects(check_project, project_edited)
self.assertEqual(description, project_edited.description)
self.assertEqual(is_public, project_edited.is_public)
self.assertEqual(html_mail, project_edited.html_mail)
self.assertEqual(moderate_notifications,
project_edited.moderate_notifications)
self.assertEqual(is_archived, project_edited.is_archived)
self.assertEqual(plugins, project_edited.enabled_plugins_list)
self.assertEqual(important_metadata_keys,
project_edited.important_metadata_keys)
self.assertEqual(wait_before_notification_timeout,
project_edited.wait_before_notification)
self.assertEqual(notification_timeout,
project_edited.notification_timeout)
self.assertEqual(data_retention, project_edited.data_retention_days)
project_edited.delete()
def test_no_overwrite(self):
project_slug = 'project-without-overwritten-data'
project, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name',
)
self.assertIsNotNone(project)
self.assertEqual(0, len(errors))
check_project = first(
self.squad.projects(group__slug=self.group_slug,
slug=project_slug))
self.assertEqual(check_project.id, project.id)
self.assertEqual(check_project.name, project.name)
project_edited, errors = create_or_update_project(
group_slug=self.group_slug,
slug=project_slug,
name='new name edited',
overwrite=False,
)
self.assertIsNone(project_edited)
self.assertEqual(1, len(errors))
self.assertEqual(['Project exists already'], errors)
project.delete()
class SquadTest(unittest.TestCase):
def setUp(self):
self.squad = Squad()
def test_groups(self):
groups = self.squad.groups()
self.assertTrue(True, len(groups))
def test_not_found_groups(self):
groups = self.squad.groups(name__startswith='no group with this name')
self.assertEqual(0, len(groups))
def test_groups_with_count(self):
all_groups = self.squad.groups(count=ALL)
self.assertEqual(2, len(all_groups))
one_groups = self.squad.groups(count=1)
self.assertEqual(1, len(one_groups))
def test_not_found_group(self):
not_found_group = self.squad.group('this-group-does-not-really-exist')
self.assertEqual(None, not_found_group)
def test_group(self):
group = self.squad.group('my_group')
self.assertTrue(group is not None)
def test_projects(self):
projects = self.squad.projects()
self.assertTrue(True, len(projects))
def test_builds(self):
builds = self.squad.builds()
self.assertTrue(True, len(builds))
def test_testjobs(self):
testjobs = self.squad.testjobs()
self.assertTrue(True, len(testjobs))
def test_testruns(self):
testruns = self.squad.testruns()
self.assertTrue(True, len(testruns))
def test_tests(self):
tests = self.squad.tests()
self.assertTrue(True, len(tests))
def test_suites(self):
suites = self.squad.suites()
self.assertTrue(True, len(suites))
def test_environments(self):
environments = self.squad.environments()
self.assertTrue(True, len(environments))
def test_backends(self):
backends = self.squad.backends()
self.assertTrue(True, len(backends))
def test_emailtemplates(self):
emailtemplates = self.squad.emailtemplates()
self.assertTrue(True, len(emailtemplates))
def test_knownissues(self):
knownissues = self.squad.knownissues()
self.assertTrue(True, len(knownissues))
def test_suitemetadata(self):
suitemetadata = self.squad.suitemetadata()
self.assertTrue(True, len(suitemetadata))
def test_annotations(self):
annotations = self.squad.annotations()
self.assertTrue(True, len(annotations))
def test_metricthresholds(self):
metricthresholds = self.squad.metricthresholds()
self.assertTrue(True, len(metricthresholds))
def test_reports(self):
reports = self.squad.reports()
self.assertTrue(True, len(reports))
class CreateOrUpdateProjectTest(TestCase):
def setUp(self):
self.squad = Squad()
self.testing_server = 'http://localhost:%s' % settings.DEFAULT_SQUAD_PORT
self.testing_token = '193cd8bb41ab9217714515954e8724f651ef8601'
SquadApi.configure(self.testing_server, self.testing_token)
self.group = 'my_group'
self.slug = 'create-project-via-cmdline'
def manage_create_or_update_project(self,
group=None,
slug=None,
name=None,
description=None,
settings=None,
is_public=None,
html_mail=None,
moderate_notifications=None,
is_archived=None,
email_template=None,
plugins=None,
important_metadata_keys=None,
wait_before_notification_timeout=None,
notification_timeout=None,
data_retention=None,
no_overwrite=False,
thresholds=None,
build_confidence_count=None,
build_confidence_threshold=None):
argv = [
'./manage.py', '--squad-host', self.testing_server,
'--squad-token', self.testing_token, 'create-or-update-project'
]
if group:
argv += ['--group', group]
if slug:
argv += ['--slug', slug]
if name:
argv += ['--name', name]
if description:
argv += ['--description', description]
if settings:
argv += ['--settings', settings]
if is_public is not None:
argv += ['--is-public'] if is_public else ['--is-private']
if html_mail is not None:
argv += ['--html-mail'] if html_mail else ['--no-html-mail']
if moderate_notifications is not None:
argv += [
'--moderate-notifications'
] if moderate_notifications else ['--no-moderate-notifications']
if is_archived is not None and is_archived:
argv += ['--is-archived']
if email_template:
argv += ['--email-template', email_template]
if plugins and len(plugins):
argv += ['--plugins', ','.join(plugins)]
if important_metadata_keys and len(important_metadata_keys):
argv += [
'--important-metadata-keys', ','.join(important_metadata_keys)
]
if wait_before_notification_timeout is not None:
argv += [
'--wait-before-notification-timeout',
str(wait_before_notification_timeout)
]
if notification_timeout is not None:
argv += ['--notification-timeout', str(notification_timeout)]
if data_retention is not None:
argv += ['--data-retention', str(data_retention)]
if no_overwrite:
argv += ['--no-overwrite']
if thresholds:
argv += ['--thresholds'] + thresholds
if build_confidence_count:
argv += ['--build_confidence_count', str(build_confidence_count)]
if build_confidence_threshold:
argv += [
'build_confidence_threshold',
str(build_confidence_threshold)
]
proc = sp.Popen(argv, stdout=sp.PIPE, stderr=sp.PIPE)
proc.ok = False
try:
out, err = proc.communicate()
proc.ok = (proc.returncode == 0)
except sp.TimeoutExpired:
self.logger.error('Running "%s" time out after %i seconds!' %
' '.join(argv))
proc.kill()
out, err = proc.communicate()
proc.out = out.decode('utf-8')
proc.err = err.decode('utf-8')
return proc
def test_empty(self):
proc = self.manage_create_or_update_project()
self.assertFalse(proc.ok)
self.assertIn('the following arguments are required: --group, --slug',
proc.err)
def test_basics(self):
proc = self.manage_create_or_update_project(group=self.group,
slug=self.slug)
self.assertTrue(proc.ok)
project = first(
self.squad.projects(group__slug=self.group, slug=self.slug))
self.assertIsNotNone(project)
self.assertIn('Project saved', proc.out)
def test_no_overwrite(self):
proc = self.manage_create_or_update_project(group=self.group,
slug=self.slug)
self.assertTrue(proc.ok)
proc = self.manage_create_or_update_project(group=self.group,
slug=self.slug,
name='trying to edit',
no_overwrite=True)
self.assertFalse(proc.ok)
self.assertIn('Project exists already', proc.err)
def test_all_parameters(self):
name = 'new name'
description = 'project description'
settings = '{"SETTING_KEY": "SETTING VALUE"}'
is_public = True
html_mail = False
moderate_notifications = False
is_archived = False
plugins = ['linux-log-parser']
important_metadata_keys = ['important-key-1', 'important key 2']
wait_before_notification_timeout = 60
notification_timeout = 120
data_retention = 1
thresholds = ["my-threshold"]
build_confidence_count = 25
build_confidence_threshold = 95
proc = self.manage_create_or_update_project(
group=self.group,
slug=self.slug,
name=name,
description=description,
settings=settings,
is_public=is_public,
html_mail=html_mail,
moderate_notifications=moderate_notifications,
is_archived=is_archived,
plugins=plugins,
important_metadata_keys=important_metadata_keys,
wait_before_notification_timeout=wait_before_notification_timeout,
notification_timeout=notification_timeout,
data_retention=data_retention,
thresholds=thresholds,
build_confidence_count=build_confidence_count,
build_confidence_threshold=build_confidence_threshold,
)
self.assertTrue(proc.ok)
project = first(
self.squad.projects(group__slug=self.group, slug=self.slug))
self.assertIsNotNone(project)
self.assertIn('Project saved', proc.out)
self.assertIn('MetricThreshold saved', proc.out)
self.assertEqual(description, project.description)
self.assertEqual(settings, project.project_settings)
self.assertEqual(is_public, project.is_public)
self.assertEqual(html_mail, project.html_mail)
self.assertEqual(moderate_notifications,
project.moderate_notifications)
self.assertEqual(is_archived, project.is_archived)
self.assertEqual(plugins, project.enabled_plugins_list)
self.assertEqual('\n'.join(important_metadata_keys),
project.important_metadata_keys)
self.assertEqual(wait_before_notification_timeout,
project.wait_before_notification)
self.assertEqual(notification_timeout, project.notification_timeout)
self.assertEqual(data_retention, project.data_retention_days)
self.assertEqual(1, len(project.thresholds().values()))
threshold = first(project.thresholds())
self.assertEqual(thresholds[0], threshold.name)
self.assertEqual(build_confidence_count,
project.build_confidence_count)
self.assertEqual(build_confidence_threshold,
project.build_confidence_threshold)
def main(args):
# Some configuration, might get parameterized later
group_slug = args.get('group', None)
suite_slug = args.get('suite', None)
SquadApi.configure(args.get('squadapi_url', None))
number_of_builds = args.get('number', None)
squad = Squad()
getid = lambda s: int(re.search('\d+', s).group())
# First we need to know which projects from the selected group
# contain the specified suite.
print('Fetching projects that contain "%s" suites for "%s" group' %
(suite_slug, group_slug),
flush=True)
suites = squad.suites(slug=suite_slug, project__group__slug=group_slug)
projects_ids = list(
set([str(getid(suite.project)) for suite in suites.values()]))
projects = squad.projects(id__in=','.join(projects_ids),
ordering='slug').values()
# Env/arch cache
environments = set()
# Table will be layed out like below
# table = {
# 'kernelA': {
# 'buildA': {
# 'summary': {
# 'envA': {'pass': 1, 'fail': 2, 'skip': 3},
# 'envB': {'pass': 1, 'fail': 2, 'skip': 3},
# }
# 'envA': [
# {'kunit/test1': 'pass'}
# {'kunit/test2': 'fail'}
# ]
# },
# }
# }
table = {}
if number_of_builds == "0":
for project in projects:
print('- %s' % project.slug, flush=True)
return
for project in projects:
print('- %s: fetching %s builds' % (project.slug, number_of_builds),
flush=True)
environments = project.environments(count=ALL)
for build in project.builds(count=int(number_of_builds),
ordering='-id').values():
print(' - %s: fetching tests' % build.version, flush=True)
results = {'summary': defaultdict(dict)}
for test in build.tests(suite__slug=suite_slug).values():
env = environments[getid(test.environment)].slug
if test.status not in results['summary'][env]:
results['summary'][env][test.status] = 0
results['summary'][env][test.status] += 1
if env not in results:
results[env] = []
results[env].append((test.name, test.status))
if len(results['summary']):
print(' - summary:', flush=True)
summary = results.pop('summary')
for env in sorted(summary.keys()):
print(' - %s: %s' % (env, summary[env]), flush=True)
for env in sorted(results.keys()):
print(' - %s:' % env, flush=True)
for test in sorted(results[env], key=lambda d: d[0]):
print(' - %s: %s' % (test[0], test[1]),
flush=True)
