functional_test.yml

# Functional Test is a subset of minikube integration test, testing the most essential features of minikube.
name: Functional Test
on:
  workflow_dispatch:
  pull_request:
    paths:
      - "go.mod"
      - "**.go"
      - "Makefile"
      - .github/workflows/functional_test.yml
      - "!site/**"
      - "!**.md"
      - "!**.json"
  push:
    branches: [ master ]
    paths:
      - "go.mod"
      - "**.go"
      - "Makefile"
      - "!site/**"
      - "!**.md"
      - "!**.json"
# Limit one functional test job running per PR/Branch
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  # For example, if you push multiple commits to a pull request in quick succession, only the latest workflow run will continue
  cancel-in-progress: true
env:
  GOPROXY: https://proxy.golang.org
  GO_VERSION: '1.25.5'
permissions:
  contents: read
jobs:
  # build-test-binaries job runs before all other jobs and produces binaries/test-data per arch to be shared by all following jobs
  build-test-binaries:
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: build-test-binaries-x86
            arch: amd64
            runs-on: ubuntu-24.04
            make-targets: e2e-linux-amd64
          - name: build-test-binaries-arm
            arch: arm64
            runs-on: ubuntu-24.04-arm
            make-targets: e2e-linux-arm64
    runs-on: ${{ matrix.runs-on }}
    name: ${{ matrix.name }}
    steps:
      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
      - uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5
        with:
          go-version: ${{env.GO_VERSION}}
          cache: true      
      - name: Download Dependencies
        run: go mod download
      - name: Build minikube and e2e test binaries
        run: |
          make ${{ matrix.make-targets }}
          cp -r test/integration/testdata ./out
      - name: Upload Test Binaries
        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f
        with:
          name: binaries-${{ matrix.arch }}
          path: out
  functional-test:
    name: ${{ matrix.name }}
    needs: build-test-binaries
    runs-on: ${{ matrix.os }}
    permissions:
      contents: none
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: docker-docker-ubuntu24.04-x86
            driver: docker
            cruntime: docker
            os: ubuntu-24.04
            arch: amd64
            test-timeout: 18m
          - name: docker-docker-ubuntu24.04-arm
            driver: docker
            cruntime: docker
            os: ubuntu-24.04-arm
            arch: arm64
            test-timeout: 18m 
          - name: docker-containerd-ubuntu-24.04-x86
            driver: docker
            cruntime: containerd
            extra-start-args: --container-runtime=containerd
            os: ubuntu-24.04
            arch: amd64
            test-timeout: 18m 
          - name: docker-containerd-ubuntu-24.04-arm
            driver: docker
            cruntime: containerd
            extra-start-args: --container-runtime=containerd
            os: ubuntu-24.04-arm
            arch: arm64
            test-timeout: 18m 
          - name: docker-containerd-rootless-ubuntu-24.04-x86
            driver: docker
            cruntime: containerd
            os: ubuntu-24.04            
            extra-start-args: --container-runtime=containerd --rootless
            rootless: true
            arch: amd64
            test-timeout: 18m 
          - name: podman-docker-ubuntu-24.04-x86
            driver: podman
            cruntime: docker
            os: ubuntu-24.04
            arch: amd64
            test-timeout: 22m
          - name: baremetal-docker-ubuntu-24.04-x86
            driver: none
            cruntime: docker
            os: ubuntu-24.04
            arch: amd64
            test-timeout: 10m
          - name: baremetal-docker-ubuntu-24.04-arm
            driver: none
            cruntime: docker
            os: ubuntu-24.04-arm
            arch: arm64
            test-timeout: 10m
          - name: baremetal-containerd-ubuntu-24.04-x86
            driver: none
            cruntime: containerd
            os: ubuntu-24.04
            arch: amd64
            extra-start-args: --container-runtime=containerd
            test-timeout: 10m
          - name: baremetal-containerd-ubuntu-24.04-arm
            driver: none
            cruntime: containerd
            os: ubuntu-24.04-arm
            arch: arm64
            extra-start-args: --container-runtime=containerd
            test-timeout: 10m
    steps:
      - id: info-block
        uses: medyagh/info-block@main
      - uses: actions/checkout@v6

      - uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5
        with:
          go-version: ${{env.GO_VERSION}}
          cache: true      
      - name: Install gopogh
        uses: ./.github/actions/install-gopogh
      - name: Set up cgroup v2 delegation (rootless)
        if: ${{ matrix.rootless }}
        run: |
          sudo mkdir -p /etc/systemd/system/user@.service.d
          cat <<EOF | sudo tee /etc/systemd/system/user@.service.d/delegate.conf
          [Service]
          Delegate=cpu cpuset io memory pids
          EOF
          sudo systemctl daemon-reload
      - name: Set up Rootless Docker (rootless)
        if: ${{ matrix.rootless }}
        run: |
          sudo apt-get remove moby-engine-*
          curl https://get.docker.com | sudo sh
          dockerd-rootless-setuptool.sh install -f
          docker context use rootless
      - name: Update brew package index (macos)
        if: contains(matrix.os, 'macos')
        run: brew update
      - name: Update apt-get package index (ubuntu)
        if: runner.os == 'Linux' && (matrix.driver == 'podman' || matrix.driver == 'none')
        run: sudo apt-get update -qq
      - name: Install cri_dockerd (baremetal only)
        shell: bash
        if: matrix.driver == 'none' && matrix.cruntime == 'docker'
        run: |
          CRI_DOCKERD_VERSION="v0.4.1"
          CRI_DOCKERD_COMMIT="55d6e1a1d6f2ee58949e13a0c66afe7d779ac942"
          CRI_DOCKERD_BASE_URL="https://storage.googleapis.com/kicbase-artifacts/cri-dockerd/${CRI_DOCKERD_COMMIT}"
          ARCH="${{ matrix.arch }}"
          sudo curl -L "${CRI_DOCKERD_BASE_URL}/${ARCH}/cri-dockerd" -o /usr/bin/cri-dockerd
          sudo curl -L "${CRI_DOCKERD_BASE_URL}/cri-docker.socket" -o /usr/lib/systemd/system/cri-docker.socket
          sudo curl -L "${CRI_DOCKERD_BASE_URL}/cri-docker.service" -o /usr/lib/systemd/system/cri-docker.service
          sudo chmod +x /usr/bin/cri-dockerd
      - name: Install crictl (baremetal only)
        shell: bash
        if: matrix.driver == 'none'
        run: |
          CRICTL_VERSION="v1.35.0"
          ARCH="${{ matrix.arch }}"
          CRICTL_TAR="crictl-${CRICTL_VERSION}-linux-${ARCH}.tar.gz"
          curl -L "https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRICTL_VERSION}/${CRICTL_TAR}" --output "${CRICTL_TAR}"
          sudo tar zxvf "${CRICTL_TAR}" -C /usr/local/bin
      # conntrack is required for kubernetes 1.18 and higher
      - name: Install conntrack & socat (baremetal only)
        shell: bash
        if: matrix.driver == 'none'
        run: sudo apt-get -qq -y install conntrack
      # socat is required for kubectl port forward which is used in some tests
      - name: Install socat (baremetal only)
        shell: bash
        if: matrix.driver == 'none'
        run: sudo apt-get -qq -y install socat        
      - name: Install container networking plugins (baremetal only)
        shell: bash
        if: matrix.driver == 'none'
        run: |
          CNI_PLUGIN_VERSION="v1.9.0"
          ARCH="${{ matrix.arch }}"
          CNI_PLUGIN_TAR="cni-plugins-linux-${ARCH}-$CNI_PLUGIN_VERSION.tgz"
          CNI_PLUGIN_INSTALL_DIR="/opt/cni/bin"
          curl -LO "https://github.com/containernetworking/plugins/releases/download/$CNI_PLUGIN_VERSION/$CNI_PLUGIN_TAR"
          sudo mkdir -p "$CNI_PLUGIN_INSTALL_DIR"
          sudo tar -xf "$CNI_PLUGIN_TAR" -C "$CNI_PLUGIN_INSTALL_DIR"
          rm "$CNI_PLUGIN_TAR"
      - name: Install docker-cli
        run: |
          set -x
          if [[ "$RUNNER_OS" == "macOS" ]]; then
            brew install docker
          fi
          echo "=== Docker Version ==="
          docker version || true
          if [[ "$RUNNER_OS" == "Linux" ]]; then
            echo "=== Docker Info ==="
            docker info || true

            echo "=== Docker Disk Usage ==="
            docker system df || true

            echo "=== Docker System Info (JSON) ==="
            docker system info --format='{{json .}}' | { command -v jq >/dev/null 2>&1 && jq . || cat; } || true

            echo "=== Running Containers ==="
            docker ps -a || true

            echo "=== Images ==="
            docker images || true
          fi
      - name: Install podman
        if: matrix.driver == 'podman'
        shell: bash
        run: |
          sudo apt -q update
          sudo apt install -q -y podman
          lsb_release -a || true
          echo "=== podman version ==="
          podman version || true
          echo "=== podman info ==="
          podman info || true
          echo "=== podman system df ==="
          podman system df || true
          echo "=== podman system info (JSON) ==="
          podman system info --format='{{json .}}' || true
          echo "=== podman ps ==="
          podman ps || true
      - name: Install kubectl
        uses: azure/setup-kubectl@v4
      - name: Install qemu and socket_vmnet (macos)
        if: contains(matrix.os, 'macos') && matrix.driver == 'qemu'
        run: |
          brew install qemu socket_vmnet
          HOMEBREW=$(which brew) && sudo ${HOMEBREW} services start socket_vmnet
      - name: Install vfkit and vmnet_helper (macos)
        if: matrix.driver == 'vfkit'
        run: |
          brew install vfkit
          curl -fsSL https://github.com/minikube-machine/vmnet-helper/releases/latest/download/install.sh | sudo VMNET_INTERACTIVE=0 bash
      - name: Download Test Binaries
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131
        with:
          name: binaries-${{ matrix.arch }}
      - name: Disable AppArmor for MySQL
        if: runner.os == 'Linux'
        run: |
          sudo ln -s /etc/apparmor.d/usr.sbin.mysqld /etc/apparmor.d/disable/
          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
      - name: Install containerd (baremetal only)
        if: matrix.driver == 'none' && matrix.cruntime == 'containerd'
        run: |
          sudo apt-get update
          sudo apt-get install -y containerd
          # Configure containerd
          sudo mkdir -p /etc/containerd
          containerd config default | sudo tee /etc/containerd/config.toml
          sudo systemctl restart containerd
      - name: Run Functional Test
        id: run_test
        continue-on-error: true
        shell: bash
        run: |
          set -x
          mkdir -p report
          chmod a+x ./e2e-*
          chmod a+x ./minikube-*
          ./minikube-$(go env GOOS)-$(go env GOARCH) delete --all --purge
          START_TIME=$(date -u +%s)
          ./e2e-$(go env GOOS)-$(go env GOARCH) -minikube-start-args=" --driver=${{ matrix.driver }} ${{ matrix.extra-start-args }} -v=6 --alsologtostderr"  -test.run TestFunctional -test.timeout=${{ matrix.test-timeout }} -test.v -binary=./minikube-$(go env GOOS)-$(go env GOARCH) 2>&1 | tee ./report/testout.txt
          END_TIME=$(date -u +%s)
          TIME_ELAPSED=$(($END_TIME-$START_TIME))
          min=$((${TIME_ELAPSED}/60))
          sec=$((${TIME_ELAPSED}%60))
          TIME_ELAPSED="${min} min $sec seconds "
          # make variables available for next step 
          echo "TIME_ELAPSED=${TIME_ELAPSED}" >> $GITHUB_ENV
      - name: Convert Test Output to JSON
        if: always()
        shell: bash
        run: go tool test2json -t < ./report/testout.txt > ./report/testout.json || true
      - name: Generate Gopogh HTML Report
        uses: ./.github/actions/generate-report
        if: always()
        with:
          json_report_path: './report/testout.json'
          report_dir: './report'
          report_title: "${{ matrix.name }} ${GITHUB_REF}"
          artifact_name_suffix: "${{ matrix.name }}"
          time_elapsed: "${{ env.TIME_ELAPSED }}"
          check_strict: 'true'
          test_outcome: "${{ steps.run_test.outcome }}"
          test_text_path: './report/testout.txt'