Testing in Azure DevOps Pipelines

# azure-pipelines.yml
trigger:
  branches: { include: [main] }

pr:
  branches: { include: [main] }

variables:
  buildConfiguration: 'Release'
  DOTNET_NOLOGO: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true

stages:
  # ---------------------------------------------------------------- #
  - stage: Build
    jobs:
      - job: Compile
        pool: { vmImage: 'ubuntu-latest' }
        steps:
          - task: UseDotNet@2
            inputs: { version: '9.x' }

          - task: Cache@2
            inputs:
              key: 'nuget | "$(Agent.OS)" | **/packages.lock.json'
              restoreKeys: 'nuget | "$(Agent.OS)"'
              path: $(NUGET_PACKAGES)

          - script: dotnet build --configuration $(buildConfiguration)
            displayName: Build

  # ---------------------------------------------------------------- #
  - stage: Test
    dependsOn: Build
    jobs:
      - job: Unit
        pool: { vmImage: 'ubuntu-latest' }
        steps:
          - task: UseDotNet@2
            inputs: { version: '9.x' }

          - script: |
              dotnet test \
                --configuration $(buildConfiguration) \
                --filter "Category!=Integration" \
                --logger "trx;LogFileName=unit.trx" \
                --collect:"XPlat Code Coverage" \
                --results-directory $(Agent.TempDirectory)/TestResults
            displayName: Unit tests

          # condition: always() — a report is needed most when the step failed
          - task: PublishTestResults@2
            condition: always()
            inputs:
              testResultsFormat: VSTest
              testResultsFiles: '**/unit.trx'
              testRunTitle: 'Unit tests'
              failTaskOnFailedTests: true

          - task: PublishCodeCoverageResults@2
            condition: always()
            inputs:
              summaryFileLocation: '$(Agent.TempDirectory)/TestResults/**/coverage.cobertura.xml'

      - job: Integration
        pool: { vmImage: 'ubuntu-latest' }
        steps:
          - task: UseDotNet@2
            inputs: { version: '9.x' }
          # The hosted Ubuntu agent has Docker, so Testcontainers just works.
          - script: dotnet test --filter "Category=Integration" --logger "trx;LogFileName=integration.trx"
            displayName: Integration tests
          - task: PublishTestResults@2
            condition: always()
            inputs: { testResultsFormat: VSTest, testResultsFiles: '**/integration.trx' }

      - job: E2E
        pool: { vmImage: 'ubuntu-latest' }
        # Four agents run this job; each slices the suite itself.
        strategy:
          parallel: 4
        steps:
          - task: NodeTool@0
            inputs: { versionSpec: '22.x' }
          - script: npm ci && npx playwright install --with-deps chromium
          - script: |
              npx playwright test \
                --shard=$((System.JobPositionInPhase))/$((System.TotalJobsInPhase)) \
                --reporter=junit,blob
            displayName: Playwright
            env:
              PLAYWRIGHT_JUNIT_OUTPUT_NAME: results.xml

          - task: PublishTestResults@2
            condition: always()
            inputs:
              testResultsFormat: JUnit
              testResultsFiles: 'results.xml'
              testRunTitle: 'E2E shard $(System.JobPositionInPhase)'

          - task: PublishPipelineArtifact@1
            condition: always()
            inputs:
              targetPath: 'blob-report'
              artifact: 'blob-$(System.JobPositionInPhase)'

  # ---------------------------------------------------------------- #
  - stage: Deploy
    dependsOn: Test
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: Production
        environment: production        # approvals and gates attach here
        strategy:
          runOnce:
            deploy:
              steps:
                - script: ./deploy.sh

- task: VSTest@3
  inputs:
    testSelector: testAssemblies
    testAssemblyVer2: '**/*Tests.dll'
    runInParallel: true
    # Slice by previous run time — the best distribution available here.
    distributionBatchType: basedOnTestCases
    rerunFailedTests: true
    rerunMaxAttempts: 2

resources:
  containers:
    - container: postgres
      image: postgres:16-alpine
      ports: ['5432:5432']
      env:
        POSTGRES_PASSWORD: test
        POSTGRES_DB: test

jobs:
  - job: Integration
    services:
      postgres: postgres
    steps:
      - script: dotnet test
        env:
          ConnectionStrings__Default: 'Host=localhost;Database=test;Username=postgres;Password=test'

# templates/dotnet-test.yml
parameters:
  - name: filter
    type: string
    default: ''
  - name: title
    type: string

steps:
  - script: dotnet test --filter "${{ parameters.filter }}" --logger "trx;LogFileName=${{ parameters.title }}.trx"
  - task: PublishTestResults@2
    condition: always()
    inputs:
      testResultsFormat: VSTest
      testResultsFiles: '**/${{ parameters.title }}.trx'
      testRunTitle: ${{ parameters.title }}

# azure-pipelines.yml
- template: templates/dotnet-test.yml
  parameters: { filter: 'Category!=Integration', title: 'Unit' }