build.ps1

# SPDX-License-Identifier: Apache-2.0
# Licensed to the Ed-Fi Alliance under one or more agreements.
# The Ed-Fi Alliance licenses this file to you under the Apache License, Version 2.0.
# See the LICENSE and NOTICES files in the project root for more information.

[CmdLetBinding()]
<#
    .SYNOPSIS
        Automation script for running build operations from the command line.

    .DESCRIPTION
        Provides automation of the following tasks:

        * Clean: runs `dotnet clean`
        * Build: runs `dotnet build` with several implicit steps
          (clean, restore, inject version information).
        * UnitTest: executes NUnit tests in projects named `*.UnitTests`, which
          do not connect to a database.
    .EXAMPLE
        .\build-dms.ps1 build -Configuration Release -Version "2.0" -BuildCounter 45

        Overrides the default build configuration (Debug) to build in release
        mode with assembly version 2.0.45.

    .EXAMPLE
        .\build-dms.ps1 unittest

        Output: test results displayed in the console and saved to XML files.
#>
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'False positive')]
param(
    # Command to execute, defaults to "Build".
    [string]
    [ValidateSet("Clean", "Build", "BuildAndPublish", "Package", "Push", "UnitTest")]
    $Command = "Build",

    # Assembly and package version number for the Data Management Service. The
    # current package number is configured in the build automation tool and
    # passed to this script.
    [string]
    $Version = "0.1",

    # .NET project build configuration, defaults to "Debug". Options are: Debug, Release.
    [string]
    [ValidateSet("Debug", "Release")]
    $Configuration = "Debug",

    # Ed-Fi's official NuGet package feed for package download and distribution.
    [string]
    $EdFiNuGetFeed = "https://pkgs.dev.azure.com/ed-fi-alliance/Ed-Fi-Alliance-OSS/_packaging/EdFi/nuget/v3/index.json",

    # API key for accessing the feed above. Only required with the Push
    # command.
    [string]
    $NuGetApiKey,

    # Full path of a package file to push to the NuGet feed. Optional, only
    # applies with the Push command. If not set, then the script looks for a
    # NuGet package corresponding to the provided $Version and $BuildCounter.
    [string]
    $PackageFile,

    # Only required with local builds and testing.
    [switch]
    $IsLocalBuild
)

$solutionRoot = "$PSScriptRoot/src"
$csprojFolderName = "EdFi.AdminConsole.InstanceManagementWorker"
$defaultSolution = "$solutionRoot/EdFi.AdminConsole.InstanceManagement.sln"
$projectName = "Ed-Fi-Admin-Console-Instance-Management-Worker-Process"
$packageName = "Ed-Fi-Admin-Console-Instance-Management-Worker-Process"
$testResults = "$PSScriptRoot/TestResults"

$maintainers = "Ed-Fi Alliance, LLC and contributors"

Import-Module -Name "$PSScriptRoot/eng/build-helpers.psm1" -Force

function DotNetClean {
    Invoke-Execute { dotnet clean $defaultSolution -c $Configuration --nologo -v minimal }
}

function Restore {
    Invoke-Execute { dotnet restore $defaultSolution }
}

function AssemblyInfo {
    Invoke-Execute {
        $assembly_version = $Version

        Invoke-RegenerateFile "$PSScriptRoot/Directory.Build.props" @"
<Project>
    <!-- This file is generated by the build script. -->
    <PropertyGroup>
        <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
        <ErrorLog>results.sarif,version=2.1</ErrorLog>
        <Product>Ed-Fi Admin Console Instance Management Worker Process</Product>
        <Authors>$maintainers</Authors>
        <Company>$maintainers</Company>
        <Copyright>Copyright © ${(Get-Date).year)} Ed-Fi Alliance</Copyright>
        <VersionPrefix>$assembly_version</VersionPrefix>
        <VersionSuffix></VersionSuffix>
    </PropertyGroup>
</Project>
"@
    }
}

function Compile {
    Invoke-Execute {
        dotnet build $defaultSolution -c $Configuration --nologo --no-restore
    }
}

function Publish {
    Invoke-Execute {
        $outputPath = "$solutionRoot/$csprojFolderName/publish"
        dotnet publish $defaultSolution -c $Configuration /p:EnvironmentName=Production -o $outputPath --no-build --nologo
    }
}

function RunDotNetPack {
    param (
        [string]
        $PackageVersion,

        [string]
        $ProjectName,

        [string]
        $NuspecFileName
    )

    dotnet pack "$ProjectName.csproj" --no-build --no-restore --output "$PSScriptRoot" --configuration $Configuration
}

function Package {
    Invoke-Execute {
        $baseProjectFullName = "$solutionRoot/$csprojFolderName/$csprojFolderName"
        RunDotNetPack -PackageVersion $Version -projectName $baseProjectFullName $baseProjectFullName        
    }
}

function Push {
    param (
        [string]
        $PackageVersion = $Version       
    )

    if (-not $NuGetApiKey) {
        throw "Cannot push a NuGet package without providing an API key in the `NuGetApiKey` argument."
    }

    if (-not $PackageFile) {
        $PackageFile = "$PSScriptRoot/EdFi.AdminConsole.InstanceManagementWorker.$Version.nupkg"  
    }

    DotnetPush  -PackageFileName $PackageFile       
}

function DotnetPush {
    param (
        [string]
        $PackageFileName
    )

    Write-Host "Pushing $PackageFileName to $EdFiNuGetFeed"
    dotnet nuget push $PackageFileName --api-key $NuGetApiKey --source $EdFiNuGetFeed
}

function RunTests {
    param (
        # File search filter
        [string]
        $Filter
    )

    $testAssemblyPath = "$solutionRoot/$Filter/bin/$Configuration/"
    $testAssemblies = Get-ChildItem -Path $testAssemblyPath -Filter "$Filter.dll" -Recurse

    if ($testAssemblies.Length -eq 0) {
        Write-Output "no test assemblies found in $testAssemblyPath"
    }

    $testAssemblies | ForEach-Object {
        Write-Output "Executing: dotnet test $($_)"
        Invoke-Execute {
            dotnet test $_ `
                --logger "trx;LogFileName=$($_).trx" `
                --nologo
        }
    }
}

function UnitTests {
    Invoke-Execute { RunTests -Filter "*.UnitTests" }
}

function Invoke-Build {
    Invoke-Step { DotNetClean }
    Invoke-Step { Restore }
    Invoke-Step { Compile }
}

function Invoke-SetAssemblyInfo {
    Write-Output "Setting Assembly Information"

    Invoke-Step { AssemblyInfo }
}

function Invoke-BuildAndPublish {
    Invoke-Build
    Invoke-Step { Publish }
}

function Invoke-Clean {
    Invoke-Step { DotNetClean }
}

function Invoke-TestExecution {
    param (
        [ValidateSet("UnitTests",
            ErrorMessage = "Please specify a valid Test Type name from the list.",
            IgnoreCase = $true)]
        # File search filter
        [string]
        $Filter
    )
    switch ($Filter) {
        UnitTests { Invoke-Step { UnitTests } }
        Default { "Unknow Test Type" }
    }
}

function Invoke-Package {
    Invoke-Step { Package }
}

function Invoke-Push {
    Invoke-Step { Push }
}

Invoke-Main {
    if ($IsLocalBuild) {
        $nugetExePath = Install-NugetCli
        Set-Alias nuget $nugetExePath -Scope Global -Verbose
    }
    switch ($Command) {
        Clean { Invoke-Clean }
        Build { Invoke-Build }
        BuildAndPublish { 
            Invoke-SetAssemblyInfo
            Invoke-BuildAndPublish 
        }
        Package { Invoke-Package }
        Push { Invoke-Push }
        UnitTest { Invoke-TestExecution UnitTests }
        default { throw "Command '$Command' is not recognized" }
    }
}