Merge pull request #261 from ckadluba/refactoring-cleanup-tests

ckadluba · web-flow · commit d474e716f753 · 2020-04-12T21:51:23.000+02:00
Added SqlConnectionFactory and added/adapted unit tests.
diff --git a/src/Serilog.Sinks.MSSqlServer/GlobalSuppressions.cs b/src/Serilog.Sinks.MSSqlServer/GlobalSuppressions.cs
@@ -10,7 +10,7 @@
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSinkTraits.TryChangeType(System.Object,System.Type,System.Object@)~System.Boolean")]
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSink.EmitBatchAsync(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSinkTraits.ConvertPropertiesToXmlStructure(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Serilog.Events.LogEventPropertyValue}})~System.String")]
-[assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSinkTraits.#ctor(System.String,System.String,System.String,Serilog.Sinks.MSSqlServer.ColumnOptions,System.IFormatProvider,System.Boolean,Serilog.Formatting.ITextFormatter,Serilog.Sinks.MSSqlServer.Platform.ISqlTableCreator)")]
+[assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSinkTraits.#ctor(System.String,System.String,Serilog.Sinks.MSSqlServer.ColumnOptions,System.IFormatProvider,System.Boolean,Serilog.Formatting.ITextFormatter,Serilog.Sinks.MSSqlServer.Platform.ISqlTableCreator)")]
 [assembly: SuppressMessage("Design", "CA1062:Validate arguments of public methods", Justification = "Serilog core guarantees to call Emit() with non-null logEvent parameter.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerAuditSink.Emit(Serilog.Events.LogEvent)")]
 [assembly: SuppressMessage("Design", "CA1062:Validate arguments of public methods", Justification = "Serilog core guarantees to call EmitBatchAsync() with non-null logEvent parameter.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.MSSqlServerSink.EmitBatchAsync(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Design", "CA1034:Nested types should not be visible", Justification = "Cannot be changed on public classes for backward compatibility reasons.", Scope = "namespaceanddescendants", Target = "Serilog.Sinks.MSSqlServer")]
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs
@@ -20,6 +20,7 @@
 using Serilog.Debugging;
 using Serilog.Events;
 using Serilog.Formatting;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 
 namespace Serilog.Sinks.MSSqlServer
 {
@@ -29,6 +30,7 @@ namespace Serilog.Sinks.MSSqlServer
     /// </summary>
     public class MSSqlServerAuditSink : ILogEventSink, IDisposable
     {
+        private readonly ISqlConnectionFactory _sqlConnectionFactory;
         private readonly MSSqlServerSinkTraits _traits;
 
         /// <summary>
@@ -58,8 +60,8 @@ public MSSqlServerAuditSink(
                     throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");
             }
 
-            _traits = new MSSqlServerSinkTraits(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);
-
+            _sqlConnectionFactory = new SqlConnectionFactory(connectionString);
+            _traits = new MSSqlServerSinkTraits(_sqlConnectionFactory, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);
         }
 
         /// <summary>Emit the provided log event to the sink.</summary>
@@ -68,7 +70,7 @@ public void Emit(LogEvent logEvent)
         {
             try
             {
-                using (var connection = new SqlConnection(_traits.ConnectionString))
+                using (var connection = _sqlConnectionFactory.Create())
                 {
                     connection.Open();
                     using (SqlCommand command = connection.CreateCommand())
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs
@@ -22,6 +22,7 @@
 using Serilog.Debugging;
 using Serilog.Events;
 using Serilog.Formatting;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 using Serilog.Sinks.PeriodicBatching;
 
 namespace Serilog.Sinks.MSSqlServer
@@ -31,6 +32,7 @@ namespace Serilog.Sinks.MSSqlServer
     /// </summary>
     public class MSSqlServerSink : PeriodicBatchingSink
     {
+        private readonly ISqlConnectionFactory _sqlConnectionFactory;
         private readonly MSSqlServerSinkTraits _traits;
 
         /// <summary>
@@ -69,7 +71,9 @@ public MSSqlServerSink(
             : base(batchPostingLimit, period)
         {
             columnOptions?.FinalizeConfigurationForSinkConstructor();
-            _traits = new MSSqlServerSinkTraits(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);
+
+            _sqlConnectionFactory = new SqlConnectionFactory(connectionString);
+            _traits = new MSSqlServerSinkTraits(_sqlConnectionFactory, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);
         }
 
         /// <summary>
@@ -88,7 +92,7 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
 
             try
             {
-                using (var cn = new SqlConnection(_traits.ConnectionString))
+                using (var cn = _sqlConnectionFactory.Create())
                 {
                     await cn.OpenAsync().ConfigureAwait(false);
                     using (var copy = _traits.ColumnOptions.DisableTriggers
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSinkTraits.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSinkTraits.cs
@@ -23,6 +23,7 @@
 using Serilog.Formatting;
 using Serilog.Sinks.MSSqlServer.Output;
 using Serilog.Sinks.MSSqlServer.Platform;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 
 namespace Serilog.Sinks.MSSqlServer
 {
@@ -31,7 +32,6 @@ internal class MSSqlServerSinkTraits : IDisposable
     {
         private bool _disposedValue;
 
-        public string ConnectionString { get; }
         public string TableName { get; }
         public string SchemaName { get; }
         public ColumnOptions ColumnOptions { get; }
@@ -42,21 +42,20 @@ internal class MSSqlServerSinkTraits : IDisposable
         public ISet<string> StandardColumnNames { get; }
 
         public MSSqlServerSinkTraits(
-            string connectionString,
+            ISqlConnectionFactory sqlConnectionFactory,
             string tableName,
             string schemaName,
             ColumnOptions columnOptions,
             IFormatProvider formatProvider,
             bool autoCreateSqlTable,
             ITextFormatter logEventFormatter)
-            : this(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable,
-                logEventFormatter, new SqlTableCreator(new SqlCreateTableWriter()))
+            : this(tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable,
+                logEventFormatter, new SqlTableCreator(new SqlCreateTableWriter(), sqlConnectionFactory))
         {
         }
 
         // Internal constructor with injectable dependencies for better testability
         internal MSSqlServerSinkTraits(
-            string connectionString,
             string tableName,
             string schemaName,
             ColumnOptions columnOptions,
@@ -65,13 +64,12 @@ internal MSSqlServerSinkTraits(
             ITextFormatter logEventFormatter,
             ISqlTableCreator sqlTableCreator)
         {
-            if (string.IsNullOrWhiteSpace(connectionString))
-                throw new ArgumentNullException(nameof(connectionString));
-
             if (string.IsNullOrWhiteSpace(tableName))
                 throw new ArgumentNullException(nameof(tableName));
 
-            ConnectionString = connectionString;
+            if (sqlTableCreator == null)
+                throw new ArgumentNullException(nameof(sqlTableCreator));
+
             TableName = tableName;
             SchemaName = schemaName;
             ColumnOptions = columnOptions ?? new ColumnOptions();
@@ -98,7 +96,7 @@ internal MSSqlServerSinkTraits(
             {
                 try
                 {
-                    sqlTableCreator.CreateTable(ConnectionString, SchemaName, TableName, EventTable, ColumnOptions); // return code ignored, 0 = failure?
+                    sqlTableCreator.CreateTable(SchemaName, TableName, EventTable, ColumnOptions); // return code ignored, 0 = failure?
                 }
                 catch (Exception ex)
                 {
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlConnectionFactory.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlConnectionFactory.cs
@@ -0,0 +1,9 @@
+﻿using System.Data.SqlClient;
+
+namespace Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform
+{
+    internal interface ISqlConnectionFactory
+    {
+        SqlConnection Create();
+    }
+}
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlTableCreator.cs
@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal interface ISqlTableCreator
     {
-        int CreateTable(string connectionString, string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);
+        int CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);
     }
 }
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlConnectionFactory.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlConnectionFactory.cs
@@ -0,0 +1,22 @@
+﻿using System;
+using System.Data.SqlClient;
+
+namespace Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform
+{
+    internal class SqlConnectionFactory : ISqlConnectionFactory
+    {
+        private readonly string _connectionString;
+
+        public SqlConnectionFactory(string connectionString)
+        {
+            if (string.IsNullOrWhiteSpace(connectionString))
+            {
+                throw new ArgumentNullException(nameof(connectionString));
+            }
+
+            _connectionString = connectionString;
+        }
+
+        public SqlConnection Create() => new SqlConnection(_connectionString);
+    }
+}
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs
@@ -1,23 +1,27 @@
-﻿using System.Data;
+﻿using System;
+using System.Data;
 using System.Data.SqlClient;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 
 namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal class SqlTableCreator : ISqlTableCreator
     {
         private readonly ISqlCreateTableWriter _sqlCreateTableWriter;
+        private readonly ISqlConnectionFactory _sqlConnectionFactory;
 
-        public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter)
+        public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter, ISqlConnectionFactory sqlConnectionFactory)
         {
-            _sqlCreateTableWriter = sqlCreateTableWriter;
+            _sqlCreateTableWriter = sqlCreateTableWriter ?? throw new ArgumentNullException(nameof(sqlCreateTableWriter));
+            _sqlConnectionFactory = sqlConnectionFactory ?? throw new ArgumentNullException(nameof(sqlConnectionFactory));
         }
 
-        public int CreateTable(string connectionString, string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)
+        public int CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)
         {
-            using (var conn = new SqlConnection(connectionString))
+            using (var conn = _sqlConnectionFactory.Create())
             {
-                string sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);
-                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                var sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);
+                using (var cmd = new SqlCommand(sql, conn))
                 {
                     conn.Open();
                     return cmd.ExecuteNonQuery();
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerSinkTraitsTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerSinkTraitsTests.cs
@@ -9,18 +9,24 @@
 using Serilog.Formatting;
 using Serilog.Parsing;
 using Serilog.Sinks.MSSqlServer.Platform;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 using Xunit;
 
 namespace Serilog.Sinks.MSSqlServer.Tests.Sinks.MSSqlServer
 {
     public class MSSqlServerSinkTraitsTests : IDisposable
     {
-        private readonly string _connectionString = "connectionString";
+        private readonly Mock<ISqlConnectionFactory> _sqlConnectionFactoryMock;
         private readonly string _tableName = "tableName";
         private readonly string _schemaName = "schemaName";
         private MSSqlServerSinkTraits _sut;
         private bool _disposedValue;
 
+        public MSSqlServerSinkTraitsTests()
+        {
+            _sqlConnectionFactoryMock = new Mock<ISqlConnectionFactory>();
+        }
+
         [Trait("Bugfix", "#187")]
         [Fact]
         public void GetColumnsAndValuesCreatesTimeStampOfTypeDateTimeAccordingToColumnOptions()
@@ -162,7 +168,7 @@ public void InitializeWithAutoCreateSqlTableCallsSqlTableCreator()
             SetupSut(options, autoCreateSqlTable: true, sqlTableCreator: sqlTableCreatorMock.Object);
 
             // Assert
-            sqlTableCreatorMock.Verify(c => c.CreateTable(_connectionString, _schemaName, _tableName,
+            sqlTableCreatorMock.Verify(c => c.CreateTable(_schemaName, _tableName,
                 It.IsAny<DataTable>(), options),
                 Times.Once);
         }
@@ -178,7 +184,7 @@ public void InitializeWithoutAutoCreateSqlTableDoesNotCallsSqlTableCreator()
             SetupSut(options, autoCreateSqlTable: false, sqlTableCreator: sqlTableCreatorMock.Object);
 
             // Assert
-            sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
+            sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<DataTable>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()),
                 Times.Never);
         }
@@ -197,14 +203,14 @@ private void SetupSut(
         {
             if (sqlTableCreator == null)
             {
-                _sut = new MSSqlServerSinkTraits(_connectionString, _tableName, _schemaName,
+                _sut = new MSSqlServerSinkTraits(_sqlConnectionFactoryMock.Object, _tableName, _schemaName,
                     options, CultureInfo.InvariantCulture, autoCreateSqlTable, logEventFormatter);
             }
             else
             {
                 // Internal constructor to use ISqlTableCreator mock
-                _sut = new MSSqlServerSinkTraits(_connectionString, _tableName, _schemaName,
-                    options, CultureInfo.InvariantCulture, autoCreateSqlTable, logEventFormatter, sqlTableCreator);
+                _sut = new MSSqlServerSinkTraits(_tableName, _schemaName, options, CultureInfo.InvariantCulture,
+                    autoCreateSqlTable, logEventFormatter, sqlTableCreator);
             }
         }
 
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Output/JsonLogEventFormatterTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Output/JsonLogEventFormatterTests.cs
@@ -2,9 +2,11 @@
 using System.Collections.Generic;
 using System.Data;
 using System.IO;
+using Moq;
 using Serilog.Events;
 using Serilog.Parsing;
 using Serilog.Sinks.MSSqlServer.Output;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
 using Xunit;
 
 namespace Serilog.Sinks.MSSqlServer.Tests.Sinks.MSSqlServer.Output
@@ -136,7 +138,7 @@ private void SetupTest()
         {
             _testColumnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
             _testColumnOptions.Store.Add(StandardColumn.LogEvent);
-            _testTraits = new MSSqlServerSinkTraits("ConnectionString", "TableName", "SchemaName", _testColumnOptions,
+            _testTraits = new MSSqlServerSinkTraits(new Mock<ISqlConnectionFactory>().Object, "TableName", "SchemaName", _testColumnOptions,
                 formatProvider: null, autoCreateSqlTable: false, logEventFormatter: null);
             _sut = new JsonLogEventFormatter(_testTraits);
         }
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlConnectionFactoryTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlConnectionFactoryTests.cs
@@ -0,0 +1,42 @@
+﻿using System;
+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;
+using Serilog.Sinks.MSSqlServer.Tests.TestUtils;
+using Xunit;
+
+namespace Serilog.Sinks.MSSqlServer.Tests.Sinks.MSSqlServer.Platform
+{
+    public class SqlConnectionFactoryTests
+    {
+        [Fact]
+        public void IntializeThrowsIfConnectionStringIsNull()
+        {
+            Assert.Throws<ArgumentNullException>(() => new SqlConnectionFactory(null));
+        }
+
+        [Fact]
+        public void IntializeThrowsIfConnectionStringIsEmpty()
+        {
+            Assert.Throws<ArgumentNullException>(() => new SqlConnectionFactory(string.Empty));
+        }
+
+        [Fact]
+        public void IntializeThrowsIfConnectionStringIsWhitespace()
+        {
+            Assert.Throws<ArgumentNullException>(() => new SqlConnectionFactory("    "));
+        }
+
+        [Fact]
+        public void CreatesSqlConnectionWithSpecifiedConnectionString()
+        {
+            // Arrange
+            var sut = new SqlConnectionFactory(DatabaseFixture.LogEventsConnectionString);
+
+            // Act
+            using (var connection = sut.Create())
+            {
+                // Assert
+                Assert.Equal(DatabaseFixture.LogEventsConnectionString, connection.ConnectionString);
+            }
+        }
+    }
+}
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlTableCreatorTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlTableCreatorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`using Serilog.Debugging;`
`21`	`21`	`using Serilog.Events;`
`22`	`22`	`using Serilog.Formatting;`
	`23`	`+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;`
`23`	`24`
`24`	`25`	`namespace Serilog.Sinks.MSSqlServer`
`25`	`26`	`{`
`@@ -29,6 +30,7 @@ namespace Serilog.Sinks.MSSqlServer`
`29`	`30`	`/// </summary>`
`30`	`31`	`public class MSSqlServerAuditSink : ILogEventSink, IDisposable`
`31`	`32`	`{`
	`33`	`+ private readonly ISqlConnectionFactory _sqlConnectionFactory;`
`32`	`34`	`private readonly MSSqlServerSinkTraits _traits;`
`33`	`35`
`34`	`36`	`/// <summary>`
`@@ -58,8 +60,8 @@ public MSSqlServerAuditSink(`
`58`	`60`	`throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");`
`59`	`61`	`}`
`60`	`62`
`61`		`- _traits = new MSSqlServerSinkTraits(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);`
`62`		`-`
	`63`	`+ _sqlConnectionFactory = new SqlConnectionFactory(connectionString);`
	`64`	`+ _traits = new MSSqlServerSinkTraits(_sqlConnectionFactory, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`/// <summary>Emit the provided log event to the sink.</summary>`
`@@ -68,7 +70,7 @@ public void Emit(LogEvent logEvent)`
`68`	`70`	`{`
`69`	`71`	`try`
`70`	`72`	`{`
`71`		`- using (var connection = new SqlConnection(_traits.ConnectionString))`
	`73`	`+ using (var connection = _sqlConnectionFactory.Create())`
`72`	`74`	`{`
`73`	`75`	`connection.Open();`
`74`	`76`	`using (SqlCommand command = connection.CreateCommand())`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`using Serilog.Debugging;`
`23`	`23`	`using Serilog.Events;`
`24`	`24`	`using Serilog.Formatting;`
	`25`	`+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;`
`25`	`26`	`using Serilog.Sinks.PeriodicBatching;`
`26`	`27`
`27`	`28`	`namespace Serilog.Sinks.MSSqlServer`
`@@ -31,6 +32,7 @@ namespace Serilog.Sinks.MSSqlServer`
`31`	`32`	`/// </summary>`
`32`	`33`	`public class MSSqlServerSink : PeriodicBatchingSink`
`33`	`34`	`{`
	`35`	`+ private readonly ISqlConnectionFactory _sqlConnectionFactory;`
`34`	`36`	`private readonly MSSqlServerSinkTraits _traits;`
`35`	`37`
`36`	`38`	`/// <summary>`
`@@ -69,7 +71,9 @@ public MSSqlServerSink(`
`69`	`71`	`: base(batchPostingLimit, period)`
`70`	`72`	`{`
`71`	`73`	`columnOptions?.FinalizeConfigurationForSinkConstructor();`
`72`		`- _traits = new MSSqlServerSinkTraits(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);`
	`74`	`+`
	`75`	`+ _sqlConnectionFactory = new SqlConnectionFactory(connectionString);`
	`76`	`+ _traits = new MSSqlServerSinkTraits(_sqlConnectionFactory, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable, logEventFormatter);`
`73`	`77`	`}`
`74`	`78`
`75`	`79`	`/// <summary>`
`@@ -88,7 +92,7 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)`
`88`	`92`
`89`	`93`	`try`
`90`	`94`	`{`
`91`		`- using (var cn = new SqlConnection(_traits.ConnectionString))`
	`95`	`+ using (var cn = _sqlConnectionFactory.Create())`
`92`	`96`	`{`
`93`	`97`	`await cn.OpenAsync().ConfigureAwait(false);`
`94`	`98`	`using (var copy = _traits.ColumnOptions.DisableTriggers`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform`
`4`	`4`	`{`
`5`	`5`	`internal interface ISqlTableCreator`
`6`	`6`	`{`
`7`		`- int CreateTable(string connectionString, string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);`
	`7`	`+ int CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,23 +1,27 @@`
`1`		`-using System.Data;`
	`1`	`+using System;`
	`2`	`+using System.Data;`
`2`	`3`	`using System.Data.SqlClient;`
	`4`	`+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;`
`3`	`5`
`4`	`6`	`namespace Serilog.Sinks.MSSqlServer.Platform`
`5`	`7`	`{`
`6`	`8`	`internal class SqlTableCreator : ISqlTableCreator`
`7`	`9`	`{`
`8`	`10`	`private readonly ISqlCreateTableWriter _sqlCreateTableWriter;`
	`11`	`+ private readonly ISqlConnectionFactory _sqlConnectionFactory;`
`9`	`12`
`10`		`- public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter)`
	`13`	`+ public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter, ISqlConnectionFactory sqlConnectionFactory)`
`11`	`14`	`{`
`12`		`- _sqlCreateTableWriter = sqlCreateTableWriter;`
	`15`	`+ _sqlCreateTableWriter = sqlCreateTableWriter ?? throw new ArgumentNullException(nameof(sqlCreateTableWriter));`
	`16`	`+ _sqlConnectionFactory = sqlConnectionFactory ?? throw new ArgumentNullException(nameof(sqlConnectionFactory));`
`13`	`17`	`}`
`14`	`18`
`15`		`- public int CreateTable(string connectionString, string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)`
	`19`	`+ public int CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)`
`16`	`20`	`{`
`17`		`- using (var conn = new SqlConnection(connectionString))`
	`21`	`+ using (var conn = _sqlConnectionFactory.Create())`
`18`	`22`	`{`
`19`		`- string sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);`
`20`		`- using (SqlCommand cmd = new SqlCommand(sql, conn))`
	`23`	`+ var sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);`
	`24`	`+ using (var cmd = new SqlCommand(sql, conn))`
`21`	`25`	`{`
`22`	`26`	`conn.Open();`
`23`	`27`	`return cmd.ExecuteNonQuery();`
Original file line number	Diff line number	Diff line change
`@@ -9,18 +9,24 @@`
`9`	`9`	`using Serilog.Formatting;`
`10`	`10`	`using Serilog.Parsing;`
`11`	`11`	`using Serilog.Sinks.MSSqlServer.Platform;`
	`12`	`+using Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform;`
`12`	`13`	`using Xunit;`
`13`	`14`
`14`	`15`	`namespace Serilog.Sinks.MSSqlServer.Tests.Sinks.MSSqlServer`
`15`	`16`	`{`
`16`	`17`	`public class MSSqlServerSinkTraitsTests : IDisposable`
`17`	`18`	`{`
`18`		`- private readonly string _connectionString = "connectionString";`
	`19`	`+ private readonly Mock<ISqlConnectionFactory> _sqlConnectionFactoryMock;`
`19`	`20`	`private readonly string _tableName = "tableName";`
`20`	`21`	`private readonly string _schemaName = "schemaName";`
`21`	`22`	`private MSSqlServerSinkTraits _sut;`
`22`	`23`	`private bool _disposedValue;`
`23`	`24`
	`25`	`+ public MSSqlServerSinkTraitsTests()`
	`26`	`+ {`
	`27`	`+ _sqlConnectionFactoryMock = new Mock<ISqlConnectionFactory>();`
	`28`	`+ }`
	`29`	`+`
`24`	`30`	`[Trait("Bugfix", "#187")]`
`25`	`31`	`[Fact]`
`26`	`32`	`public void GetColumnsAndValuesCreatesTimeStampOfTypeDateTimeAccordingToColumnOptions()`
`@@ -162,7 +168,7 @@ public void InitializeWithAutoCreateSqlTableCallsSqlTableCreator()`
`162`	`168`	`SetupSut(options, autoCreateSqlTable: true, sqlTableCreator: sqlTableCreatorMock.Object);`
`163`	`169`
`164`	`170`	`// Assert`
`165`		`- sqlTableCreatorMock.Verify(c => c.CreateTable(_connectionString, _schemaName, _tableName,`
	`171`	`+ sqlTableCreatorMock.Verify(c => c.CreateTable(_schemaName, _tableName,`
`166`	`172`	`It.IsAny<DataTable>(), options),`
`167`	`173`	`Times.Once);`
`168`	`174`	`}`
`@@ -178,7 +184,7 @@ public void InitializeWithoutAutoCreateSqlTableDoesNotCallsSqlTableCreator()`
`178`	`184`	`SetupSut(options, autoCreateSqlTable: false, sqlTableCreator: sqlTableCreatorMock.Object);`
`179`	`185`
`180`	`186`	`// Assert`
`181`		`- sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),`
	`187`	`+ sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(),`
`182`	`188`	`It.IsAny<DataTable>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()),`
`183`	`189`	`Times.Never);`
`184`	`190`	`}`
`@@ -197,14 +203,14 @@ private void SetupSut(`
`197`	`203`	`{`
`198`	`204`	`if (sqlTableCreator == null)`
`199`	`205`	`{`
`200`		`- _sut = new MSSqlServerSinkTraits(_connectionString, _tableName, _schemaName,`
	`206`	`+ _sut = new MSSqlServerSinkTraits(_sqlConnectionFactoryMock.Object, _tableName, _schemaName,`
`201`	`207`	`options, CultureInfo.InvariantCulture, autoCreateSqlTable, logEventFormatter);`
`202`	`208`	`}`
`203`	`209`	`else`
`204`	`210`	`{`
`205`	`211`	`// Internal constructor to use ISqlTableCreator mock`
`206`		`- _sut = new MSSqlServerSinkTraits(_connectionString, _tableName, _schemaName,`
`207`		`- options, CultureInfo.InvariantCulture, autoCreateSqlTable, logEventFormatter, sqlTableCreator);`
	`212`	`+ _sut = new MSSqlServerSinkTraits(_tableName, _schemaName, options, CultureInfo.InvariantCulture,`
	`213`	`+ autoCreateSqlTable, logEventFormatter, sqlTableCreator);`
`208`	`214`	`}`
`209`	`215`	`}`
`210`	`216`