def test_server_response(self):
# will require automatic test server to shutdown, for now, just to it by hand before running this test
if not is_test_server_running():
with self.assertRaises(ApiException):
SquadApi.get('/api/groups')
else:
self.assertTrue(SquadApi.get('/api/groups') is not None)
def setUp(self):
SquadApi.configure(url='http://localhost:%s' %
settings.DEFAULT_SQUAD_PORT,
token='193cd8bb41ab9217714515954e8724f651ef8601')
self.project = first(Squad().projects(slug='my_project'))
self.build = first(Squad().builds(version='my_build'))
self.build2 = first(Squad().builds(version='my_build2'))
def setUp(self):
self.squad = Squad()
SquadApi.configure(
url="http://localhost:%s" % settings.DEFAULT_SQUAD_PORT,
token="193cd8bb41ab9217714515954e8724f651ef8601",
)
self.group_slug = 'my_group'
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 setUp(self):
self.squad = Squad()
SquadApi.configure(url=self.testing_server, token=self.testing_token)
self.root_dir = os.path.join("tests", "data", "submit_tuxbuild")
self.assertTrue(os.path.exists(self.root_dir))
self.build_dir = os.path.join(self.root_dir, "build-x86-gcc")
self.assertTrue(os.path.exists(self.build_dir))
self.buildset_dir = os.path.join(self.root_dir, "buildset-x86")
self.assertTrue(os.path.exists(self.buildset_dir))
def test_unauthorized_access(self):
with self.assertRaises(ApiException):
SquadApi.get('/my_group/my_private_project')
SquadApi.configure(url='http://localhost:%s' %
settings.DEFAULT_SQUAD_PORT,
token='193cd8bb41ab9217714515954e8724f651ef8601')
response = SquadApi.get('/my_group/my_private_project')
self.assertTrue(response.ok)
# reset config
self.setUp()
def send_to_qa_reports(self):
if None in (self.qa_reports_server, self.qa_reports_token, self.qa_reports_group, self.qa_reports_project, self.qa_reports_build_version, self.qa_reports_env):
self.logger.warning("All parameters for qa reports are not set, results will not be pushed to qa reports")
return
SquadApi.configure(
url=self.qa_reports_server, token=self.qa_reports_token
)
tests = {}
metrics = {}
for metric in self.metrics:
if metric['measurement'] != "":
metrics["{}/{}".format(self.test['test_name'], metric['test_case_id'])] = metric['measurement']
else:
tests["{}/{}".format(self.test['test_name'], metric['test_case_id'])] = metric['result']
with open("{}/stdout.log".format(self.test['test_path']), "r") as logfile:
log = logfile.read()
metadata = {}
if not self.qa_reports_disable_metadata:
if self.qa_reports_metadata:
metadata.update(self.qa_reports_metadata)
if self.qa_reports_metadata_file:
try:
with open(self.qa_reports_metadata_file, "r") as metadata_file:
loaded_metadata = yaml.load(metadata_file, Loader=yaml.SafeLoader)
# check if loaded metadata is key=value and both are strings
for key, value in loaded_metadata.items():
if type(key) == str and type(value) == str:
# only update metadata with simple keys
# ignore all other items in the dictionary
metadata.update({key: value})
else:
self.logger.warning("Ignoring key: %s" % key)
except FileNotFoundError:
self.logger.warning("Metadata file not found")
except PermissionError:
self.logger.warning("Insufficient permissions to open metadata file")
if submit_results(
group_project_slug="{}/{}".format(self.qa_reports_group, self.qa_reports_project),
build_version=self.qa_reports_build_version,
env_slug=self.qa_reports_env,
tests=tests,
metrics=metrics,
log=log,
metadata=metadata,
attachments=None):
self.logger.info("Results pushed to QA Reports")
else:
self.logger.warning("Results upload to QA Reports failed!")
def generate(self):
for report in self.reports:
SquadApi.configure(self.squad_url, self.token)
output = report.generate()
if report.output is None:
# print to stdout
print(output)
elif type(report.output) is StringIO:
report.output.write(output)
elif type(report.output) is str and path.isfile(report.output):
with open(report.output, 'w') as f:
f.write(output)
else:
raise InvalidReportOutput('Report "%s" output configuration is neither None, a file or StringIO object' % report.name)
return self.reports
def main():
parser = argparse.ArgumentParser(prog='./manage.py')
parser.add_argument('--debug',
action='store_true',
help='display debug messages')
parser.add_argument(
'--squad-host',
help='SQUAD host, example: https://qa-reports.linaro.org')
parser.add_argument('--squad-token', help='SQUAD authentication token')
parser.add_argument(
'--cache',
default=0,
help='Cache API results for N number of seconds. Disabled by default.')
subparser = parser.add_subparsers(help='available subcommands',
dest='command')
SquadClientCommand.add_commands(subparser)
args = parser.parse_args()
if args.command is None:
parser.print_help()
return -1
if args.command != 'test':
squad_host = args.squad_host or os.getenv('SQUAD_HOST')
squad_token = args.squad_token or os.getenv('SQUAD_TOKEN')
if squad_host is None:
logger.error(
'Either --squad-host or SQUAD_HOST env variable are required')
return -1
try:
SquadApi.configure(squad_host, token=squad_token)
except ApiException as e:
logger.error('Failed to configure squad api: %s' % e)
return -1
if args.cache > 0:
logger.debug(
'Caching results in "squad_client_cache.sqlite" for %d seconds' %
args.cache)
requests_cache.install_cache('squad_client_cache',
expire_after=args.cache)
rc = SquadClientCommand.process(args)
return 1 if rc is False else 0 if rc is True else -1
def main(args):
# Some configuration, might get parameterized later
SquadApi.configure(args.get('squadapi_url', None))
squad = Squad()
getid = lambda s: int(re.search('\d+', s).group())
group = squad.group(args.get('group', None))
project = group.project(args.get('project', None))
bad_suite = project.suite(args.get('suite', None))
bad_test = args.get('test', None)
bad_build = project.build(args.get('kernel_build', None))
bad_env = project.environment(args.get('arch', None))
# sh environment on build next-20201210
#bad_build = project.build('next-20201210')
#bad_env = project.environment('sh')
# now with arm64 on build next-20201204
#bad_build = project.build('next-20201204')
#bad_env = project.environment('arm64')
# now with parisc on build next-20201124 (it should not return anything)
#bad_build = project.build('next-20201124')
#bad_env = project.environment('parisc')
print('Looking at the next good build in %s/%s for build %s' %
(group.slug, project.slug, bad_build.version),
flush=True)
tests = squad.tests(build__created_at__lt=bad_build.created_at,
suite=bad_suite.id,
environment=bad_env.id,
metadata__name=bad_test,
ordering='-build_id',
result=True,
count=1)
if len(tests):
test = first(tests)
build = Build(getid(test.build))
print('%s: https://qa-reports.linaro.org/%s/%s/build/%s' %
(build.version, group.slug, project.slug, build.version))
else:
print('No good build')
def main():
parser = argparse.ArgumentParser(prog='./manage.py')
parser.add_argument('--debug', action='store_true', help='display debug messages')
parser.add_argument('--squad-host', help='SQUAD host, example: https://qa-reports.linaro.org')
parser.add_argument('--squad-token', help='SQUAD authentication token')
parser.add_argument('--cache', default=0, help='Cache API results for N number of seconds. Disabled by default.')
parser.add_argument('--version', action='store_true', help='Display versions of squad-client and server')
subparser = parser.add_subparsers(help='available subcommands', dest='command')
SquadClientCommand.add_commands(subparser)
args = parser.parse_args()
if args.debug:
logging.setLevel(logging.DEBUG)
if args.command not in ['test']:
squad_host = args.squad_host or os.getenv('SQUAD_HOST')
squad_token = args.squad_token or os.getenv('SQUAD_TOKEN')
if squad_host is None:
logger.error('Either --squad-host or SQUAD_HOST env variable are required')
return -1
try:
SquadApi.configure(squad_host, token=squad_token, cache=args.cache)
except ApiException as e:
logger.error('Failed to configure squad api: %s' % e)
return -1
if args.version:
print('squad-client: %s' % squad_client_version)
print('squad server: %s' % SquadApi.version)
return 0
if args.command is None:
parser.print_help()
return -1
rc = SquadClientCommand.process(args)
return 1 if rc is False else 0 if rc is True else -1
def setUp(self):
SquadApi.configure(url='http://localhost:%s' %
settings.DEFAULT_SQUAD_PORT,
token='193cd8bb41ab9217714515954e8724f651ef8601')
self.group = first(Squad().groups(slug='my_group'))
def setUp(self):
self.squad = Squad()
SquadApi.configure(url=self.testing_server, token=self.testing_token)
def setUp(self):
self.squad = Squad()
SquadApi.configure(url="http://localhost:%s" %
settings.DEFAULT_SQUAD_PORT)
#!/usr/bin/env python3
import os
import jinja2
import sys
sys.path.append('..')
from squad_client.core.api import SquadApi
from squad_client.core.models import Squad
SquadApi.configure(url='https://qa-reports.linaro.org/', token=os.getenv('QA_REPORTS_TOKEN'))
group = Squad().group('schneider')
project = group.project('schneider')
build = project.build('184')
testruns = build.testruns(bucket_suites=True, completed=True).values()
templateLoader = jinja2.FileSystemLoader(searchpath="./")
templateEnv = jinja2.Environment(loader=templateLoader)
TEMPLATE_FILE = "schneider_template.html"
template = templateEnv.get_template(TEMPLATE_FILE)
outputText = template.render(group=group, project=project, build=build, testruns=testruns)
with open('schneider_generated_report.html', 'w') as reportFile:
reportFile.write(outputText)
def setUp(self):
SquadApi.configure(url='http://localhost:%s' %
settings.DEFAULT_SQUAD_PORT)
def test_malformed_url(self):
with self.assertRaises(ApiException):
SquadApi.configure('http:/malformed/url')
def test_out_of_domain_object_url(self):
with self.assertRaises(ApiException):
SquadApi.get('http://some.other.url')
def main(args):
global do_color
do_color = args.color
SquadApi.configure(args.squadapi_url)
squad = Squad()
print(f'I: Fetching group {args.group}')
group = squad.group(args.group)
print(f'I: Fetching project {args.project}')
project = group.project(args.project)
build_filters = {}
if args.builds and len(args.builds):
build_filters["version__in"] = join(args.builds)
else:
build_filters["count"] = args.n
test_filters = {}
if args.tests and len(args.tests):
test_filters["metadata__name__in"] = join(args.tests)
if args.suites and len(args.suites):
print(
f'I: Fetching {args.group}/{args.project} suites ({args.suites})')
suites = project.suites(slug__in=join(args.suites))
test_filters["suite__id__in"] = join(
[str(_id) for _id in suites.keys()])
else:
print(f'I: Fetching {args.group}/{args.project} suites')
suites = project.suites()
if args.no_arch:
envs = {}
elif args.archs and len(args.archs):
print(
f'I: Fetching {args.group}/{args.project} environments ({args.archs})'
)
envs = project.environments(slug__in=join(args.archs))
test_filters["environment__id__in"] = join(
[str(_id) for _id in envs.keys()])
else:
print(f'I: Fetching {args.group}/{args.project} environments')
envs = project.environments()
tests = []
print(f'I: Fetching {args.n} builds ({build_filters}):', flush=True)
for build in project.builds(**build_filters).values():
print(f'D: Fetching build {build.version} tests ({test_filters})',
flush=True)
num_tests = 0
for test in build.tests(**test_filters).values():
if test.name.startswith('linux-log-parser'):
continue
tests.append(test)
if num_tests % 1000 == 0:
print('.', end='', flush=True)
num_tests += 1
if num_tests:
print()
print('I: Finding stable tests')
find_stable_tests(
tests,
envs=envs,
suites=suites,
)
def test_unconfigured(self):
with self.assertRaises(ApiException):
SquadApi.configure(None)
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)
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)
dest='intro',
required=False,
default=None,
help='Free form text or HTML to be added to template introduction')
parser.add_argument('--output',
dest='output',
required=True,
help='Output filename')
parser.add_argument('--squad-host',
dest='server',
default='https://qa-reports.linaro.org/',
help='SQUAD server')
args = parser.parse_args()
SquadApi.configure(url=args.server, token=args.token)
def getid(url):
matches = re.search('^.*/(\d+)/$', url)
try:
_id = int(matches.group(1))
return _id
except ValueError:
print('Could not get id for %s' % url)
return -1
group = Squad().group(args.group)
project = group.project(args.project)
environments = project.environments(count=ALL)
def setUp(self):
self.squad = Squad()
SquadApi.configure(url='http://localhost:%s' %
settings.DEFAULT_SQUAD_PORT,
token='193cd8bb41ab9217714515954e8724f651ef8601')
#!/usr/bin/env python3
import jinja2
import sys
sys.path.append('..')
from squad_client.core.api import SquadApi
from squad_client.core.models import Squad
# Configure SQUAD url
SquadApi.configure(url='https://qa-reports.linaro.org/')
# Generate a report with all groups
groups = Squad().groups()
templateLoader = jinja2.FileSystemLoader(searchpath="./")
templateEnv = jinja2.Environment(loader=templateLoader)
TEMPLATE_FILE = "example_template.html"
template = templateEnv.get_template(TEMPLATE_FILE)
outputText = template.render(groups=groups.values())
with open('generated_report.html', 'w') as reportFile:
reportFile.write(outputText)
import unittest
from squad_client.core.api import SquadApi
from squad_client.core.models import Squad, Group, Project, Build, TestJob, TestRun, Test, Suite, Environment, Backend, EmailTemplate, KnownIssue, SuiteMetadata, Annotation, MetricThreshold, Report
from squad_client.utils import first
SquadApi.configure(url='http://localhost:8000')
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):
four_groups = self.squad.groups(count=4)
self.assertEqual(4, len(four_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):
lkft_group = self.squad.group('lkft')
def setUp(self):
SquadApi.configure('http://localhost:8000')