build.ps1

# Default to Debug
$Configuration = 'Debug'

# Color
$Success = 'Green'
$Warning = 'Yellow'
$Err = 'Red'

if (($args.Count -eq 0) -or ($args[0] -match 'Nightly')) 
{
    $TestType = 'Nightly'
    $Configuration = 'Release'
}
elseif ($args[0] -match 'Quick' -or ($args[0] -match '-q')) 
{
    $TestType = "Quick"
}
elseif ($args[0] -match 'Rolling')
{
    # Rolling is a legacy options - run all tests.
    $TestType = "Nightly"
}
elseif ($args[0] -match 'E2E')
{
    # Rolling is a legacy options - run all tests.
    $TestType = "Nightly"
}
elseif ($args[0] -match 'DisableSkipStrongName')
{
    $TestType = "DisableSkipStrongName"
}
elseif ($args[0] -match 'EnableSkipStrongName')
{
    $TestType = "EnableSkipStrongName"
}
elseif ($args[0] -match 'SkipStrongName')
{
    # SkipStrongName is a legacy options.
    $TestType = "EnableSkipStrongName"
}
else 
{
    Write-Host 'Please choose Nightly Test or Quick Test!' -ForegroundColor $Err
    exit
}

$Build = 'build'
if ($args -contains 'rebuild')
{
    $Build = 'rebuild'
}

$PROGRAMFILESX86 = [Environment]::GetFolderPath("ProgramFilesX86")
$env:ENLISTMENT_ROOT = Split-Path -Parent $MyInvocation.MyCommand.Definition
$ENLISTMENT_ROOT = Split-Path -Parent $MyInvocation.MyCommand.Definition
$LOGDIR = $ENLISTMENT_ROOT + "\bin"

# Default to use Visual Studio 2017
$VSTEST = $PROGRAMFILESX86 + "\Microsoft Visual Studio 14.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe"
$FXCOPDIR = $PROGRAMFILESX86 + "\Microsoft Visual Studio 14.0\Team Tools\Static Analysis Tools\FxCop"
$SN = $PROGRAMFILESX86 + "\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\sn.exe"
$SNx64 = $PROGRAMFILESX86 + "\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\x64\sn.exe"

# Use Visual Studio 2017 compiler for .NET Core and .NET Standard. Because VS2017 has different paths for different
# versions, we have to check for each version. Meanwhile, the dotnet CLI is required to run the .NET Core unit tests in this script.
$VS15VERSIONS = "Enterprise",
    "Professional",
    "Community"
$VS15MSBUILD = $null
ForEach ($version in $VS15VERSIONS)
{
    $tempMSBuildPath = ($PROGRAMFILESX86 + "\Microsoft Visual Studio\2017\{0}\MSBuild\15.0\Bin\MSBuild.exe") -f $version
    if([System.IO.File]::Exists($tempMSBuildPath))
    {
        $VS15MSBUILD = $tempMSBuildPath
        break
    }
}
$DOTNETDIR = "C:\Program Files\dotnet\"
$DOTNETTEST = $null
if ([System.IO.File]::Exists($DOTNETDIR + "dotnet.exe"))
{
    $DOTNETTEST = $DOTNETDIR + "dotnet.exe"
}

# Other variables
$FXCOP = $FXCOPDIR + "\FxCopCmd.exe"
$BUILDLOG = $LOGDIR + "\msbuild.log"
$TESTLOG = $LOGDIR + "\mstest.log"
$TESTDIR = $ENLISTMENT_ROOT + "\bin\AnyCPU\$Configuration\Test\Desktop"
$NETCORETESTDIR = $ENLISTMENT_ROOT + "\bin\AnyCPU\$Configuration\Test\.NETPortable\netcoreapp1.0"
$PRODUCTDIR = $ENLISTMENT_ROOT + "\bin\AnyCPU\$Configuration\Product\Desktop"
$NUGETEXE = $ENLISTMENT_ROOT + "\sln\.nuget\NuGet.exe"
$NUGETPACK = $ENLISTMENT_ROOT + "\sln\packages"
$XUNITADAPTER = "/TestAdapterPath:" + $NUGETPACK + "\xunit.runner.visualstudio.2.1.0\build\_common"

$NugetRestoreSolutions = "ODataClientFactory.sln", "ODataMigration.sln"

$ProductDlls = "Microsoft.OData.Extensions.Client.dll",
    "Microsoft.OData.Extensions.Client.Abstractions",
    "Microsoft.OData.Extensions.Migration.dll"

$XUnitTestDlls = @()

$NetCoreXUnitTestDlls = "Microsoft.OData.Extensions.Client.Tests.dll",
    "Microsoft.OData.Extensions.Client.E2ETests.dll",
    "Microsoft.OData.Extensions.Migration.Tests.dll"

$TestSupportDlls = @()

$NightlyTestDlls = @()
    
# .NET Core tests are different and require the dotnet tool. The tool references the .csproj (VS2017) files instead of dlls
$NetCoreXUnitTestProjs = "\test\FunctionalTests\Microsoft.OData.Extensions.Client.Tests\OData.Client.Tests.csproj",
    "\test\EndToEndTests\Tests\Microsoft.OData.Extensions.Client.E2ETests\OData.Client.E2ETests.csproj",
    "\test\FunctionalTests\Microsoft.OData.Extensions.Migration.Tests\Microsoft.OData.Extensions.Migration.Tests.csproj"

$QuickTestSuite = @()
$NightlyTestSuite = @()
ForEach($dll in $XUnitTestDlls)
{
    $QuickTestSuite += $TESTDIR + "\" + $dll
    $NightlyTestSuite += $TESTDIR + "\" + $dll
}

ForEach($dll in $NightlyTestDlls)
{
    $NightlyTestSuite += $TESTDIR + "\" + $dll
}

$E2eTestDlls = @()
ForEach ($dll in $E2eTestDlls)
{
    $NightlyTestSuite += $TESTDIR + "\" + $dll
}

$FxCopRulesOptions = "/rule:$FxCopDir\Rules\DesignRules.dll",
    "/rule:$FxCopDir\Rules\NamingRules.dll",
    "/rule:$FxCopDir\Rules\PerformanceRules.dll",
    "/rule:$FxCopDir\Rules\SecurityRules.dll",
    "/rule:$FxCopDir\Rules\GlobalizationRules.dll",
    "/dictionary:$ENLISTMENT_ROOT\src\CustomDictionary.xml",
    "/ruleid:-Microsoft.Design#CA1006",
    "/ruleid:-Microsoft.Design#CA1016",
    "/ruleid:-Microsoft.Design#CA1020",
    "/ruleid:-Microsoft.Design#CA1021",
    "/ruleid:-Microsoft.Design#CA1045",
    "/ruleid:-Microsoft.Design#CA2210",
    "/ruleid:-Microsoft.Performance#CA1814"
$DataWebRulesOption = "/rule:$TESTDIR\DataWebRules.dll"

Function GetDlls
{
    $dlls = @()

    ForEach($dll in $ProductDlls)
    {
        $dlls += $PRODUCTDIR + "\" + $dll
    }

    ForEach($dll in $XUnitTestDlls)
    {
        $dlls += $TESTDIR + "\" + $dll
    }

    ForEach($dll in $NetCoreXUnitTestDlls)
    {
        $dlls += $NETCORETESTDIR + "\" + $dll
    }

    ForEach($dll in $TestSupportDlls)
    {
        $dlls += $TESTDIR + "\" + $dll
    }

    ForEach($dll in $NightlyTestDlls)
    {
        $dlls += $TESTDIR + "\" + $dll
    }

    ForEach($dll in $E2eTestDlls)
    {
        $dlls += $TESTDIR + "\" + $dll
    }

    return $dlls
}

Function SkipStrongName
{
    $SnLog = $LOGDIR + "\SkipStrongName.log"
    Out-File $SnLog

    Write-Host 'Skip strong name validations for ODataLib assemblies...'

    $dlls = GetDlls
    ForEach ($dll in $dlls)
    {
        & $SN /Vr $dll | Out-File $SnLog -Append
    }

    ForEach ($dll in $dlls)
    {
        & $SNx64 /Vr $dll | Out-File $SnLog -Append
    }

    Write-Host "SkipStrongName Done" -ForegroundColor $Success
}

Function DisableSkipStrongName
{
    $SnLog = $LOGDIR + "\DisableSkipStrongName.log"
    Out-File $SnLog

    Write-Host 'Disable skip strong name validations for ODataLib assemblies...'

    $dlls = GetDlls
    ForEach ($dll in $dlls)
    {
        & $SN /Vu $dll | Out-File $SnLog -Append
    }

    ForEach ($dll in $dlls)
    {
        & $SNx64 /Vu $dll | Out-File $SnLog -Append
    }

    Write-Host "DisableSkipStrongName Done" -ForegroundColor $Success
}

Function Cleanup 
{    
    cd $ENLISTMENT_ROOT\tools\Scripts
    #Write-Host "Dropping stale databases..."
    #cscript "$ENLISTMENT_ROOT\tools\Scripts\artdbclean.js" //Nologo
    cd $ENLISTMENT_ROOT
    Write-Host "Clean Done" -ForegroundColor $Success
}

Function CleanBeforeScorch
{
    Write-Host 'Stopping VSTest as it should no longer be running'
    taskkill /F /IM "vstest.console.exe" 1>$null 2>$null

    Write-Host 'Stopping MSbuild as it should no longer be running'
    taskkill /F /IM "MSbuild.exe" 1>$null 2>$null

    Write-Host 'Stopping code coverage gathering...'
    taskkill /f /im VSPerfMon.exe 1>$null 2>$null

    net stop w3svc 1>$null 2>$null

    Write-Host 'Minimize SQLExpress memory footprint'
    net stop "SQL Server (SQLEXPRESS)" 1>$null 2>$null
    net start "SQL Server (SQLEXPRESS)" 1>$null 2>$null
    
    Write-Host "Clean Done" -ForegroundColor $Success
}

# Incremental build and rebuild
Function RunBuild ($sln, $vsToolVersion)
{
    Write-Host "*** Building $sln ***"
    $slnpath = $ENLISTMENT_ROOT + "\sln\$sln"
    $Conf = "/p:Configuration=" + "$Configuration"

    # Default to VS2017 for .net core/standard
    $MSBUILD = $VS15MSBUILD
        
    & $MSBUILD $slnpath /t:$Build /m /nr:false /fl "/p:Platform=Any CPU" $Conf /p:Desktop=true `
        /flp:LogFile=$LOGDIR/msbuild.log /flp:Verbosity=Normal 1>$null 2>$null
    if($LASTEXITCODE -eq 0)
    {
        Write-Host "Build $sln SUCCESS" -ForegroundColor $Success
    }
    else
    {
        Write-Host "Build $sln FAILED" -ForegroundColor $Err
        Write-Host "For more information, please open the following test result files:"
        Write-Host "$LOGDIR\msbuild.log"
        Cleanup
        exit
    }
}

Function FailedTestLog ($playlist , $reruncmd , $failedtest1 ,$failedtest2)
{
    Write-Output "<Playlist Version=`"1.0`">" | Out-File $playlist
    Write-Output "@echo off" | Out-File -Encoding ascii $reruncmd
    Write-Output "cd $TESTDIR" | Out-File -Append -Encoding ascii $reruncmd
    $rerun = "`"$VSTEST`""
    if ($TestType -eq 'Nightly')
    {
        foreach ($dll in $NightlyTestSuite) 
        {
            $rerun += " $dll" 
        }
    }
    else
    {
        foreach ($dll in $QuickTestSuite) 
        {
            $rerun += " $dll" 
        }
    }
    if ($failedtest1.count -gt 0)
    {
        $rerun += " /Tests:"
    }
    foreach($case in $failedtest1)
    {
        $name = $case.split('.')[-1]
        $rerun += $name + ","
        $output = "<Add Test=`"" + $case + "`" />"
        Write-Output $output  | Out-File -Append $playlist
    } 
    # build the command only if failed tests exist
    if ($failedtest1.count -gt 0)
    {
        $rerun += " " + $XUNITADAPTER
        Write-Output $rerun | Out-File -Append -Encoding ascii $reruncmd
    }
    $rerun = "`"$VSTEST`""
    foreach ($dll in $E2eTestSuite)
    {
        $rerun += " $dll" 
    }
    if ($failedtest2.count -gt 0)
    {
        $rerun += " /Tests:"
    }
    foreach($case in $failedtest2)
    {
        $name = $case.split('.')[-1]
        $rerun += $name + ","
        $output = "<Add Test=`"" + $case + "`" />"
        Write-Output $output  | Out-File -Append $playlist
    }
    # build the command only if failed tests exist
    if ($failedtest2.count -gt 0)
    {
        Write-Output $rerun | Out-File -Append -Encoding ascii $reruncmd
    }
    Write-Output "cd $LOGDIR" | Out-File -Append -Encoding ascii $reruncmd
    Write-Output "</Playlist>" | Out-File -Append $playlist
    Write-Host "There are some test cases failed!" -ForegroundColor $Err
    Write-Host "To replay failed tests, please open the following playlist file:" -ForegroundColor $Err
    Write-Host $playlist -ForegroundColor $Err
    Write-Host "To rerun failed tests, please run the following script:" -ForegroundColor $Err
    Write-Host $reruncmd -ForegroundColor $Err
}

Function TestSummary
{
    Write-Host 'Collecting test results'
    $playlist = "$LOGDIR\FailedTests.playlist"
    $reruncmd = "$LOGDIR\rerun.cmd"
    if (Test-Path $playlist)
    {
        rm $playlist
    }
    if (Test-Path $reruncmd)
    {
        rm $reruncmd
    }
    
    $file = Get-Content -Path $TESTLOG
    $pass = 0
    $skipped = 0
    $fail = 0
    $trxfile = New-Object -TypeName System.Collections.ArrayList
    $failedtest1 = New-Object -TypeName System.Collections.ArrayList
    $failedtest2 = New-Object -TypeName System.Collections.ArrayList
    $part = 1
    foreach ($line in $file)
    {
        # Consolidate logic for retrieving number of passed and skipped tests. Failed tests is separate due to the way
        # VSTest and DotNet (for .NET Core tests) report results differently.
        if ($line -match "^Total tests: .*") 
        {
            # The line is in this format:
            # Total tests: 5735. Passed: 5735. Failed: 0. Skipped: 0.
            # We want to extract the total passed and total skipped.
            
            # Extract total passed by taking the substring between "Passed: " and "."
            # The regex first extracts the string after the hardcoded "Passed: " (i.e. "#. Failed: #. Skipped: #.")
            # Then we tokenize by "." and retrieve the first token which is the number for passed.
            $pattern = "Passed: (.*)"
            $extractedNumber = [regex]::match($line, $pattern).Groups[1].Value.Split(".")[0]
            $pass += $extractedNumber
            
            # Extract total skipped by taking the substring between "Skipped: " and "."
            # The regex first extracts the string after the hardcoded "Skipped: " (i.e. "#.")
            # Then we tokenize by "." and retrieve the first token which is the number for skipped.
            $pattern = "Skipped: (.*)"
            $extractedNumber = [regex]::match($line, $pattern).Groups[1].Value.Split(".")[0]
            $skipped += $extractedNumber
        }
        elseif ($line -match "^Failed\s+(.*)")
        {
            $fail = $fail + 1
            if ($part -eq 1)
            {
                [void]$failedtest1.Add($Matches[1])
            }
            else
            {    
                [void]$failedtest2.Add($Matches[1])
            }
        }
        elseif ($line -match "^Results file: (.*)")
        {
            [void]$trxfile.Add($Matches[1])
            $part = 2
        }
    }

    Write-Host "Test summary:" -ForegroundColor $Success
    Write-Host "Passed :`t$pass"  -ForegroundColor $Success

    if ($skipped -ne 0)
    {
        Write-Host "Skipped:`t$skipped"  -ForegroundColor $Warning
    }

    $color = $Success
    if ($fail -ne 0)
    {
        $color = $Err
    }
    Write-Host "Failed :`t$fail"  -ForegroundColor $color
    Write-Host "---------------"  -ForegroundColor $Success
    Write-Host "Total :`t$($pass + $fail)"  -ForegroundColor $Success
    Write-Host "For more information, please open the following test result files:"
    foreach ($trx in $trxfile)
    {
        Write-Host $trx
    }
    if ($fail -gt 0)
    {
        FailedTestLog -playlist $playlist -reruncmd $reruncmd -failedtest1 $failedtest1 -failedtest2 $failedtest2 
    }
    else
    {
        Write-Host "Congratulation! All of the tests passed!" -ForegroundColor $Success
    }
}

Function RunTest($title, $testdir, $framework)
{
    Write-Host "**********Running $title***********"
    if ($framework -eq 'dotnet')
    {
        foreach($testProj in $testdir)
        {
            Write-Host "Launching $testProj..."
            & $DOTNETTEST "test" ($ENLISTMENT_ROOT + $testProj) "--no-build" >> $TESTLOG
        }
    }
    else
    {
        & $VSTEST $testdir $XUNITADAPTER >> $TESTLOG
    }

    if($LASTEXITCODE -ne 0)
    {
        Write-Host "Run $title FAILED" -ForegroundColor $Err
    }
}

Function NugetRestoreSolution
{
    Write-Host '**********Pull NuGet Packages*********'
    foreach($solution in $NugetRestoreSolutions)
    {
        & $NUGETEXE "restore" ($ENLISTMENT_ROOT + "\sln\" + $solution)
    }
}

Function BuildProcess
{
    Write-Host '**********Start To Build The Project*********'
    
    $script:BUILD_START_TIME = Get-Date
    if (Test-Path $BUILDLOG)
    {
        rm $BUILDLOG
    }

    RunBuild ('ODataClientFactory.sln')
    RunBuild ('ODataMigration.sln')

    if ($TestType -ne 'Quick')
    {
        # OData.Tests.E2E.sln contains the product code for Net45 framework and a comprehensive list of test projects
        # RunBuild ('ODataClientFactory.sln')
        # Solutions that contain .NET Core projects require VS2017 for full support. VS2015 supports only .NET Standard.
        if($VS15MSBUILD)
        {
            Write-Host "Found VS2017 version: $VS15MSBUILD"
            #RunBuild ('OData.CodeGen.sln') -vsToolVersion '15.0'
        }
        else
        {
            Write-Host ('Warning! Skipping build for .NET Core tests because no versions of VS2017 found. ' + `
            'Building only product in .NET Standard.') -ForegroundColor $Warning
            #RunBuild ('OData.NetStandard.sln')
        }
        
    }

    Write-Host "Build Done" -ForegroundColor $Success
    $script:BUILD_END_TIME = Get-Date
}

Function TestProcess
{
    Write-Host '**********Start To Run The Test*********'
    if (Test-Path $TESTLOG)
    {
        rm $TESTLOG
    }
    $script:TEST_START_TIME = Get-Date

    if (Test-Path $TESTDIR)
    {
        cd $TESTDIR
        if ($TestType -eq 'Nightly')
        {
            RunTest -title 'NightlyTests' -testdir $NightlyTestSuite
        }
        elseif ($TestType -eq 'Quick')
        {
            RunTest -title 'XUnitTests' -testdir $QuickTestSuite
        }
        else
        {
            Write-Host 'Error : TestType' -ForegroundColor $Err
            Cleanup
            exit
        }
    }

    if ($DOTNETTEST)
    {
        RunTest -title 'NetCoreTests' -testdir $NetCoreXUnitTestProjs -framework 'dotnet'
    }
    else
    {
        Write-Host 'The dotnet CLI must be installed to run any .NET Core tests.' -ForegroundColor $Warning
    }

    Write-Host "Test Done" -ForegroundColor $Success
    TestSummary
    $script:TEST_END_TIME = Get-Date
    cd $ENLISTMENT_ROOT
}

Function FxCopProcess
{
    Write-Host '**********Start To FxCop*********'
    & $FXCOP "/f:$ProductDir\Microsoft.OData.Extensions.Client.Abstractions.dll" "/o:$LOGDIR\FxCopRulesODataClientAbstractions.xml" $FxCopRulesOptions 1>$null 2>$null
    & $FXCOP "/f:$ProductDir\Microsoft.OData.Extensions.Client.dll" "/o:$LOGDIR\ClientFxCopReport.xml" $FxCopRulesOptions 1>$null 2>$null
    Write-Host "For more information, please open the following test result files:"
    Write-Host "$LOGDIR\FxCopRulesODataClientAbstractions.xml"
    Write-Host "$LOGDIR\ClientFxCopReport.xml"
    Write-Host "FxCop Done" -ForegroundColor $Success
}

# Main Process

if (! (Test-Path $LOGDIR))
{
    mkdir $LOGDIR 1>$null
}

if ($TestType -eq 'EnableSkipStrongName')
{
    CleanBeforeScorch
    NugetRestoreSolution
    BuildProcess
    SkipStrongName
    Exit
}
elseif ($TestType -eq 'DisableSkipStrongName')
{
    CleanBeforeScorch
    NugetRestoreSolution
    BuildProcess
    DisableSkipStrongName
    Exit
}

CleanBeforeScorch
NugetRestoreSolution
BuildProcess
SkipStrongName
TestProcess
FxCopProcess
Cleanup

$buildTime = New-TimeSpan $script:BUILD_START_TIME -end $script:BUILD_END_TIME
$testTime = New-TimeSpan $script:TEST_START_TIME -end $script:TEST_END_TIME
Write-Host("Build time:`t" + $buildTime)
Write-Host("Test time:`t" + $testTime)