def test_fetch_build_with_required_hooks(client, db_session, default_login,
default_tenant, default_repo,
default_revision):
hook1 = factories.HookFactory.create(repository_id=default_repo.id)
hook2 = factories.HookFactory.create(repository_id=default_repo.id)
db_session.commit()
factories.BuildFactory.create(
revision=default_revision,
data={"required_hook_ids": [str(hook1.id),
str(hook2.id)]},
hook_id=hook1.id,
passed=True,
)
merged_build = fetch_build_for_revision(default_revision)
assert merged_build.result == Result.failed
factories.BuildFactory.create(
revision=default_revision,
data={"required_hook_ids": [str(hook1.id),
str(hook2.id)]},
hook_id=hook2.id,
passed=True,
)
merged_build = fetch_build_for_revision(default_revision)
assert merged_build.result == Result.passed
def get(self, revision: Revision):
"""
Return a list of style violations for a given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = (StyleViolation.query.options(contains_eager("job")).join(
Job, StyleViolation.job_id == Job.id).filter(
Job.build_id.in_(build_ids)))
severity = request.args.get("severity")
if severity:
try:
query = query.filter(
StyleViolation.severity == getattr(Severity, severity))
except AttributeError:
raise NotImplementedError
query = query.order_by(
(StyleViolation.severity == Severity.error).desc(),
StyleViolation.filename.asc(),
StyleViolation.lineno.asc(),
StyleViolation.colno.asc(),
)
return self.paginate_with_schema(styleviolation_schema, query)
def get(self, revision: Revision):
"""
Return a list of file coverage objects for a given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = FileCoverage.query.filter(FileCoverage.build_id.in_(build_ids))
diff_only = request.args.get("diff_only") in ("1", "yes", "true")
if diff_only:
query = query.filter(
or_(
FileCoverage.diff_lines_covered > 0,
FileCoverage.diff_lines_uncovered > 0,
))
query = query.order_by(
(FileCoverage.diff_lines_covered +
FileCoverage.diff_lines_uncovered > 0).desc(),
FileCoverage.filename.asc(),
)
return self.respond_with_schema(filecoverage_schema, query)
def get(self, revision: Revision, repo=None):
"""
Return all artifacts of all builds in a revision.
"""
build = fetch_build_for_revision(revision.repository, revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = (
Artifact.query.options(
joinedload("job"),
joinedload("job").joinedload("build"),
joinedload("job").joinedload("build").joinedload("source"),
joinedload("job")
.joinedload("build")
.joinedload("source")
.joinedload("repository"),
)
.join(Job, Job.id == Artifact.job_id)
.filter(Job.build_id.in_(build_ids))
.order_by(Artifact.name.asc())
)
return self.respond_with_schema(artifacts_schema, query)
def get(self, revision: Revision):
"""
Return a list of test cases for a given revision.
"""
build = fetch_build_for_revision(revision.repository, revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = TestCase.query.options(contains_eager('job')).join(
Job,
TestCase.job_id == Job.id,
).filter(Job.build_id.in_(build_ids), )
result = request.args.get('result')
if result:
try:
query = query.filter(
TestCase.result == getattr(Result, result))
except AttributeError:
raise NotImplementedError
query = query.order_by((TestCase.result == Result.failed).desc(),
TestCase.name.asc())
return self.paginate_with_schema(testcases_schema, query)
def get(self, revision: Revision, repo=None):
"""
Return the joined build status of a revision.
"""
build = fetch_build_for_revision(revision.repository, revision)
if not build:
return self.respond(status=404)
return self.respond_with_schema(build_schema, build)
def get(self, revision: Revision, repo=None):
"""
Return the joined build status of a revision.
"""
with nplusone.ignore("eager_load"):
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
return self.respond_with_schema(build_schema, build)
def get(self, revision: Revision):
"""
Return a list of jobs for a given revision.
"""
build = fetch_build_for_revision(revision.repository, revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = Job.query.options(
subqueryload_all('stats'),
subqueryload_all('failures'),
).filter(Job.build_id.in_(build_ids)).order_by(Job.number.asc())
return self.respond_with_schema(jobs_schema, query)
def get(self, revision: Revision):
"""
Return bundle stats for a given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
job_ids = (db.session.query(Job.id).filter(
Job.build_id.in_(build_ids)).subquery())
query = (Bundle.query.filter(Bundle.job_id.in_(job_ids)).options(
subqueryload_all(Bundle.assets)).order_by(Bundle.name.asc()))
return self.paginate_with_schema(bundle_schema, query)
def get(self, revision: Revision):
"""
Return a list of test cases for a given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
job_query = db.session.query(Job.id).filter(
Job.build_id.in_(build_ids))
result = request.args.get("allowed_failures")
if result == "false":
job_query = job_query.filter(Job.allow_failure == False) # NOQA
job_ids = job_query.subquery()
query = (db.session.query(
TestCase.hash,
TestCase.name,
array_agg_row(TestCase.id, TestCase.job_id, TestCase.duration,
TestCase.result).label("runs"),
).filter(TestCase.job_id.in_(job_ids)).group_by(
TestCase.hash, TestCase.name))
result = request.args.get("result")
if result:
try:
query = query.filter(
TestCase.result == getattr(Result, result))
except AttributeError:
raise NotImplementedError
query = query.order_by(
(array_agg(TestCase.result).label("results").contains(
[Result.failed])).desc(),
TestCase.name.asc(),
)
schema = AggregateTestCaseSummarySchema(many=True,
strict=True,
exclude=("build", ))
return self.paginate_with_schema(schema, query)
def get(self, revision: Revision):
"""
Return a list of failure reasons for a given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
build_ids = [original.id for original in build.original]
query = (db.session.query(
FailureReason.reason,
array_agg_row(FailureReason.id,
FailureReason.job_id).label("runs"),
).filter(FailureReason.build_id.in_(build_ids)).group_by(
FailureReason.reason))
query = query.order_by(FailureReason.reason.asc())
return self.paginate_with_schema(failurereasons_schema, query)
def get(self, revision: Revision):
"""
Return a tree of file coverage for the given revision.
"""
build = fetch_build_for_revision(revision)
if not build:
return self.respond(status=404)
parent = request.args.get("parent")
build_ids = [original.id for original in build.original]
query = FileCoverage.query.filter(
FileCoverage.build_id.in_(build_ids)
).order_by(FileCoverage.filename.asc())
if parent:
query = query.filter(FileCoverage.filename.startswith(parent))
coverage_list = list(query)
is_leaf = all(c.filename == parent for c in coverage_list)
if is_leaf:
response = self._get_leaf(revision, coverage_list)
elif coverage_list:
groups = build_tree(
list(set([f.filename for f in coverage_list])),
sep=SEPERATOR,
min_children=2,
parent=parent,
)
results = []
for group in groups:
lines_covered, lines_uncovered = 0, 0
diff_lines_covered, diff_lines_uncovered = 0, 0
is_leaf = len(coverage_list) == 1 and coverage_list[0].filename == group
for coverage in coverage_list:
if coverage.filename == group or coverage.filename.startswith(
group + SEPERATOR
):
lines_covered += coverage.lines_covered
lines_uncovered += coverage.lines_uncovered
diff_lines_covered += coverage.diff_lines_covered
diff_lines_uncovered += coverage.diff_lines_uncovered
if parent:
name = group[len(parent) + len(SEPERATOR) :]
else:
name = group
data = {
"name": name,
"path": group,
"lines_covered": lines_covered,
"lines_uncovered": lines_uncovered,
"diff_lines_covered": diff_lines_covered,
"diff_lines_uncovered": diff_lines_uncovered,
"is_leaf": is_leaf,
}
results.append(data)
results.sort(key=lambda x: x["name"])
response = {"is_leaf": False, "entries": results}
else:
response = {"is_leaf": False, "entries": []}
trail = []
context = []
if parent:
for chunk in parent.split(SEPERATOR):
context.append(chunk)
trail.append({"path": SEPERATOR.join(context), "name": chunk})
response.update({"trail": trail})
return response
