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/Extensibility/ExtensionTests.cs

@@ -9,51 +9,51 @@ using System.Linq;
 using System.Reflection;
 using Microsoft.SqlTools.Extensibility;
 using Microsoft.SqlTools.ServiceLayer.Formatter;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
 {
     public class ExtensionTests
     {
 
-        [Fact]
+        [Test]
         public void CreateAssemblyStoreShouldFindTypesInAssembly()
         {
             // Given a store for MyExportType
             ExtensionStore store = ExtensionStore.CreateAssemblyStore<MyExportType>(GetType().GetTypeInfo().Assembly);
             // Then should get any export for this type and subtypes
-            Assert.Equal(2, store.GetExports<MyExportType>().Count());
+            Assert.AreEqual(2, store.GetExports<MyExportType>().Count());
 
             // But for a different type, expect throw as the store only contains MyExportType
             Assert.Throws<InvalidCastException>(() => store.GetExports<MyOtherType>().Count());
         }
         
-        [Fact]
+        [Test]
         public void CreateDefaultLoaderShouldFindTypesOnlyInMainAssembly()
         {
             // Given a store created using CreateDefaultLoader
             // Then not should find exports from a different assembly
             ExtensionStore store = ExtensionStore.CreateDefaultLoader<MyExportType>();
-            Assert.Equal(0, store.GetExports<MyExportType>().Count());
+            Assert.AreEqual(0, store.GetExports<MyExportType>().Count());
 
             // And should not find exports that are defined in the ServiceLayer assembly
             store = ExtensionStore.CreateDefaultLoader<ASTNodeFormatterFactory>();
-            Assert.Empty(store.GetExports<ASTNodeFormatterFactory>());            
+            Assert.That(store.GetExports<ASTNodeFormatterFactory>(), Is.Empty);            
         }
 
-        [Fact]
+        [Test]
         public void CreateDefaultServiceProviderShouldFindTypesInAllKnownAssemblies()
         {
             // Given a default ExtensionServiceProvider
             // Then we should not find exports from a test assembly
             ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
-            Assert.Empty(serviceProvider.GetServices<MyExportType>());
+            Assert.That(serviceProvider.GetServices<MyExportType>(), Is.Empty);
 
             // But should find exports that are defined in the main assembly            
-            Assert.NotEmpty(serviceProvider.GetServices<ASTNodeFormatterFactory>());
+            Assert.That(serviceProvider.GetServices<ASTNodeFormatterFactory>(), Is.Not.Empty);
         }
 
-        // [Fact]
+        // [Test]
         public void CreateStoreForCurrentDirectoryShouldFindExportsInDirectory()
         {
             // Given stores created for types in different assemblies
@@ -62,8 +62,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
 
             // When I query exports
             // Then exports for all assemblies should be found
-            Assert.Equal(2, myStore.GetExports<MyExportType>().Count());
-            Assert.NotEmpty(querierStore.GetExports<ASTNodeFormatterFactory>());
+            Assert.AreEqual(2, myStore.GetExports<MyExportType>().Count());
+            Assert.That(querierStore.GetExports<ASTNodeFormatterFactory>(), Is.Not.Empty);
         }        
     }
 

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Extensibility/ServiceProviderTests.cs

@@ -6,19 +6,21 @@
 using System;
 using System.Linq;
 using Microsoft.SqlTools.Extensibility;
-using Xunit;
+using NUnit.Framework;
 
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
 {
     public class ServiceProviderTests
     {
         private RegisteredServiceProvider provider;
-        public ServiceProviderTests()
+
+        [SetUp]
+        public void InitServiceProviderTests()
         {
             provider = new RegisteredServiceProvider();
         }
 
-        [Fact]
+        [Test]
         public void GetServiceShouldReturnNullIfNoServicesRegistered()
         {
             // Given no service registered
@@ -29,7 +31,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
         }
 
 
-        [Fact]
+        [Test]
         public void GetSingleServiceThrowsMultipleServicesRegistered()
         {
             // Given 2 services registered
@@ -39,7 +41,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
             Assert.Throws<InvalidOperationException>(() => provider.GetService<MyProviderService>());
         }
 
-        [Fact]
+        [Test]
         public void GetServicesShouldReturnEmptyIfNoServicesRegistered()
         {
             // Given no service regisstered
@@ -47,36 +49,36 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
             var services = provider.GetServices<MyProviderService>();
             // Then I expect empty enumerable to be returned
             Assert.NotNull(services);
-            Assert.Equal(0, services.Count());
+            Assert.AreEqual(0, services.Count());
         }
 
-        [Fact]
+        [Test]
         public void GetServiceShouldReturnRegisteredService()
         {
             MyProviderService service = new MyProviderService();
             provider.RegisterSingleService(service);
 
             var returnedService = provider.GetService<MyProviderService>();
-            Assert.Equal(service, returnedService);            
+            Assert.AreEqual(service, returnedService);            
         }
 
-        [Fact]
+        [Test]
         public void GetServicesShouldReturnRegisteredServiceWhenMultipleServicesRegistered()
         {
             MyProviderService service = new MyProviderService();
             provider.RegisterSingleService(service);          
 
             var returnedServices = provider.GetServices<MyProviderService>();
-            Assert.Equal(service, returnedServices.Single());
+            Assert.AreEqual(service, returnedServices.Single());
         }
 
-        [Fact]
+        [Test]
         public void RegisterServiceProviderShouldThrowIfServiceIsIncompatible()
         {
             MyProviderService service = new MyProviderService();
             Assert.Throws<InvalidOperationException>(() => provider.RegisterSingleService(typeof(OtherService), service));
         }
-        [Fact]
+        [Test]
         public void RegisterServiceProviderShouldThrowIfServiceAlreadyRegistered()
         {
             MyProviderService service = new MyProviderService();
@@ -85,7 +87,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
             Assert.Throws<InvalidOperationException>(() => provider.RegisterSingleService(service));
         }
         
-        [Fact]
+        [Test]
         public void RegisterShouldThrowIfServiceAlreadyRegistered()
         {
             MyProviderService service = new MyProviderService();
@@ -94,7 +96,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
             Assert.Throws<InvalidOperationException>(() => provider.Register(() => service.SingleItemAsEnumerable()));
         }
 
-        [Fact]
+        [Test]
         public void RegisterShouldThrowIfServicesAlreadyRegistered()
         {
             provider.Register<MyProviderService>(() => new [] { new MyProviderService(), new MyProviderService() });