More utility functions for the kernelci-core api helper

Makefile

@@ -14,7 +14,9 @@ test: \
  validate-yaml
 
 mypy:
- mypy \
+ mypy --ignore-missing-imports \
+ --follow-imports=skip \
+ --strict-optional \
  -m kernelci.api \
  -m kernelci.api.latest \
  -m kernelci.api.helper

kernelci/api/helper.py

@@ -10,7 +10,7 @@
 import json
 import requests
 
-from . import API
+from . import API, models
 
 
 def merge(primary: dict, secondary: dict):
@@ -157,17 +157,30 @@ def create_job_node(self, job_config, input_node,
  except requests.exceptions.HTTPError as error:
  raise RuntimeError(json.loads(error.response.text)) from error
 
- def submit_regression(self, regression):
- """Post a regression object
+ def submit_regression(self, fail_node: dict, pass_node: dict):
+ """Creates and submits a regression object from two existing
+ nodes (test or kbuilds) passed as parameters:
 
- [TODO] Leave this function in place in case we'll need any other
- processing or formatting before submitting the regression node
+ Arguments:
+ fail_node: dict describing the node that failed and triggered
+ the regression creation.
+ pass_node: dict describing the previous passing run of the same
+ test/build
+
+ General use case: failure detected, the fail_node and pass_node
+ are retrieved from the API and passed to this function to define
+ and submit a regression.
+
+ Returns the API request response.
  """
- # pylint: disable=protected-access
+ fail_node_obj = self.get_node_obj(fail_node)
+ pass_node_obj = self.get_node_obj(pass_node)
+ regression_dict = models.Regression.create_regression(
+ fail_node_obj, pass_node_obj, as_dict=True)
  try:
- return self.api._post('node', regression)
+ return self.api.node.add(regression_dict)
  except requests.exceptions.HTTPError as error:
- raise RuntimeError(error.response.text) from error
+ raise RuntimeError(json.loads(error.response.text)) from error
 
  def _prepare_results(self, results, parent, base):
  node = results['node'].copy()
@@ -246,6 +259,46 @@ def submit_results(self, results, root):
  except requests.exceptions.HTTPError as error:
  raise RuntimeError(json.loads(error.response.text)) from error
 
+ def get_node_obj(self, node_dict, get_linked=False):
+ """Takes a dict defining a Node and returns it as a concrete
+ Node object (or Node subtype object). If get_linked is set to
+ True, linked nodes are vivified (not recursively).
+
+ It will also accept a Node (or subclass) object instead of a
+ dict. This can be used to fetch and vivify the linked objects if
+ get_linked is set to True.
+ """
+ # pylint: disable=protected-access
+ def get_attr(obj, attr):
+ """Similar behavior to the builtin getattr, but it can be
+ used with nested attributes in.dot.notation
+ """
+ fields = attr.split('.')
+ if len(fields) == 1:
+ return getattr(obj, fields[0])
+ return get_attr(getattr(obj, fields[0]), '.'.join(fields[1:]))
+
+ def set_attr(obj, attr, value):
+ """Similar behavior to the builtin setattr, but it can be
+ used with nested attributes in.dot.notation
+ """
+ fields = attr.split('.')
+ if len(fields) == 1:
+ setattr(obj, fields[0], value)
+ return
+ obj = get_attr(obj, '.'.join(fields[:-1]))
+ setattr(obj, fields[-1], value)
+
+ node_obj = models.parse_node_obj(node_dict)
+ if get_linked:
+ for linked_node_attr in node_obj._OBJECT_ID_FIELDS:
+ node_id = get_attr(node_obj, linked_node_attr)
+ if node_id:
+ resp = self.api.node.get(node_id)
+ linked_obj = models.parse_node_obj(resp)
+ set_attr(node_obj, linked_node_attr, linked_obj)
+ return node_obj
+
  @classmethod
  def load_json(cls, json_path, encoding='utf-8'):
  """Read content from JSON file"""

kernelci/api/models.py

@@ -314,7 +314,7 @@
  description='Type of the object',
  const=True
  )
  data: CheckoutData = Field(
  description="Checkout details"
  )
 
@@ -365,7 +365,7 @@
  description='Type of the object',
  const=True
  )
  data: KbuildData = Field(
  description="Kbuild details"
  )
 
@@ -422,10 +422,16 @@
  description='Type of the object',
  const=True
  )
  data: TestData = Field(
  description="Test details"
  )
 
+ def is_test_suite(self):
+ """Returns True if the node represents a test suite, false
+ otherwise (test case)
+ """
+ return self.name == self.group
+
 
 class RegressionData(BaseModel):
  """Model for the data field of a Regression node"""
@@ -460,7 +466,7 @@
  description='Type of the object',
  const=True
  )
  data: RegressionData = Field(
  description="Regression details"
  )
 
@@ -566,11 +572,20 @@
  )
 
 
-def parse_node_obj(node: Node):
+def parse_node_obj(node: Node | dict):
  """Parses a generic Node object using the appropriate Node submodel
  depending on its 'kind'.
+
+ If the node is passed as a Node object, it returns the appropriate
+ submodel object.
+ If it's passed as a dict, it's converted to the appropriate Node
+ submodel object.
+ If it's passed as a concrete Node submodel object, it's returned as
+ is.
  """
- for submodel in type(node).__subclasses__():
+ if isinstance(node, dict):
+ node = Node.parse_obj(node)
+ for submodel in Node.__subclasses__():
  if node.kind == submodel.class_kind:
  return submodel.parse_obj(node)
  raise ValueError(f"Unsupported node kind: {node.kind}")

requirements.txt

@@ -13,3 +13,4 @@ pyyaml==6.0
 requests==2.31.0
 scp==0.14.5
 toml==0.10.2
+pymongo-stubs==0.2.0

tests/api/conftest.py

@@ -54,30 +54,115 @@ def __init__(self):
  "timeout": "2022-09-28T11:05:25.814000",
  "holdoff": None
  }
- self._regression_node = {
- "kind": "regression",
- "name": "kver",
+ self._pass_node = {
+ "kind": "test",
+ "name": "login",
  "path": [
  "checkout",
- "kver"
+ "kbuild-gcc-10-x86",
+ "baseline-x86",
+ "login"
  ],
- "group": "kver",
- "data": {
- "fail_node": "636143c38f94e20c6826b0b6",
- "pass_node": "636143c38f94e20c6826b0b5"
- },
- "parent": "6361440f8f94e20c6826b0b7",
+ "group": "baseline-x86",
  "state": "done",
  "result": "pass",
+ "data": {
+ "kernel_revision": {
+ "tree": "kernelci",
+ "url": "https://github.com/kernelci/linux.git",
+ "branch": "staging-mainline",
+ "commit": "7f036eb8d7a5ff2f655c5d949343bac6a2928bce",
+ "describe": "staging-mainline-20220927.0",
+ "version": {
+ "version": 6,
+ "patchlevel": 0,
+ "sublevel": None,
+ "extra": "-rc7-36-g7f036eb8d7a5",
+ "name": None
+ }
+ },
+ "arch": "x86_64",
+ "defconfig": "x86_64_defconfig",
+ "platform": "gcc-10",
+ },
  "artifacts": {
- "tarball": "http://staging.kernelci.org:9080/linux-kernelci\
- -staging-mainline-staging-mainline-20221101.1.tar.gz"
+ "tarball": ("http://staging.kernelci.org:9080/linux-kernelci"
+  "-staging-mainline-staging-mainline-20221101.1.tar.gz")
  },
  "created": "2022-11-01T16:07:09.770000",
  "updated": "2022-11-01T16:07:09.770000",
  "timeout": "2022-11-02T16:07:09.770000",
  "holdoff": None
  }
+ self._fail_node = {
+ "kind": "test",
+ "name": "login",
+ "path": [
+ "checkout",
+ "kbuild-gcc-10-x86",
+ "baseline-x86",
+ "login"
+ ],
+ "group": "baseline-x86",
+ "state": "done",
+ "result": "fail",
+ "data": {
+ "kernel_revision": {
+ "tree": "kernelci",
+ "url": "https://github.com/kernelci/linux.git",
+ "branch": "staging-mainline",
+ "commit": "7f036eb8d7a5ff2f655c5d949343bac6a2928bce",
+ "describe": "staging-mainline-20220927.0",
+ "version": {
+ "version": 6,
+ "patchlevel": 0,
+ "sublevel": None,
+ "extra": "-rc7-36-g7f036eb8d7a5",
+ "name": None
+ }
+ },
+ "arch": "x86_64",
+ "defconfig": "x86_64_defconfig",
+ "platform": "gcc-10",
+ },
+ "artifacts": {
+ "tarball": ("http://staging.kernelci.org:9080/linux-kernelci"
+ "-staging-mainline-staging-mainline-20221101.1.tar.gz")
+ },
+ "created": "2022-11-02T16:07:09.770000",
+ "updated": "2022-11-02T16:07:09.770000",
+ "timeout": "2022-11-03T16:07:09.770000",
+ "holdoff": None
+ }
+ self._expected_regression_node = {
+ 'kind': 'regression',
+ 'name': 'login',
+ 'path': [
+ 'checkout',
+ 'kbuild-gcc-10-x86',
+ 'baseline-x86',
+ 'login'
+ ],
+ 'group': 'baseline-x86',
+ 'state': 'done',
+ 'data': {
+ 'failed_kernel_revision': {
+ 'tree': 'kernelci',
+ 'url': 'https://github.com/kernelci/linux.git',
+ 'branch': 'staging-mainline',
+ 'commit': '7f036eb8d7a5ff2f655c5d949343bac6a2928bce',
+ 'describe': 'staging-mainline-20220927.0',
+ 'version': {
+ 'version': 6,
+ 'patchlevel': 0,
+ 'extra': '-rc7-36-g7f036eb8d7a5'
+ }
+ },
+ 'arch': 'x86_64',
+ 'defconfig': 'x86_64_defconfig',
+ 'platform': 'gcc-10'
+ }
+ }
  self._kunit_node = {
  "id": "6332d92f1a45d41c279e7a06",
  "kind": "node",
@@ -129,9 +214,19 @@ def checkout_node(self):
  return self._checkout_node
 
  @property
- def regression_node(self):
- """Get the regression node"""
- return self._regression_node
+ def fail_node(self):
+ """Get the input fail node for a regression"""
+ return self._fail_node
+
+ @property
+ def pass_node(self):
+ """Get the input pass node for a regression"""
+ return self._pass_node
+
+ @property
+ def expected_regression_node(self):
+ """Get the expected regression node"""
+ return self._expected_regression_node
 
  @property
  def kunit_node(self):
@@ -143,13 +238,6 @@ def kunit_child_node(self):
  """Get the kunit sample child node"""
  return self._kunit_child_node
 
- def get_regression_node_with_id(self):
- """Get regression node with node ID"""
- self._regression_node.update({
- "id": "6361442d8f94e20c6826b0b9"
- })
- return self._regression_node
-
  def update_kunit_node(self):
  """Update kunit node with timestamp fields"""
  self._kunit_node.update({
@@ -227,16 +315,19 @@ def mock_api_get_node_from_id(mocker):
 
 
 @pytest.fixture
-def mock_api_post_regression(mocker):
- """Mocks call to LatestAPI class method used to submit regression node"""
- resp = Response()
- resp.status_code = 200
- resp._content = json.dumps( # pylint: disable=protected-access
- APIHelperTestData().get_regression_node_with_id()).encode('utf-8')
+def mock_api_node_add(mocker):
+ """Mocks call to LatestAPI Node add so that it returns the sent node
+ as a response (echo)
+ """
+ def return_node_response(input_node):
+ resp = Response()
+ resp.status_code = 200
+ resp._content = json.dumps(input_node).encode('utf-8') # pylint: disable=protected-access
+ return resp
 
  mocker.patch(
- 'kernelci.api.API._post',
- return_value=resp,
+ 'kernelci.api.latest.LatestAPI.Node.add',
+ side_effect=return_node_response
  )
 
 

tests/api/test_api.py

@@ -81,31 +81,21 @@ def test_get_node_from_event(get_api_config, mock_api_get_node_from_id):
  }
 
 
-def test_submit_regression(get_api_config, mock_api_post_regression):
- """Test method to submit regression object to API"""
+def test_submit_regression(get_api_config, mock_api_node_add):
+ """Tests the regression generation and submission done by
+ helper.submit_regression()
+ """
  for _, api_config in get_api_config.items():
  api = kernelci.api.get_api(api_config)
  helper = kernelci.api.helper.APIHelper(api)
  resp = helper.submit_regression(
- regression=APIHelperTestData().regression_node
+ APIHelperTestData().fail_node,
+ APIHelperTestData().pass_node
  )
  assert resp.status_code == 200
- assert resp.json().keys() == {
- 'id',
- 'artifacts',
- 'created',
- 'data',
- 'group',
- 'holdoff',
- 'kind',
- 'name',
- 'path',
- 'parent',
- 'result',
- 'state',
- 'timeout',
- 'updated',
- }
+ created_regression = resp.json()
+ for field, expected_val in APIHelperTestData().expected_regression_node.items():
+ assert created_regression[field] == expected_val
 
 
 def test_pubsub_event_filter_positive(get_api_config, mock_api_subscribe):