upgrade-tests.yaml

name: Upgrade Tests

on:
  workflow_call:
    inputs:
      skip:
        description: 'URL of a previous successful run; if non-empty, all steps are skipped'
        required: false
        type: string
        default: ''
      lkg_release_tag:
        description: 'Tag of the last known good release to upgrade from (default: latest release)'
        required: false
        type: string
        default: ''

permissions:
  contents: read
  actions: read

jobs:
  upgrade_test:
    runs-on: windows-2025
    name: Upgrade
    timeout-minutes: 30

    strategy:
      matrix:
        configuration: [ Release ]
        scenario:
          - staging-upgrade
          - clean-upgrade
          - double-staging
          - staging-then-clean
          - mount-safety-deferral
          - unmount-all-triggers-upgrade
      fail-fast: false

    steps:
    - name: Skip this job if there is a previous successful run
      if: inputs.skip != ''
      id: skip
      uses: actions/github-script@v9
      with:
        script: |
          core.info(`Skipping: There already is a successful run: ${{ inputs.skip }}`)
          return true

    # -- Artifacts --

    - name: Download LKG release installer
      if: steps.skip.outputs.result != 'true'
      shell: pwsh
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
        $tag = "${{ inputs.lkg_release_tag }}"
        if (-not $tag) {
          $tag = gh api repos/microsoft/VFSForGit/releases/latest --jq '.tag_name'
          Write-Host "Auto-detected latest release: $tag"
        }
        New-Item -ItemType Directory -Path gvfs-lkg -Force | Out-Null
        gh release download $tag --repo microsoft/VFSForGit --pattern "SetupGVFS*.exe" --dir gvfs-lkg

    - name: Download Git installer
      id: download-git
      if: steps.skip.outputs.result != 'true'
      continue-on-error: true
      uses: actions/download-artifact@v8
      with:
        name: MicrosoftGit
        path: git

    - name: Download Git installer (retry)
      if: steps.skip.outputs.result != 'true' && steps.download-git.outcome == 'failure'
      uses: actions/download-artifact@v8
      with:
        name: MicrosoftGit
        path: git

    - name: Download current GVFS installer
      id: download-gvfs
      if: steps.skip.outputs.result != 'true'
      continue-on-error: true
      uses: actions/download-artifact@v8
      with:
        name: GVFS_${{ matrix.configuration }}_x64
        path: gvfs-new

    - name: Download current GVFS installer (retry)
      if: steps.skip.outputs.result != 'true' && steps.download-gvfs.outcome == 'failure'
      uses: actions/download-artifact@v8
      with:
        name: GVFS_${{ matrix.configuration }}_x64
        path: gvfs-new

    # -- Setup --

    - name: Install Git
      if: steps.skip.outputs.result != 'true'
      shell: cmd
      run: git\install.bat

    - name: Enable ProjFS
      if: steps.skip.outputs.result != 'true'
      shell: pwsh
      run: |
        $feature = Get-WindowsOptionalFeature -Online -FeatureName Client-ProjFS
        if ($feature.State -ne 'Enabled') {
          Enable-WindowsOptionalFeature -Online -FeatureName Client-ProjFS -NoRestart
        }

    # -- Test Execution --

    - name: Run upgrade test - ${{ matrix.scenario }}
      if: steps.skip.outputs.result != 'true'
      shell: pwsh
      run: |
        $ErrorActionPreference = 'Stop'

        $lkgInstaller = (Get-ChildItem gvfs-lkg\SetupGVFS*.exe).FullName
        $newInstaller = (Get-ChildItem gvfs-new\SetupGVFS*.exe).FullName
        $installDir = "C:\Program Files\VFS for Git"
        $testRepo = "https://dev.azure.com/gvfs/ci/_git/ForTests"
        $enlistment = "C:\gvfs-upgrade-test"

        function Install-GVFS($installer, [string[]]$extraArgs = @()) {
          $logDir = "C:\temp\gvfs-install-logs"
          New-Item -ItemType Directory -Path $logDir -Force | Out-Null
          $logFile = Join-Path $logDir "gvfs-$(Get-Date -Format 'yyyyMMdd-HHmmss').log"
          $allArgs = @("/VERYSILENT", "/SUPPRESSMSGBOXES", "/NORESTART", "/LOG=$logFile") + $extraArgs
          Write-Host "Installing: $installer $($allArgs -join ' ')"
          # Start without -Wait: Inno Setup launches child processes
          # (e.g. GVFS.Service.UI) that stay running, causing -Wait to
          # hang. Instead, wait only for the installer process itself.
          $proc = Start-Process -FilePath $installer -ArgumentList $allArgs -PassThru
          $proc.WaitForExit()
          if ($proc.ExitCode -ne 0) {
            Get-Content $logFile -Tail 30 -ErrorAction SilentlyContinue
            throw "Installer failed with exit code $($proc.ExitCode)"
          }
          Write-Host "Installed successfully"
        }

        function Assert-ServiceRunning {
          $svc = sc.exe query GVFS.Service 2>&1 | Select-String "STATE"
          if ($svc -notmatch "RUNNING") { throw "GVFS.Service is not running: $svc" }
        }

        function Mount-TestRepo {
          if (Test-Path $enlistment) {
            & "$installDir\gvfs.exe" mount $enlistment 2>&1 | Write-Host
          } else {
            & "$installDir\gvfs.exe" clone $testRepo $enlistment 2>&1 | Write-Host
          }
          if ($LASTEXITCODE -ne 0) { throw "Mount/clone failed" }
          $mountProc = Get-Process -Name "GVFS.Mount" -ErrorAction SilentlyContinue
          if (-not $mountProc) { throw "No GVFS.Mount process after mount" }
          return $mountProc.Id
        }

        function Assert-MountAlive($expectedPid) {
          $proc = Get-Process -Id $expectedPid -ErrorAction SilentlyContinue
          if (-not $proc -or $proc.ProcessName -ne "GVFS.Mount") {
            throw "Mount process $expectedPid is no longer running"
          }
          # Verify the mount is functional by accessing a file
          $readmePath = Join-Path $enlistment "src\Readme.md"
          if (-not (Test-Path $readmePath)) {
            throw "Mount is running but cannot access $readmePath"
          }
        }

        function Unmount-TestRepo {
          & "$installDir\gvfs.exe" unmount $enlistment 2>&1
          Start-Sleep -Seconds 3
        }

        function Restart-Service {
          sc.exe stop GVFS.Service | Out-Null
          Start-Sleep -Seconds 10
          sc.exe start GVFS.Service | Out-Null
          Start-Sleep -Seconds 10
          Assert-ServiceRunning
        }

        function Assert-PendingUpgrade($expected) {
          $exists = Test-Path "$installDir\PendingUpgrade"
          if ($exists -ne $expected) {
            throw "PendingUpgrade directory: expected=$expected, actual=$exists"
          }
        }

        function Assert-HookVersionsMatch {
          Write-Host "Verifying hook binary versions in enlistment..."
          $hooksDir = Join-Path $enlistment "src\.git\hooks"

          # Native hooks: each has its own source binary in the install directory
          # Command hooks: copies of GitHooksLoader.exe
          $hooks = @(
            @{ Source = "GVFS.ReadObjectHook.exe";        Target = "read-object.exe" }
            @{ Source = "GVFS.VirtualFileSystemHook.exe"; Target = "virtual-filesystem.exe" }
            @{ Source = "GVFS.PostIndexChangedHook.exe";  Target = "post-index-change.exe" }
            @{ Source = "GitHooksLoader.exe";             Target = "pre-command.exe" }
            @{ Source = "GitHooksLoader.exe";             Target = "post-command.exe" }
          )

          foreach ($hook in $hooks) {
            $sourcePath = Join-Path $installDir $hook.Source
            $targetPath = Join-Path $hooksDir $hook.Target
            if (-not (Test-Path $targetPath)) {
              throw "Hook not found: $targetPath"
            }
            $sourceVer = [System.Diagnostics.FileVersionInfo]::GetVersionInfo($sourcePath).FileVersion
            $targetVer = [System.Diagnostics.FileVersionInfo]::GetVersionInfo($targetPath).FileVersion
            if ($sourceVer -ne $targetVer) {
              throw "Hook version mismatch: $($hook.Target) is $targetVer, expected $sourceVer (from $($hook.Source))"
            }
            Write-Host "  $($hook.Target): $targetVer OK"
          }
          Write-Host "All hook binary versions match"
        }

        # =============================================
        # Test scenarios
        # =============================================

        switch ("${{ matrix.scenario }}") {

          "staging-upgrade" {
            Write-Host "=== Scenario: Staging upgrade e2e ==="
            # Install LKG, mount, staging upgrade, unmount, verify completion
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            $mountPid = Mount-TestRepo

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            Unmount-TestRepo
            Restart-Service
            Assert-PendingUpgrade $false

            # Remount and verify all hooks were updated to new version
            $null = Mount-TestRepo
            Assert-HookVersionsMatch
            Unmount-TestRepo
            Write-Host "PASS: Staging upgrade completed"
          }

          "clean-upgrade" {
            Write-Host "=== Scenario: Clean upgrade (traditional) ==="
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            Mount-TestRepo | Write-Host

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=false")
            Assert-PendingUpgrade $false
            Assert-ServiceRunning

            # Remount and verify all hooks were updated to new version
            $null = Mount-TestRepo
            Assert-HookVersionsMatch
            Unmount-TestRepo
            Write-Host "PASS: Clean upgrade completed"
          }

          "double-staging" {
            Write-Host "=== Scenario: Double staging install ==="
            # Install LKG, mount, staging install twice, verify second overwrites
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            $mountPid = Mount-TestRepo

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            # Second staging install should overwrite PendingUpgrade
            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            Unmount-TestRepo
            Restart-Service
            Assert-PendingUpgrade $false
            Write-Host "PASS: Double staging handled correctly"
          }

          "staging-then-clean" {
            Write-Host "=== Scenario: Staging then clean install ==="
            # Install LKG, mount, staging install, unmount, clean install
            # Verify PendingUpgrade is cleaned up by clean install
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            $mountPid = Mount-TestRepo

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            Unmount-TestRepo
            # Now clean install — should remove PendingUpgrade
            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=false")
            Assert-PendingUpgrade $false
            Assert-ServiceRunning
            Write-Host "PASS: Staging then clean install handled correctly"
          }

          "mount-safety-deferral" {
            Write-Host "=== Scenario: Mount safety deferral ==="
            # Install LKG, mount, staging install, restart service WITH mount
            # running — upgrade should be deferred
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            $mountPid = Mount-TestRepo

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            # Restart service WITHOUT unmounting — upgrade should defer
            Restart-Service
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true
            Write-Host "Upgrade correctly deferred while mount running"

            # Now unmount and restart — should complete
            Unmount-TestRepo
            Restart-Service
            Assert-PendingUpgrade $false
            Write-Host "PASS: Mount safety deferral works correctly"
          }

          "unmount-all-triggers-upgrade" {
            Write-Host "=== Scenario: unmount-all triggers staged upgrade ==="
            # Install LKG, mount, staging upgrade with new installer (which
            # replaces GVFS.Service.exe in-place with the new version that
            # includes PendingUpgradeMonitor). Then unmount via --unmount-all.
            # The new service monitors mount process exits and applies the
            # upgrade automatically — no pipe message from gvfs.exe needed.
            Install-GVFS $lkgInstaller
            Assert-ServiceRunning
            $mountPid = Mount-TestRepo

            Install-GVFS $newInstaller @("/STAGEIFMOUNTED=true")
            Assert-MountAlive $mountPid
            Assert-PendingUpgrade $true

            # Unmount via --unmount-all (uses LKG gvfs.exe — no new pipe msg)
            & "$installDir\gvfs.exe" service --unmount-all 2>&1 | Write-Host
            if ($LASTEXITCODE -ne 0) { throw "unmount-all failed" }

            # The monitor's debounce timer fires 5s after the last mount
            # process exits, then applies the upgrade. Wait for completion.
            $deadline = (Get-Date).AddSeconds(30)
            while ((Test-Path "$installDir\PendingUpgrade") -and (Get-Date) -lt $deadline) {
              Start-Sleep -Seconds 2
            }

            Assert-PendingUpgrade $false
            Write-Host "PASS: unmount-all triggers staged upgrade via process monitor"
          }

          default {
            throw "Unknown scenario: ${{ matrix.scenario }}"
          }
        }

    - name: Upload service logs
      if: always() && steps.skip.outputs.result != 'true'
      uses: actions/upload-artifact@v7
      continue-on-error: true
      with:
        name: UpgradeTest_Logs_${{ matrix.scenario }}
        path: |
          C:\ProgramData\GVFS\GVFS.Service\Logs\
          C:\temp\gvfs-install-logs\