From Fedora Project Wiki
m (fixed links)
(bringing summary to main page, adding evaluation section)
Line 3: Line 3:
 
{{admon/warning|This Page is being reworked|This message will be removed when refactoring is complete}}
 
{{admon/warning|This Page is being reworked|This message will be removed when refactoring is complete}}
  
== Current Proposals ==
+
== Summary ==
 +
 
 +
Lets define a clear delineation of between a ''test suite'' (including framework) and the CI system that is running the test suite. This is the standard interface.
 +
 
 +
[[File:Invoking-tests-standard-interface.png|800px]]
 +
 
 +
What follows is a standard way to discover, package and invoke integration tests for a package stored in a Fedora dist-git repo.
 +
 
 +
Many Fedora packages have unit tests. These tests are typically run during a <code>%check</code> RPM build step and run in a build root. On the other hand, integration testing should happen against a composed system. Upstream projects have integration tests, both Fedora QA and the Atomic Host team would like to create more integration tests, Red Hat would like to bring integration tests upstream.
 +
 
 +
== Owner ==
 +
 
 +
* Name: '''TODO:''' Fill in owner here. Maybe pingou, tflink, other? More than one owner is possible.
 +
* Email: '''TODO:''' Fill in email of owner here.
 +
 
 +
== Terminology ==
 +
 
 +
* '''Test Subject''': The items that are to be tested.
 +
** Examples: RPMs, OCI image, ISO, QCow2, Module repository ...
 +
* '''Test''': A callable/runnable piece of code and corresponding test data and mocks which exercises and evaluates a ''test subject''.
 +
* '''Test Suite''': The collection of all tests that apply to a ''test subject''.
 +
* '''Test Framework''': A library or component that the ''test suite'' and ''tests'' use to accomplish their job.
 +
** Examples: [https://avocado-framework.github.io/ Avocado], [https://wiki.gnome.org/Initiatives/GnomeGoals/InstalledTests GNOME Installed Tests], [https://pagure.io/modularity-testing-framework/ Modularity Testing Framework], [https://github.com/projectatomic/atomic-host-tests Ansible tests in Atomic Host], [https://tunir.readthedocs.io/en/latest/ Tunir tests], docker test images, ...
 +
* '''Test Result''': A boolean pass/fail output of a ''test suite''.
 +
** ''Test results'' are for consumption by automated aspects of a ''testing systems''.
 +
* '''Test Artifact''': Any additional output of the test suite such as the stdout/stderr output, log files, screenshots, core dumps, or TAP/Junit/subunit streams.
 +
** ''Test artifacts'' are for consumption by humans, archival or big data analysis.
 +
* '''Testing System''': A CI or other ''testing system'' that would like to discover, stage and invoke tests for a ''test subject''.
 +
** Examples: [https://jenkins.io/ Jenkins], [https://taskotron.fedoraproject.org/ Taskotron], [https://docs.openstack.org/infra/zuul/ ZUUL], [https://ci.centos.org/ CentOS CI], Red Hat CI, [https://travis-ci.org/ Travis], [https://semaphoreci.com/ Semaphore], [https://developers.openshift.com/managing-your-applications/continuous-integration.html Openshift CI/CD], [https://wiki.ubuntu.com/ProposedMigration/AutopkgtestInfrastructure Ubuntu CI], ...
 +
 
 +
== Responsibilities ==
 +
 
 +
The '''testing system''' is responsible to:
 +
* Build or otherwise acquire the ''test subject'', such as package, container image, tree …
 +
* Decide which ''test suite'' to run, often by using the standard interface to discover appropriate ''tests'' for the dist-git repo that a test subject originated in.
 +
* Schedule, provision or orchestrate a job to run the ''test suite'' on appropriate compute, storage, ...
 +
* Stage the ''test suite'' as described by the ''standard interface''.
 +
* Invoke the ''test suite'' as described by the ''standard interface''.
 +
* Gather the ''test results'' and ''test artifacts'' as described by the ''standard interface''.
 +
* Announce and relay the ''test results'' and ''test artifacts'' for gating, archival ...
 +
 
 +
The '''standard interface''' describes how to:
 +
* Discover a ''test suite'' for a given dist-git repo.
 +
* Uniquely identify a ''test suite''.
 +
* Stage a ''test suite'' and its dependencies such as ''test frameworks''.
 +
* Provide the ''test subject'' to the ''test suite''.
 +
* Invoke a ''test suite'' in a consistent way.
 +
* Gather ''test results'' and ''test artifacts'' from the invoked ''test suite''.
 +
 
 +
The '''test suite''' is responsible to:
 +
* Declare its dependencies such as a ''test framework'' via the ''standard interface''.
 +
* Execute the ''test framework'' as necessary.
 +
* Provision (usually locally) any containers or virtual machines necessary for testing the ''test subject''.
 +
* Provide ''test results'' and ''test subjects'' back according to the standard 
 +
 
 +
The format of the textual logs and ''test artifacts'' that come out of a test suite is not prescribed by this document. Nor is it envisioned to be standardized across all possible ''test suites''.
 +
 
 +
== Requirements ==
 +
 
 +
* The ''test suite'' and ''test framework'' SHOULD NOT leak its implementation details into the testing system, other than via the ''standard interface''.
 +
* The ''test suite'' and ''test framework'' SHOULD NOT rely on behavior of the testing system other than the ''standard interface''.
 +
* The ''standard interface'' MUST enable a dist-git packager to run a ''test suite'' locally.
 +
** ''Test suites'' or ''test frameworks'' MAY call out to the network for certain tasks.
 +
* It MUST be possible to stage an upstream ''test suite'' using the ''standard interface''.
 +
* Both ''in-situ tests'', and more rigorous ''outside-in tests'' MUST be possible with the ''standard interface''.
 +
** For ''in-situ tests'' the ''test suite'' is in the same file system tree and process space as the ''test subject''.
 +
** For ''outside-in tests'' the ''test suite'' is outside of the file system tree and process space of the ''test subject''.
 +
* The ''test suite'' and ''test framework'' SHOULD be able to provision containers and virtual machines necessary for its testing without requesting them from the ''testing system''.
 +
* The ''standard interface'' SHOULD describe how to uniquely identify a ''test suite'',
 +
 
 +
== Detailed Description ==
 +
 
 +
This standard interface describes how to discover, stage and invoke tests. It is important to cleanly separate implementation details of the ''testing system'' from the ''test suite'' and its framework. It is also important to allow Fedora packagers to locally and manually invoke a ''test suite''.
 +
 
 +
=== Staging ===
 +
 
 +
 
 +
Tests files will be added into the ''tests'' folder in the dist-git of the package that they are testing. The structure of the files and folders is left to the liberty of the packagers but there should be a ''run_tests.yml'' playbook at the top level of the tests folder to set up and run all the tests.
 +
 
 +
=== Invocation ===
 +
 
 +
The test can be invoke simply by calling ''sudo ansible-playbook run_tests.yml'' on the ''run_tests.yml'' playbook of interest.
 +
 
 +
=== Discovery ===
 +
 
 +
A testing system needs to be able to efficiently answer the question "does this subject have any tests packages, and if so, what are their names". This should be automatically discoverable to the extent possible.
 +
 
 +
 
 +
Use repoquery, basically I propose we rely on the dependency chain of the
 +
RPMs itself instead of trying to replicate it differently.
 +
 
 +
repoquery --whatrequires or an equivalent relying on mdapi:
 +
https://apps.fedoraproject.org/mdapi/ (which I need to adjust to support
 +
back walking (ie find which packages requires "foo" instead of what packages
 +
"foo" requires which we currently have)
 +
and we should be able to build a list of dependencies.
 +
 
 +
== Test Output Collection ==
 +
 
 +
This will enable us to collect full consistent output regardless of the test output to report with ansible invocation
 +
 
 +
https://github.com/openstack/ara
 +
 
 +
 
 +
In addition, a ''test suite'' can be uniquely identified using the git hash of the commit of the git repo.
 +
 
 +
== Scope ==
 +
 
 +
Since the tests are added in a sub-folder of the dist-git repo, there are no changes required to the Fedora infrastructure and will have no impact on the packagers' workflow and tooling.
 +
 
 +
Only the testing system will need to be taught to install the requirements and run the playbooks.
 +
 
 +
== Benefit to Fedora ==
 +
 
 +
Developers benefit by having a consistent target for how to describe tests, while also being able to execute them locally while debugging issues or iterating on tests.
 +
 
 +
By staging and invoking tests consistently in Fedora we create an eco-system for the tests that allows varied test frameworks as well as CI system infrastructure to interoperate. The integration tests outlast the implementation details of either the frameworks they're written in or the CI systems running them.
 +
 
 +
'''TODO:''' note any additional benefits to Fedora.
 +
 
 +
 
 +
= Current Proposals =
 +
 
 +
There are currently two proposals for how to implement this change and a final decision has not yet been made as to which is the final proposal. The two current proposals are:
 +
 
 
* [[Changes/InvokingTestsPackaged|Tests invoked via RPM packages]]
 
* [[Changes/InvokingTestsPackaged|Tests invoked via RPM packages]]
 
* [[Changes/InvokingTestsAnsible|Tests invoked via Ansible]]
 
* [[Changes/InvokingTestsAnsible|Tests invoked via Ansible]]
 +
 +
== Evaluations ==
 +
Interested parties should put their evaluations here. Please add to the table below with your vote for which option you think is the better choice at this point in time.
 +
 +
{|
 +
! Contributor !! Packaged Tests !! Ansible Tests !! Notes
 +
|-
 +
| [[User:YourUserName|YourUserName]] || || +1 ||  This is just an example, please vote for one of the options
 +
|-
 +
|  || ||  || 
 +
|-
 +
|}

Revision as of 16:08, 11 April 2017

Standard Discovery, Packaging, Invocation of Integration Tests

Warning.png
This Page is being reworked
This message will be removed when refactoring is complete

Summary

Lets define a clear delineation of between a test suite (including framework) and the CI system that is running the test suite. This is the standard interface.

Invoking-tests-standard-interface.png

What follows is a standard way to discover, package and invoke integration tests for a package stored in a Fedora dist-git repo.

Many Fedora packages have unit tests. These tests are typically run during a %check RPM build step and run in a build root. On the other hand, integration testing should happen against a composed system. Upstream projects have integration tests, both Fedora QA and the Atomic Host team would like to create more integration tests, Red Hat would like to bring integration tests upstream.

Owner

  • Name: TODO: Fill in owner here. Maybe pingou, tflink, other? More than one owner is possible.
  • Email: TODO: Fill in email of owner here.

Terminology

  • Test Subject: The items that are to be tested.
    • Examples: RPMs, OCI image, ISO, QCow2, Module repository ...
  • Test: A callable/runnable piece of code and corresponding test data and mocks which exercises and evaluates a test subject.
  • Test Suite: The collection of all tests that apply to a test subject.
  • Test Framework: A library or component that the test suite and tests use to accomplish their job.
  • Test Result: A boolean pass/fail output of a test suite.
    • Test results are for consumption by automated aspects of a testing systems.
  • Test Artifact: Any additional output of the test suite such as the stdout/stderr output, log files, screenshots, core dumps, or TAP/Junit/subunit streams.
    • Test artifacts are for consumption by humans, archival or big data analysis.
  • Testing System: A CI or other testing system that would like to discover, stage and invoke tests for a test subject.

Responsibilities

The testing system is responsible to:

  • Build or otherwise acquire the test subject, such as package, container image, tree …
  • Decide which test suite to run, often by using the standard interface to discover appropriate tests for the dist-git repo that a test subject originated in.
  • Schedule, provision or orchestrate a job to run the test suite on appropriate compute, storage, ...
  • Stage the test suite as described by the standard interface.
  • Invoke the test suite as described by the standard interface.
  • Gather the test results and test artifacts as described by the standard interface.
  • Announce and relay the test results and test artifacts for gating, archival ...

The standard interface describes how to:

  • Discover a test suite for a given dist-git repo.
  • Uniquely identify a test suite.
  • Stage a test suite and its dependencies such as test frameworks.
  • Provide the test subject to the test suite.
  • Invoke a test suite in a consistent way.
  • Gather test results and test artifacts from the invoked test suite.

The test suite is responsible to:

  • Declare its dependencies such as a test framework via the standard interface.
  • Execute the test framework as necessary.
  • Provision (usually locally) any containers or virtual machines necessary for testing the test subject.
  • Provide test results and test subjects back according to the standard

The format of the textual logs and test artifacts that come out of a test suite is not prescribed by this document. Nor is it envisioned to be standardized across all possible test suites.

Requirements

  • The test suite and test framework SHOULD NOT leak its implementation details into the testing system, other than via the standard interface.
  • The test suite and test framework SHOULD NOT rely on behavior of the testing system other than the standard interface.
  • The standard interface MUST enable a dist-git packager to run a test suite locally.
    • Test suites or test frameworks MAY call out to the network for certain tasks.
  • It MUST be possible to stage an upstream test suite using the standard interface.
  • Both in-situ tests, and more rigorous outside-in tests MUST be possible with the standard interface.
    • For in-situ tests the test suite is in the same file system tree and process space as the test subject.
    • For outside-in tests the test suite is outside of the file system tree and process space of the test subject.
  • The test suite and test framework SHOULD be able to provision containers and virtual machines necessary for its testing without requesting them from the testing system.
  • The standard interface SHOULD describe how to uniquely identify a test suite,

Detailed Description

This standard interface describes how to discover, stage and invoke tests. It is important to cleanly separate implementation details of the testing system from the test suite and its framework. It is also important to allow Fedora packagers to locally and manually invoke a test suite.

Staging

Tests files will be added into the tests folder in the dist-git of the package that they are testing. The structure of the files and folders is left to the liberty of the packagers but there should be a run_tests.yml playbook at the top level of the tests folder to set up and run all the tests.

Invocation

The test can be invoke simply by calling sudo ansible-playbook run_tests.yml on the run_tests.yml playbook of interest.

Discovery

A testing system needs to be able to efficiently answer the question "does this subject have any tests packages, and if so, what are their names". This should be automatically discoverable to the extent possible.


Use repoquery, basically I propose we rely on the dependency chain of the RPMs itself instead of trying to replicate it differently.

repoquery --whatrequires or an equivalent relying on mdapi: https://apps.fedoraproject.org/mdapi/ (which I need to adjust to support back walking (ie find which packages requires "foo" instead of what packages "foo" requires which we currently have) and we should be able to build a list of dependencies.

Test Output Collection

This will enable us to collect full consistent output regardless of the test output to report with ansible invocation

https://github.com/openstack/ara


In addition, a test suite can be uniquely identified using the git hash of the commit of the git repo.

Scope

Since the tests are added in a sub-folder of the dist-git repo, there are no changes required to the Fedora infrastructure and will have no impact on the packagers' workflow and tooling.

Only the testing system will need to be taught to install the requirements and run the playbooks.

Benefit to Fedora

Developers benefit by having a consistent target for how to describe tests, while also being able to execute them locally while debugging issues or iterating on tests.

By staging and invoking tests consistently in Fedora we create an eco-system for the tests that allows varied test frameworks as well as CI system infrastructure to interoperate. The integration tests outlast the implementation details of either the frameworks they're written in or the CI systems running them.

TODO: note any additional benefits to Fedora.


Current Proposals

There are currently two proposals for how to implement this change and a final decision has not yet been made as to which is the final proposal. The two current proposals are:

Evaluations

Interested parties should put their evaluations here. Please add to the table below with your vote for which option you think is the better choice at this point in time.

Contributor Packaged Tests Ansible Tests Notes
YourUserName +1 This is just an example, please vote for one of the options