Taskfile.yml

version: "3"

vars:
  BINARY_NAME: deps
  BUILD_DIR: ./.bin
  MAIN_PATH: ./cmd/deps/main.go
  GINKGO: go run github.com/onsi/ginkgo/v2/ginkgo

tasks:
  default:
    desc: List all available tasks
    cmds:
      - task --list

  install-ginkgo:
    desc: Install Ginkgo test framework
    status:
      - which ginkgo
    cmds:
      - go install github.com/onsi/ginkgo/v2/ginkgo

  build:
    desc: Build the deps binary
    vars:
      VERSION:
        sh: git describe --tags --always 2>/dev/null || echo "dev"
      COMMIT:
        sh: git rev-parse --short HEAD 2>/dev/null || echo "unknown"
      DATE:
        sh: date -u '+%Y-%m-%dT%H:%M:%SZ'
      DIRTY:
        sh: if [ -n "$(git status --porcelain 2>/dev/null)" ]; then echo "true"; else echo "false"; fi
      LDFLAGS: -s -w -X main.version={{.VERSION}} -X main.commit={{.COMMIT}} -X main.date={{.DATE}} -X main.dirty={{.DIRTY}}
    cmds:
      - mkdir -p {{.BUILD_DIR}}
      - go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}} {{.MAIN_PATH}}
    sources:
      - "**/*.go"
      - pkg/**/*.yaml
      - pkg/config/defaults.yaml
      - go.mod
      - go.sum
    generates:
      - "{{.BUILD_DIR}}/{{.BINARY_NAME}}"

  build-all:
    desc: Build for all supported platforms
    vars:
      VERSION:
        sh: git describe --tags --always 2>/dev/null || echo "dev"
      COMMIT:
        sh: git rev-parse --short HEAD 2>/dev/null || echo "unknown"
      DATE:
        sh: date -u '+%Y-%m-%dT%H:%M:%SZ'
      DIRTY:
        sh: if [ -n "$(git status --porcelain 2>/dev/null)" ]; then echo "true"; else echo "false"; fi
      LDFLAGS: -s -w -X main.version={{.VERSION}} -X main.commit={{.COMMIT}} -X main.date={{.DATE}} -X main.dirty={{.DIRTY}}
    cmds:
      - mkdir -p {{.BUILD_DIR}}
      - GOOS=linux GOARCH=amd64 go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}}-linux-amd64 {{.MAIN_PATH}}
      - GOOS=linux GOARCH=arm64 go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}}-linux-arm64 {{.MAIN_PATH}}
      - GOOS=darwin GOARCH=amd64 go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}}-darwin-amd64 {{.MAIN_PATH}}
      - GOOS=darwin GOARCH=arm64 go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}}-darwin-arm64 {{.MAIN_PATH}}
      - GOOS=windows GOARCH=amd64 go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}}-windows-amd64.exe {{.MAIN_PATH}}

  dup:
    desc: Run jscpd against production Go source
    cmds:
      - jscpd --config .jscpd.json
    sources:
      - "cmd/**/*.go"
      - "pkg/**/*.go"
      - ".jscpd.json"

  test:
    desc: Run all tests using Ginkgo
    deps:
      - install-ginkgo

    cmds:
      - "{{.GINKGO}} -v ./..."
    sources:
      - "**/*.go"

  test:unit:
    desc: Run all unit tests using Ginkgo
    cmds:
      - "{{.GINKGO}} -v  --skip-package e2e ./..."
    sources:
      - "**/*.go"

  test:e2e:
    desc: Run all e2e tests using Ginkgo
    deps:
      - install-ginkgo
    cmds:
      - go run github.com/onsi/ginkgo/v2/ginkgo -v -p -nodes=4  --skip-package ./e2e
    sources:
      - "**/*.go"

  test:report:
    desc: Run all tests with Ginkgo JSON and JUnit report generation
    deps:
      - install-ginkgo

    cmds:
      - mkdir -p test-results
      - ginkgo -v --json-report test-results/test-results.json --junit-report test-results/test-junit.xml ./... || true
      - echo "Test results saved to test-results/"
    sources:
      - "**/*.go"
    generates:
      - "test-results/test-results.json"
      - "test-results/test-junit.xml"

  test:e2e-report:
    desc: Run e2e tests with Ginkgo JSON and JUnit report generation
    cmds:
      - mkdir -p test-results
      - ginkgo -v --json-report test-results/e2e-results.json --junit-report test-results/e2e-junit.xml -timeout=30m ./e2e || true
      - echo "E2E test results saved to test-results/"
    sources:
      - "e2e/**/*.go"
      - "**/*.go"
    generates:
      - "test-results/e2e-results.json"
      - "test-results/e2e-junit.xml"

  test:failed:
    desc: Rerun only failed tests from last test run
    deps: ["test:parse-failed"]
    cmds:
      - |
        if [ ! -f test-results/failed-focus.txt ]; then
          echo "No failed tests found. Run 'task test:report' or 'task test:e2e-report' first."
          exit 0
        fi
        if [ ! -s test-results/failed-focus.txt ]; then
          echo "No failed tests to rerun. All tests passed in last run!"
          exit 0
        fi
        echo "Rerunning failed tests..."
        FOCUS_PATTERN=$(cat test-results/failed-focus.txt)
        echo "Focus pattern: $FOCUS_PATTERN"
        if grep -q "e2e" test-results/test-type.txt 2>/dev/null; then
          echo "Running failed e2e tests..."
          ginkgo -v --focus="$FOCUS_PATTERN" -timeout=30m ./e2e
        else
          echo "Running failed unit tests..."
          go test -v -run="$FOCUS_PATTERN" -timeout=10m ./...
        fi

  test:parse-failed:
    desc: Parse failed tests from Ginkgo JSON reports and generate focus patterns
    cmds:
      - mkdir -p test-results
      - |
        # Parse failed tests from Ginkgo JSON reports
        echo "Parsing failed tests from Ginkgo JSON reports..."

        # Check for both e2e and regular test results
        FAILED_TESTS=""
        FOCUS_PATTERNS=""

        # Parse regular test results from Ginkgo JSON report (Ginkgo format)
        if [ -f test-results/test-results.json ]; then
          # Check if this contains E2E tests by looking for "E2E Suite" description
          IS_E2E=$(/usr/local/bin/jq -r '.[] | select(.SuiteDescription == "E2E Suite")' test-results/test-results.json 2>/dev/null)
          # Ginkgo JSON format: look for State=failed and extract platform/test info
          UNIT_FAILED=$(/usr/local/bin/jq -r '.[] | select(.SpecReports != null) | .SpecReports[] | select(.State == "failed") | if (.ContainerHierarchyTexts | length) > 1 then "\(.ContainerHierarchyTexts[1])/\(.LeafNodeText)" else .LeafNodeText end' test-results/test-results.json 2>/dev/null | sort -u)
          if [ ! -z "$UNIT_FAILED" ]; then
            FAILED_TESTS="$UNIT_FAILED"
            if [ ! -z "$IS_E2E" ]; then
              echo "e2e" > test-results/test-type.txt
            else
              echo "unit" > test-results/test-type.txt
            fi
          fi
        fi

        # Parse e2e test results from Ginkgo JSON report (Ginkgo format)
        if [ -f test-results/e2e-results.json ]; then
          # Ginkgo JSON format: look for State=failed and extract platform/test info
          E2E_FAILED=$(/usr/local/bin/jq -r '.[] | select(.SpecReports != null) | .SpecReports[] | select(.State == "failed") | if (.ContainerHierarchyTexts | length) > 1 then "\(.ContainerHierarchyTexts[1])/\(.LeafNodeText)" else .LeafNodeText end' test-results/e2e-results.json 2>/dev/null | sort -u)
          if [ ! -z "$E2E_FAILED" ]; then
            if [ ! -z "$FAILED_TESTS" ]; then
              FAILED_TESTS="$FAILED_TESTS"$'\n'"$E2E_FAILED"
            else
              FAILED_TESTS="$E2E_FAILED"
            fi
            echo "e2e" > test-results/test-type.txt
          fi
        fi

        # Clean up failed tests list
        FAILED_TESTS=$(echo "$FAILED_TESTS" | grep -v '^$' | sort -u)

        # Convert test names to focus patterns
        if [ ! -z "$FAILED_TESTS" ]; then
          while IFS= read -r test; do
            if [ ! -z "$test" ]; then
              # For Ginkgo tests with platform/test format, convert to space-separated format
              FOCUS_TEST=$(echo "$test" | sed 's/\// /')
              if [ -z "$FOCUS_PATTERNS" ]; then
                FOCUS_PATTERNS="$FOCUS_TEST"
              else
                FOCUS_PATTERNS="$FOCUS_PATTERNS|$FOCUS_TEST"
              fi
            fi
          done <<< "$FAILED_TESTS"
        fi

        # Save results
        echo "$FAILED_TESTS" > test-results/failed-tests.txt
        echo "$FOCUS_PATTERNS" > test-results/failed-focus.txt

        if [ -z "$FOCUS_PATTERNS" ]; then
          echo "No failed tests found"
        else
          echo "Found failed tests:"
          echo "$FAILED_TESTS"
          echo "Generated focus pattern: $FOCUS_PATTERNS"
        fi
    sources:
      - "test-results/test-results.json"
      - "test-results/e2e-results.json"
    generates:
      - "test-results/failed-tests.txt"
      - "test-results/failed-focus.txt"

  install-golangci-lint:
    desc: Install golangci-lint
    status:
      - which golangci-lint
    cmds:
      - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v2.4.0
  lint:
    desc: Run golangci-lint
    cmds:
      - golangci-lint run

  fmt:
    desc: Format Go code
    cmds:
      - go fmt ./...

  vet:
    desc: Run go vet
    cmds:
      - go vet ./...

  mod-tidy:
    desc: Tidy Go modules
    cmds:
      - go mod tidy

  mod-download:
    desc: Download Go module dependencies
    cmds:
      - go mod download

  clean:
    desc: Clean build artifacts
    cmds:
      - rm -rf {{.BUILD_DIR}}
      - go clean

  install:
    desc: Install the binary to /usr/local/bin
    deps: [build]
    cmds:
      - mv "{{.BUILD_DIR}}/{{.BINARY_NAME}}" /usr/local/bin

  check:
    desc: Run all checks (fmt, vet, lint, test)
    deps: [fmt, vet, lint, test]

  ci:
    desc: Run all CI checks
    deps: [mod-download, check, build]