refactored test runners

payroll test result: adde failed properties
updated version to 0.6.0-beta.5

Author: Jani Giannoudis

Client.Test/Case/CaseTestRunner.cs

@@ -1,20 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using PayrollEngine.Client.Model;
 using PayrollEngine.Client.Service;
 using PayrollEngine.Client.Service.Api;
-using PayrollEngine.Serialization;
 using Task = System.Threading.Tasks.Task;
 
 namespace PayrollEngine.Client.Test.Case;
 
 /// <summary>Case test runner</summary>
-public class CaseTestRunner : FileTestRunner
+public class CaseTestRunner : TestRunnerBase
 {
 
     /// <summary>Parse case custom test class</summary>
@@ -36,21 +34,17 @@ protected override List<Type> GetDefaultReferences()
         }
     }
 
-    /// <summary>Initializes a new instance of the <see cref="CaseTestRunner"/> class</summary>
+    /// <summary>Initializes a new instance of the class</summary>
     /// <param name="httpClient">The payroll engine http client</param>
-    /// <param name="fileName">Name of the file</param>
-    public CaseTestRunner(PayrollHttpClient httpClient, string fileName) :
-        base(httpClient, fileName)
+    public CaseTestRunner(PayrollHttpClient httpClient) :
+        base(httpClient)
     {
     }
 
     /// <summary>Test case</summary>
     /// <returns>The case test results</returns>
-    public virtual async Task<CaseTestResult> TestAsync()
+    public virtual async Task<CaseTestResult> TestAsync(CaseTest caseTest)
     {
-        // load test
-        var caseTest = await LoadCaseTest();
-
         // test context
         var context = await CreateTestContext(caseTest);
 
@@ -422,38 +416,6 @@ protected virtual async Task<CaseTestContext> CreateTestContext(CaseTest caseTes
         return context;
     }
 
-    /// <summary>Loads the case test</summary>
-    protected virtual async Task<CaseTest> LoadCaseTest()
-    {
-        // import file
-        if (!File.Exists(FileName))
-        {
-            throw new PayrollException($"Missing import file {FileName}");
-        }
-        var json = await File.ReadAllTextAsync(FileName);
-        if (string.IsNullOrWhiteSpace(json))
-        {
-            throw new PayrollException($"Invalid import file {FileName}");
-        }
-
-        // import from JSON
-        var caseTest = DefaultJsonSerializer.Deserialize<CaseTest>(json);
-        if (string.IsNullOrWhiteSpace(caseTest.TenantIdentifier))
-        {
-            throw new PayrollException($"Missing tenant {caseTest.TenantIdentifier}");
-        }
-        if (string.IsNullOrWhiteSpace(caseTest.UserIdentifier))
-        {
-            throw new PayrollException($"Missing user {caseTest.UserIdentifier}");
-        }
-        if (string.IsNullOrWhiteSpace(caseTest.PayrollName))
-        {
-            throw new PayrollException($"Missing payroll {caseTest.PayrollName}");
-        }
-
-        return caseTest;
-    }
-
     /// <summary>Get division by id</summary>
     /// <param name="tenantId">The tenant id</param>
     /// <param name="divisionId">The division id</param>

Client.Test/PayrollEngine.Client.Test.csproj

@@ -16,7 +16,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.6.0" />
-		<PackageReference Include="PayrollEngine.Client.Core" Version="0.6.0-beta.4" />
+		<PackageReference Include="PayrollEngine.Client.Core" Version="0.6.0-beta.5" />
 	</ItemGroup>
 
 	<!-- include xml documention files and json schemas to the nuget package -->
@@ -28,11 +28,27 @@
 			<PackageCopyToOutput>true</PackageCopyToOutput>
 		</None>
 	</ItemGroup>
+	<ItemGroup>
+	  <Compile Remove="ExchangeFileTestDataProvider.cs" />
+	  <Compile Remove="FileTestDataProvider.cs" />
+	  <Compile Remove="FileTestRunner.cs" />
+	  <Compile Remove="ITestDataProvider.cs" />
+	  <Compile Remove="ResourceTestDataProvider.cs" />
+	  <Compile Remove="StreamTestDataProvider.cs" />
+	  <Compile Remove="StringTestDataProvider.cs" />
+	</ItemGroup>
 	<ItemGroup>
 	  <None Include="..\README.md">
 	    <Pack>True</Pack>
 	    <PackagePath>\</PackagePath>
 	  </None>
+	  <None Include="ExchangeFileTestDataProvider.cs" />
+	  <None Include="FileTestDataProvider.cs" />
+	  <None Include="FileTestRunner.cs" />
+	  <None Include="ITestDataProvider.cs" />
+	  <None Include="ResourceTestDataProvider.cs" />
+	  <None Include="StreamTestDataProvider.cs" />
+	  <None Include="StringTestDataProvider.cs" />
 	</ItemGroup>
 
 	<!--  build json schemas -->

Client.Test/PayrollEngine.Client.Test.xml

@@ -30,6 +30,24 @@ public class PayrollTestResult
     public int TotalResultCount =>
         WageTypeResults.Count + CollectorResults.Count + PayrunResults.Count;
 
+    /// <summary>Test if wage type test is failed</summary>
+    public bool FailedWageTypeResult =>
+        WageTypeResults.Any(x => x.IsFailed());
+
+    /// <summary>Test if collector test is failed</summary>
+    public bool FailedCollectorResult =>
+        CollectorResults.Any(x => x.IsFailed());
+
+    /// <summary>Test if payrun test is failed</summary>
+    public bool FailedPayrunResult =>
+        PayrunResults.Any(x => x.IsFailed());
+
+    /// <summary>Test if payroll test is failed</summary>
+    public bool Failed =>
+        FailedWageTypeResult ||
+        FailedCollectorResult ||
+        FailedPayrunResult;
+
     /// <summary>Initializes a new instance of the <see cref="PayrollTestResult"/> class</summary>
     /// <param name="tenant">The tenant</param>
     /// <param name="payrunJob">The payrun job</param>
@@ -40,10 +58,4 @@ public PayrollTestResult(Tenant tenant, Employee employee, PayrunJob payrunJob)
         Employee = employee ?? throw new ArgumentNullException(nameof(employee));
         PayrunJob = payrunJob ?? throw new ArgumentNullException(nameof(payrunJob));
     }
-
-    /// <summary>Test if payrun test is failed</summary>
-    public bool IsFailed() =>
-        WageTypeResults.Any(x => x.IsFailed()) ||
-        CollectorResults.Any(x => x.IsFailed()) ||
-        PayrunResults.Any(x => x.IsFailed());
 }

Client.Test/Payrun/PayrollTestResult.cs

@@ -10,7 +10,7 @@
 namespace PayrollEngine.Client.Test.Payrun;
 
 /// <summary>Payrun employee test runner</summary>
-public class PayrunEmployeeTestRunner : PayrunFileTestRunner
+public class PayrunEmployeeTestRunner : PayrunTestRunnerBase
 {
     /// <summary>The delay between creation and test</summary>
     public int DelayBetweenCreateAndTest { get; set; }
@@ -23,26 +23,23 @@ public class PayrunEmployeeTestRunner : PayrunFileTestRunner
 
     /// <summary>Initializes a new instance of the <see cref="PayrunEmployeeTestRunner"/> class</summary>
     /// <param name="httpClient">The payroll engine http client</param>
-    /// <param name="fileName">Name of the file</param>
     /// <param name="scriptParser">The script parser</param>
     /// <param name="owner">The test owner</param>
     /// <param name="testPrecision">The testing precision</param>
     /// <param name="employeeMode">The employee test mode</param>
-    public PayrunEmployeeTestRunner(PayrollHttpClient httpClient, string fileName, IScriptParser scriptParser,
-        TestPrecision testPrecision, string owner = null, EmployeeTestMode employeeMode = EmployeeTestMode.InsertEmployee) :
-        base(httpClient, fileName, testPrecision, owner)
+    public PayrunEmployeeTestRunner(PayrollHttpClient httpClient, IScriptParser scriptParser,
+        TestPrecision testPrecision = TestPrecision.TestPrecision2, string owner = null,
+        EmployeeTestMode employeeMode = EmployeeTestMode.InsertEmployee) :
+        base(httpClient, testPrecision, owner)
     {
         ScriptParser = scriptParser ?? throw new ArgumentNullException(nameof(scriptParser));
         EmployeeMode = employeeMode;
     }
 
     /// <summary>Start the test</summary>
-    /// <param name="namespace">The tenant name</param>
     /// <returns>A list of payrun job results</returns>
-    public override async Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(string @namespace = null)
+    public override async Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(Model.Exchange exchange)
     {
-        // exchange
-        var exchange = await LoadExchangeAsync(@namespace);
         // apply owner
         ApplyOwner(exchange, Owner);
 

Client.Test/Payrun/PayrunEmployeeTestRunner.cs

@@ -11,7 +11,7 @@
 namespace PayrollEngine.Client.Test.Payrun;
 
 /// <summary>Payrun test runner</summary>
-public class PayrunTestRunner : PayrunFileTestRunner
+public class PayrunTestRunner : PayrunTestRunnerBase
 {
     /// <summary>The employee test mode</summary>
     public IScriptParser ScriptParser { get; }
@@ -27,29 +27,26 @@ public class PayrunTestRunner : PayrunFileTestRunner
 
     /// <summary>Initializes a new instance of the <see cref="PayrunTestRunner"/> class</summary>
     /// <param name="httpClient">The payroll engine http client</param>
-    /// <param name="fileName">Name of the file</param>
     /// <param name="scriptParser">The script parser</param>
     /// <param name="testPrecision">The testing precision</param>
     /// <param name="owner">The test owner</param>
     /// <param name="importMode">The data import mode (default: single)</param>
     /// <param name="resultMode">The test result mode (default: clean)</param>
-    public PayrunTestRunner(PayrollHttpClient httpClient, string fileName, IScriptParser scriptParser,
-        TestPrecision testPrecision, string owner = null, DataImportMode importMode = DataImportMode.Single,
+    public PayrunTestRunner(PayrollHttpClient httpClient, IScriptParser scriptParser,
+        TestPrecision testPrecision = TestPrecision.TestPrecision2,
+        string owner = null, DataImportMode importMode = DataImportMode.Single,
         TestResultMode resultMode = TestResultMode.CleanTest) :
-        base(httpClient, fileName, testPrecision, owner)
+        base(httpClient, testPrecision, owner)
     {
         ScriptParser = scriptParser ?? throw new ArgumentNullException(nameof(scriptParser));
         ImportMode = importMode;
         ResultMode = resultMode;
     }
 
     /// <summary>Start the test</summary>
-    /// <param name="namespace">The tenant name</param>
     /// <returns>A list of payrun job results</returns>
-    public override async Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(string @namespace = null)
+    public override async Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(Model.Exchange exchange)
     {
-        // exchange
-        var exchange = await LoadExchangeAsync(@namespace);
         // apply owner
         ApplyOwner(exchange, Owner);
 

Client.Test/Payrun/PayrunTestRunner.cs

@@ -1,57 +1,35 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using PayrollEngine.Client.Exchange;
 using PayrollEngine.Client.Model;
 using PayrollEngine.Client.Service.Api;
 
 namespace PayrollEngine.Client.Test.Payrun;
 
 /// <summary>Base class for file based payroll tests</summary>
-public abstract class PayrunFileTestRunner : FileTestRunner
+public abstract class PayrunTestRunnerBase : TestRunnerBase
 {
     /// <summary>The testing precision</summary>
     public TestPrecision TestPrecision { get; }
 
     /// <summary>The test owner</summary>
     public string Owner { get; }
 
-    /// <summary>Initializes a new instance of the <see cref="PayrunFileTestRunner"/> class</summary>
+    /// <summary>Initializes a new instance of the <see cref="PayrunTestRunnerBase"/> class</summary>
     /// <param name="httpClient">The payroll engine http client</param>
-    /// <param name="fileName">Name of the file</param>
     /// <param name="testPrecision">The testing precision</param>
     /// <param name="owner">The test owner</param>
-    protected PayrunFileTestRunner(PayrollHttpClient httpClient, string fileName,
-        TestPrecision testPrecision, string owner) :
-        base(httpClient, fileName)
+    protected PayrunTestRunnerBase(PayrollHttpClient httpClient, TestPrecision testPrecision, string owner = null) :
+        base(httpClient)
     {
         TestPrecision = testPrecision;
         Owner = owner;
     }
 
     /// <summary>Start the test</summary>
-    /// <param name="namespace">The namespace</param>
+    /// <param name="exchange">The test exchange</param>
     /// <returns>A list of payrun job results</returns>
-    public virtual Task<IList<PayrollTestResult>> TestAsync(string @namespace = null) =>
-        default;
-
-    /// <summary>Start the test</summary>
-    /// <param name="namespace">The import namespace</param>
-    /// <returns>A list of payrun job results</returns>
-    public virtual Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(string @namespace = null) =>
-        default;
-
-    /// <summary>Loads the exchange</summary>
-    protected virtual async Task<Model.Exchange> LoadExchangeAsync(string @namespace)
-    {
-        // exchange import
-        var exchange = await ExchangeReader.ReadAsync(FileName, @namespace);
-        if (exchange.Tenants == null || !exchange.Tenants.Any())
-        {
-            throw new PayrollException($"Missing tenant in test file {FileName}");
-        }
-        return exchange;
-    }
+    public abstract Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllAsync(Model.Exchange exchange);
 
     /// <summary>Tests the payrun job</summary>
     /// <param name="tenant">The tenant</param>
@@ -147,7 +125,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                     var payrunJobs = employePayrunJobs.Where(x => x.JobResult == PayrunJobResult.Full &&
                                                                   string.Equals(x.Name, payrollResult.PayrunJobName)).ToList();
                     if (!payrunJobs.Any())
-                    {    
+                    {
                         throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}");
                     }
                     payrunJob = payrunJobs.OrderByDescending(x => x.Created).First();

…ient.Test/Payrun/PayrunFileTestRunner.cs …ient.Test/Payrun/PayrunTestRunnerBase.csClient.Test/Payrun/PayrunFileTestRunner.cs renamed to Client.Test/Payrun/PayrunTestRunnerBase.cs Client.Test/Payrun/PayrunFileTestRunner.cs renamed to Client.Test/Payrun/PayrunTestRunnerBase.cs

@@ -1,17 +1,15 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using PayrollEngine.Client.Model;
 using PayrollEngine.Client.Service.Api;
-using PayrollEngine.Serialization;
 
 namespace PayrollEngine.Client.Test.Report;
 
 /// <summary>Report test runner</summary>
-public class ReportTestRunner : FileTestRunner
+public class ReportTestRunner : TestRunnerBase
 {
     /// <summary>Parse report custom test class</summary>
     private sealed class ReportCustomTestParser : CustomTestParser<ReportCustomTest, ReportTestContext>
@@ -31,21 +29,17 @@ protected override List<Type> GetDefaultReferences()
         }
     }
 
-    /// <summary>Initializes a new instance of the <see cref="ReportTestRunner"/> class</summary>
+    /// <summary>Initializes a new instance of the class</summary>
     /// <param name="httpClient">The payroll engine http client</param>
-    /// <param name="fileName">Name of the file</param>
-    public ReportTestRunner(PayrollHttpClient httpClient, string fileName) :
-        base(httpClient, fileName)
+    public ReportTestRunner(PayrollHttpClient httpClient) :
+        base(httpClient)
     {
     }
 
     /// <summary>Test case</summary>
     /// <returns>The report test results</returns>
-    public virtual async Task<ReportTestResult> TestAsync()
+    public virtual async Task<ReportTestResult> TestAsync(ReportTest reportTest)
     {
-        // load test
-        var reportTest = await LoadReportTest();
-
         // test context
         var context = await CreateTestContext(reportTest);
 
@@ -216,32 +210,4 @@ protected virtual async Task<ReportTestContext> CreateTestContext(ReportTest rep
     /// <param name="name">The regulation name</param>
     protected async Task<Regulation> GetRegulationAsync(int tenantId, string name) =>
         await new RegulationService(HttpClient).GetAsync<Regulation>(new(tenantId), name);
-
-    /// <summary>Loads the case test</summary>
-    protected virtual async Task<ReportTest> LoadReportTest()
-    {
-        // read file
-        if (!File.Exists(FileName))
-        {
-            throw new PayrollException($"Missing import file {FileName}");
-        }
-        var json = await File.ReadAllTextAsync(FileName);
-        if (string.IsNullOrWhiteSpace(json))
-        {
-            throw new PayrollException($"Invalid import file {FileName}");
-        }
-
-        // convert from json
-        var reportTest = DefaultJsonSerializer.Deserialize<ReportTest>(json);
-        if (string.IsNullOrWhiteSpace(reportTest.TenantIdentifier))
-        {
-            throw new PayrollException($"Missing tenant {reportTest.TenantIdentifier}");
-        }
-        if (string.IsNullOrWhiteSpace(reportTest.UserIdentifier))
-        {
-            throw new PayrollException($"Missing user {reportTest.UserIdentifier}");
-        }
-
-        return reportTest;
-    }
 }