9205616287

Committed 23 May 2024 09:29AM UTC coverage: 81.332% (+0.1%) from 81.193%

Build # 9205616287

Build Type

Pull #170

github

Committed by

web-flow

Commit Message

Merge 4b30677c3 into cc602d3ca

Pull Request Pull Request #170: Add API to create generic results

Run Details

343 of 456 branches covered (75.22%)

Branch coverage included in aggregate %.

29 of 29 new or added lines in 3 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

1086 of 1301 relevant lines covered (83.47%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.13

/resultsdb/controllers/api_v2.py

# Copyright 2013-2016, Red Hat, Inc
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Authors:
#   Josef Skladanka <jskladan@redhat.com>
#   Ralph Bean <rbean@redhat.com>

import re
import uuid

from flask import Blueprint
from flask import current_app as app
from flask import jsonify, request, url_for
from flask_pydantic import validate
from sqlalchemy.orm import exc as orm_exc

from resultsdb.controllers.common import SERIALIZE, commit_result
from resultsdb.models import db
from resultsdb.models.results import (
    Group,
    Result,
    ResultData,
    Testcase,
    result_outcomes,
)
from resultsdb.parsers.api_v2 import (
    QUERY_LIMIT,
    CreateGroupParams,
    CreateResultParams,
    CreateTestcaseParams,
    GroupsParams,
    ResultsParams,
    TestcasesParams,
)

api = Blueprint("api_v2", __name__)


# =============================================================================
#                               GLOBAL VARIABLES
# =============================================================================

RE_PAGE = re.compile(r"([?&])page=([0-9]+)")
RE_CALLBACK = re.compile(r"([?&])callback=[^&]*&?")
RE_CLEAN_AMPERSANDS = re.compile(r"&+")

# =============================================================================
#                               GLOBAL METHODS
# =============================================================================


def pagination(q, page, limit):
    """
    Sets the offset/limit for the DB query.
    limit+1 is purposely set as 'limit' so we can later on decide whether 'next'
    page link should be provided or set to None.
    """
    # pagination offset
    try:
        page = int(page)
        if page > 0:
            offset = page * limit
            q = q.offset(offset)
    except (TypeError, ValueError):
        pass

    q = q.limit(limit + 1)
    return q


def prev_next_urls(data, limit=QUERY_LIMIT):
    global RE_PAGE

    try:
        match = RE_PAGE.findall(request.url)
        flag, page = match[0][0], int(match[0][1])
    except IndexError:  # page not found
        page = None

    prev = None
    next = None
    placeholder = "[!@#$%^&*PLACEHOLDER*&^%$#@!]"

    if page is None:
        if "?" in request.url:
            baseurl = f"{request.url}&page={placeholder}"
        else:
            baseurl = f"{request.url}?page={placeholder}"
        page = 0
    else:
        baseurl = RE_PAGE.sub(f"{flag}page={placeholder}", request.url)

    baseurl = RE_CALLBACK.sub(r"\1", baseurl)
    baseurl = RE_CLEAN_AMPERSANDS.sub("&", baseurl)

    if page > 0:
        prev = baseurl.replace(placeholder, str(page - 1))
    if len(data) > limit:
        next = baseurl.replace(placeholder, str(page + 1))
        data = data[:limit]

    return data, prev, next


# =============================================================================
#                                      GROUPS
# =============================================================================


@api.route("/groups", methods=["GET"])
@validate()
def get_groups(query: GroupsParams):
    q = db.session.query(Group).order_by(db.desc(Group.id))

    desc_filters = []
    if query.description:
        for description in query.description.split(","):
            if not description.strip():
                continue
            desc_filters.append(Group.description == description)
    #        desc_filters.append(Group.description.in_(query.description.split(',')))
    elif query.description_like_:
        for description in query.description_like_.split(","):
            if not description.strip():
                continue
            desc_filters.append(Group.description.like(description.replace("*", "%")))
    if desc_filters:
        q = q.filter(db.or_(*desc_filters))

    # Filter by uuid
    if query.uuid:
        q = q.filter(Group.uuid.in_(query.uuid.split(",")))

    q = pagination(q, query.page, query.limit)
    data, prev, next = prev_next_urls(q.all(), query.limit)

    return jsonify(
        dict(
            prev=prev,
            next=next,
            data=[SERIALIZE(o) for o in data],
        )
    )


@api.route("/groups/<group_id>", methods=["GET"])
def get_group(group_id):
    q = Group.query.filter_by(uuid=group_id)
    group = q.first()
    if not group:
        return jsonify({"message": "Group not found"}), 404

    return jsonify(SERIALIZE(group))


@api.route("/groups", methods=["POST"])
@validate()
def create_group(body: CreateGroupParams):
    if body.uuid:
        group = Group.query.filter_by(uuid=body.uuid).first()
        if not group:
            group = Group(uuid=body.uuid)
    else:
        group = Group(uuid=str(uuid.uuid1()))

    if body.ref_url:
        group.ref_url = body.ref_url
    if body.description:
        group.description = body.description

    db.session.add(group)
    db.session.commit()

    return jsonify(SERIALIZE(group)), 201


# =============================================================================
#                                     RESULTS
# =============================================================================
def select_results(
    since_start=None,
    since_end=None,
    outcomes=None,
    groups=None,
    testcases=None,
    testcases_like=None,
    result_data=None,
    _sort=None,
):
    # Checks if the sort parameter specified in the request is valid before querying.
    # Sorts by submit_time in a descending order if the sort parameter is absent or invalid.
    q = db.session.query(Result)
    query_sorted = False
    if _sort:
        sort_match = re.match(r"^(?P<order>asc|desc):(?P<column>.+)$", _sort)
        if sort_match and sort_match.group("column") == "submit_time":
            sort_order = {"asc": db.asc, "desc": db.desc}[sort_match.group("order")]
            sort_column = getattr(Result, sort_match.group("column"))
            q = q.order_by(sort_order(sort_column))
            query_sorted = True
    if _sort and _sort == "disable_sorting":
        query_sorted = True
    if not query_sorted:
        q = q.order_by(db.desc(Result.submit_time))

    # Time constraints
    if since_start:
        q = q.filter(Result.submit_time >= since_start)
    if since_end:
        q = q.filter(Result.submit_time <= since_end)

    # Filter by outcome
    if outcomes:
        q = q.filter(Result.outcome.in_(outcomes))

    # Filter by group_id
    if groups:
        q = q.filter(Result.groups.any(Group.uuid.in_(groups)))

    # Filter by testcase_name
    filter_by_testcase = []
    if testcases:
        filter_by_testcase.append(Result.testcase_name.in_(testcases))
    if testcases_like:
        for testcase in testcases_like:
            testcase = testcase.replace("*", "%")
            filter_by_testcase.append(Result.testcase_name.like(testcase))
    if filter_by_testcase:
        q = q.filter(db.or_(*filter_by_testcase))

    # Filter by result_data
    if result_data is not None:
        for key, values in result_data.items():
            try:
                key, modifier = key.split(":")
            except ValueError:  # no : in key
                key, modifier = (key, None)

            if modifier == "like":
                alias = db.aliased(ResultData)
                if len(values) > 1:  # multiple values
                    likes = []
                    # create the (value LIKE foo OR value LIKE bar OR ...) part
                    for value in values:
                        value = value.replace("*", "%")
                        likes.append(alias.value.like(value))
                    # put it together to (key = key AND (value LIKE foo OR value LIKE bar OR ...))
                    q = q.join(alias).filter(db.and_(alias.key == key, db.or_(*likes)))
                else:
                    value = values[0].replace("*", "%")
                    q = q.join(alias).filter(
                        db.and_(alias.key == key, alias.value.like(value))
                    )

            else:
                alias = db.aliased(ResultData)
                q = q.join(alias).filter(
                    db.and_(alias.key == key, alias.value.in_(values))
                )
    return q


def __get_results_parse_args(query: ResultsParams):
    args = {
        "_sort": query.sort_,
        "limit": query.limit,
        "page": query.page,
        "testcases": query.testcases,
        "testcases:like": query.testcases_like_,
        "groups": query.groups,
        "_distinct_on": query.distinct_on_,
        "outcome": query.outcome,
        "since": query.since,
    }

    # find results_data with the query parameters
    #  these are the paramters other than those defined in RequestParser
    # request.args is a ImmutableMultiDict, which allows for more values to be
    #  stored in one key (so one can do stuff like .../results?item=foo&item=bar in URL).
    # Here we transform the `request.args` MultiDict to `results_data` dict of lists, and
    #  while also filtering out the reserved-keyword-args
    results_data = {
        k: request.args.getlist(k) for k in request.args.keys() if k not in args
    }
    for param, values in results_data.items():
        for i, value in enumerate(values):
            results_data[param][i] = value.split(",")
        # flatten the list
        results_data[param] = [
            item for sublist in results_data[param] for item in sublist
        ]

    return {
        "result_data": results_data if results_data else None,
        "args": args,
    }


def __get_results(query: ResultsParams, group_ids=None, testcase_names=None):
    p = __get_results_parse_args(query)
    args = p["args"]

    groups = group_ids if group_ids is not None else args["groups"]
    testcases = testcase_names if testcase_names is not None else args["testcases"]

    q = select_results(
        since_start=args["since"]["start"],
        since_end=args["since"]["end"],
        outcomes=args["outcome"],
        groups=groups,
        testcases=testcases,
        testcases_like=args["testcases:like"],
        result_data=p["result_data"],
        _sort=args["_sort"],
    )

    q = pagination(q, args["page"], args["limit"])
    data, prev, next = prev_next_urls(q.all(), args["limit"])

    return jsonify(
        dict(
            prev=prev,
            next=next,
            data=[SERIALIZE(o) for o in data],
        )
    )


@api.route("/results", methods=["GET"])
@validate()
def get_results(query: ResultsParams):
    return __get_results(query)


@api.route("/results/latest", methods=["GET"])
@validate()
def get_results_latest(query: ResultsParams):
    p = __get_results_parse_args(query)
    args = p["args"]
    since_start = args["since"].get("start", None)
    since_end = args["since"].get("end", None)
    groups = args.get("groups", None)
    testcases = args.get("testcases", None)
    testcases_like = args.get("testcases:like", None)
    distinct_on = args.get("_distinct_on", None)

    if not distinct_on:
        q = select_results(
            since_start=since_start,
            since_end=since_end,
            groups=groups,
            testcases=testcases,
            testcases_like=testcases_like,
            result_data=p["result_data"],
        )

        # Produce a subquery with the same filter criteria as above *except*
        # test case name, which we group by and join on.
        sq = (
            select_results(
                since_start=since_start,
                since_end=since_end,
                groups=groups,
                result_data=p["result_data"],
            )
            .order_by(None)
            .with_entities(
                Result.testcase_name.label("testcase_name"),
                db.func.max(Result.submit_time).label("max_submit_time"),
            )
            .group_by(Result.testcase_name)
            .subquery()
        )
        q = q.join(
            sq,
            db.and_(
                Result.testcase_name == sq.c.testcase_name,
                Result.submit_time == sq.c.max_submit_time,
            ),
        )

        results = q.all()

        return jsonify(
            dict(
                data=[SERIALIZE(o) for o in results],
            )
        )

    if not any(
        [testcases, testcases_like, since_start, since_end, groups, p["result_data"]]
    ):
        return (
            jsonify(
                {
                    "message": (
                        "Please, provide at least one " "filter beside '_distinct_on'"
                    )
                }
            ),
            400,
        )

    q = db.session.query(Result)
    q = select_results(
        since_start=since_start,
        since_end=since_end,
        groups=groups,
        testcases=testcases,
        testcases_like=testcases_like,
        result_data=p["result_data"],
        _sort="disable_sorting",
    )

    values_distinct_on = [Result.testcase_name]
    for i, key in enumerate(distinct_on):
        name = f"result_data_{i}_{key}"
        alias = db.aliased(
            db.session.query(ResultData).filter(ResultData.key == key).subquery(),
            name=name,
        )
        q = q.outerjoin(alias)
        values_distinct_on.append(db.text(f"{name}.value"))

    q = q.distinct(*values_distinct_on)
    q = q.order_by(*values_distinct_on).order_by(db.desc(Result.submit_time))

    results = q.all()
    results = dict(
        data=[SERIALIZE(o) for o in results],
    )
    results["data"] = sorted(
        results["data"], key=lambda x: x["submit_time"], reverse=True
    )
    return jsonify(results)


@api.route("/groups/<group_id>/results", methods=["GET"])
@validate()
def get_results_by_group(group_id: str, query: ResultsParams):
    group = Group.query.filter_by(uuid=group_id).first()
    if not group:
        return jsonify({"message": f"Group not found: {group_id}"}), 404
    return __get_results(query, group_ids=[group.uuid])


@api.route("/testcases/<path:testcase_name>/results", methods=["GET"])
@validate()
def get_results_by_testcase(testcase_name: str, query: ResultsParams):
    testcase = Testcase.query.filter_by(name=testcase_name).first()
    if not testcase:
        return jsonify({"message": "Testcase not found"}), 404
    return __get_results(query, testcase_names=[testcase.name])


@api.route("/results/<result_id>", methods=["GET"])
def get_result(result_id):
    try:
        result = Result.query.filter_by(id=result_id).one()
    except orm_exc.NoResultFound:
        return jsonify({"message": "Result not found"}), 404

    return jsonify(SERIALIZE(result))


@api.route("/results", methods=["POST"])
@validate()
def create_result(body: CreateResultParams):
    return create_result_generic(body)


def create_result_generic(body: CreateResultParams):
    if body.data:
        invalid_keys = [key for key in body.data.keys() if ":" in key]
        if invalid_keys:
            app.logger.warning("Colon not allowed in key name: %s", invalid_keys)
            return jsonify(
                {"message": "Colon not allowed in key name: %r" % invalid_keys}
            ), 400

    tc = body.testcase

    testcase = Testcase.query.filter_by(name=tc["name"]).first()
    if not testcase:
        app.logger.debug("Testcase %s does not exist yet. Creating", tc["name"])
        testcase = Testcase(name=tc["name"])
    testcase.ref_url = tc.get("ref_url", testcase.ref_url)
    db.session.add(testcase)

    # groups is a list of strings(uuid) or dicts(group object)
    #  when a group defined by the string is not found, new is created
    #  group defined by the object, is updated/created with the values from the object
    # non-existing groups are created automatically
    groups = []
    if body.groups:
        for grp in body.groups:
            if isinstance(grp, (str, bytes)):
                grp = dict(uuid=grp)
            elif isinstance(grp, dict):
                grp["uuid"] = grp.get("uuid", str(uuid.uuid1()))

            group = Group.query.filter_by(uuid=grp["uuid"]).first()
            if not group:
                group = Group(uuid=grp["uuid"])

            group.description = grp.get("description", group.description)
            group.ref_url = grp.get("ref_url", group.ref_url)

            db.session.add(group)
            groups.append(group)

    result = Result(
        testcase, body.outcome, groups, body.ref_url, body.note, body.submit_time
    )
    # Convert result_data
    #  for each key-value pair in body.data
    #    convert keys to unicode
    #    if value is string: NOP
    #    if value is list or tuple:
    #      convert values to unicode, create key-value pair for each value from the list
    #    if value is something else: convert to unicode
    #  Store all the key-value pairs
    if isinstance(body.data, dict):
        to_store = []
        for key, value in body.data.items():
            if not isinstance(key, str):
                key = str(key)

            if isinstance(value, str):
                to_store.append((key, value))

            elif isinstance(value, (list, tuple)):
                for v in value:
                    if not isinstance(v, str):
                        v = str(v)
                    to_store.append((key, v))
            else:
                value = str(value)
                to_store.append((key, value))

        for key, value in to_store:
            ResultData(result, key, value)

    return commit_result(result)


# =============================================================================
#                                    TESTCASES
# =============================================================================


def select_testcases(args_name=None, args_name_like=None):
    q = db.session.query(Testcase).order_by(db.asc(Testcase.name))

    name_filters = []
    if args_name:
        for name in [name.strip() for name in args_name.split(",") if name.strip()]:
            name_filters.append(Testcase.name == name)
    elif args_name_like:
        for name in [
            name.strip() for name in args_name_like.split(",") if name.strip()
        ]:
            name_filters.append(Testcase.name.like(name.replace("*", "%")))
    if name_filters:
        q = q.filter(db.or_(*name_filters))

    return q


@api.route("/testcases", methods=["GET"])
@validate()
def get_testcases(query: TestcasesParams):
    q = select_testcases(query.name, query.name_like_)
    q = pagination(q, query.page, query.limit)
    data, prev, next = prev_next_urls(q.all(), query.limit)

    return jsonify(
        dict(
            prev=prev,
            next=next,
            data=[SERIALIZE(o) for o in data],
        )
    )


@api.route("/testcases/<path:testcase_name>", methods=["GET"])
def get_testcase(testcase_name):
    try:
        testcase = Testcase.query.filter_by(name=testcase_name).one()
    except orm_exc.NoResultFound:
        return jsonify({"message": "Testcase not found"}), 404

    return jsonify(SERIALIZE(testcase))


@api.route("/testcases", methods=["POST"])
@validate()
def create_testcase(body: CreateTestcaseParams):
    testcase = Testcase.query.filter_by(name=body.name).first()
    if not testcase:
        testcase = Testcase(name=body.name)
    if body.ref_url is not None:
        testcase.ref_url = body.ref_url

    db.session.add(testcase)
    db.session.commit()

    return jsonify(SERIALIZE(testcase)), 201


@api.route("/healthcheck", methods=["GET"])
def healthcheck():
    """
    Request handler for performing an application-level health check. This is
    not part of the published API, it is intended for use by OpenShift or other
    monitoring tools.

    Returns a 200 response if the application is alive and able to serve requests.
    """
    try:
        db.session.execute(db.text("SELECT 1 FROM result LIMIT 0")).fetchall()
    except Exception:
        app.logger.exception("Healthcheck failed on DB query.")
        return jsonify({"message": "Unable to communicate with database"}), 503

    return jsonify({"message": "Health check OK"}), 200


@api.route("", methods=["GET"])
@api.route("/", methods=["GET"])
def landing_page():
    return (
        jsonify(
            {
                "message": "Everything is fine. But choose wisely, for while "
                "the true Grail will bring you life, the false "
                "Grail will take it from you.",
                "documentation": "http://docs.resultsdb20.apiary.io/",
                "groups": url_for(".get_groups", _external=True),
                "results": url_for(".get_results", _external=True),
                "testcases": url_for(".get_testcases", _external=True),
                "outcomes": result_outcomes(),
            }
        ),
        300,
    )

1	# Copyright 2013-2016, Red Hat, Inc
2	#
3	# This program is free software; you can redistribute it and/or modify
4	# it under the terms of the GNU General Public License as published by
5	# the Free Software Foundation; either version 2 of the License, or
6	# (at your option) any later version.
7	#
8	# This program is distributed in the hope that it will be useful,
9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11	# GNU General Public License for more details.
12	#
13	# You should have received a copy of the GNU General Public License along
14	# with this program; if not, write to the Free Software Foundation, Inc.,
15	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16	#
17	# Authors:
18	# Josef Skladanka <jskladan@redhat.com>
19	# Ralph Bean <rbean@redhat.com>
20
21	import re	1✔
22	import uuid	1✔
23
24	from flask import Blueprint	1✔
25	from flask import current_app as app	1✔
26	from flask import jsonify, request, url_for	1✔
27	from flask_pydantic import validate	1✔
28	from sqlalchemy.orm import exc as orm_exc	1✔
29
30	from resultsdb.controllers.common import SERIALIZE, commit_result	1✔
31	from resultsdb.models import db	1✔
32	from resultsdb.models.results import (	1✔
33	Group,
34	Result,
35	ResultData,
36	Testcase,
37	result_outcomes,
38	)
39	from resultsdb.parsers.api_v2 import (	1✔
40	QUERY_LIMIT,
41	CreateGroupParams,
42	CreateResultParams,
43	CreateTestcaseParams,
44	GroupsParams,
45	ResultsParams,
46	TestcasesParams,
47	)
48
49	api = Blueprint("api_v2", __name__)	1✔
50
51
52	# =============================================================================
53	# GLOBAL VARIABLES
54	# =============================================================================
55
56	RE_PAGE = re.compile(r"([?&])page=([0-9]+)")	1✔
57	RE_CALLBACK = re.compile(r"([?&])callback=[^&]*&?")	1✔
58	RE_CLEAN_AMPERSANDS = re.compile(r"&+")	1✔
59
60	# =============================================================================
61	# GLOBAL METHODS
62	# =============================================================================
63
64
65	def pagination(q, page, limit):	1✔
66	"""
67	Sets the offset/limit for the DB query.
68	limit+1 is purposely set as 'limit' so we can later on decide whether 'next'
69	page link should be provided or set to None.
70	"""
71	# pagination offset
72	try:	1✔
73	page = int(page)	1✔
74	if page > 0:	1!
75	offset = page * limit	×
76	q = q.offset(offset)	×
77	except (TypeError, ValueError):	×
78	pass	×
79
80	q = q.limit(limit + 1)	1✔
81	return q	1✔
82
83
84	def prev_next_urls(data, limit=QUERY_LIMIT):	1✔
85	global RE_PAGE
86
87	try:	1✔
88	match = RE_PAGE.findall(request.url)	1✔
89	flag, page = match[0][0], int(match[0][1])	1✔
90	except IndexError: # page not found	1✔
91	page = None	1✔
92
93	prev = None	1✔
94	next = None	1✔
95	placeholder = "[!@#$%^&PLACEHOLDER&^%$#@!]"	1✔
96
97	if page is None:	1✔
98	if "?" in request.url:	1✔
99	baseurl = f"{request.url}&page={placeholder}"	1✔
100	else:
101	baseurl = f"{request.url}?page={placeholder}"	1✔
102	page = 0	1✔
103	else:
104	baseurl = RE_PAGE.sub(f"{flag}page={placeholder}", request.url)	1✔
105
106	baseurl = RE_CALLBACK.sub(r"\1", baseurl)	1✔
107	baseurl = RE_CLEAN_AMPERSANDS.sub("&", baseurl)	1✔
108
109	if page > 0:	1✔
110	prev = baseurl.replace(placeholder, str(page - 1))	1✔
111	if len(data) > limit:	1✔
112	next = baseurl.replace(placeholder, str(page + 1))	1✔
113	data = data[:limit]	1✔
114
115	return data, prev, next	1✔
116
117
118	# =============================================================================
119	# GROUPS
120	# =============================================================================
121
122
123	@api.route("/groups", methods=["GET"])	1✔
124	@validate()	1✔
125	def get_groups(query: GroupsParams):	1✔
126	q = db.session.query(Group).order_by(db.desc(Group.id))	1✔
127
128	desc_filters = []	1✔
129	if query.description:	1✔
130	for description in query.description.split(","):	1✔
131	if not description.strip():	1!
132	continue	×
133	desc_filters.append(Group.description == description)	1✔
134	# desc_filters.append(Group.description.in_(query.description.split(',')))
135	elif query.description_like_:	1✔
136	for description in query.description_like_.split(","):	1✔
137	if not description.strip():	1!
138	continue	×
139	desc_filters.append(Group.description.like(description.replace("*", "%")))	1✔
140	if desc_filters:	1✔
141	q = q.filter(db.or_(*desc_filters))	1✔
142
143	# Filter by uuid
144	if query.uuid:	1✔
145	q = q.filter(Group.uuid.in_(query.uuid.split(",")))	1✔
146
147	q = pagination(q, query.page, query.limit)	1✔
148	data, prev, next = prev_next_urls(q.all(), query.limit)	1✔
149
150	return jsonify(	1!
151	dict(
152	prev=prev,
153	next=next,
154	data=[SERIALIZE(o) for o in data],
155	)
156	)
157
158
159	@api.route("/groups/<group_id>", methods=["GET"])	1✔
160	def get_group(group_id):	1✔
161	q = Group.query.filter_by(uuid=group_id)	1✔
162	group = q.first()	1✔
163	if not group:	1✔
164	return jsonify({"message": "Group not found"}), 404	1✔
165
166	return jsonify(SERIALIZE(group))	1✔
167
168
169	@api.route("/groups", methods=["POST"])	1✔
170	@validate()	1✔
171	def create_group(body: CreateGroupParams):	1✔
172	if body.uuid:	1✔
173	group = Group.query.filter_by(uuid=body.uuid).first()	1✔
174	if not group:	1✔
175	group = Group(uuid=body.uuid)	1✔
176	else:
177	group = Group(uuid=str(uuid.uuid1()))	1✔
178
179	if body.ref_url:	1✔
180	group.ref_url = body.ref_url	1✔
181	if body.description:	1✔
182	group.description = body.description	1✔
183
184	db.session.add(group)	1✔
185	db.session.commit()	1✔
186
187	return jsonify(SERIALIZE(group)), 201	1✔
188
189
190	# =============================================================================
191	# RESULTS
192	# =============================================================================
193	def select_results(	1✔
194	since_start=None,
195	since_end=None,
196	outcomes=None,
197	groups=None,
198	testcases=None,
199	testcases_like=None,
200	result_data=None,
201	_sort=None,
202	):
203	# Checks if the sort parameter specified in the request is valid before querying.
204	# Sorts by submit_time in a descending order if the sort parameter is absent or invalid.
205	q = db.session.query(Result)	1✔
206	query_sorted = False	1✔
207	if _sort:	1✔
208	sort_match = re.match(r"^(?P<order>asc\|desc):(?P<column>.+)$", _sort)	1✔
209	if sort_match and sort_match.group("column") == "submit_time":	1✔
210	sort_order = {"asc": db.asc, "desc": db.desc}[sort_match.group("order")]	1✔
211	sort_column = getattr(Result, sort_match.group("column"))	1✔
212	q = q.order_by(sort_order(sort_column))	1✔
213	query_sorted = True	1✔
214	if _sort and _sort == "disable_sorting":	1✔
215	query_sorted = True	1✔
216	if not query_sorted:	1✔
217	q = q.order_by(db.desc(Result.submit_time))	1✔
218
219	# Time constraints
220	if since_start:	1✔
221	q = q.filter(Result.submit_time >= since_start)	1✔
222	if since_end:	1✔
223	q = q.filter(Result.submit_time <= since_end)	1✔
224
225	# Filter by outcome
226	if outcomes:	1✔
227	q = q.filter(Result.outcome.in_(outcomes))	1✔
228
229	# Filter by group_id
230	if groups:	1✔
231	q = q.filter(Result.groups.any(Group.uuid.in_(groups)))	1✔
232
233	# Filter by testcase_name
234	filter_by_testcase = []	1✔
235	if testcases:	1✔
236	filter_by_testcase.append(Result.testcase_name.in_(testcases))	1✔
237	if testcases_like:	1✔
238	for testcase in testcases_like:	1✔
239	testcase = testcase.replace("*", "%")	1✔
240	filter_by_testcase.append(Result.testcase_name.like(testcase))	1✔
241	if filter_by_testcase:	1✔
242	q = q.filter(db.or_(*filter_by_testcase))	1✔
243
244	# Filter by result_data
245	if result_data is not None:	1✔
246	for key, values in result_data.items():	1✔
247	try:	1✔
248	key, modifier = key.split(":")	1✔
249	except ValueError: # no : in key	1✔
250	key, modifier = (key, None)	1✔
251
252	if modifier == "like":	1✔
253	alias = db.aliased(ResultData)	1✔
254	if len(values) > 1: # multiple values	1✔
255	likes = []	1✔
256	# create the (value LIKE foo OR value LIKE bar OR ...) part
257	for value in values:	1✔
258	value = value.replace("*", "%")	1✔
259	likes.append(alias.value.like(value))	1✔
260	# put it together to (key = key AND (value LIKE foo OR value LIKE bar OR ...))
261	q = q.join(alias).filter(db.and_(alias.key == key, db.or_(*likes)))	1✔
262	else:
263	value = values[0].replace("*", "%")	1✔
264	q = q.join(alias).filter(	1✔
265	db.and_(alias.key == key, alias.value.like(value))
266	)
267
268	else:
269	alias = db.aliased(ResultData)	1✔
270	q = q.join(alias).filter(	1✔
271	db.and_(alias.key == key, alias.value.in_(values))
272	)
273	return q	1✔
274
275
276	def __get_results_parse_args(query: ResultsParams):	1✔
277	args = {	1✔
278	"_sort": query.sort_,
279	"limit": query.limit,
280	"page": query.page,
281	"testcases": query.testcases,
282	"testcases:like": query.testcases_like_,
283	"groups": query.groups,
284	"_distinct_on": query.distinct_on_,
285	"outcome": query.outcome,
286	"since": query.since,
287	}
288
289	# find results_data with the query parameters
290	# these are the paramters other than those defined in RequestParser
291	# request.args is a ImmutableMultiDict, which allows for more values to be
292	# stored in one key (so one can do stuff like .../results?item=foo&item=bar in URL).
293	# Here we transform the `request.args` MultiDict to `results_data` dict of lists, and
294	# while also filtering out the reserved-keyword-args
295	results_data = {	1!
296	k: request.args.getlist(k) for k in request.args.keys() if k not in args
297	}
298	for param, values in results_data.items():	1✔
299	for i, value in enumerate(values):	1✔
300	results_data[param][i] = value.split(",")	1✔
301	# flatten the list
302	results_data[param] = [	1!
303	item for sublist in results_data[param] for item in sublist
304	]
305
306	return {	1✔
307	"result_data": results_data if results_data else None,
308	"args": args,
309	}
310
311
312	def __get_results(query: ResultsParams, group_ids=None, testcase_names=None):	1✔
313	p = __get_results_parse_args(query)	1✔
314	args = p["args"]	1✔
315
316	groups = group_ids if group_ids is not None else args["groups"]	1✔
317	testcases = testcase_names if testcase_names is not None else args["testcases"]	1✔
318
319	q = select_results(	1✔
320	since_start=args["since"]["start"],
321	since_end=args["since"]["end"],
322	outcomes=args["outcome"],
323	groups=groups,
324	testcases=testcases,
325	testcases_like=args["testcases:like"],
326	result_data=p["result_data"],
327	_sort=args["_sort"],
328	)
329
330	q = pagination(q, args["page"], args["limit"])	1✔
331	data, prev, next = prev_next_urls(q.all(), args["limit"])	1✔
332
333	return jsonify(	1!
334	dict(
335	prev=prev,
336	next=next,
337	data=[SERIALIZE(o) for o in data],
338	)
339	)
340
341
342	@api.route("/results", methods=["GET"])	1✔
343	@validate()	1✔
344	def get_results(query: ResultsParams):	1✔
345	return __get_results(query)	1✔
346
347
348	@api.route("/results/latest", methods=["GET"])	1✔
349	@validate()	1✔
350	def get_results_latest(query: ResultsParams):	1✔
351	p = __get_results_parse_args(query)	1✔
352	args = p["args"]	1✔
353	since_start = args["since"].get("start", None)	1✔
354	since_end = args["since"].get("end", None)	1✔
355	groups = args.get("groups", None)	1✔
356	testcases = args.get("testcases", None)	1✔
357	testcases_like = args.get("testcases:like", None)	1✔
358	distinct_on = args.get("_distinct_on", None)	1✔
359
360	if not distinct_on:	1✔
361	q = select_results(	1✔
362	since_start=since_start,
363	since_end=since_end,
364	groups=groups,
365	testcases=testcases,
366	testcases_like=testcases_like,
367	result_data=p["result_data"],
368	)
369
370	# Produce a subquery with the same filter criteria as above except
371	# test case name, which we group by and join on.
372	sq = (	1✔
373	select_results(
374	since_start=since_start,
375	since_end=since_end,
376	groups=groups,
377	result_data=p["result_data"],
378	)
379	.order_by(None)
380	.with_entities(
381	Result.testcase_name.label("testcase_name"),
382	db.func.max(Result.submit_time).label("max_submit_time"),
383	)
384	.group_by(Result.testcase_name)
385	.subquery()
386	)
387	q = q.join(	1✔
388	sq,
389	db.and_(
390	Result.testcase_name == sq.c.testcase_name,
391	Result.submit_time == sq.c.max_submit_time,
392	),
393	)
394
395	results = q.all()	1✔
396
397	return jsonify(	1!
398	dict(
399	data=[SERIALIZE(o) for o in results],
400	)
401	)
402
403	if not any(	1✔
404	[testcases, testcases_like, since_start, since_end, groups, p["result_data"]]
405	):
406	return (	1✔
407	jsonify(
408	{
409	"message": (
410	"Please, provide at least one " "filter beside '_distinct_on'"
411	)
412	}
413	),
414	400,
415	)
416
417	q = db.session.query(Result)	1✔
418	q = select_results(	1✔
419	since_start=since_start,
420	since_end=since_end,
421	groups=groups,
422	testcases=testcases,
423	testcases_like=testcases_like,
424	result_data=p["result_data"],
425	_sort="disable_sorting",
426	)
427
428	values_distinct_on = [Result.testcase_name]	1✔
429	for i, key in enumerate(distinct_on):	1✔
430	name = f"result_data_{i}_{key}"	1✔
431	alias = db.aliased(	1✔
432	db.session.query(ResultData).filter(ResultData.key == key).subquery(),
433	name=name,
434	)
435	q = q.outerjoin(alias)	1✔
436	values_distinct_on.append(db.text(f"{name}.value"))	1✔
437
438	q = q.distinct(*values_distinct_on)	1✔
439	q = q.order_by(*values_distinct_on).order_by(db.desc(Result.submit_time))	1✔
440
441	results = q.all()	1✔
442	results = dict(	1!
443	data=[SERIALIZE(o) for o in results],
444	)
445	results["data"] = sorted(	1✔
446	results["data"], key=lambda x: x["submit_time"], reverse=True
447	)
448	return jsonify(results)	1✔
449
450
451	@api.route("/groups/<group_id>/results", methods=["GET"])	1✔
452	@validate()	1✔
453	def get_results_by_group(group_id: str, query: ResultsParams):	1✔
454	group = Group.query.filter_by(uuid=group_id).first()	1✔
455	if not group:	1!
456	return jsonify({"message": f"Group not found: {group_id}"}), 404	×
457	return __get_results(query, group_ids=[group.uuid])	1✔
458
459
460	@api.route("/testcases/<path:testcase_name>/results", methods=["GET"])	1✔
461	@validate()	1✔
462	def get_results_by_testcase(testcase_name: str, query: ResultsParams):	1✔
463	testcase = Testcase.query.filter_by(name=testcase_name).first()	1✔
464	if not testcase:	1!
465	return jsonify({"message": "Testcase not found"}), 404	×
466	return __get_results(query, testcase_names=[testcase.name])	1✔
467
468
469	@api.route("/results/<result_id>", methods=["GET"])	1✔
470	def get_result(result_id):	1✔
471	try:	1✔
472	result = Result.query.filter_by(id=result_id).one()	1✔
473	except orm_exc.NoResultFound:	1✔
474	return jsonify({"message": "Result not found"}), 404	1✔
475
476	return jsonify(SERIALIZE(result))	1✔
477
478
479	@api.route("/results", methods=["POST"])	1✔
480	@validate()	1✔
481	def create_result(body: CreateResultParams):	1✔
482	return create_result_generic(body)	1✔
483
484
485	def create_result_generic(body: CreateResultParams):	1✔
486	if body.data:	1✔
487	invalid_keys = [key for key in body.data.keys() if ":" in key]	1!
488	if invalid_keys:	1✔
489	app.logger.warning("Colon not allowed in key name: %s", invalid_keys)	1✔
490	return jsonify(	1✔
491	{"message": "Colon not allowed in key name: %r" % invalid_keys}
492	), 400
493
494	tc = body.testcase	1✔
495
496	testcase = Testcase.query.filter_by(name=tc["name"]).first()	1✔
497	if not testcase:	1✔
498	app.logger.debug("Testcase %s does not exist yet. Creating", tc["name"])	1✔
499	testcase = Testcase(name=tc["name"])	1✔
500	testcase.ref_url = tc.get("ref_url", testcase.ref_url)	1✔
501	db.session.add(testcase)	1✔
502
503	# groups is a list of strings(uuid) or dicts(group object)
504	# when a group defined by the string is not found, new is created
505	# group defined by the object, is updated/created with the values from the object
506	# non-existing groups are created automatically
507	groups = []	1✔
508	if body.groups:	1✔
509	for grp in body.groups:	1✔
510	if isinstance(grp, (str, bytes)):	1✔
511	grp = dict(uuid=grp)	1✔
512	elif isinstance(grp, dict):	1!
513	grp["uuid"] = grp.get("uuid", str(uuid.uuid1()))	1✔
514
515	group = Group.query.filter_by(uuid=grp["uuid"]).first()	1✔
516	if not group:	1✔
517	group = Group(uuid=grp["uuid"])	1✔
518
519	group.description = grp.get("description", group.description)	1✔
520	group.ref_url = grp.get("ref_url", group.ref_url)	1✔
521
522	db.session.add(group)	1✔
523	groups.append(group)	1✔
524
525	result = Result(	1✔
526	testcase, body.outcome, groups, body.ref_url, body.note, body.submit_time
527	)
528	# Convert result_data
529	# for each key-value pair in body.data
530	# convert keys to unicode
531	# if value is string: NOP
532	# if value is list or tuple:
533	# convert values to unicode, create key-value pair for each value from the list
534	# if value is something else: convert to unicode
535	# Store all the key-value pairs
536	if isinstance(body.data, dict):	1✔
537	to_store = []	1✔
538	for key, value in body.data.items():	1✔
539	if not isinstance(key, str):	1!
UNCOV 540	key = str(key)	×
541
542	if isinstance(value, str):	1✔
543	to_store.append((key, value))	1✔
544
545	elif isinstance(value, (list, tuple)):	1!
546	for v in value:	1✔
547	if not isinstance(v, str):	1!
UNCOV 548	v = str(v)	×
549	to_store.append((key, v))	1✔
550	else:
UNCOV 551	value = str(value)	×
552	to_store.append((key, value))	×
553
554	for key, value in to_store:	1✔
555	ResultData(result, key, value)	1✔
556
557	return commit_result(result)	1✔
558
559
560	# =============================================================================
561	# TESTCASES
562	# =============================================================================
563
564
565	def select_testcases(args_name=None, args_name_like=None):	1✔
566	q = db.session.query(Testcase).order_by(db.asc(Testcase.name))	1✔
567
568	name_filters = []	1✔
569	if args_name:	1✔
570	for name in [name.strip() for name in args_name.split(",") if name.strip()]:	1!
571	name_filters.append(Testcase.name == name)	1✔
572	elif args_name_like:	1✔
573	for name in [	1!
574	name.strip() for name in args_name_like.split(",") if name.strip()
575	]:
576	name_filters.append(Testcase.name.like(name.replace("*", "%")))	1✔
577	if name_filters:	1✔
578	q = q.filter(db.or_(*name_filters))	1✔
579
580	return q	1✔
581
582
583	@api.route("/testcases", methods=["GET"])	1✔
584	@validate()	1✔
585	def get_testcases(query: TestcasesParams):	1✔
586	q = select_testcases(query.name, query.name_like_)	1✔
587	q = pagination(q, query.page, query.limit)	1✔
588	data, prev, next = prev_next_urls(q.all(), query.limit)	1✔
589
590	return jsonify(	1!
591	dict(
592	prev=prev,
593	next=next,
594	data=[SERIALIZE(o) for o in data],
595	)
596	)
597
598
599	@api.route("/testcases/<path:testcase_name>", methods=["GET"])	1✔
600	def get_testcase(testcase_name):	1✔
601	try:	1✔
602	testcase = Testcase.query.filter_by(name=testcase_name).one()	1✔
603	except orm_exc.NoResultFound:	1✔
604	return jsonify({"message": "Testcase not found"}), 404	1✔
605
606	return jsonify(SERIALIZE(testcase))	1✔
607
608
609	@api.route("/testcases", methods=["POST"])	1✔
610	@validate()	1✔
611	def create_testcase(body: CreateTestcaseParams):	1✔
612	testcase = Testcase.query.filter_by(name=body.name).first()	1✔
613	if not testcase:	1✔
614	testcase = Testcase(name=body.name)	1✔
615	if body.ref_url is not None:	1!
616	testcase.ref_url = body.ref_url	1✔
617
618	db.session.add(testcase)	1✔
619	db.session.commit()	1✔
620
621	return jsonify(SERIALIZE(testcase)), 201	1✔
622
623
624	@api.route("/healthcheck", methods=["GET"])	1✔
625	def healthcheck():	1✔
626	"""
627	Request handler for performing an application-level health check. This is
628	not part of the published API, it is intended for use by OpenShift or other
629	monitoring tools.
630
631	Returns a 200 response if the application is alive and able to serve requests.
632	"""
633	try:	1✔
634	db.session.execute(db.text("SELECT 1 FROM result LIMIT 0")).fetchall()	1✔
635	except Exception:	1✔
636	app.logger.exception("Healthcheck failed on DB query.")	1✔
637	return jsonify({"message": "Unable to communicate with database"}), 503	1✔
638
639	return jsonify({"message": "Health check OK"}), 200	1✔
640
641
642	@api.route("", methods=["GET"])	1✔
643	@api.route("/", methods=["GET"])	1✔
644	def landing_page():	1✔
645	return (	1✔
646	jsonify(
647	{
648	"message": "Everything is fine. But choose wisely, for while "
649	"the true Grail will bring you life, the false "
650	"Grail will take it from you.",
651	"documentation": "http://docs.resultsdb20.apiary.io/",
652	"groups": url_for(".get_groups", _external=True),
653	"results": url_for(".get_results", _external=True),
654	"testcases": url_for(".get_testcases", _external=True),
655	"outcomes": result_outcomes(),
656	}
657	),
658	300,
659	)

release-engineering / resultsdb / 9205616287

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous