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)