- IConnectionConfigurationProvider / unit tests

Author: eben-roux

Shuttle.Core.Data.Tests/App.config

@@ -1,10 +1,10 @@
 <?xml version="1.0"?>
+
 <configuration>
-  <appSettings>
-    <add key="my-key" value="my-value"/>
-  </appSettings>
   <connectionStrings>
-    <clear/>
-    <add name="Shuttle" connectionString="Data Source=.\sqlexpress;Initial Catalog=Shuttle;Integrated Security=SSPI" providerName="System.Data.SqlClient"/>
+    <clear />
+    <add name="Shuttle" 
+         connectionString="Data Source=.\sqlexpress;Initial Catalog=Shuttle;Integrated Security=SSPI"
+         providerName="System.Data.SqlClient" />
   </connectionStrings>
-</configuration>
+</configuration>

Shuttle.Core.Data.Tests/ConnectionConfigurationProviderFixture.cs

@@ -0,0 +1,22 @@
+using NUnit.Framework;
+
+namespace Shuttle.Core.Data.Tests
+{
+    [TestFixture]
+    public class ConnectionConfigurationProviderFixture
+    {
+        [Test]
+        public void Should_be_able_to_get_configuration()
+        {
+            var provider = new ConnectionConfigurationProvider();
+
+            Assert.That(provider.Get("not-defined"), Is.Null);
+
+            var configuration = provider.Get("Shuttle");
+
+            Assert.That(configuration.Name, Is.EqualTo("Shuttle"));
+            Assert.That(configuration.ProviderName, Is.EqualTo("System.Data.SqlClient"));
+            Assert.That(configuration.ConnectionString, Is.EqualTo("Data Source=.\\sqlexpress;Initial Catalog=Shuttle;Integrated Security=SSPI"));
+        }
+    }
+}

Shuttle.Core.Data.Tests/ConnectionStringServiceFixture.cs

@@ -14,14 +14,19 @@ public void Should_be_able_to_create_a_database_context()
 			}
 		}
 
-	    private static IDatabaseContextFactory GetDefaultDatabaseContextFactory()
+	    private IDatabaseContextFactory GetDefaultDatabaseContextFactory()
 	    {
 #if (!NETCOREAPP2_0 && !NETSTANDARD2_0)
-	        return DatabaseContextFactory.Default();
+	        var connectionFactory = new DbConnectionFactory();
 #else
-            return DatabaseContextFactory.Default(new DefaultDbProviderFactories());
+            var connectionFactory = new DbConnectionFactory(new DefaultDbProviderFactories());
 #endif
-        }
+            return new DatabaseContextFactory(
+	            GetConnectionConfigurationProvider(),
+	            connectionFactory,
+	            new DbCommandFactory(),
+	            new ThreadStaticDatabaseContextCache());
+	    }
 
         [Test]
 		public void Should_be_able_to_get_an_existing_database_context()

Shuttle.Core.Data.Tests/DatabaseContextFactoryFixture.cs

@@ -22,16 +22,28 @@ protected DbConnectionFactory GetDbConnectionFactory()
 
 	    protected IDatabaseContext GetDatabaseContext()
 		{
-			return new DatabaseContextFactory(GetDbConnectionFactory(), new DbCommandFactory(), new ThreadStaticDatabaseContextCache()).Create(DefaultConnectionStringName);
+			return new DatabaseContextFactory(GetConnectionConfigurationProvider(), GetDbConnectionFactory(), new DbCommandFactory(), new ThreadStaticDatabaseContextCache()).Create(DefaultConnectionStringName);
 		}
 
-	    protected IDatabaseContext GetDatabaseContext(Mock<IDbCommand> command)
+        protected IConnectionConfigurationProvider GetConnectionConfigurationProvider()
+        {
+            var provider = new Mock<IConnectionConfigurationProvider>();
+
+            provider.Setup(m => m.Get("Shuttle")).Returns(new ConnectionConfiguration(
+                "Shuttle",
+                "System.Data.SqlClient",
+                "Data Source=.\\sqlexpress;Initial Catalog=Shuttle;Integrated Security=SSPI"));
+
+            return provider.Object;
+        }
+
+        protected IDatabaseContext GetDatabaseContext(Mock<IDbCommand> command)
 	    {
 		    var commandFactory = new Mock<IDbCommandFactory>();
 
 		    commandFactory.Setup(m => m.CreateCommandUsing(It.IsAny<IDbConnection>(), It.IsAny<IQuery>())).Returns(command.Object);
 
-			return new DatabaseContextFactory(GetDbConnectionFactory(), commandFactory.Object, new ThreadStaticDatabaseContextCache()).Create(DefaultConnectionStringName);
+			return new DatabaseContextFactory(GetConnectionConfigurationProvider(), GetDbConnectionFactory(), commandFactory.Object, new ThreadStaticDatabaseContextCache()).Create(DefaultConnectionStringName);
 	    }
     }
 }

Shuttle.Core.Data.Tests/Fixture.cs

@@ -30,6 +30,7 @@
     </ItemGroup>
 
     <ItemGroup>
-        <Compile Remove="DefaultDbProviderFactories.cs" Condition="'$(TargetFramework)' != 'netcoreapp2.0'"/>
+        <Compile Remove="ConnectionConfigurationProvider.cs" Condition="'$(TargetFramework)' != 'net46'" />
+        <Compile Remove="DefaultDbProviderFactories.cs" Condition="'$(TargetFramework)' != 'netcoreapp2.0'" />
     </ItemGroup>
 </Project>

Shuttle.Core.Data.Tests/Shuttle.Core.Data.Tests.csproj

@@ -0,0 +1,22 @@
+using Shuttle.Core.Contract;
+
+namespace Shuttle.Core.Data
+{
+    public class ConnectionConfiguration
+    {
+        public ConnectionConfiguration(string name, string providerName, string connectionString)
+        {
+            Guard.AgainstNullOrEmptyString(name, nameof(name));
+            Guard.AgainstNullOrEmptyString(providerName, nameof(providerName));
+            Guard.AgainstNullOrEmptyString(connectionString, nameof(connectionString));
+
+            Name = name;
+            ProviderName = providerName;
+            ConnectionString = connectionString;
+        }
+
+        public string Name { get; }
+        public string ProviderName { get; }
+        public string ConnectionString { get; }
+    }
+}

Shuttle.Core.Data/ConnectionConfiguration.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Configuration;
+using Shuttle.Core.Contract;
+
+namespace Shuttle.Core.Data
+{
+    public class ConnectionConfigurationProvider : IConnectionConfigurationProvider
+    {
+        public ConnectionConfiguration Get(string name)
+        {
+            Guard.AgainstNullOrEmptyString(name, nameof(name));
+
+            var settings = ConfigurationManager.ConnectionStrings[name];
+
+            if (settings == null)
+            {
+                throw new InvalidOperationException(string.Format(Resources.ConnectionStringMissing, name));
+            }
+
+            return new ConnectionConfiguration(name, settings.ProviderName, settings.ConnectionString);
+        }
+    }
+}

Shuttle.Core.Data/ConnectionConfigurationProvider.cs

@@ -7,36 +7,39 @@ namespace Shuttle.Core.Data
 {
     public class DatabaseContextFactory : IDatabaseContextFactory
     {
+        public IConnectionConfigurationProvider ConfigurationProvider { get; }
         private string _connectionString;
         private string _connectionStringName;
         private IDbConnection _dbConnection;
         private string _providerName;
 
-        public DatabaseContextFactory(IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory,
+        public DatabaseContextFactory(IConnectionConfigurationProvider connectionConfigurationProvider,
+            IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory,
             IDatabaseContextCache databaseContextCache)
         {
+            Guard.AgainstNull(connectionConfigurationProvider, nameof(connectionConfigurationProvider));
             Guard.AgainstNull(dbConnectionFactory, nameof(dbConnectionFactory));
             Guard.AgainstNull(dbCommandFactory, nameof(dbCommandFactory));
             Guard.AgainstNull(databaseContextCache, nameof(databaseContextCache));
 
+            ConfigurationProvider = connectionConfigurationProvider;
             DbConnectionFactory = dbConnectionFactory;
             DbCommandFactory = dbCommandFactory;
             DatabaseContextCache = databaseContextCache;
 
             DatabaseContext.Assign(databaseContextCache);
         }
 
-        public IDatabaseContext Create(string connectionStringName)
+        public IDatabaseContext Create(string name)
         {
-            var settings = ConfigurationManager.ConnectionStrings[connectionStringName];
+            var configuration = ConfigurationProvider.Get(name);
 
-            if (settings == null)
+            if (configuration == null)
             {
-                throw new InvalidOperationException(string.Format(Resources.ConnectionStringMissing,
-                    connectionStringName));
+                throw new InvalidOperationException(string.Format(Resources.ConnectionConfigurationMissing, GetType().FullName, name));
             }
 
-            return Create(settings.ProviderName, settings.ConnectionString);
+            return Create(configuration.ProviderName, configuration.ConnectionString);
         }
 
         public IDatabaseContext Create(string providerName, string connectionString)
@@ -114,7 +117,7 @@ public static IDatabaseContextFactory Default(IDbProviderFactories dbProviderFac
             var dbConnectionFactory = new DbConnectionFactory(dbProviderFactories);
 #endif
 
-            return new DatabaseContextFactory(dbConnectionFactory, new DbCommandFactory(), new ThreadStaticDatabaseContextCache());
+            return new DatabaseContextFactory(new ConnectionConfigurationProvider(), dbConnectionFactory, new DbCommandFactory(), new ThreadStaticDatabaseContextCache());
         }
 
         private void ClearConfiguredValues()