Issue-2 Added test exceptions to allow for implementation specific testing.

Author: Jason Valdez

src/IntegrationShared/ConfirmMatchingTests.cs

@@ -5,6 +5,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using FluentAssertions;
+using SharedTestFramework;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -19,67 +20,119 @@ public ConfirmMatchingTests(ITestOutputHelper output)
             _output = output;
         }
 
+        private class ConfirmMatchingTestHelper
+        {
+            public ConfirmMatchingTestHelper()
+            {
+                PostgreAssembly = typeof(ivaldez.Sql.IntegrationPostgreSqlTests.BulkLoading.BulkLoaderForBatchSizeTests)
+                    .Assembly;
+                SqlServerAssembly = typeof(ivaldez.Sql.IntegrationSqlServerTests.BulkLoading.BulkLoaderForBatchSizeTests)
+                    .Assembly;
+
+                var postgreAssemblyName = PostgreAssembly.GetName().Name;
+                var sqlServerAssemblyName = SqlServerAssembly.GetName().Name;
+
+                PostgreClasses = PostgreAssembly.GetTypes().Where(x => x.Name.ToLower().EndsWith("tests")).ToArray();
+                SqlServerClasses = SqlServerAssembly.GetTypes().Where(x => x.Name.ToLower().EndsWith("tests")).ToArray();
+
+                PostgreClassInfo = PostgreClasses.Select(x => new ClassInfo
+                    {
+                        Class = x,
+                        Assembly = x.Assembly,
+                        ReferenceName = x.FullName.Replace(postgreAssemblyName, ""),
+                        Ignore = ShouldIgnore(x)
+                    })
+                    .Where(x => x.Ignore == false).ToArray();
+                SqlServerClassInfo = SqlServerClasses.Select(x => new ClassInfo
+                    {
+                        Class = x,
+                        Assembly = x.Assembly,
+                        ReferenceName = x.FullName.Replace(sqlServerAssemblyName, ""),
+                        Ignore = ShouldIgnore(x)
+                    })
+                    .Where(x => x.Ignore == false).ToArray();
+            }
+
+            private bool ShouldIgnore(Type type)
+            {
+                Attribute[] attrs = System.Attribute.GetCustomAttributes(type);
+
+                return attrs.Any(x => x.GetType().FullName == typeof(ImplementationSpecificTestAttribute).FullName);
+            }
+
+            public class ClassInfo
+            {
+                public string ReferenceName { get; set; }
+                public Assembly Assembly { get; set; }
+                public bool Ignore { get; set; }
+                public Type Class { get; set; }
+            }
+
+            public Type[] PostgreClasses { get; set; }
+            
+            public Type[] SqlServerClasses { get; set; }
+
+            public ClassInfo[] SqlServerClassInfo { get; set; }
+
+            public ClassInfo[] PostgreClassInfo { get; set; }
+
+            public Assembly SqlServerAssembly { get; set; }
+
+            public Assembly PostgreAssembly { get; set; }
+        }
+
         [Fact(DisplayName = "Should find matching tests for all shared features between implementations")]
         public void TestClassesMatchingTests()
         {
-            var sourceClass1 = typeof(ivaldez.Sql.IntegrationPostgreSqlTests.BulkLoading.BulkLoaderForBatchSizeTests)
-                .Assembly;
-            var sourceClass2 = typeof(ivaldez.Sql.IntegrationSqlServerTests.BulkLoading.BulkLoaderForBatchSizeTests)
-                .Assembly;
+            var helper = new ConfirmMatchingTestHelper();
 
-            var allTestMethods1 = sourceClass1.GetTypes().Where(x => x.Name.ToLower().EndsWith("tests")).Select(x => x.Name).ToArray();
-            var allTestMethods2 = sourceClass2.GetTypes().Where(x => x.Name.ToLower().EndsWith("tests")).Select(x => x.Name).ToArray();
+            var postgreClasses = helper.PostgreClassInfo.Select(x => x.ReferenceName).ToArray();
+            var sqlServerClasses = helper.SqlServerClassInfo.Select(x => x.ReferenceName).ToArray();
 
-            var testsMIssingIn1 = allTestMethods1.Except(allTestMethods2).ToArray();
-            var testsMIssingIn2 = allTestMethods2.Except(allTestMethods1).ToArray();
+            var postgreMissingClasses = postgreClasses.Except(sqlServerClasses).ToArray();
+            var sqlServerMissingClasses = sqlServerClasses.Except(postgreClasses).ToArray();
 
-            _output.WriteLine($"Test classes missing in: {sourceClass1}");
-            foreach (var missing in testsMIssingIn1)
+            _output.WriteLine($"Test classes missing in: {helper.PostgreAssembly}");
+            foreach (var missing in postgreMissingClasses)
             {
                 _output.WriteLine($"Test classes missing: {missing}");
             }
 
-            _output.WriteLine($"Test classes missing in: {sourceClass2}");
-            foreach (var missing in testsMIssingIn2)
+            _output.WriteLine($"Test classes missing in: {helper.SqlServerAssembly}");
+            foreach (var missing in sqlServerMissingClasses)
             {
                 _output.WriteLine($"Test classes missing: {missing}");
             }
 
-            testsMIssingIn1.Length.Should().Be(0);
-            testsMIssingIn2.Length.Should().Be(0);
+            postgreMissingClasses.Length.Should().Be(0);
+            sqlServerMissingClasses.Length.Should().Be(0);
         }
 
         [Fact(DisplayName = "Should find matching test methods for all shared features between implementations")]
         public void TestMethodMatchingTests()
         {
-            var sourceClass1 = typeof(ivaldez.Sql.IntegrationPostgreSqlTests.BulkLoading.BulkLoaderForBatchSizeTests)
-                .Assembly;
-            var sourceClass2 = typeof(ivaldez.Sql.IntegrationSqlServerTests.BulkLoading.BulkLoaderForBatchSizeTests)
-                .Assembly;
-
-            var allTestClasses1 = sourceClass1.GetTypes().Where(x => x.IsClass && x.Name.ToLower().EndsWith("tests")).ToArray();
-            var allTestClasses2 = sourceClass2.GetTypes().Where(x => x.IsClass && x.Name.ToLower().EndsWith("tests")).ToArray();
-
+            var helper = new ConfirmMatchingTestHelper();
+            
             var errorCount = 0;
-            foreach (var classDefinition in allTestClasses1)
+            foreach (var postgreClassInfo in helper.PostgreClassInfo)
             {
-                var matchingType = allTestClasses2.First(x => x.Name == classDefinition.Name);
+                var matchingSqlServerClassInfo = helper.SqlServerClassInfo.First(x => x.ReferenceName == postgreClassInfo.ReferenceName);
 
-                var allTestMethods1 = classDefinition.GetMethods().Select(x => x.Name).ToArray();
-                var allTestMethods2 = matchingType.GetMethods().Select(x => x.Name).ToArray();
+                var postgreMethods = postgreClassInfo.Class.GetMethods().Select(x => x.Name).ToArray();
+                var sqlServerMethods = matchingSqlServerClassInfo.Class.GetMethods().Select(x => x.Name).ToArray();
 
-                var testsMIssingIn1 = allTestMethods1.Except(allTestMethods2).ToArray();
-                var testsMIssingIn2 = allTestMethods2.Except(allTestMethods1).ToArray();
+                var postgreMissingSqlServer = postgreMethods.Except(sqlServerMethods).ToArray();
+                var sqlServerMissingPostgre = sqlServerMethods.Except(postgreMethods).ToArray();
 
-                _output.WriteLine($"Test class: {classDefinition}");
-                foreach (var missing in testsMIssingIn1)
+                _output.WriteLine($"Test class: {postgreClassInfo}");
+                foreach (var missing in postgreMissingSqlServer)
                 {
                     errorCount++;
                     _output.WriteLine($"***missing method: {missing}");
                 }
 
-                _output.WriteLine($"Test class: {matchingType}");
-                foreach (var missing in testsMIssingIn2)
+                _output.WriteLine($"Test class: {matchingSqlServerClassInfo}");
+                foreach (var missing in sqlServerMissingPostgre)
                 {
                     errorCount++;
                     _output.WriteLine($"***missing method: {missing}");

src/IntegrationShared/IntegrationCompatibilityTests.csproj

@@ -79,6 +79,10 @@
       <Project>{2570e931-33d4-4d86-b49d-d27f7ed29265}</Project>
       <Name>IntegrationSqlServerTests</Name>
     </ProjectReference>
+    <ProjectReference Include="..\SharedTestFramework\SharedTestFramework.csproj">
+      <Project>{692d1c7c-4403-468b-b2e8-51da8ef0c654}</Project>
+      <Name>SharedTestFramework</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">