def get_build_reports(project_name, release_name):
"""Get all summary of all the builds for a particular release."""
limit = 15
if request.args.get("limit"):
try:
limit = int(request.args.get("limit"))
except:
pass
groupType = "SERIAL"
if request.args.get("groupType"):
groupType = request.args.get("groupType")
project_id, release_id, build_id = Project.lookup_project_release_build_ids(project_name, release_name, None, get_all_builds=True, limit=limit)
report = {}
report['name'] = "Release Report for {} {}".format(project_name, release_name)
report['builds'] = []
report['grouptype'] = groupType
if build_id is None:
return JsonResponse({})
for build_object in build_id:
testrun_group = TestrunGroup()
testrun_group.name = "Build Report for {} {} Build {}".format(project_name, release_name, build_object['name'])
testrun_group.grouptype = groupType
testrun_group.testruns = Testrun.objects(build__buildId=build_object['id']).order_by("-dateCreated")
report['builds'].append(testrun_group)
return JsonResponse(report)
def cancel_results_for_build(project_name, release_name, build_name):
"""Cancel all results that are scheduled for this build."""
project_id, release_id, build_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name)
canceled_results = []
if build_id is None:
return JsonResponse(None)
for testrun in Testrun.objects(build__buildId=build_id).order_by("-dateCreated"):
results_to_cancel = Result.objects(testrun__testrunId=testrun.id, status='NO_RESULT', runstatus__in=['SCHEDULED', 'TO_BE_RUN'])
canceled_results.extend(results_to_cancel)
for result in results_to_cancel:
cancel_individual_result(result.id)
return JsonResponse(canceled_results)
def reschedule_results_with_status_on_build(project_name, release_name, build_name, status):
"""Reschedule all results with a particular status for a build."""
project_id, release_id, build_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name)
rescheduled_results = []
if build_id is None:
return JsonResponse(None)
for testrun in Testrun.objects(build__buildId=build_id).order_by("-dateCreated"):
results_to_reschedule = Result.objects(testrun__testrunId=testrun.id, status=status)
rescheduled_results.extend(results_to_reschedule)
for result in results_to_reschedule:
reschedule_individual_result(result.id)
return JsonResponse(rescheduled_results)
def get_tps_report(project_name, release_name, testplan_name):
"""Get all summary of all the testruns run against a particular build."""
project_id, release_id, _ = Project.lookup_project_release_build_ids(project_name, release_name, None)
testplan = TestPlan.objects(project__id=project_id, name=testplan_name)
if len(testplan) > 0:
testplan = testplan[0]
report = TestrunGroup()
report.name = "{} Summary for {}".format(testplan_name, release_name)
report.grouptype = "SERIAL"
report.testruns = []
report.testruns.extend(Testrun.objects(project__id=project_id, release__releaseId=release_id, testplanId=testplan.id).order_by('-dateCreated').limit(50))
report.testruns.reverse()
return JsonResponse(report)
else:
return JsonResponse({})
def get_build_report(project_name, release_name, build_name):
"""Get all summary of all the testruns run against a particular build."""
project_id, release_id, build_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name)
report = TestrunGroup()
report.name = "Build Report for {} {} Build {}".format(project_name, release_name, build_name)
report.grouptype = "PARALLEL"
report.testruns = []
testplans = []
for testrun in Testrun.objects(build__buildId=build_id).order_by("-dateCreated"):
assert isinstance(testrun, Testrun)
if testrun.testplanId not in testplans:
report.testruns.append(testrun)
testplans.append(testrun.testplanId)
return JsonResponse(report)
def add_pipeline():
"""Create a new pipeline."""
project_name = None
release_name = None
build_name = None
raw = read_request()
new_pipeline = deserialize_that(raw, Pipeline())
proj_id = None
existing_pipeline = get_pipeline(new_pipeline.name)
if existing_pipeline:
new_pipeline = deserialize_that(raw, existing_pipeline)
else:
# resolve project, release and build, create if necessary
if is_provided(new_pipeline, 'project'):
project_name = new_pipeline.project.name
if is_provided(new_pipeline, 'release'):
release_name = new_pipeline.release.name
if is_provided(new_pipeline, 'build'):
build_name = new_pipeline.build.name
if project_name is not None or release_name is not None or build_name is not None:
# we have something to lookup / create
proj_id, rel_id, bld_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name,
create_if_missing=True)
if proj_id is not None:
new_pipeline.project.id = proj_id
if rel_id is not None:
new_pipeline.release.releaseId = rel_id
if bld_id is not None:
new_pipeline.build.buildId = bld_id
for ind, phase in enumerate(new_pipeline.phases):
new_pipeline.phases[ind] = phase_check(new_pipeline.phases[ind])
new_pipeline = pipeline_check(new_pipeline)
new_pipeline.save()
# add an event
events.CreateEvent(new_pipeline)
return JsonResponse(new_pipeline)
def get_build_report(project_name, release_name, build_name):
"""Get all summary of all the testruns run against a particular build."""
project_id, release_id, build_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name)
report = TestrunGroup()
report.name = "Build Report for {} {} Build {}".format(project_name, release_name, build_name)
report.grouptype = "PARALLEL"
report.testruns = []
testplans = []
if build_id is None:
return JsonResponse(None)
for testrun in Testrun.objects(build__buildId=build_id).order_by("-dateCreated"):
assert isinstance(testrun, Testrun)
if testrun.testplanId not in testplans:
report.testruns.append(testrun)
testplans.append(testrun.testplanId)
if report.state() == "FINISHED" and not report.finished:
report.finished = datetime.datetime.utcnow()
# report.save() Warning, be careful not to do this, build reports don't get saved
# this will create a new testrungroup every time the build report is
# queried
return JsonResponse(report)
def add_testrun():
"""Create a new testrun."""
project_name = None
release_name = None
build_name = None
raw = read_request()
new_tr = deserialize_that(raw, Testrun())
proj_id = None
# resolve project, release and build, create if necessary
if is_provided(new_tr, 'project'):
project_name = new_tr.project.name
if is_provided(new_tr, 'release'):
release_name = new_tr.release.name
if is_provided(new_tr, 'build'):
build_name = new_tr.build.name
if project_name is not None or release_name is not None or build_name is not None:
# we have something to lookup / create
proj_id, rel_id, bld_id = Project.lookup_project_release_build_ids(project_name, release_name, build_name,
create_if_missing=True)
if proj_id is not None:
new_tr.project.id = proj_id
if rel_id is not None:
new_tr.release.releaseId = rel_id
if bld_id is not None:
new_tr.build.buildId = bld_id
# if testplanId not provided, but testplan object is, resolve creating if necessary
if is_not_provided(new_tr, 'testplanId') and 'testplan' in raw:
tplan = TestPlan()
tplan = deserialize_that(raw['testplan'], tplan)
""":type : TestPlan"""
query = {'name': tplan.name}
if proj_id is not None:
query['project__id'] = proj_id
existing_plan = TestPlan.objects(**query).first()
if existing_plan is not None:
new_tr.testplanId = existing_plan.id
else:
if proj_id is not None:
tplan.project = ProjectReference()
tplan.project.id = proj_id
tplan.project.name = new_tr.project.name
tplan.save()
new_tr.testplanId = tplan.id
if is_not_provided(new_tr, 'dateCreated'):
new_tr.dateCreated = datetime.datetime.utcnow()
if is_not_provided(new_tr, 'info') and is_provided(new_tr, 'build') and \
is_provided(new_tr, 'project') and is_provided(new_tr, 'release'):
project = get_project(new_tr.project.name)
build = None
if project is None:
project = get_project(new_tr.project.id)
if project is not None:
release = get_release(project, new_tr.release.name)
if release is None:
release = get_release(project, new_tr.release.releaseId)
if release is not None:
build = get_build(release, new_tr.build.name)
if build is None:
build = get_build(release, new_tr.build.buildId)
if build is not None and is_provided(build, 'description'):
new_tr.info = build.description
new_tr.save()
# add an event
events.CreateEvent(new_tr)
return JsonResponse(new_tr)
def get_single_scheduled_result(hostname):
parameters = read_request()
""":type : dict"""
rawquery = {'runstatus': 'SCHEDULED',
'status': 'NO_RESULT'}
update = {'set__runstatus': 'TO_BE_RUN',
'set__hostname': hostname}
attr_query = dict(**parameters)
if 'project' in attr_query:
del attr_query['project']
if 'release' in attr_query:
del attr_query['release']
if 'build' in attr_query:
del attr_query['build']
if 'provides' in attr_query:
del attr_query['provides']
for key, value in list(attr_query.items()):
rawquery["attributes.{}".format(key)] = value
project_id, release_id, build_id = Project.lookup_project_release_build_ids(parameters.get('project', None),
parameters.get('release', None),
parameters.get('build', None))
if project_id is not None:
rawquery['project.id'] = project_id
else:
rawquery['project.name'] = parameters.get('project', None)
if release_id is not None:
rawquery['release.releaseId'] = release_id
elif parameters.get('release', None) is not None:
rawquery['release.name'] = parameters.get('release', None)
if build_id is not None:
rawquery['build.buildId'] = build_id
elif parameters.get('build', None) is not None:
rawquery['build.name'] = parameters.get('build', None)
# if 'project' in parameters:
# project = get_project(parameters["project"])
# if project is not None:
# rawquery['project.id'] = project.id
# else:
# rawquery['project.name'] = parameters["project"]
# if 'release' in parameters:
# if project is not None:
# release = get_release(project, parameters['release'])
# if release is not None:
# rawquery['release.releaseId'] = release.id
# else:
# rawquery['release.name'] = parameters['release']
# if 'build' in parameters:
# if release is not None:
# build = get_build(release, parameters['build'])
# if build is not None:
# rawquery['build.buildId'] = build.id
# else:
# rawquery['build.name'] = parameters['build']
provides = []
if 'provides' in parameters:
provides = parameters['provides']
# from http://stackoverflow.com/questions/22518867/mongodb-querying-array-field-with-exclusion
rawquery['requirements'] = {'$not': {'$elemMatch': {'$nin': provides}}}
import mongoengine
# mongoengine.QuerySet.modify()
result = Result.objects(__raw__=rawquery).order_by("recorded").modify(new=True, full_response=False, **update)
# query = {}
# if 'project' in parameters:
# query['project__name'] = parameters['project']
# if 'release' in parameters:
# query['release__name'] = parameters['release']
# if 'build' in parameters:
# query['build__name'] = parameters['build']
return JsonResponse(result)
