Convert most tools service tests to nunit (#1037)

* Remove xunit dependency from testdriver

* swap expected/actual as needed

* Convert Test.Common to nunit

* port hosting unit tests to nunit

* port batchparser integration tests to nunit

* port testdriver.tests to nunit

* fix target to copy dependency

* port servicelayer unittests to nunit

* more unit test fixes

* port integration tests to nunit

* fix test method type

* try using latest windows build for PRs

* reduce test memory use

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Connection/CachedServerInfoTests.cs

@@ -4,12 +4,13 @@
 //
 
 using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection;
-using Xunit;
+using NUnit.Framework;
 using Microsoft.Data.SqlClient;
 using Microsoft.SqlServer.Management.Common;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
 {
+    [TestFixture]
     /// <summary>
     /// Tests for Sever Information Caching Class
     /// </summary>
@@ -22,12 +23,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             cache = new CachedServerInfo();
         }
 
-        [Fact]
+        [Test]
         public void CacheMatchesNullDbNameToEmptyString()
         {
             // Set sqlDw result into cache
-            string dataSource = "testDataSource";
-            DatabaseEngineEdition engineEdition;
+            string dataSource = "testDataSource";
             SqlConnectionStringBuilder testSource = new SqlConnectionStringBuilder
             {
                 DataSource = dataSource,
@@ -36,31 +36,26 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             cache.AddOrUpdateCache(testSource, DatabaseEngineEdition.SqlDataWarehouse, CachedServerInfo.CacheVariable.EngineEdition);
 
             // Expect the same returned result
-            Assert.Equal(cache.TryGetEngineEdition(testSource, out engineEdition), DatabaseEngineEdition.SqlDataWarehouse);
+            Assert.AreEqual(DatabaseEngineEdition.SqlDataWarehouse, cache.TryGetEngineEdition(testSource, out _));
 
             // And expect the same for the null string
-            Assert.Equal(cache.TryGetEngineEdition(new SqlConnectionStringBuilder
+            Assert.AreEqual(DatabaseEngineEdition.SqlDataWarehouse, cache.TryGetEngineEdition(new SqlConnectionStringBuilder
             {
                 DataSource = dataSource
                 // Initial Catalog is null. Can't set explicitly as this throws
-            }, out engineEdition), DatabaseEngineEdition.SqlDataWarehouse);
+            }, out _));
 
-            // But expect NotEqual for a different DB
-            Assert.NotEqual(cache.TryGetEngineEdition(new SqlConnectionStringBuilder
+            Assert.That(cache.TryGetEngineEdition(new SqlConnectionStringBuilder
             {
                 DataSource = dataSource,
                 InitialCatalog = "OtherDb"
-            }, out engineEdition), DatabaseEngineEdition.SqlDataWarehouse);
+            }, out _), Is.Not.EqualTo(DatabaseEngineEdition.SqlDataWarehouse), "expect NotEqual for a different DB");
         }
 
-        [Theory]
-        [InlineData(null, DatabaseEngineEdition.SqlDataWarehouse)]  // is SqlDW instance
-        [InlineData("", DatabaseEngineEdition.SqlDataWarehouse)]  // is SqlDW instance
-        [InlineData("myDb", DatabaseEngineEdition.SqlDataWarehouse)]  // is SqlDW instance
-        [InlineData(null, DatabaseEngineEdition.SqlOnDemand)]   // is SqlOnDemand Instance
-        [InlineData("", DatabaseEngineEdition.SqlOnDemand)]   // is SqlOnDemand Instance
-        [InlineData("myDb", DatabaseEngineEdition.SqlOnDemand)]  // is SqlOnDemand instance
-        public void AddOrUpdateEngineEditiopn(string dbName, DatabaseEngineEdition state)
+        
+        [Test]
+        public void AddOrUpdateEngineEdition([Values(null, "", "myDb")] string dbName, 
+                                              [Values(DatabaseEngineEdition.SqlDataWarehouse, DatabaseEngineEdition.SqlOnDemand)] DatabaseEngineEdition state)
         {
             // Set result into cache
             DatabaseEngineEdition engineEdition;
@@ -75,15 +70,15 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
 
             cache.AddOrUpdateCache(testSource, state, CachedServerInfo.CacheVariable.EngineEdition);
 
-            // Expect the same returned result
-            Assert.NotEqual(cache.TryGetEngineEdition(testSource, out engineEdition), DatabaseEngineEdition.Unknown);
-            Assert.Equal(engineEdition, state);
+            Assert.Multiple(() =>
+            {
+                Assert.That(cache.TryGetEngineEdition(testSource, out engineEdition), Is.Not.EqualTo(DatabaseEngineEdition.Unknown) );
+                Assert.That(engineEdition, Is.EqualTo(state), "Expect the same returned result");
+            });
         }
 
-        [Theory]
-        [InlineData(DatabaseEngineEdition.SqlDataWarehouse)]  // is SqlDW instance
-        [InlineData(DatabaseEngineEdition.SqlOnDemand)]   // is SqlOnDemand Instance
-        public void AddOrUpdateEngineEditionToggle(DatabaseEngineEdition state)
+        [Test]
+        public void AddOrUpdateEngineEditionToggle([Values(DatabaseEngineEdition.SqlDataWarehouse, DatabaseEngineEdition.SqlOnDemand)] DatabaseEngineEdition state)
         {
             // Set result into cache
             DatabaseEngineEdition engineEdition;
@@ -93,21 +88,25 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             };
             cache.AddOrUpdateCache(testSource, state, CachedServerInfo.CacheVariable.EngineEdition);
 
-            // Expect the same returned result
-            Assert.NotEqual(cache.TryGetEngineEdition(testSource, out engineEdition), DatabaseEngineEdition.Unknown);
-            Assert.Equal(engineEdition, state);
+            Assert.Multiple(() =>
+            {                 
+                Assert.That(cache.TryGetEngineEdition(testSource, out engineEdition), Is.Not.EqualTo(DatabaseEngineEdition.Unknown));
+                Assert.That(engineEdition, Is.EqualTo(state), "Expect the same returned result");
+            });
 
             DatabaseEngineEdition newState = state == DatabaseEngineEdition.SqlDataWarehouse ?
                 DatabaseEngineEdition.SqlOnDemand : DatabaseEngineEdition.SqlDataWarehouse;
 
             cache.AddOrUpdateCache(testSource, newState, CachedServerInfo.CacheVariable.EngineEdition);
 
-            // Expect the opposite returned result
-            Assert.NotEqual(cache.TryGetEngineEdition(testSource, out engineEdition), DatabaseEngineEdition.Unknown);
-            Assert.Equal(engineEdition, newState);
+            Assert.Multiple(() =>
+            {
+                Assert.That(cache.TryGetEngineEdition(testSource, out engineEdition), Is.Not.EqualTo(DatabaseEngineEdition.Unknown));
+                Assert.That(engineEdition, Is.EqualTo(newState), "Expect the opposite returned result");
+            });
         }
 
-       /* [Fact]
+       /* [Test]
         public void AddOrUpdateIsSqlDwFalseToggle()
         {
             bool state = true;
@@ -142,22 +141,21 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             Assert.True(cache.TryGetIsSqlDw(differentServerSameDb, out isSqlDwResult3));
 
             // Assert cache is set on a per connection basis
-            Assert.Equal(isSqlDwResult, state);
-            Assert.Equal(isSqlDwResult2, !state);
-            Assert.Equal(isSqlDwResult3, !state);
+            Assert.AreEqual(isSqlDwResult, state);
+            Assert.AreEqual(isSqlDwResult2, !state);
+            Assert.AreEqual(isSqlDwResult3, !state);
 
         }
         */
 
-        [Fact]
+        [Test]
         public void AskforEngineEditionBeforeCached()
-        {
-            DatabaseEngineEdition engineEdition;
-            Assert.Equal(cache.TryGetEngineEdition(new SqlConnectionStringBuilder
+        {
+            Assert.AreEqual(DatabaseEngineEdition.Unknown, cache.TryGetEngineEdition(new SqlConnectionStringBuilder
             {
                 DataSource = "testDataSourceUnCached"
             }, 
-            out engineEdition), DatabaseEngineEdition.Unknown);
+            out _));
         }
     }
 }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Connection/ConnectionDetailsTests.cs

@@ -6,17 +6,18 @@
 using System.Linq;
 using Microsoft.SqlTools.Hosting.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
-using Xunit;
+using NUnit.Framework;
 using Microsoft.SqlTools.ServiceLayer.Connection;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
 {
+    [TestFixture]
     /// <summary>
     /// Tests for ConnectionDetails Class
     /// </summary>
     public class ConnectionDetailsTests
     {
-        [Fact]
+        [Test]
         public void ConnectionDetailsWithoutAnyOptionShouldReturnNullOrDefaultForOptions()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -25,39 +26,39 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             var expectedForInt = default(int?);
             var expectedForBoolean = default(bool?);
 
-            Assert.Equal(details.ApplicationIntent, expectedForStrings);
-            Assert.Equal(details.ApplicationName, expectedForStrings);
-            Assert.Equal(details.AttachDbFilename, expectedForStrings);
-            Assert.Equal(details.AuthenticationType, expectedForStrings);
-            Assert.Equal(details.CurrentLanguage, expectedForStrings);
-            Assert.Equal(details.DatabaseName, expectedForStrings);
-            Assert.Equal(details.FailoverPartner, expectedForStrings);
-            Assert.Equal(details.Password, expectedForStrings);
-            Assert.Equal(details.ServerName, expectedForStrings);
-            Assert.Equal(details.TypeSystemVersion, expectedForStrings);
-            Assert.Equal(details.UserName, expectedForStrings);
-            Assert.Equal(details.WorkstationId, expectedForStrings);
-            Assert.Equal(details.ConnectRetryInterval, expectedForInt);
-            Assert.Equal(details.ConnectRetryCount, expectedForInt);
-            Assert.Equal(details.ConnectTimeout, expectedForInt);
-            Assert.Equal(details.LoadBalanceTimeout, expectedForInt);
-            Assert.Equal(details.MaxPoolSize, expectedForInt);
-            Assert.Equal(details.MinPoolSize, expectedForInt);
-            Assert.Equal(details.PacketSize, expectedForInt);
-            Assert.Equal(details.ColumnEncryptionSetting, expectedForStrings);
-            Assert.Equal(details.EnclaveAttestationUrl, expectedForStrings);
-            Assert.Equal(details.EnclaveAttestationProtocol, expectedForStrings);
-            Assert.Equal(details.Encrypt, expectedForBoolean);
-            Assert.Equal(details.MultipleActiveResultSets, expectedForBoolean);
-            Assert.Equal(details.MultiSubnetFailover, expectedForBoolean);
-            Assert.Equal(details.PersistSecurityInfo, expectedForBoolean);
-            Assert.Equal(details.Pooling, expectedForBoolean);
-            Assert.Equal(details.Replication, expectedForBoolean);
-            Assert.Equal(details.TrustServerCertificate, expectedForBoolean);
-            Assert.Equal(details.Port, expectedForInt);
+            Assert.AreEqual(details.ApplicationIntent, expectedForStrings);
+            Assert.AreEqual(details.ApplicationName, expectedForStrings);
+            Assert.AreEqual(details.AttachDbFilename, expectedForStrings);
+            Assert.AreEqual(details.AuthenticationType, expectedForStrings);
+            Assert.AreEqual(details.CurrentLanguage, expectedForStrings);
+            Assert.AreEqual(details.DatabaseName, expectedForStrings);
+            Assert.AreEqual(details.FailoverPartner, expectedForStrings);
+            Assert.AreEqual(details.Password, expectedForStrings);
+            Assert.AreEqual(details.ServerName, expectedForStrings);
+            Assert.AreEqual(details.TypeSystemVersion, expectedForStrings);
+            Assert.AreEqual(details.UserName, expectedForStrings);
+            Assert.AreEqual(details.WorkstationId, expectedForStrings);
+            Assert.AreEqual(details.ConnectRetryInterval, expectedForInt);
+            Assert.AreEqual(details.ConnectRetryCount, expectedForInt);
+            Assert.AreEqual(details.ConnectTimeout, expectedForInt);
+            Assert.AreEqual(details.LoadBalanceTimeout, expectedForInt);
+            Assert.AreEqual(details.MaxPoolSize, expectedForInt);
+            Assert.AreEqual(details.MinPoolSize, expectedForInt);
+            Assert.AreEqual(details.PacketSize, expectedForInt);
+            Assert.AreEqual(details.ColumnEncryptionSetting, expectedForStrings);
+            Assert.AreEqual(details.EnclaveAttestationUrl, expectedForStrings);
+            Assert.AreEqual(details.EnclaveAttestationProtocol, expectedForStrings);
+            Assert.AreEqual(details.Encrypt, expectedForBoolean);
+            Assert.AreEqual(details.MultipleActiveResultSets, expectedForBoolean);
+            Assert.AreEqual(details.MultiSubnetFailover, expectedForBoolean);
+            Assert.AreEqual(details.PersistSecurityInfo, expectedForBoolean);
+            Assert.AreEqual(details.Pooling, expectedForBoolean);
+            Assert.AreEqual(details.Replication, expectedForBoolean);
+            Assert.AreEqual(details.TrustServerCertificate, expectedForBoolean);
+            Assert.AreEqual(details.Port, expectedForInt);
         }
 
-        [Fact]
+        [Test]
         public void ConnectionDetailsPropertySettersShouldSetOptionValuesCorrectly()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -97,39 +98,39 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             details.Port = expectedForInt + index++;
 
             index = 0;
-            Assert.Equal(details.ApplicationIntent, expectedForStrings + index++);
-            Assert.Equal(details.ApplicationName, expectedForStrings + index++);
-            Assert.Equal(details.AttachDbFilename, expectedForStrings + index++);
-            Assert.Equal(details.AuthenticationType, expectedForStrings + index++);
-            Assert.Equal(details.CurrentLanguage, expectedForStrings + index++);
-            Assert.Equal(details.DatabaseName, expectedForStrings + index++);
-            Assert.Equal(details.FailoverPartner, expectedForStrings + index++);
-            Assert.Equal(details.Password, expectedForStrings + index++);
-            Assert.Equal(details.ServerName, expectedForStrings + index++);
-            Assert.Equal(details.TypeSystemVersion, expectedForStrings + index++);
-            Assert.Equal(details.UserName, expectedForStrings + index++);
-            Assert.Equal(details.WorkstationId, expectedForStrings + index++);
-            Assert.Equal(details.ConnectRetryInterval, expectedForInt + index++);
-            Assert.Equal(details.ConnectRetryCount, expectedForInt + index++);
-            Assert.Equal(details.ConnectTimeout, expectedForInt + index++);
-            Assert.Equal(details.LoadBalanceTimeout, expectedForInt + index++);
-            Assert.Equal(details.MaxPoolSize, expectedForInt + index++);
-            Assert.Equal(details.MinPoolSize, expectedForInt + index++);
-            Assert.Equal(details.PacketSize, expectedForInt + index++);
-            Assert.Equal(details.ColumnEncryptionSetting, expectedForStrings + index++);
-            Assert.Equal(details.EnclaveAttestationProtocol, expectedForStrings + index++);
-            Assert.Equal(details.EnclaveAttestationUrl, expectedForStrings + index++);
-            Assert.Equal(details.Encrypt, (index++ % 2 == 0));
-            Assert.Equal(details.MultipleActiveResultSets, (index++ % 2 == 0));
-            Assert.Equal(details.MultiSubnetFailover, (index++ % 2 == 0));
-            Assert.Equal(details.PersistSecurityInfo, (index++ % 2 == 0));
-            Assert.Equal(details.Pooling, (index++ % 2 == 0));
-            Assert.Equal(details.Replication, (index++ % 2 == 0));
-            Assert.Equal(details.TrustServerCertificate, (index++ % 2 == 0));
-            Assert.Equal(details.Port, (expectedForInt + index++));
+            Assert.AreEqual(details.ApplicationIntent, expectedForStrings + index++);
+            Assert.AreEqual(details.ApplicationName, expectedForStrings + index++);
+            Assert.AreEqual(details.AttachDbFilename, expectedForStrings + index++);
+            Assert.AreEqual(details.AuthenticationType, expectedForStrings + index++);
+            Assert.AreEqual(details.CurrentLanguage, expectedForStrings + index++);
+            Assert.AreEqual(details.DatabaseName, expectedForStrings + index++);
+            Assert.AreEqual(details.FailoverPartner, expectedForStrings + index++);
+            Assert.AreEqual(details.Password, expectedForStrings + index++);
+            Assert.AreEqual(details.ServerName, expectedForStrings + index++);
+            Assert.AreEqual(details.TypeSystemVersion, expectedForStrings + index++);
+            Assert.AreEqual(details.UserName, expectedForStrings + index++);
+            Assert.AreEqual(details.WorkstationId, expectedForStrings + index++);
+            Assert.AreEqual(details.ConnectRetryInterval, expectedForInt + index++);
+            Assert.AreEqual(details.ConnectRetryCount, expectedForInt + index++);
+            Assert.AreEqual(details.ConnectTimeout, expectedForInt + index++);
+            Assert.AreEqual(details.LoadBalanceTimeout, expectedForInt + index++);
+            Assert.AreEqual(details.MaxPoolSize, expectedForInt + index++);
+            Assert.AreEqual(details.MinPoolSize, expectedForInt + index++);
+            Assert.AreEqual(details.PacketSize, expectedForInt + index++);
+            Assert.AreEqual(details.ColumnEncryptionSetting, expectedForStrings + index++);
+            Assert.AreEqual(details.EnclaveAttestationProtocol, expectedForStrings + index++);
+            Assert.AreEqual(details.EnclaveAttestationUrl, expectedForStrings + index++);
+            Assert.AreEqual(details.Encrypt, (index++ % 2 == 0));
+            Assert.AreEqual(details.MultipleActiveResultSets, (index++ % 2 == 0));
+            Assert.AreEqual(details.MultiSubnetFailover, (index++ % 2 == 0));
+            Assert.AreEqual(details.PersistSecurityInfo, (index++ % 2 == 0));
+            Assert.AreEqual(details.Pooling, (index++ % 2 == 0));
+            Assert.AreEqual(details.Replication, (index++ % 2 == 0));
+            Assert.AreEqual(details.TrustServerCertificate, (index++ % 2 == 0));
+            Assert.AreEqual(details.Port, (expectedForInt + index++));
         }
 
-        [Fact]
+        [Test]
         public void ConnectionDetailsOptionsShouldBeDefinedInConnectionProviderOptions()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -195,7 +196,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
         }
 
 
-        [Fact]
+        [Test]
         public void SettingConnectiomTimeoutToLongShouldStillReturnInt()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -204,27 +205,27 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             int? expectedValue = 30;
             details.Options["connectTimeout"] = timeout;
 
-            Assert.Equal(details.ConnectTimeout, expectedValue);
+            Assert.AreEqual(details.ConnectTimeout, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void ConnectTimeoutShouldReturnNullIfNotSet()
         {
             ConnectionDetails details = new ConnectionDetails();
             int? expectedValue = null;
-            Assert.Equal(details.ConnectTimeout, expectedValue);
+            Assert.AreEqual(details.ConnectTimeout, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void ConnectTimeoutShouldReturnNullIfSetToNull()
         {
             ConnectionDetails details = new ConnectionDetails();
             details.Options["connectTimeout"] = null;
             int? expectedValue = null;
-            Assert.Equal(details.ConnectTimeout, expectedValue);
+            Assert.AreEqual(details.ConnectTimeout, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void SettingEncryptToStringShouldStillReturnBoolean()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -233,10 +234,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             bool? expectedValue = true;
             details.Options["encrypt"] = encrypt;
 
-            Assert.Equal(details.Encrypt, expectedValue);
+            Assert.AreEqual(details.Encrypt, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void SettingEncryptToLowecaseStringShouldStillReturnBoolean()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -245,27 +246,27 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             bool? expectedValue = true;
             details.Options["encrypt"] = encrypt;
 
-            Assert.Equal(details.Encrypt, expectedValue);
+            Assert.AreEqual(details.Encrypt, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void EncryptShouldReturnNullIfNotSet()
         {
             ConnectionDetails details = new ConnectionDetails();
             bool? expectedValue = null;
-            Assert.Equal(details.Encrypt, expectedValue);
+            Assert.AreEqual(details.Encrypt, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void EncryptShouldReturnNullIfSetToNull()
         {
             ConnectionDetails details = new ConnectionDetails();
             details.Options["encrypt"] = null;
             int? expectedValue = null;
-            Assert.Equal(details.ConnectTimeout, expectedValue);
+            Assert.AreEqual(details.ConnectTimeout, expectedValue);
         }
 
-        [Fact]
+        [Test]
         public void SettingConnectiomTimeoutToLongWhichCannotBeConvertedToIntShouldNotCrash()
         {
             ConnectionDetails details = new ConnectionDetails();
@@ -275,8 +276,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             details.Options["connectTimeout"] = timeout;
             details.Options["encrypt"] = true;
 
-            Assert.Equal(details.ConnectTimeout, expectedValue);
-            Assert.Equal(details.Encrypt, true);
+            Assert.AreEqual(details.ConnectTimeout, expectedValue);
+            Assert.AreEqual(true, details.Encrypt);
         }
     }
 }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Connection/DatabaseLocksManagerTests.cs

@@ -6,16 +6,17 @@
 using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.LanguageServices;
 using Moq;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
 {
+    [TestFixture]
     public class DatabaseLocksManagerTests
     {
         private const string server1 = "server1";
         private const string database1 = "database1";
        
-        [Fact]
+        [Test]
         public void GainFullAccessShouldDisconnectTheConnections()
         {
             var connectionLock = new Mock<IConnectedBindingQueue>();
@@ -30,7 +31,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             }
         }
 
-        [Fact]
+        [Test]
         public void ReleaseAccessShouldConnectTheConnections()
         {
             var connectionLock = new Mock<IConnectedBindingQueue>();
@@ -45,7 +46,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             }
         }
 
-        //[Fact]
+        //[Test]
         public void SecondProcessToGainAccessShouldWaitForTheFirstProcess()
         {
             var connectionLock = new Mock<IConnectedBindingQueue>();
@@ -62,9 +63,9 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
                 {
                     secondTimeGettingAccessFails = true;
                 }
-                Assert.Equal(secondTimeGettingAccessFails, true);
+                Assert.AreEqual(true, secondTimeGettingAccessFails);
                 databaseLocksManager.ReleaseAccess(server1, database1);
-                Assert.Equal(databaseLocksManager.GainFullAccessToDatabase(server1, database1), true);
+                Assert.AreEqual(true, databaseLocksManager.GainFullAccessToDatabase(server1, database1));
                 databaseLocksManager.ReleaseAccess(server1, database1);
             }
         }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Connection/ReliableConnectionTests.cs

@@ -7,16 +7,17 @@ using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection;
 using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
 {
+    [TestFixture]
     /// <summary>
     /// Tests for ReliableConnection code
     /// </summary>
     public class ReliableConnectionTests
     {
-        [Fact]
+        [Test]
         public void ReliableSqlConnectionUsesAzureToken()
         {
             ConnectionDetails details = TestObjects.GetTestConnectionDetails();
@@ -30,7 +31,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Connection
             var reliableConnection = new ReliableSqlConnection(connectionString, retryPolicy, retryPolicy, azureAccountToken);
 
             // Then the connection's azureAccountToken gets set
-            Assert.Equal(azureAccountToken, reliableConnection.GetUnderlyingConnection().AccessToken);
+            Assert.AreEqual(azureAccountToken, reliableConnection.GetUnderlyingConnection().AccessToken);
         }
     }
 }