ci-testing-deploy.yml

name: CI

on:
  push:
    branches:
      - "*"
    tags-ignore:
      - "*"
    paths-ignore:
      - "*.md"
      - "*.png"
      - "*.svg"
      - "docs/**"
      - ".vscode/**"
  pull_request:
    branches:
      - "*"
    paths-ignore:
      - "*.md"
      - "*.png"
      - "*.svg"
      - "docs/**"
      - ".vscode/**"
      - ".vscode-template/**"

env:
  # secrets can be set in settings/secrets on github
  DOCKER_REGISTRY: ${{ secrets.DOCKER_REGISTRY }}
  DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
  DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
  CC_TEST_REPORTER_ID: 21a72eb30476c870140b1576258873a41be6692f71bd9aebe812174b7d8f4b4e
  #enable buildkit
  DOCKER_BUILDKIT: 1
  COMPOSE_DOCKER_CLI_BUILD: 1

jobs:
  unit-test-api:
    name: "[unit] api"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-api-${{ hashFiles('api/tests/requirements.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-api-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install api
        run: ./ci/github/unit-testing/api.bash install
      - name: test
        run: ./ci/github/unit-testing/api.bash test

  unit-test-api-server:
    name: "[unit] api-server"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-api-server-${{ hashFiles('services/api-server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-api-server-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/api-server.bash install
      - name: test
        run: ./ci/github/unit-testing/api-server.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-catalog:
    name: "[unit] catalog"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-catalog-${{ hashFiles('services/catalog/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-catalog-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/catalog.bash install
      - name: test
        run: ./ci/github/unit-testing/catalog.bash test
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/catalog/test_failures
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-director:
    name: "[unit] director"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-director-${{ hashFiles('services/director/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-director-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/director.bash install
      - name: test
        run: ./ci/github/unit-testing/director.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-director-v2:
    name: "[unit] director-v2"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v1
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-
      - name: install
        run: ./ci/github/unit-testing/director_v2.bash install
      - name: test
        run: ./ci/github/unit-testing/director_v2.bash test
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/director-v2/test_failures
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-sidecar:
    name: "[unit] sidecar"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-sidecar-${{ hashFiles('services/sidecar/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-sidecar-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/sidecar.bash install
      - name: test
        run: ./ci/github/unit-testing/sidecar.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-dynamic-sidecar:
    name: "[unit] dynamic-sidecar"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-dynamic-sidecar-${{ hashFiles('services/dynamic-sidecar/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-dynamic-sidecar-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/dynamic-sidecar.bash install
      - name: codestyle
        run: ./ci/github/unit-testing/dynamic-sidecar.bash codestyle
      - name: test
        run: ./ci/github/unit-testing/dynamic-sidecar.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-frontend:
    name: "[unit] frontend"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        node: [14]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - uses: actions/setup-node@v1
        with:
          node-version: ${{ matrix.node }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - name: install
        run: ./ci/github/unit-testing/frontend.bash install
      - name: test
        run: ./ci/github/unit-testing/frontend.bash test
    # no coverage here??
    # - uses: codecov/codecov-action@v1
    #   with:
    #     flags: unittests #optional

  unit-test-python-linting:
    name: "[unit] python-linting"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-linting-${{ hashFiles('ci/helpers/install_pylint.bash') }}
          restore-keys: |
            ${{ runner.os }}-pip-linting-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/python-linting.bash install
      - name: test
        run: ./ci/github/unit-testing/python-linting.bash test

  unit-test-postgres-database:
    name: "[unit] postgres-database"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-postgres-database-${{ hashFiles('packages/postgres-database/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-postgres-database-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/postgres-database.bash install
      - name: test
        run: ./ci/github/unit-testing/postgres-database.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter
          ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-service-integration:
    name: "[unit] service-integration"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-service-integration-${{ hashFiles('packages/service-integration/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-service-integration-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/service-integration.bash install
      - name: test
        run: ./ci/github/unit-testing/service-integration.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-service-library:
    name: "[unit] service-library"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-service-library-${{ hashFiles('packages/service-library/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-service-library-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/service-library.bash install
      - name: test
        run: ./ci/github/unit-testing/service-library.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-models-library:
    name: "[unit] models-library"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-models-library-${{ hashFiles('packages/models-library/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-models-library-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/models-library.bash install
      - name: test
        run: ./ci/github/unit-testing/models-library.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-simcore-sdk:
    name: "[unit] simcore-sdk"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-simcore-sdk${{ hashFiles('packages/simcore-sdk/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-simcore-sdk
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/simcore-sdk.bash install
      - name: test
        run: ./ci/github/unit-testing/simcore-sdk.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-storage:
    name: "[unit] storage"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-storage-${{ hashFiles('services/storage/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-storage-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/unit-testing/storage.bash install
      - name: test
        run: ./ci/github/unit-testing/storage.bash test
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-isolated:
    name: "[unit] webserver isolated"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_isolated
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-01:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 01"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 01
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-02:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 02"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 02
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-03:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 03"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 03
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-04:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 04"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 04
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-05:
    timeout-minutes: 15 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 05"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 05
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-06:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 06"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 06
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-07:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 07"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 07
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-08:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 08"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 08
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-09:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 09"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 09
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  unit-test-webserver-10:
    timeout-minutes: 12 # if this timeout gets too small, then split the tests
    name: "[unit] webserver 10"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install webserver
        run: ./ci/github/unit-testing/webserver.bash install
      - name: test
        run: ./ci/github/unit-testing/webserver.bash test_with_db 10
      - uses: codecov/codecov-action@v1
        with:
          flags: unittests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  build-test-images:
    # make PR faster by executing this one straight as PR cannot push to the registry anyway
    runs-on: ubuntu-20.04
    name: "[build] docker images"
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        if: github.event_name == 'push'
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: show system environs
        if: github.event_name == 'push'
        run: ./ci/helpers/show_system_versions.bash
      - name: pull images
        if: github.event_name == 'push'
        run: ./ci/build/test-images.bash pull_images
      - name: build images
        if: github.event_name == 'push'
        run: ./ci/build/test-images.bash build_images
      - name: set owner variable
        if: github.event_name == 'push'
        run: echo "OWNER=${GITHUB_REPOSITORY%/*}" >> $GITHUB_ENV
      - name: push images
        # only pushes have access to the docker credentials
        if: github.event_name == 'push'
        run: ./ci/deploy/dockerhub-test-images.bash

  integration-test-webserver-01:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[int] webserver 01"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/integration-testing/webserver.bash install
      - name: test
        run: ./ci/github/integration-testing/webserver.bash test 01
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/web/server/test_failures
      - name: cleanup
        if: always()
        run: ./ci/github/integration-testing/webserver.bash clean_up
      - uses: codecov/codecov-action@v1
        with:
          flags: integrationtests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  integration-test-webserver-02:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[int] webserver 02"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-webserver-${{ hashFiles('services/web/server/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-webserver-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/integration-testing/webserver.bash install
      - name: test
        run: ./ci/github/integration-testing/webserver.bash test 02
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/web/server/test_failures
      - name: cleanup
        if: always()
        run: ./ci/github/integration-testing/webserver.bash clean_up
      - uses: codecov/codecov-action@v1
        with:
          flags: integrationtests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  integration-test-director-v2:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[int] director-v2"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-director-v2-${{ hashFiles('services/director-v2/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-director-v2-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/integration-testing/director-v2.bash install
      - name: test
        run: ./ci/github/integration-testing/director-v2.bash test
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/director-v2/test_failures
      - name: cleanup
        if: always()
        run: ./ci/github/integration-testing/director-v2.bash clean_up
      - uses: codecov/codecov-action@v1
        with:
          flags: integrationtests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  integration-test-sidecar:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[int] sidecar"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-sidecar-${{ hashFiles('services/sidecar/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-sidecar-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/integration-testing/sidecar.bash install
      - name: test
        run: ./ci/github/integration-testing/sidecar.bash test
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./services/sidecar/test_failures
      - name: cleanup
        if: always()
        run: ./ci/github/integration-testing/sidecar.bash clean_up
      - uses: codecov/codecov-action@v1
        with:
          flags: integrationtests #optional
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  integration-test-simcore-sdk:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[int] simcore-sdk"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-simcore-sdk-${{ hashFiles('packages/simcore-sdk/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-simcore-sdk-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/integration-testing/simcore-sdk.bash install
      - name: test
        run: ./ci/github/integration-testing/simcore-sdk.bash test
      - name: upload failed tests logs
        if: failure()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: ./packages/simcore-sdk/test_failures
      - name: cleanup
        if: always()
        run: ./ci/github/integration-testing/simcore-sdk.bash clean_up
      - uses: codecov/codecov-action@v1
        with:
          flags: integrationtests
      - name: prepare codeclimate coverage file
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter format-coverage -t coverage.py -o codeclimate.${{ github.job }}_coverage.json coverage.xml
      - name: upload codeclimate coverage
        uses: actions/upload-artifact@v2
        with:
          name: codeclimate-${{ github.job }}-coverage
          path: codeclimate.${{ github.job }}_coverage.json

  system-test-public-api:
    timeout-minutes: 25 # if this timeout gets too small, then split the tests
    name: "[sys] public api"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-public-api-${{ hashFiles('tests/public-api/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-public-api-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/system-testing/public-api.bash install
      - name: test
        run: ./ci/github/system-testing/public-api.bash test
      - name: cleanup
        if: always()
        run: ./ci/github/system-testing/public-api.bash clean_up

  system-test-swarm-deploy:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[sys] deploy simcore"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-swarm-deploy-${{ hashFiles('tests/swarm-deploy/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-swarm-deploy-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/system-testing/swarm-deploy.bash install
      - name: test
        run: ./ci/github/system-testing/swarm-deploy.bash test
      - name: cleanup
        if: always()
        run: ./ci/github/system-testing/swarm-deploy.bash clean_up

  system-test-e2e:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[sys] e2e"
    needs: [build-test-images]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        node: [14]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - uses: actions/setup-node@v1
        with:
          node-version: ${{ matrix.node }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data python
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-swarm-e2e-${{ hashFiles('tests/e2e/requirements/requirements.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-swarm-e2e-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - uses: actions/cache@v2
        name: getting cached data node
        with:
          path: ~/.npm
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-
      - name: setup
        run: ./ci/github/system-testing/e2e.bash install
      - name: test
        run: ./ci/github/system-testing/e2e.bash test
      - name: recover docker logs
        id: logs_recovery
        if: always()
        run: ./ci/github/system-testing/e2e.bash dump_docker_logs
      - name: upload docker logs
        if: always()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_docker_logs
          path: simcore_logs
      - name: upload screenshots
        if: always()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_screenshots
          path: tests/e2e/screenshots
      - name: upload e2e logs
        if: always()
        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.job }}_logs
          path: tests/e2e/logs
      - name: cleanup
        if: always()
        run: ./ci/github/system-testing/e2e.bash clean_up

  system-test-environment-setup:
    timeout-minutes: 20 # if this timeout gets too small, then split the tests
    name: "[sys] environment setup"
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        python: [3.6]
        os: [ubuntu-20.04]
      fail-fast: false
    steps:
      - name: set PR default variables
        # only pushes have access to the docker credentials, use a default
        if: github.event_name == 'pull_request'
        run: |
          export TMP_DOCKER_REGISTRY=${GITHUB_REPOSITORY%/*}
          echo "DOCKER_REGISTRY=${TMP_DOCKER_REGISTRY,,}" >> $GITHUB_ENV
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: setup python environment
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - name: show system version
        run: ./ci/helpers/show_system_versions.bash
      - uses: actions/cache@v2
        name: getting cached data
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-environment-setup-${{ hashFiles('tests/environment-setup/requirements/ci.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-environment-setup-
            ${{ runner.os }}-pip-
            ${{ runner.os }}-
      - name: install
        run: ./ci/github/system-testing/environment-setup.bash install
      - name: test
        run: ./ci/github/system-testing/environment-setup.bash test
      - name: cleanup
        if: always()
        run: ./ci/github/system-testing/environment-setup.bash clean_up

  coverage:
    needs:
      [
        unit-test-catalog,
        unit-test-director,
        unit-test-director-v2,
        unit-test-sidecar,
        unit-test-dynamic-sidecar,
        unit-test-service-integration,
        unit-test-service-library,
        unit-test-models-library,
        unit-test-simcore-sdk,
        unit-test-storage,
        unit-test-webserver-isolated,
        unit-test-webserver-01,
        unit-test-webserver-02,
        unit-test-webserver-03,
        unit-test-webserver-04,
        unit-test-webserver-05,
        unit-test-webserver-06,
        unit-test-webserver-07,
        unit-test-webserver-08,
        unit-test-webserver-09,
        unit-test-webserver-10,
        integration-test-webserver-01,
        integration-test-webserver-02,
        integration-test-director-v2,
        integration-test-sidecar,
        integration-test-simcore-sdk,
      ]
    name: coverage
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/download-artifact@v2
        name: download all artifacts
        with:
          path: artifacts
      - name: put all artefacts together
        run: |
          mkdir --parents all_coverages
          cp artifacts/codeclimate*/*.json all_coverages
          ls --all -l all_coverages/*.json
      - name: install codeclimate test reporter
        run: |
          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-0.7.0-linux-amd64 > ./cc-test-reporter
          chmod +x ./cc-test-reporter && ./cc-test-reporter --version
          ./cc-test-reporter sum-coverage all_coverages/codeclimate.*.json --parts $(ls all_coverages/*.json | wc --lines)
      - name: upload coverages
        run: |
          ./cc-test-reporter upload-coverage

  deploy:
    name: deploy to dockerhub
    if: github.event_name == 'push'
    needs:
      [
        unit-test-api,
        unit-test-catalog,
        unit-test-director,
        unit-test-director-v2,
        unit-test-sidecar,
        unit-test-dynamic-sidecar,
        unit-test-frontend,
        unit-test-python-linting,
        unit-test-service-integration,
        unit-test-service-library,
        unit-test-models-library,
        unit-test-simcore-sdk,
        unit-test-storage,
        unit-test-webserver-isolated,
        unit-test-webserver-01,
        unit-test-webserver-02,
        unit-test-webserver-03,
        unit-test-webserver-04,
        unit-test-webserver-05,
        unit-test-webserver-06,
        unit-test-webserver-07,
        unit-test-webserver-08,
        unit-test-webserver-09,
        unit-test-webserver-10,
        integration-test-webserver-01,
        integration-test-webserver-02,
        integration-test-director-v2,
        integration-test-sidecar,
        integration-test-simcore-sdk,
        system-test-public-api,
        system-test-swarm-deploy,
      ]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: setup docker
        run: |
          sudo ./ci/github/helpers/setup_docker_compose.bash
          ./ci/github/helpers/setup_docker_experimental.bash
      - name: set owner variable
        run: echo "OWNER=${GITHUB_REPOSITORY%/*}" >> $GITHUB_ENV
      - name: deploy master
        if: github.ref == 'refs/heads/master'
        env:
          TAG_PREFIX: master-github
        run: ./ci/deploy/dockerhub-deploy.bash
      - name: deploy hotfix
        if: contains(github.ref, 'refs/heads/hotfix_v')
        env:
          TAG_PREFIX: hotfix-github
        run: ./ci/deploy/dockerhub-deploy.bash