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/Credentials/CredentialServiceTests.cs

@@ -12,16 +12,17 @@ using Microsoft.SqlTools.Credentials.Contracts;
 using Microsoft.SqlTools.Credentials.Linux;
 using Microsoft.SqlTools.ServiceLayer.Test.Common.RequestContextMocking;
 using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
 {
+    [TestFixture]
     /// <summary>
     /// Credential Service tests that should pass on all platforms, regardless of backing store.
     /// These tests run E2E, storing values in the native credential store for whichever platform
     /// tests are being run on
     /// </summary>
-    public class CredentialServiceTests : IDisposable
+    public class CredentialServiceTests
     {
         private static readonly StoreConfig Config = new StoreConfig
         {
@@ -39,18 +40,18 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
 
         // Test-owned credential store used to clean up before/after tests to ensure code works as expected
         // even if previous runs stopped midway through
-        private readonly ICredentialStore credStore;
-        private readonly CredentialService service;
-        /// <summary>
-        /// Constructor called once for every test
-        /// </summary>
-        public CredentialServiceTests()
+        private ICredentialStore credStore;
+        private CredentialService service;
+        
+        [SetUp]
+        public void SetupCredentialServiceTests()
         {
             credStore = CredentialService.GetStoreForOS(Config);
             service = new CredentialService(credStore, Config);
             DeleteDefaultCreds();
         }
 
+        [TearDown]
         public void Dispose()
         {
             DeleteDefaultCreds();
@@ -73,7 +74,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
 #endif
         }
 
-        [Fact]
+        [Test]
         public async Task SaveCredentialThrowsIfCredentialIdMissing()
         {
             string errorResponse = null;
@@ -81,10 +82,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
 
             await service.HandleSaveCredentialRequest(new Credential(null), contextMock.Object);
             TestUtils.VerifyErrorSent(contextMock);
-            Assert.Contains("ArgumentException", errorResponse);
+            Assert.That(errorResponse, Does.Contain("ArgumentException"));
         }
 
-        [Fact]
+        [Test]
         public async Task SaveCredentialThrowsIfPasswordMissing()
         {
             string errorResponse = null;
@@ -95,7 +96,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
             Assert.True(errorResponse.Contains("ArgumentException") || errorResponse.Contains("ArgumentNullException"));
         }
 
-        [Fact]
+        [Test]
         public async Task SaveCredentialWorksForSingleCredential()
         {
             await TestUtils.RunAndVerify<bool>(
@@ -103,7 +104,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 verify: Assert.True);
         }
 
-        [Fact]
+        [Test]
         public async Task SaveCredentialWorksForEmptyPassword()
         {
             await TestUtils.RunAndVerify<bool>(
@@ -111,7 +112,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 verify: Assert.True);
         }
 
-        [Fact]
+        [Test]
         public async Task SaveCredentialSupportsSavingCredentialMultipleTimes()
         {
             await TestUtils.RunAndVerify<bool>(
@@ -123,7 +124,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 verify: Assert.True);
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialWorksForSingleCredential()
         {
             // Given we have saved the credential
@@ -137,11 +138,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 test: (requestContext) => service.HandleReadCredentialRequest(new Credential(CredentialId, null), requestContext),
                 verify: (actual =>
                 {
-                    Assert.Equal(Password1, actual.Password);
+                    Assert.AreEqual(Password1, actual.Password);
                 }));
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialWorksForMultipleCredentials()
         {
 
@@ -159,17 +160,17 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 test: (requestContext) => service.HandleReadCredentialRequest(new Credential(CredentialId, null), requestContext),
                 verify: (actual =>
                 {
-                    Assert.Equal(Password1, actual.Password);
+                    Assert.AreEqual(Password1, actual.Password);
                 }));
             await TestUtils.RunAndVerify<Credential>(
                 test: (requestContext) => service.HandleReadCredentialRequest(new Credential(OtherCredId, null), requestContext),
                 verify: (actual =>
                 {
-                    Assert.Equal(OtherPassword, actual.Password);
+                    Assert.AreEqual(OtherPassword, actual.Password);
                 }));
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialHandlesPasswordUpdate()
         {
             // Given we have saved twice with a different password
@@ -187,11 +188,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 test: (requestContext) => service.HandleReadCredentialRequest(new Credential(CredentialId), requestContext),
                 verify: (actual =>
                 {
-                    Assert.Equal(Password2, actual.Password);
+                    Assert.AreEqual(Password2, actual.Password);
                 }));
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialThrowsIfCredentialIsNull()
         {
             string errorResponse = null;
@@ -200,10 +201,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
             // Verify throws on null, and this is sent as an error
             await service.HandleReadCredentialRequest(null, contextMock.Object);
             TestUtils.VerifyErrorSent(contextMock);
-            Assert.Contains("ArgumentNullException", errorResponse);
+            Assert.That(errorResponse, Does.Contain("ArgumentNullException"));
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialThrowsIfIdMissing()
         {
             string errorResponse = null;
@@ -212,10 +213,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
             // Verify throws with no ID
             await service.HandleReadCredentialRequest(new Credential(), contextMock.Object);
             TestUtils.VerifyErrorSent(contextMock);
-            Assert.Contains("ArgumentException", errorResponse);
+            Assert.That(errorResponse, Does.Contain("ArgumentException"));
         }
 
-        [Fact]
+        [Test]
         public async Task ReadCredentialReturnsNullPasswordForMissingCredential()
         {
             // Given a credential whose password doesn't exist
@@ -228,12 +229,12 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
                 verify: (actual =>
                 {
                     Assert.NotNull(actual);
-                    Assert.Equal(credWithNoPassword, actual.CredentialId);
+                    Assert.AreEqual(credWithNoPassword, actual.CredentialId);
                     Assert.Null(actual.Password);
                 }));
         }
 
-        [Fact]
+        [Test]
         public async Task DeleteCredentialThrowsIfIdMissing()
         {
             object errorResponse = null;
@@ -245,7 +246,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
             Assert.True(((string)errorResponse).Contains("ArgumentException"));
         }
 
-        [Fact]
+        [Test]
         public async Task DeleteCredentialReturnsTrueOnlyIfCredentialExisted()
         {
             // Save should be true

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Credentials/Linux/LinuxInteropTests.cs

@@ -6,13 +6,14 @@
 using Microsoft.SqlTools.Credentials;
 using Microsoft.SqlTools.Credentials.Linux;
 using Microsoft.SqlTools.ServiceLayer.Test.Common;
-using Xunit;
-
+using NUnit.Framework;
+
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Linux
 {
+    [TestFixture]
     public class LinuxInteropTests
     {
-        [Fact]
+        [Test]
         public void GetEUidReturnsInt()
         {
 #if !WINDOWS_ONLY_BUILD           
@@ -23,14 +24,14 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Linux
 #endif           
         }
 
-        [Fact]
+        [Test]
         public void GetHomeDirectoryFromPwFindsHomeDir()
         {
 #if !WINDOWS_ONLY_BUILD
             RunIfWrapper.RunIfLinux(() =>
             {
                 string userDir = LinuxCredentialStore.GetHomeDirectoryFromPw();
-                Assert.StartsWith("/", userDir);
+                Assert.That(userDir, Does.StartWith("/"), "GetHomeDirectoryFromPw");
             });
 #endif
         }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Credentials/Win32/CredentialSetTests.cs

@@ -6,13 +6,14 @@
 using System;
 using Microsoft.SqlTools.Credentials.Win32;
 using Microsoft.SqlTools.ServiceLayer.Test.Common;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
 {
+    [TestFixture]
     public class CredentialSetTests
     {
-        [Fact]
+        [Test]
         public void CredentialSetCreate()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -21,7 +22,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void CredentialSetCreateWithTarget()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -30,7 +31,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void CredentialSetShouldBeIDisposable()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -39,7 +40,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void CredentialSetLoad()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -56,7 +57,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
                 CredentialSet set = new CredentialSet();
                 set.Load();
                 Assert.NotNull(set);
-                Assert.NotEmpty(set);
+                Assert.That(set, Is.Not.Empty);
 
                 credential.Delete();
 
@@ -64,19 +65,19 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void CredentialSetLoadShouldReturnSelf()
         {
             RunIfWrapper.RunIfWindows(() =>
             {
                 CredentialSet set = new CredentialSet();
-                Assert.IsType<CredentialSet>(set.Load());
+                Assert.That(set.Load(), Is.SameAs(set));
 
                 set.Dispose();
             });
         }
 
-        [Fact]
+        [Test]
         public void CredentialSetLoadWithTargetFilter()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -90,7 +91,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
                 credential.Save();
 
                 CredentialSet set = new CredentialSet("filtertarget");
-                Assert.Equal(1, set.Load().Count);
+                Assert.AreEqual(1, set.Load().Count);
                 set.Dispose();
             });
         }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Credentials/Win32/Win32CredentialTests.cs

@@ -6,13 +6,14 @@
 using System;
 using Microsoft.SqlTools.Credentials.Win32;
 using Microsoft.SqlTools.ServiceLayer.Test.Common;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
 {
+    [TestFixture]
     public class Win32CredentialTests
     {
-        [Fact]
+        [Test]
         public void Credential_Create_ShouldNotThrowNull()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -21,7 +22,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Create_With_Username_ShouldNotThrowNull()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -30,7 +31,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Create_With_Username_And_Password_ShouldNotThrowNull()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -39,7 +40,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Create_With_Username_Password_Target_ShouldNotThrowNull()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -48,7 +49,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_ShouldBe_IDisposable()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -57,7 +58,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
         
-        [Fact]
+        [Test]
         public void Credential_Dispose_ShouldNotThrowException()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -66,7 +67,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_ShouldThrowObjectDisposedException()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -77,7 +78,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Save()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -88,7 +89,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
         
-        [Fact]
+        [Test]
         public void Credential_Delete()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -98,7 +99,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Delete_NullTerminator()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -109,7 +110,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
             });
         }
        
-        [Fact]
+        [Test]
         public void Credential_Load()
         {
             RunIfWrapper.RunIfWindows(() =>
@@ -120,15 +121,15 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials.Win32
                 Win32Credential credential = new Win32Credential { Target = "target", Type = CredentialType.Generic };
                 Assert.True(credential.Load());
 
-                Assert.NotEmpty(credential.Username);
+                Assert.That(credential.Username, Is.Not.Empty);
                 Assert.NotNull(credential.Password);
-                Assert.Equal("username", credential.Username);
-                Assert.Equal("password", credential.Password);
-                Assert.Equal("target", credential.Target);
+                Assert.AreEqual("username", credential.Username);
+                Assert.AreEqual("password", credential.Password);
+                Assert.AreEqual("target", credential.Target);
             });
         }
 
-        [Fact]
+        [Test]
         public void Credential_Exists_Target_ShouldNotBeNull()
         {
             RunIfWrapper.RunIfWindows(() =>