Test using solution and in-place

Author: ErikSchierboom

.gitignore

@@ -24,3 +24,6 @@ build/
 
 # Other files
 .DS_Store
+
+# Temporary files
+exercises/**/*.tmp

bin/test.ps1

@@ -26,95 +26,131 @@ param (
 $ErrorActionPreference = "Stop"
 $PSNativeCommandUseErrorActionPreference = $true
 
-function Invoke-Build-Generators {
-    Write-Output "Building generators"
-    & dotnet build ./generators 
+function Invoke-Tests($Path) {
+    & dotnet test $Path
 }
 
-function Clean($BuildDir) {
-    Write-Output "Cleaning previous build"
-    Remove-Item -Recurse -Force $BuildDir -ErrorAction Ignore
-}
+function Prepare-Exercise($Path) {
+    $files = Get-Content (Join-Path $Path ".meta" "config.json") -Raw | ConvertFrom-Json | Select-Object -ExpandProperty files
 
-function Copy-Exercise($SourceDir, $BuildDir) {
-    Write-Output "Copying exercises"
-    Copy-Item $SourceDir -Destination $BuildDir -Recurse
-}
+    foreach ($fileType in @("example", "exemplar")) {
+        for (($i = 0); $i -lt $files.$fileType.length; $i++) {
+            $exampleFile = Join-Path $Path $files.$fileType[$i]
+            $solutionFile = Join-Path $Path $files.solution[$i]
 
-function Enable-All-UnitTests($BuildDir) {
-    Write-Output "Enabling all tests"
-    Get-ChildItem -Path $BuildDir -Include "*Tests.cs" -Recurse | ForEach-Object {
-        (Get-Content $_.FullName) -replace "Skip = ""Remove this Skip property to run this test""", "" | Set-Content $_.FullName
+            Copy-Item -Path $solutionFile -Destination "${solutionFile}.tmp"
+            Copy-Item -Path $exampleFile -Destination $solutionFile
+        }
     }
-}
 
-function Test-Refactoring-Projects($PracticeExercisesDir) {
-    Write-Output "Testing refactoring projects"
-    & dotnet test "${PracticeExercisesDir}/Refactoring.sln"
+    foreach ($testFile in $files.test) {
+        $testFile = Join-Path $Path $testFile
+        Copy-Item -Path $testFile -Destination "${testFile}.tmp"
+        (Get-Content $testFile) -replace "Skip = ""Remove this Skip property to run this test""", "" | Set-Content $testFile
+    }
 }
 
-function Set-ExampleImplementation {
-    [CmdletBinding(SupportsShouldProcess)]
-    param($ExercisesDir, $ReplaceFileName)
-
-    if ($PSCmdlet.ShouldProcess("Exercise ${ReplaceFileName}", "replace solution with example")) {
-        Get-ChildItem -Path $ExercisesDir -Include "*.csproj" -Recurse | ForEach-Object {
-            $stub = Join-Path -Path $_.Directory ($_.BaseName + ".cs")
-            $example = Join-Path -Path $_.Directory ".meta" $ReplaceFileName
+function Restore-Exercise($Path) {
+    Get-ChildItem -Path $Path -Include "*.tmp" -Recurse | ForEach-Object {
+        $tmpFile = $_.FullName
+        $originalFile = ($tmpFile -replace "\.tmp$", "")
+        Move-Item -Path $tmpFile -Destination $originalFile -Force
+    }
+}
 
-            Move-Item -Path $example -Destination $stub -Force
+function Process-Exercises($Exercises, [ScriptBlock]$Action) {
+    foreach ($ExerciseType in @("practice", "concept")) {
+        $Exercises.$ExerciseType | ForEach-Object {
+            &$Action (Join-Path "exercises" $ExerciseType $_)
         }
     }
 }
 
-function Use-ExampleImplementation {
-    [CmdletBinding(SupportsShouldProcess)]
-    param($ConceptExercisesDir, $PracticeExercisesDir)
-
-    if ($PSCmdlet.ShouldProcess("Exercises directory", "replace all solutions with corresponding examples")) {
-        Write-Output "Replacing concept exercise stubs with exemplar"
-        Set-ExampleImplementation $ConceptExercisesDir "Exemplar.cs"
+function Prepare-Exercises($Exercises) {
+    Process-Exercises $Exercises {
+        param($Path)
+        Prepare-Exercise $Path
+    }
+}
 
-        Write-Output "Replacing practice exercise stubs with example"
-        Set-ExampleImplementation $PracticeExercisesDir "Example.cs"
+function Restore-Exercises($Exercises) {
+    Process-Exercises $Exercises {
+        param($Path)
+        Restore-Exercise $Path
     }
 }
 
-function Test-ExerciseImplementation($Exercise, $BuildDir, $ConceptExercisesDir, $PracticeExercisesDir) {
-    Write-Output "Running tests"
+function Run-Tests($Path) {
+    & dotnet test $Path
+}
 
-    if (-Not $Exercise) {
-        Invoke-Tests -Path $BuildDir
+function Find-Exercise-Path($Exercise, $Exercises) {
+    if ($Exercises.practice.Contains($Exercise)) {
+        Join-Path "exercises" "practice" $Exercise
     }
-    elseif (Test-Path "${ConceptExercisesDir}/${Exercise}") {
-        Invoke-Tests -Path "${ConceptExercisesDir}/${Exercise}"
+    elseif ($Exercises.concept.Contains($Exercise)) {
+        Join-Path "exercises" "concept" $Exercise
+    } else {
+        throw "Could not find exercise '${Exercise}'"
     }
-    elseif (Test-Path "${PracticeExercisesDir}/${Exercise}") {
-        Invoke-Tests -Path "${PracticeExercisesDir}/${Exercise}"
+}
+
+function Test-Single-Exercise($Exercise, $Exercises) {
+    $path = Find-Exercise-Path $Exercise $Exercises
+
+    try {
+        Prepare-Exercise $path
+        Run-Tests $path
+    } finally {
+        Restore-Exercise $path
     }
-    else {
-        throw "Could not find exercise '${Exercise}'"
+}
+
+function Test-All-Exercises($Exercises) {
+    try {
+        Prepare-Exercises $Exercises
+        Run-Tests "exercises/Exercises.sln"
+    } finally {
+        Restore-Exercises $Exercises
     }
 }
 
-function Invoke-Tests($Path) {
-    & dotnet test $Path
+function Parse-Exercises {
+    Get-Content .\config.json -Raw |
+    ConvertFrom-Json |
+    Select-Object -ExpandProperty exercises |
+    ForEach-Object {
+        @{
+            concept  = $_.concept  | Select-Object -ExpandProperty slug | Sort-Object
+            practice = $_.practice | Select-Object -ExpandProperty slug | Sort-Object
+        }
+    }
 }
 
+function Build-Generators {
+    Write-Output "Build generators"
+    & dotnet build generators
+}
 
-$buildDir = "${PSScriptRoot}/build"
-$practiceExercisesDir = "${buildDir}/practice"
-$conceptExercisesDir = "${buildDir}/concept"
-$sourceDir = Resolve-Path "exercises"
+function Test-Refactoring-Exercise-Default-Implementations {
+    Write-Output "Testing refactoring exercises"
+    & dotnet test (Join-Path "exercises" "Refactoring.sln")
+}
 
-Clean $buildDir
-Copy-Exercise $sourceDir $buildDir
-Enable-All-UnitTests $buildDir
+function Test-Exercise-Example-Implementations($Exercise) {
+    Write-Output "Testing example implementations"
+    $exercises = Parse-Exercises
 
-if (!$Exercise) {
-    Invoke-Build-Generators
-    Test-Refactoring-Projects $practiceExercisesDir
+    if ($Exercise) {
+        Test-Single-Exercise $Exercise $Exercises
+    } else {
+        Test-All-Exercises $Exercises
+    }
 }
 
-Use-ExampleImplementation $conceptExercisesDir $practiceExercisesDir
-Test-ExerciseImplementation -Exercise $Exercise -BuildDir $buildDir -ConceptExercisesDir $conceptExercisesDir -PracticeExercisesDir $practiceExercisesDir
+Test-Exercise-Example-Implementations $Exercise
+
+if (!$Exercise) {
+    Build-Generators
+    Test-Refactoring-Exercise-Default-Implementations
+}