create test infrastructure classes

Author: ceastwood

QueryBuilder.Tests/Infrastructure/TestCompiler.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Reflection;
+using SqlKata.Compilers;
+
+namespace SqlKata.Tests.Infrastructure
+{
+    /// <summary>
+    /// A test class to expose private methods
+    /// </summary>
+    class TestCompiler : Compiler
+    {
+        public override string EngineCode { get; } = "test";
+
+        public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string methodName)
+        {
+            return FindCompilerMethodInfo(clauseType, methodName);
+        }
+    }
+
+    class TestSqlServerCompiler : SqlServerCompiler
+    {
+        public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string methodName)
+        {
+            return FindCompilerMethodInfo(clauseType, methodName);
+        }
+    }
+
+    class TestMySqlCompiler : MySqlCompiler
+    {
+        public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string methodName)
+        {
+            return FindCompilerMethodInfo(clauseType, methodName);
+        }
+    }
+
+    class TestPostgresCompiler : PostgresCompiler
+    {
+        public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string methodName)
+        {
+            return FindCompilerMethodInfo(clauseType, methodName);
+        }
+    }
+
+    class TestFirebirdCompiler : FirebirdCompiler
+    {
+        public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string methodName)
+        {
+            return FindCompilerMethodInfo(clauseType, methodName);
+        }
+    }
+}

QueryBuilder.Tests/Infrastructure/TestCompilersContainer.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SqlKata.Compilers;
+
+namespace SqlKata.Tests.Infrastructure
+{
+    public class TestCompilersContainer
+    {
+        protected readonly IDictionary<string, Compiler> Compilers = new Dictionary<string, Compiler>
+        {
+            [EngineCodes.Firebird] = new FirebirdCompiler(),
+            [EngineCodes.MySql] = new MySqlCompiler(),
+            [EngineCodes.Oracle] = new OracleCompiler(),
+            [EngineCodes.PostgreSql] = new PostgresCompiler(),
+            [EngineCodes.Sqlite] = new SqliteCompiler(),
+            [EngineCodes.SqlServer] = new SqlServerCompiler()
+        };
+
+        /// <summary>
+        /// Returns the compiler instance for the given <param name="engineCode"></param>
+        /// </summary>
+        /// <param name="engineCode"></param>
+        /// <returns></returns>
+        public Compiler Get(string engineCode)
+        {
+            if (!Compilers.ContainsKey(engineCode))
+            {
+                throw new InvalidOperationException($"Engine code '{engineCode}' is not valid");
+            }
+
+            return Compilers[engineCode];
+        }
+
+        /// <summary>
+        /// Convenience method <seealso cref="Get"/>
+        /// </summary>
+        /// <remarks>Does not validate generic type against engine code before cast</remarks>
+        /// <typeparam name="TCompiler"></typeparam>
+        /// <param name="engineCode"></param>
+        /// <returns></returns>
+        public TCompiler Get<TCompiler>(string engineCode) where TCompiler : Compiler
+        {
+            return (TCompiler) Get(engineCode);
+        }
+
+        /// <summary>
+        /// Compiles the query for the given <param name="engineCode"></param>
+        /// </summary>
+        /// <param name="engineCode"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public SqlResult CompileFor(string engineCode, Query query)
+        {
+            var compiler = Get(engineCode);
+            return compiler.Compile(query);
+        }
+
+        /// <summary>
+        /// Compiles the query with all enabled compilers.
+        /// </summary>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public TestSqlResultContainer Compile(Query query)
+        {
+            var resultKeyValues = Compilers
+                .ToDictionary(k => k.Key, v => v.Value.Compile(query.Clone()));
+            return new TestSqlResultContainer(resultKeyValues);
+        }
+    }
+}

QueryBuilder.Tests/Infrastructure/TestSqlResultContainer.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace SqlKata.Tests.Infrastructure
+{
+    public class TestSqlResultContainer : ReadOnlyDictionary<string, SqlResult>
+    {
+        public TestSqlResultContainer(IDictionary<string, SqlResult> dictionary) : base(dictionary)
+        {
+
+        }
+    }
+}

QueryBuilder.Tests/Infrastructure/TestSupport.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SqlKata.Tests.Infrastructure
+{
+    public abstract class TestSupport
+    {
+        protected readonly TestCompilersContainer Compilers = new TestCompilersContainer();
+
+        /// <summary>
+        /// For legacy test support
+        /// </summary>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        protected IReadOnlyDictionary<string, string> Compile(Query query)
+        {
+            return Compilers.Compile(query).ToDictionary(s => s.Key, v => v.Value.ToString());
+        }
+    }
+}