build-and-run-tests-from-branch.yml

name: "[M] UTBot Java: build and run tests"

permissions: read-all

on:
  workflow_dispatch:
    inputs:
      commit_sha:
        required: false
        type: string
        description: "Commit SHA (optional -- otherwise the last commit from the branch will be taken)"

  workflow_call:
    inputs:
      commit_sha:
        required: false
        type: string

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: utbot_java_cli
  DOCKERFILE_PATH: docker/Dockerfile_java_cli
  # Environment variable setting gradle options.
  #
  # When configuring Gradle behavior you can use these methods,
  # listed in order of highest to lowest precedence (first one wins):
  # - Command-line flags such as --build-cache.
  #   These have precedence over properties and environment variables.
  # - System properties such as systemProp.http.proxyHost=somehost.org
  #   stored in a gradle.properties file in a root project directory.
  # - Gradle properties such as org.gradle.caching=true that are
  #   typically stored in a gradle.properties file in a project
  #   directory or in the GRADLE_USER_HOME.
  # - Environment variables such as GRADLE_OPTS sourced by the
  #   environment that executes Gradle.
  #
  # read more at: https://docs.gradle.org/current/userguide/build_environment.html
  #
  # example of GRADLE_OPTS:
#  GRADLE_OPTS: "-XX:MaxHeapSize=2048m -Dorg.gradle.daemon=false -Dorg.gradle.parallel=false -Dkotlin.compiler.execution.strategy=in-process"
  PUSHGATEWAY_HOSTNAME: monitoring.utbot.org
  ELK_HOSTNAME: logs.utbot.org
  FILEBEAT_DIR: /tmp/filebeat

jobs:
  prepare-matrices:
    permissions: read-all
    runs-on: ubuntu-latest
    # Outputs are used for passing data to dependent jobs.
    outputs:
      framework-tests-matrix: ${{ steps.set-matrices.outputs.framework-tests-matrix }}
      combined-projects-matrix: ${{ steps.set-matrices.outputs.combined-projects-matrix }}
    steps:
      - name: Print environment variables
        run: printenv

      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Check out ${{ github.event.inputs.commit_sha }} commit
        if: github.event.inputs.commit_sha != ''
        run: |
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          git fetch
          git checkout ${{ github.event.inputs.commit_sha }}
      - id: set-matrices
        name: Read and print config from framework-tests-matrix.json and combined-projects-matrix.json
        run: |
          FRAMEWORK_TESTS=$(echo $(cat .github/workflows/framework-tests-matrix.json))
          COMBINED_PROJECTS=$(echo $(cat .github/workflows/combined-projects-matrix.json))
          echo "framework-tests-matrix=$FRAMEWORK_TESTS" >> $GITHUB_OUTPUT
          echo "combined-projects-matrix=$COMBINED_PROJECTS" >> $GITHUB_OUTPUT
          echo $FRAMEWORK_TESTS
          echo $COMBINED_PROJECTS


  framework-tests:
    permissions: read-all
    needs: prepare-matrices
    # Using matrices let create multiple jobs runs based on the combinations of the variables from matrices. 
    # https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs
    strategy:
      # The option forces to execute all jobs even though some of them have failed.
      fail-fast: false
      matrix: ${{ fromJson(needs.prepare-matrices.outputs.framework-tests-matrix) }}
    runs-on: ubuntu-20.04
    container:
      image: unittestbot/java-env:java17-zulu-jdk-gradle7.6.1-kotlinc1.8.0
      volumes:
        - "/home/runner/runners:/home/runner/runners"
        - "/tmp/filebeat:/tmp/filebeat"
    steps:
      - name: Print environment variables
        run: printenv

      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Check out ${{ github.event.inputs.commit_sha }} commit
        if: github.event.inputs.commit_sha != ''
        run: |
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          git fetch
          git checkout ${{ github.event.inputs.commit_sha }}

      - name: Run monitoring
        # secret uploaded using base64 encoding to have one-line output:
        # cat file | base64 -w 0
        continue-on-error: true
        run: |
          chmod +x ./scripts/project/monitoring.sh
          ./scripts/project/monitoring.sh "${PUSHGATEWAY_HOSTNAME}" "${{ secrets.PUSHGATEWAY_USER }}" "${{ secrets.PUSHGATEWAY_PASSWORD }}"
          echo "Please visit Grafana to check metrics: https://${PUSHGATEWAY_HOSTNAME}/d/rYdddlPWk/node-exporter-full?orgId=1&from=now-1h&to=now&var-service=github&var-instance=${GITHUB_RUN_ID}-${HOSTNAME}&refresh=1m"
          echo ---
          printf ${{ secrets.CA_CERT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/ca.crt
          printf ${{ secrets.CLIENT_CRT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.crt
          printf ${{ secrets.CLIENT_KEY }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.key
          chmod +x ./scripts/project/logging.sh 
          ./scripts/project/logging.sh "${FILEBEAT_DIR}" "${{ secrets.ELK_HOST }}:5044"
          echo "Please visit ELK to check logs https://logs.utbot.org/app/discover#/ using the following search pattern: github.env.HOSTNAME:\"${HOSTNAME}\" and github.env.GITHUB_RUN_ID:\"${GITHUB_RUN_ID}\" and not github.log_level:\"INFO\""

      # cache will use the key you provided and contains the files you specify in path.
      #
      # When key matches an existing cache, it's called a cache hit, and the action
      # restores the cached files to the path directory.
      # When key doesn't match an existing cache, it's called a cache miss, and a new
      # cache is automatically created if the job completes successfully.
      #
      # The cache action first searches for cache hits for key and restore-keys in the
      # branch containing the workflow run. If there are no hits in the current branch,
      # the cache action searches for key and restore-keys in the parent branch and
      # upstream branches.
      - uses: actions/cache@v3
        with:
          path: /root/.gradle/caches
          # key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle', '*.gradle.kts', './*.gradle', './*.gradle.kts') }}
          # hashFiles returns a single hash for the set of files that matches the path pattern
          key: ${{ runner.os }}-gradle-framework-${{ hashFiles('./*.gradle*', './utbot-framework*/*.gradle*') }}
          restore-keys: ${{ runner.os }}-gradle-framework

      - name: Run tests
        run: |
          gradle --no-daemon --build-cache --no-parallel -PprojectType=Ultimate -PgithubActor=${{ github.actor }} -PgithubToken=${{ secrets.PACKAGES_RO_TOKEN }} -Dorg.gradle.jvmargs=-Xmx6g -Dkotlin.daemon.jvm.options=-Xmx4g :utbot-framework-test:test ${{ matrix.project.TESTS_TO_RUN }}

      - name: Upload logs
        if: ${{ always() }}
        uses: actions/upload-artifact@v3
        with:
          name: logs ${{ matrix.project.PART_NAME }}
          path: utbot-framework-test/logs/*

      - name: Upload UTBot temp directory content
        if: ${{ always() }}
        uses: actions/upload-artifact@v3
        with:
          name: utbot_temp ${{ matrix.project.PART_NAME }}
          path: |
            /tmp/UTBot/generated*/*
            /tmp/UTBot/utbot-instrumentedprocess-errors/*
      - name: Upload test report if tests have failed
        if: ${{ failure() }}
        uses: actions/upload-artifact@v3
        with:
          name: test_report ${{ matrix.project.PART_NAME }}
          path: utbot-framework-test/build/reports/tests/test/*


  spring-tests:
    permissions: read-all
    runs-on: ubuntu-20.04
    container:
      image: unittestbot/java-env:java17-zulu-jdk-gradle7.6.1-kotlinc1.8.0
      volumes:
        - "/home/runner/runners:/home/runner/runners"
        - "/tmp/filebeat:/tmp/filebeat"
    steps:
      - name: Print environment variables
        run: printenv

      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Check out ${{ github.event.inputs.commit_sha }} commit
        if: github.event.inputs.commit_sha != ''
        run: |
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          git fetch
          git checkout ${{ github.event.inputs.commit_sha }}

      - name: Run monitoring
        continue-on-error: true
        run: |
          chmod +x ./scripts/project/monitoring.sh
          ./scripts/project/monitoring.sh "${PUSHGATEWAY_HOSTNAME}" "${{ secrets.PUSHGATEWAY_USER }}" "${{ secrets.PUSHGATEWAY_PASSWORD }}"
          echo "Please visit Grafana to check metrics: https://${PUSHGATEWAY_HOSTNAME}/d/rYdddlPWk/node-exporter-full?orgId=1&from=now-1h&to=now&var-service=github&var-instance=${GITHUB_RUN_ID}-${HOSTNAME}&refresh=1m"
          echo ---
          printf ${{ secrets.CA_CERT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/ca.crt
          printf ${{ secrets.CLIENT_CRT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.crt
          printf ${{ secrets.CLIENT_KEY }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.key
          chmod +x ./scripts/project/logging.sh
          ./scripts/project/logging.sh "${FILEBEAT_DIR}" "${{ secrets.ELK_HOST }}:5044"
          echo "Please visit ELK to check logs https://logs.utbot.org/app/discover#/ using the following search pattern: github.env.HOSTNAME:\"${HOSTNAME}\" and github.env.GITHUB_RUN_ID:\"${GITHUB_RUN_ID}\" and not github.log_level:\"INFO\""

      - uses: actions/cache@v3
        with:
          path: /root/.gradle/caches
          key: ${{ runner.os }}-gradle-spring-${{ hashFiles('./*.gradle*', './utbot-spring*/*.gradle*') }}
          restore-keys: ${{ runner.os }}-gradle-spring

      - name: Run tests
        run: |
          cd utbot-spring-test
          gradle --no-daemon --build-cache --no-parallel -PprojectType=Community -PgithubActor=${{ github.actor }} -PgithubToken=${{ secrets.PACKAGES_RO_TOKEN }} -Dorg.gradle.jvmargs=-Xmx6g -Dkotlin.daemon.jvm.options=-Xmx4g :utbot-spring-test:test

      - name: Upload logs
        if: ${{ always() }}
        uses: actions/upload-artifact@v3
        with:
          name: logs utbot-spring-test
          path: utbot-spring-test/logs/*
      - name: Upload UTBot temp directory content
        if: ${{ always() }}
        uses: actions/upload-artifact@v3
        with:
          name: utbot_temp utbot-spring-test
          path: |
            /tmp/UTBot/generated*/*
            /tmp/UTBot/utbot-instrumentedprocess-errors/*
      - name: Upload test report if tests have failed
        if: ${{ failure() }}
        uses: actions/upload-artifact@v3
        with:
          name: test_report utbot-spring-test
          path: utbot-spring-test/build/reports/tests/test/*


  combined-projects:
    # This job does not need to wait for 'prepare-tests-matrix' result.
    # GitHub allocates runners portionally. Framework tests are time consuming. That's why we want to force them
    # to start execution early.
    needs: prepare-matrices
    # Using matrices let create multiple jobs runs based on the combinations of the variables from matrices.
    # https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs
    strategy:
      # The option forces to execute all jobs even though some of them have failed.
      fail-fast: false
      matrix: ${{ fromJson(needs.prepare-matrices.outputs.combined-projects-matrix) }}
    runs-on: ubuntu-20.04
    container:
      image: unittestbot/java-env:java17-zulu-jdk-gradle7.6.1-kotlinc1.8.0
      volumes:
        - "/home/runner/runners:/home/runner/runners"
        - "/tmp/filebeat:/tmp/filebeat"
    steps:
      - name: Print environment variables
        run: printenv

      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Check out ${{ github.event.inputs.commit_sha }} commit
        if: github.event.inputs.commit_sha != ''
        run: |
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          git fetch
          git checkout ${{ github.event.inputs.commit_sha }}

      - name: Run monitoring
        run: |
          chmod +x ./scripts/project/monitoring.sh
          ./scripts/project/monitoring.sh "${PUSHGATEWAY_HOSTNAME}" "${{ secrets.PUSHGATEWAY_USER }}" "${{ secrets.PUSHGATEWAY_PASSWORD }}"
          echo "Please visit Grafana to check metrics: https://${PUSHGATEWAY_HOSTNAME}/d/rYdddlPWk/node-exporter-full?orgId=1&from=now-1h&to=now&var-service=github&var-instance=${GITHUB_RUN_ID}-${HOSTNAME}&refresh=1m"
          echo ---
          printf ${{ secrets.CA_CERT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/ca.crt
          printf ${{ secrets.CLIENT_CRT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.crt
          printf ${{ secrets.CLIENT_KEY }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.key
          chmod +x ./scripts/project/logging.sh
          ./scripts/project/logging.sh "${FILEBEAT_DIR}" "${{ secrets.ELK_HOST }}:5044"
          echo "Please visit ELK to check logs https://logs.utbot.org/app/discover#/ using the following search pattern: github.env.HOSTNAME:\"${HOSTNAME}\" and github.env.GITHUB_RUN_ID:\"${GITHUB_RUN_ID}\" and not github.log_level:\"INFO\""

      - uses: actions/cache@v3
        with:
          path: /root/.gradle/caches
          key: ${{ runner.os }}-gradle-combined-${{ hashFiles('./*.gradle*', './*/.gradle*') }}
          restore-keys: ${{ runner.os }}-gradle-combined-
      - name: Build project ${{ matrix.projects.first }}
        id: first-project
        run: |
          cd ${{ matrix.projects.first }}
          gradle build --no-daemon --build-cache --no-parallel -PgithubActor=${{ github.actor }} -PgithubToken=${{ secrets.PACKAGES_RO_TOKEN }} -Dorg.gradle.jvmargs=-Xmx6g -Dkotlin.daemon.jvm.options=-Xmx4g

      - name: Build project ${{ matrix.projects.second }}
        if: ${{ steps.first-project.outcome != 'cancelled' && steps.first-project.outcome != 'skipped' }}
        run: |
          cd ${{ matrix.projects.second }}
          gradle build --no-daemon --build-cache --no-parallel -PgithubActor=${{ github.actor }} -PgithubToken=${{ secrets.PACKAGES_RO_TOKEN }} -Dorg.gradle.jvmargs=-Xmx6g -Dkotlin.daemon.jvm.options=-Xmx4g

      - name: Upload test report if tests have failed
        if: ${{ failure() }}
        uses: actions/upload-artifact@v3
        with:
          name: test_report ${{ matrix.projects.first }}
          path: ${{ matrix.projects.first }}/build/reports/tests/test/*

      - name: Upload test report if tests have failed
        if: ${{ failure() }}
        uses: actions/upload-artifact@v3
        with:
          name: test_report ${{ matrix.projects.second }}
          path: ${{ matrix.projects.second }}/build/reports/tests/test/*


  single-project:
    # This job does not need to wait for 'prepare-tests-matrix' result.
    # GitHub allocates runners portionally. Framework tests are time consuming. That's why we want to force them
    # to start execution early.
    needs: prepare-matrices
    # Using matrices let create multiple jobs runs based on the combinations of the variables from matrices.
    # https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs
    strategy:
      # The option forces to execute all jobs even though some of them have failed.
      fail-fast: false
      matrix:
        project: [utbot-core, utbot-java-fuzzing, utbot-gradle, utbot-junit-contest, utbot-sample]
    runs-on: ubuntu-20.04
    container:
      image: unittestbot/java-env:java17-zulu-jdk-gradle7.6.1-kotlinc1.8.0
      volumes:
        - "/home/runner/runners:/home/runner/runners"
        - "/tmp/filebeat:/tmp/filebeat"
    steps:
      - name: Print environment variables
        run: printenv

      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Check out ${{ github.event.inputs.commit_sha }} commit
        if: github.event.inputs.commit_sha != ''
        run: |
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          git fetch
          git checkout ${{ github.event.inputs.commit_sha }}

      - name: Run monitoring
        run: |
          chmod +x ./scripts/project/monitoring.sh
          ./scripts/project/monitoring.sh "${PUSHGATEWAY_HOSTNAME}" "${{ secrets.PUSHGATEWAY_USER }}" "${{ secrets.PUSHGATEWAY_PASSWORD }}"
          echo "Please visit Grafana to check metrics: https://${PUSHGATEWAY_HOSTNAME}/d/rYdddlPWk/node-exporter-full?orgId=1&from=now-1h&to=now&var-service=github&var-instance=${GITHUB_RUN_ID}-${HOSTNAME}&refresh=1m"
          echo ---
          printf ${{ secrets.CA_CERT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/ca.crt
          printf ${{ secrets.CLIENT_CRT }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.crt
          printf ${{ secrets.CLIENT_KEY }} | base64 -d > ${{ env.FILEBEAT_DIR }}/client.key
          chmod +x ./scripts/project/logging.sh
          ./scripts/project/logging.sh "${FILEBEAT_DIR}" "${{ secrets.ELK_HOST }}:5044"
          echo "Please visit ELK to check logs https://logs.utbot.org/app/discover#/ using the following search pattern: github.env.HOSTNAME:\"${HOSTNAME}\" and github.env.GITHUB_RUN_ID:\"${GITHUB_RUN_ID}\" and not github.log_level:\"INFO\""

      - uses: actions/cache@v3
        with:
          path: /root/.gradle/caches
          key: ${{ runner.os }}-gradle-${{ matrix.project }}-${{ hashFiles('./*.gradle*', format('{0}{1}{2}', './', matrix.project, '/*.gradle*')) }}
          restore-keys: ${{ runner.os }}-gradle-${{ matrix.project }}-
      - name: Run tests
        run: |
          cd ${{ matrix.project }}
          gradle build --no-daemon --build-cache --no-parallel -PgithubActor=${{ github.actor }} -PgithubToken=${{ secrets.PACKAGES_RO_TOKEN }} -Dorg.gradle.jvmargs=-Xmx6g -Dkotlin.daemon.jvm.options=-Xmx4g

      - name: Upload test report if tests have failed
        if: ${{ failure() }}
        uses: actions/upload-artifact@v3
        with:
          name: test_report ${{ matrix.project }}
          path: ${{ matrix.project }}/build/reports/tests/test/*