Implement and unit-test the MSBuild tasks

AltCover/Tasks.fs

@@ -2,17 +2,96 @@
 
 open System
 open Microsoft.Build.Utilities
+open Microsoft.Build.Framework
 
-type ACVPrepare () =
+module Args =
+  let Item a x = 
+    if x |> String.IsNullOrWhiteSpace 
+       then []
+       else [ a; x ]
+  let ItemList a x =
+      x
+      |> Seq.collect (fun i -> [ a; i ])
+      |> Seq.toList
+  let Flag a x = 
+    if x 
+       then [a]
+       else []
+
+type ACVInstrument () =
   inherit Task(null)
+  member val InputDirectory = String.Empty with get, set
+  member val OutputDirectory = String.Empty with get, set
+  member val SymbolDirectories : string array = [| |] with get, set
+#if NETCOREAPP2_0
+#else
+  member val Keys  : string array = [| |] with get, set
+  member val StrongNameKey = String.Empty with get, set
+#endif
+  member val XmlReport = String.Empty with get, set
+  member val FileFilter  : string array = [| |] with get, set
+  member val AssemblyFilter  : string array = [| |] with get, set
+  member val AssemblyExcludeFilter  : string array = [| |] with get, set
+  member val TypeFilter  : string array = [| |] with get, set
+  member val MethodFilter  : string array = [| |] with get, set
+  member val AttributeFilter  : string array = [| |] with get, set
+  member val CallContext  : string array = [| |] with get, set
 
+  member val OpenCover = true with get, set
   member val InPlace = true with get, set
+  member val Save = true with get, set
+
+  member val CommandLine = String.Empty with get, set
+
+  override self.Execute () = 
+    [
+      Args.Item "-i" self.InputDirectory;
+      Args.Item "-o" self.OutputDirectory;
+      Args.ItemList "-y" self.SymbolDirectories;
+#if NETCOREAPP2_0
+#else
+      Args.ItemList "-k" self.Keys;
+      Args.Item "--sn" self.StrongNameKey;
+#endif
+      Args.Item "-x" self.XmlReport;
+      Args.ItemList "-f" self.FileFilter;
+      Args.ItemList "-s" self.AssemblyFilter;
+      Args.ItemList "-e" self.AssemblyExcludeFilter;
+      Args.ItemList "-t" self.TypeFilter;
+      Args.ItemList "-m" self.MethodFilter;
+      Args.ItemList "-a" self.AttributeFilter;
+      Args.ItemList "-c" self.CallContext;
+
+      Args.Flag "--opencover" self.OpenCover
+      Args.Flag "--inplace" self.InPlace
+      Args.Flag "--save" self.Save
+
+      Args.Item "--" self.CommandLine;
+    ]
+    |> List.concat
+    |> List.toArray
+    |> AltCover.Main.EffectiveMain = 0
 
-  override self.Execute () = true
 
 type ACVCollect () =
   inherit Task(null)
-
+  [<Required>]
+  member val RecorderDirectory = String.Empty with get, set
+  member val WorkingDirectory = String.Empty with get, set
   member val Executable = String.Empty with get, set
 
-  override self.Execute () = true
+  member val CommandLine = String.Empty with get, set
+
+  override self.Execute () = 
+    [
+      ["Runner"];
+      Args.Item "-r" self.RecorderDirectory;
+      Args.Item "-w" self.WorkingDirectory;
+      Args.Item "-x" self.Executable;
+      Args.Flag "--collect" (self.Executable |> String.IsNullOrWhiteSpace)
+
+      Args.Item "--" self.CommandLine;
+    ]
+    |> List.concat
+    |> List.toArray
+    |> AltCover.Main.EffectiveMain = 0

Build/rules.xml

@@ -25,7 +25,7 @@
                exclude="UseCorrectSuffixRule | AvoidNonAlphanumericIdentifierRule | ParameterNamesShouldMatchOverriddenMethodRule | UseCorrectCasingRule | UseCorrectPrefixRule | AvoidDeepNamespaceHierarchyRule  | UsePluralNameInEnumFlagsRule"
                from="Gendarme.Rules.Naming.dll"/>
 		<rules include="*" 
-               exclude="AvoidRepetitiveCastsRule | AvoidUnneededUnboxingRule | AvoidUnsealedUninheritedInternalTypeRule | AvoidUncalledPrivateCodeRule"
+               exclude="AvoidReturningArraysOnPropertiesRule | AvoidRepetitiveCastsRule | AvoidUnneededUnboxingRule | AvoidUnsealedUninheritedInternalTypeRule | AvoidUncalledPrivateCodeRule"
                from="Gendarme.Rules.Performance.dll" />
 		<rules include="*" 
 		       exclude="ExitCodeIsLimitedOnUnixRule"

Tests/Tests.fs

@@ -4657,6 +4657,76 @@ or
 
     finally Console.SetError saved
 
-  // Recorder.fs => Shadow.Tests
+  // Tasks.fs
+  [<Test>]
+  member self.EmptyInstrumentIsJustTheDefaults() =
+    let subject = ACVInstrument()
+    let save = Main.EffectiveMain
+    let mutable args = [| "some junk "|]
+    try
+        Main.EffectiveMain <- (fun a -> args <- a
+                                        255)
+        let result = subject.Execute()
+        Assert.That(result, Is.False)
+        Assert.That(args, Is.EquivalentTo ["--opencover"
+                                           "--inplace"
+                                           "--save"])
+    finally
+      Main.EffectiveMain <- save
 
+  [<Test>]
+  member self.NonDefaultInstrumentIsOK() =
+    let subject = ACVInstrument()
+    let save = Main.EffectiveMain
+    let mutable args = [| "some junk "|]
+    try
+        Main.EffectiveMain <- (fun a -> args <- a
+                                        0)
+        subject.OpenCover <- false
+        subject.CommandLine <- "testing 1 2 3"
+        subject.SymbolDirectories <- [| "a"; "b" |]
+        let result = subject.Execute()
+        Assert.That(result, Is.True)
+        Assert.That(args, Is.EquivalentTo ["-y"; "a"
+                                           "-y"; "b"
+                                           "--inplace"
+                                           "--save"
+                                           "--"
+                                           "testing 1 2 3"])
+    finally
+      Main.EffectiveMain <- save
+
+  [<Test>]
+  member self.EmptyCollectIsJustTheDefaults() =
+    let subject = ACVCollect()
+    let save = Main.EffectiveMain
+    let mutable args = [| "some junk "|]
+    try
+        Main.EffectiveMain <- (fun a -> args <- a
+                                        255)
+        let result = subject.Execute()
+        Assert.That(result, Is.False)
+        Assert.That(args, Is.EquivalentTo ["Runner"
+                                           "--collect"])
+    finally
+      Main.EffectiveMain <- save
+
+  [<Test>]
+  member self.CollectWithExeIsNotCollecting() =
+    let subject = ACVCollect()
+    let save = Main.EffectiveMain
+    let mutable args = [| "some junk "|]
+    try
+        Main.EffectiveMain <- (fun a -> args <- a
+                                        0)
+        subject.Executable <- "dotnet"
+        let result = subject.Execute()
+        Assert.That(result, Is.True)
+        Assert.That(args, Is.EquivalentTo ["Runner"
+                                           "-x"
+                                           "dotnet"])
+    finally
+      Main.EffectiveMain <- save
+
+  // Recorder.fs => Shadow.Tests
 end

Tests/Tests.fsproj

@@ -86,6 +86,9 @@
     <EmbeddedResource Include="Sample1MethodExclusion.xml" />
   </ItemGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.Build.Framework" />
+    <Reference Include="Microsoft.Build.Tasks.v4.0" />
+    <Reference Include="Microsoft.Build.Utilities.v4.0" />
     <Reference Include="Mono.Cecil">
       <HintPath>..\packages\Mono.Cecil.0.10.0\lib\net40\Mono.Cecil.dll</HintPath>
     </Reference>