action.yml

name: "Schedule regression tests on Testing Farm"
description: |
             A github action will issue a request to the Testing Farm Service to run tmt tests from a certain
             repository, with certain copr-build(s) and a certain compose.
inputs:
  tft_server:
    description: 'A Testing farm server url'
    required: true
  tft_token:
    description: 'A testing farm user token'
    required: true
  compose:
    description: 'A compose for tests'
    required: true
  tests_repository:
    description: 'A git repository containing tmt tests'
    default: 'https://gitlab.cee.redhat.com/oamg/tmt-plans'
  tests_regex:
    description: 'Limit to running specific tests only with regex'
    default: '^(?!.*c2r)(?!.*sap)'
  tests_ref:
    desription: 'Specify a git ref for tests'
    default: 'master'
  arch:
    description: 'Specify an architecture for test env'
    default: 'x86_64'
  copr:
    description: 'Name of copr to use for the artifacts'
    default: 'epel-7-x86_64'
  artifacts:
    description: 'Comma-separated copr-builds to install in test env'
    required: true
  env_vars:
    description: 'Environment variables for test env, separated by ; or ,'
    default: ''
  tmt_context:
    description: 'Value of tmt.context, variables separated by ; or ,'
    default: ''
  debug:
    description: 'Print debug logs when preparing/issuing request'
    default: 'true'
  test_name:
    description: 'A name for the launched test set. Something human-readable to be shown in github comment together with the results.'
    default: ''
outputs:
  request_id:
    description: "An id of a scheduled testing farm request"
    value: ${{ steps.sched_test.outputs.req_id }}

runs:
  using: "composite"
  steps:
    - name: Generate artifacts list
      id: gen_artifacts_list
      run: |
        python -c 'import json;print(json.dumps(([{"type": "fedora-copr-build", "id": "{}:${{ inputs.copr }}".format(copr_id)} for copr_id in "${{ inputs.artifacts }}".split(",")])))' > artifacts
        echo "::set-output name=artifacts_list::$(cat artifacts)"
      shell: bash

    - name: Generate env_vars
      id: gen_env_vars
      run: |
        python -c 'import json; sep=";" if ";" in "${{ inputs.env_vars }}" else ","; print({} if not "${{ inputs.env_vars }}".strip() else json.dumps({key: value for key, value in [s.split("=", 1) for s in "${{ inputs.env_vars }}".split(sep)]}))' > env_vars
        echo "::set-output name=env_vars::$(cat env_vars)"
      shell: bash

    - name: Generate tmt context
      id: gen_tmt_context
      run: |
        python -c 'import json; sep=";" if ";" in "${{ inputs.tmt_context }}" else ","; print({} if not "${{ inputs.tmt_context }}".strip() else json.dumps({key: value for key, value in [s.split("=", 1) for s in "${{ inputs.tmt_context }}".split(sep)]}))' > tmt_context
        echo "::set-output name=tmt_context::$(cat tmt_context)"
      shell: bash

    - name: Generate a tmt test request
      id: gen_tmt_request
      run: |
        cat << EOF > request.json
        {
          "api_key": "${{ inputs.tft_token }}",
          "test": {"fmf": {
            "url": "${{ inputs.tests_repository }}",
            "ref": "${{ inputs.tests_ref }}",
            "name": "${{ inputs.tests_regex }}"
          }},
          "environments": [{
            "arch": "${{ inputs.arch }}",
            "os": {"compose": "${{ inputs.compose }}"},
            "variables": ${{ steps.gen_env_vars.outputs.env_vars }},
            "artifacts": ${{ steps.gen_artifacts_list.outputs.artifacts_list }},
            "tmt": {"context": ${{ steps.gen_tmt_context.outputs.tmt_context }}}
          }]
        }
        EOF

        if [ "${{ inputs.debug }}" = "true" ]; then
            echo request.json
            jq < request.json
        fi
      shell: bash

    - name: Send request to testing farm service
      # This step schedules a tmt test. The test id is stored in `req_id` variable for a later use.

      # All the discovered test plans matching the regex `tests.fmf.name` from the repository specified in
      # `tests.fmf.url` are run.
      #
      # At this moment repo/sha that triggered the action is used, i.e. all tests plans specified in THIS repository
      # are run.

      id: sched_test
      run: |
        curl ${{ inputs.tft_server }}/requests \
          --data @request.json \
          --header "Content-Type: application/json" \
          --output response.json

        if [ "${{ inputs.debug }}" = "true" ]; then
            echo response.json
            jq < response.json
        fi

        echo "::set-output name=req_id::$(jq -r .id response.json)"
      shell: bash

    - name: Add comment with Testing Farm request/result
      # This step adds a new comment to the pull request with a link to the test.

      # TODO: This is a temporary workaround until a proper way to set a commit status is implemented.
      id: comment
      uses: actions/github-script@v4
      with:
        script: |
          github.issues.createComment({
            issue_number: context.issue.number,
            owner: context.repo.owner,
            repo: context.repo.repo,
            body: 'Testing Farm [request](${{ inputs.tft_server }}/requests/${{ steps.sched_test.outputs.req_id }})' +
                  ' for ${{ inputs.test_name }}/${{ inputs.artifacts }} regression testing has been created. Once finished, results should be available' +
                  ' [here](http://artifacts.osci.redhat.com/testing-farm/${{ steps.sched_test.outputs.req_id }}/).' +
                  '\n[Full pipeline log](http://artifacts.osci.redhat.com/testing-farm/${{ steps.sched_test.outputs.req_id }}/pipeline.log).'
          })