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