rununityunittests.yml

name: Run Unity unit tests

on:
  workflow_call:
    inputs:
      build-target:
        required: true
        type: string
      unityversion:
        description: "The version of Unity to validate on"
        required: true
        type: string
      dependencies:
        description: "json array of dependencies and their targets"
        required: false
        type: string
    secrets:
      GIT_USER_NAME: 
        required: false            
      GIT_PAT: 
        required: false
    outputs:
      unityversion:
        description: "Returns the version of Unity the UPM package requires"
        value: ${{ jobs.run_tests.outputs.unityprojectpath }}

jobs:
  run_tests:
    name: Run Unity Unit Tests
    runs-on: ${{ matrix.os }}
    outputs:
      unityprojectpath: ${{ steps.validate.outputs.unityprojectpath }}    
    strategy:
      matrix:
        include:
          - os: self-hosted
            build-target: Android
          - os: self-hosted
            build-target: iOS
        
    steps:
      - name: Script Version
        run: |
          echo "::group::Script Versioning"
          $scriptVersion = "1.0.2"
          echo "Build Script Version: $scriptVersion"
          echo "::endgroup::"
        shell: pwsh       
      - uses: actions/checkout@v3
        with:
          submodules: recursive
          clean: true

      - id: validate
        name: 'Run Unity Unit tests'
        run: |
          echo "::group::Warm up for Unity version"

          echo 'Unity version is ${{ inputs.unityversion }}'
          $unityVersion = '${{ inputs.unityversion }}'
          
          if([string]::IsNullOrEmpty($unityVersion))
          {
              echo 'Unity version missing, using default'
              $unityVersion = '2020.3.29f1'
          }

          if ( (-not $global:PSVersionTable.Platform) -or ($global:PSVersionTable.Platform -eq "Win32NT") ) {
            echo 'Building using Windows'
            $directorySeparatorChar = "\"
            $editorRootPath = "C:/Program Files/Unity/Hub/Editor/"
            $editorFileEx = "/Editor/Unity.exe"
            $editorrunpath = $editorRootPath + $unityVersion + $editorFileEx

            function unity-editor {
              #$p = Start-Process -Verbose -NoNewWindow -PassThru -Wait -FilePath "$editorrunpath" -ArgumentList (@(' -batchmode') + $args.Split(" "))
              & $editorrunpath -batchmode $args.Split(" ") | Out-String
            }
          }
          elseif ( $global:PSVersionTable.OS.Contains("Darwin") ) {
            echo 'Building using Mac'
            $directorySeparatorChar = "/"
            $editorRootPath = "/Applications/Unity/Hub/Editor/"
            $editorFileEx = "/Unity.app/Contents/MacOS/Unity"
            $editorrunpath = $editorRootPath + $unityVersion + $editorFileEx

            function unity-editor {
              #$p = Start-Process -Verbose -NoNewWindow -PassThru -Wait -FilePath "$editorrunpath" -ArgumentList (@(' -batchmode') + $args.Split(" "))
              & $editorrunpath -batchmode $args.Split(" ") | Out-String
            }
          }
          elseif ( $global:PSVersionTable.OS.Contains("Linux") ) {
            echo 'Building using Linux'
            $directorySeparatorChar = "/"
            $editorRootPath = "$HOME/Unity/Hub/Editor/"
            $editorFileEx = "/Editor/Unity"
            $editorrunpath = $editorRootPath + $unityVersion + $editorFileEx

            function unity-editor {
              xvfb-run --auto-servernum "$editorrunpath" -batchmode $args.Split(" ")
            }
          }
          else
          {
            echo 'Unknown build platform'
          }
          
          if ( -not (Test-Path "$editorrunpath") ) 
          {
            Write-Error "$editorrunpath path not found!"
            exit 1
          }

          echo "::endgroup::"

          echo "::group::Grouping Package in a UPM folder"

          $UPMFolderName = 'u'

          if ( -not (Test-Path '$UPMFolderName') ) 
          {
            New-Item $UPMFolderName -ItemType Directory
          }

          Move-Item -Path * -Destination $UPMFolderName -exclude $UPMFolderName

          echo "::endgroup::"

          echo "::group::Creating Temp Unity project"

          $TempUnityProjectName = 'P'

          unity-editor '-createProject' $TempUnityProjectName -quit

          $destinationPath = $TempUnityProjectName + $directorySeparatorChar + 'packages'
          Move-Item -Path $UPMFolderName -Destination $destinationPath

          echo "::endgroup::"

          echo "::group::If required, clone dependencies in to test project"

          # Dependency option requires specific inputs
          # 
          # * A dependency input string in json format, listing each dependency by name and git url, e.g.
          #   $dependencies = '[{"ASADependencies": "github.com/SimonDarksideJ/upmGithubActionsTests.git"}]' 
          #   *Note, remove the https:// portion to allow using a PAT to access the repo
          #   The Name of the dependency should ALSO MATCH the name of the branch on the repo where the dependency is held (files intended for the packages folder)
          # 
          # * Additionally, if Manifest entries are required, then a manifest file with those dependencies (and ONLY the new dependancies) should also be in the dependency branch named the same as the branch name
          #   e.g. "ASADependencies.json" - keep the same structure, but only the dependancy entries
          # 
          # !!Does NOT support additional scoped registries at this time!

          echo "---------------------------------------------"
          echo "Read dependancy input value"
          if([string]::IsNullOrEmpty('${{ inputs.dependencies }}'))
          {
            echo "No dependencies provided"
            echo "input ${{ inputs.dependencies }}"
            echo "------------------------------"
          }
          else {
            echo "dependencies provided, validating"

            # Read dependancy input value
            $dependencies = '${{ inputs.dependencies }}'

            if([string]::IsNullOrEmpty('${{ secrets.GIT_USER_NAME }}') -or [string]::IsNullOrEmpty('${{ secrets.GIT_PAT }}')){
              echo ""
              echo "Secrets for GIT_USER_NAME or GIT_PAT missing, please register them with access to this runner"
              echo "*Note, Organisation secrets are not accessible to Forked repos and need registering in the local fork"
              exit 1
            }

            echo "---------------------------------------------"
            echo "Read dependancy input values as json"
            $JSONdependencies = $dependencies | ConvertFrom-Json

            echo $JSONdependencies

            # Read current Manifest json
            $manifestPath = $destinationPath + $directorySeparatorChar + 'manifest.json'
            $projectManifest = Get-Content -Path $manifestPath | ConvertFrom-Json
            $strArray = $projectManifest.dependencies.PsObject.Properties | ForEach-Object {"$($_.Name)@$($_.Value),"}

            echo "---------------------------------------------"
            echo "Loop through new dependancies and add them to the project Manifest"
            foreach($dependency in $JSONdependencies){
              $dependency.PsObject.Properties | ForEach-Object -Process { 
                $dependencyName = $_.Name
                $dependencyPath = $dependencyName.Replace("/","_")
                $dependencyURL = $_.Value
                echo "---------------------------------------------"
                echo "Cloning dependency - Name [$dependencyName] - Path [$dependencyPath] - URL [$dependencyURL]"
                $cloneURL = "https://${{ secrets.GIT_USER_NAME }}:${{ secrets.GIT_PAT }}@$dependencyURL"

                echo "cloning $dependencyName from $dependencyURL and moving to $destinationPath"
                echo "git path - $cloneURL"

                # Clone Dependancy repo to destination folder
                git clone -b $dependencyName --single-branch $cloneURL $dependencyPath

                if( -not (Test-Path -Path "$dependencyPath")){
                  echo "Unable to clone $dependencyName from $dependencyURL"
                  exit 1
                }

                # Move files from clone path into packages folder, if the dependency contains a UPM package then move the entire folder and not just its contents
                if (Test-Path -Path "$dependencyPath/package.json") {
                  $package_json = Get-Content -Path $dependencyPath/package.json | ConvertFrom-Json
                  $packageName = $package_json.name
                  Rename-Item $dependencyPath $packageName
                  echo "Moving whole $packageName UPM package to $destinationPath"
                  Move-Item -Path "$packageName" -Destination $destinationPath
                }
                else {
                  echo "Moving the contents of $dependencyName into the $destinationPath folder"
                  Move-Item -Path "$dependencyPath/*" -Destination $destinationPath
                }

                # Get Dependency manifest entries (if applicable)
                if (Test-Path -Path "$destinationPath/$dependencyName.json") {
                    $dependencyManifest = Get-Content -Path "$destinationPath/$dependencyName.json" | ConvertFrom-Json
                    $dependencyManifest.dependencies.PsObject.Properties | ForEach-Object {
                        $strArray += "$($_.Name)@$($_.Value),"
                    }
                }
                else{
                  echo "No denendency json found called $destinationPath/$dependencyName.json, skipping adding additional manifest entries"
                }
              }
            }
            echo "---------------------------------------------"
           
            # Reformat combined dependancies list
            $strArray = $strArray.Trim(",") | ConvertTo-Json 
            $strArray = $strArray.Replace("@",'":"').Replace("[","{").Replace("]","}")
            $strArrayObject = $strArray | ConvertFrom-Json
            
            # Save manifest back to project
            $projectManifest.dependencies = $strArrayObject
            $projectManifest | ConvertTo-Json | Set-Content -Path "$destinationPath/manifest.json"

            echo "Project updated with the following dependencies"
            echo "-----------------------------------------------"
            echo $projectManifest
          }

          echo "::endgroup::"

          echo "::group::Setup logging and run Unit tests"          

          # Log detail
          $logDirectory = "Logs"
          if (Test-Path -Path $logDirectory) {
            echo "Clearing logs from a previous run"
            Remove-item $logDirectory -recurse
          }

          $logDirectory = New-Item -ItemType Directory -Force -Path $logDirectory | Select-Object

          echo "Log Directory: $logDirectory"
          $date = Get-Date -Format "yyyyMMddTHHmmss"

          # If run manually, the Refname is actually blank, so just use date
          if([string]::IsNullOrEmpty(${GITHUB_REF_NAME})) {
            $logName = "$logDirectory$directorySeparatorChar$date"
          }
          else{          
            $logName = "$logDirectory$directorySeparatorChar${GITHUB_REF_NAME}-$date"
          }

          $logPath = "$logName.log"
          $testsLogPath = "$logName-tests.xml"

          echo "Logpath [$logPath]"
          echo "TestsPath [$testsLogPath]"

          echo "---------------------------------------------"
          echo "Start Testing"
          echo "Unity Command\n[unity-editor -runEditorTests -projectPath $TempUnityProjectName -logfile $logPath -editorTestsResultFile $testsLogPath -buildTarget ${{ matrix.build-target }}]"

          unity-editor -runEditorTests -projectPath $TempUnityProjectName -logfile $logPath -editorTestsResultFile $testsLogPath -buildTarget ${{ matrix.build-target }}

          echo "---------------------------------------------"
          echo "::group::Unity Unit tests Results"
          if (Test-Path $testsLogPath) {
            echo "Test Run results for ${GITHUB_REPOSITORY} Branch ${GITHUB_REF}"
            echo ""
            Select-Xml -Path $testsLogPath -XPath '/test-run/test-suite' | ForEach-Object { "Name: " +$_.Node.name, ", Result: " + $_.Node.result, ", Total Tests: " + $_.Node.total, ", Passed: " + $_.Node.passed, ", Failed: " + $_.Node.failed, ", Skipped: " + $_.Node.skipped }
          }
          else {
            echo "No test results found for ${GITHUB_REPOSITORY} Branch ${GITHUB_REF} at $testsLogPath"
            echo ""
          }

          echo "Unity Project path $TempUnityProjectName"
          echo "unityprojectpath=$TempUnityProjectName" >> $env:GITHUB_OUTPUT
          echo "::endgroup::"

          if($LASTEXITCODE -ne '0'){
          echo "::group::Unity Unit tests errors"
            $exitCode = $testResult.ExitCode
            Get-Content $logPath
            echo "Build failed due to errors ($LASTEXITCODE), please check the log at $logPath"
          echo "::endgroup::"

            exit $LASTEXITCODE
          }
          echo "::endgroup::"

          echo "::group::Run build"              

          echo "---------------------------------------------"
          echo "Start Building"
          if (Test-Path "$destinationPath/com.realitycollective.buildtools") 
          {
            if ( -not (Test-Path "$editorrunpath") ) {
              New-Item 'builds' -ItemType Directory
            }
            $buildTarget = "${{ matrix.build-target }}"
            $buildPath = 'builds' + $directorySeparatorChar + $buildTarget;
            $buildMethod = 'RealityCollective.BuildTools.Editor.BuildCommand.Build';

            echo "Unity Command\n[unity-editor -projectPath $TempUnityProjectName -logfile $logPath -nographics -quit -buildTarget $buildTarget -executeMethod $buildMethod -buildPath $buildPath]"

            unity-editor -projectPath $TempUnityProjectName -logfile $logPath -nographics -quit -buildTarget $buildTarget -executeMethod $buildMethod -buildPath $buildPath
          }
          else {
            echo "Build tools not found, have you included com.realitycollective.buildtools in the build depenendencies?"
            exit $LASTEXITCODE
          }
          echo "---------------------------------------------"          
          echo "::endgroup::"

        shell: pwsh
      - uses: actions/upload-artifact@v3
        if: always()
        with:
          name: unity-build-log
          path: Logs/**