Versioing

GoEddie · GoEddie · commit eae6bee23b07 · 2016-09-13T21:43:26.000+01:00
diff --git a/AgileSQLClub.tSQLtTestController/Properties/AssemblyInfo.cs b/AgileSQLClub.tSQLtTestController/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("0.0.70.0")]
+[assembly: AssemblyFileVersion("0.0.70.0")]
diff --git a/AgileSQLClub.tSQLtTestController/TestClass.cs b/AgileSQLClub.tSQLtTestController/TestClass.cs
@@ -187,7 +187,6 @@ public tSQLtExtendedProperty(string schemaName)
     public class TestFinder
     {
         private readonly List<string> _filePaths;
-        private readonly string _lookupPath;
         private readonly TSqlParser _parser;
 
         public TestFinder(TSqlParser parser, List<string> filePaths)
diff --git a/XMLTestAdapterVSIX/Properties/AssemblyInfo.cs b/XMLTestAdapterVSIX/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("0.0.70.0")]
+[assembly: AssemblyFileVersion("0.0.70.0")]
diff --git a/XMLTestAdapterVSIX/source.extension.vsixmanifest b/XMLTestAdapterVSIX/source.extension.vsixmanifest
@@ -1,14 +1,14 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
   <Metadata>
-    <Identity Id="AgileSQLClub.tSQLtTestAdapter" Version="0.63" Language="en-US" Publisher="EdElliott" />
+    <Identity Id="AgileSQLClub.tSQLtTestAdapter" Version="0.70" Language="en-US" Publisher="EdElliott" />
     <DisplayName>tSQLt Test Adapter</DisplayName>
     <Description xml:space="preserve">Unit Test Adapter for tSQLt Tests</Description>
-    <MoreInfo>https://the.agilsql.club/projects/tSQLt-Test-Adapter</MoreInfo>
+    <MoreInfo>https://the.agilesql.club/projects/tSQLt-Test-Adapter</MoreInfo>
     <License>LICENSE</License>
     <Tags>tSQLt, Test, Adapter</Tags>
   </Metadata>
-  <Installation>
+  <Installation InstalledByMsi="true">
     <InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[14.0,15.0)" />
     <InstallationTarget Version="[14.0,15.0)" Id="Microsoft.VisualStudio.Ultimate" />
     <InstallationTarget Version="[14.0,15.0)" Id="Microsoft.VisualStudio.Premium" />
diff --git a/XmlTestAdapter/Properties/AssemblyInfo.cs b/XmlTestAdapter/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")] 
-[assembly: AssemblyVersion("0.0.0.2")]
-[assembly: AssemblyFileVersion("0.0.0.2")]
+[assembly: AssemblyVersion("0.0.0.70")]
+[assembly: AssemblyFileVersion("0.0.0.70")]
diff --git a/XmlTestAdapter/tSQLtTestDiscoverer.cs b/XmlTestAdapter/tSQLtTestDiscoverer.cs
@@ -11,16 +11,23 @@ namespace tSQLtTestAdapter
 {
     [DefaultExecutorUri(Constants.ExecutorUriString)]
     [FileExtension(Constants.FileExtension)]
-    public class XmlTestDiscoverer : ITestDiscoverer
+    public class tSQLtTestDiscoverer : ITestDiscoverer
     {
         private static readonly object _lock = new object();
         private static readonly TestCache _tests = new TestCache();
 
         private static readonly List<Regex> _includePaths = new List<Regex>();
+        private IMessageLogger _logger;
+        private bool _debug;
 
         public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
         {
-            if (string.IsNullOrEmpty(new RunSettings(discoveryContext.RunSettings).GetSetting("TestDatabaseConnectionString")))
+            var settings = new RunSettings(discoveryContext.RunSettings);
+            _logger = logger;
+
+            _debug = settings.GetSetting("tSQLt-TestAdapter-Debug")?.ToLowerInvariant() == "true";
+            
+            if (string.IsNullOrEmpty(settings.GetSetting("TestDatabaseConnectionString")))
             {
                 logger.SendMessage(TestMessageLevel.Informational, "No RunSettings TestDatabaseConnectionString set - will not attempt to discover tests..");
                 return;
@@ -29,11 +36,10 @@ public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discove
             logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...");
             
             var includePath = new RunSettings(discoveryContext.RunSettings).GetSetting("IncludePath");
-            SetPathFilter(includePath);
-
+            
             lock (_lock)
             {
-                GetTests(sources, discoverySink);
+                GetTests(sources, discoverySink, includePath);
             }
 
             if (_tests != null)
@@ -42,7 +48,7 @@ public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discove
                 logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...done - none found");
         }
 
-        public static void SetPathFilter(string includePath)
+        public void SetPathFilter(string includePath)
         {
             _includePaths.Clear();
 
@@ -52,20 +58,32 @@ public static void SetPathFilter(string includePath)
                 {
                     foreach (var part in includePath.Split(';'))
                     {
+                        Debug($"tSQLt-Test-Adapter: Adding filter: {part}");
                         _includePaths.Add(new Regex(part));
                     }
                 }
                 else
                 {
+                    Debug($"tSQLt-Test-Adapter: Adding filter: {includePath}");
                     _includePaths.Add(new Regex(includePath));
                 }
             }
         }
 
-        public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink)
+        private void Debug(string message)
+        {
+            if (_debug)
+                _logger.SendMessage(TestMessageLevel.Informational, message);
+        }
+
+
+        public  List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink, string filter)
         {
             lock (_lock)
             {
+                if(!String.IsNullOrEmpty(filter))
+                    SetPathFilter(filter);
+
                 var tests = new List<TestCase>();
 
                 foreach (var source in sources)
@@ -81,15 +99,15 @@ public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDisc
                     foreach (var test in testClass.Tests)
                     {
                         var testCase = new TestCase(string.Format("{0}.{1}", testClass.Name, test.Name), tSQLtTestExecutor.ExecutorUri, test.Path);
-
-
+                        
                         testCase.LineNumber = test.Line;
                         testCase.CodeFilePath = test.Path;
 
                         tests.Add(testCase);
-
+                        Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name}.{test.Name}");
                         if (discoverySink != null)
                         {
+                            Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name}.{test.Name} - SENDING TO discoverSink");
                             discoverySink.SendTestCase(testCase);
                         }
                     }
@@ -101,7 +119,7 @@ public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDisc
                         tcClass.CodeFilePath = testClass.Path;
 
                         tests.Add(tcClass);
-
+                        Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name} - SENDING test class wrapper");
                         discoverySink.SendTestCase(tcClass);
                     }
                 }
diff --git a/XmlTestAdapter/tSQLtTestExecutor.cs b/XmlTestAdapter/tSQLtTestExecutor.cs
@@ -16,16 +16,22 @@ public class tSQLtTestExecutor : ITestExecutor
     {
         public void RunTests(IEnumerable<string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle)
         {
-            XmlTestDiscoverer.SetPathFilter(new RunSettings(runContext.RunSettings).GetSetting("IncludePath"));
-            IEnumerable<TestCase> tests = XmlTestDiscoverer.GetTests(sources, null);
+            var discoverer = new tSQLtTestDiscoverer();
+            IEnumerable<TestCase> tests = discoverer.GetTests(sources, null, new RunSettings(runContext.RunSettings).GetSetting("IncludePath"));
             RunTests(tests, runContext, frameworkHandle);
         }
 
         public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)
         {
-            m_cancelled = false;
-            
-            var connectionString =new RunSettings(runContext.RunSettings).GetSetting("TestDatabaseConnectionString");
+
+
+            _cancelled = false;
+            var settings = new RunSettings(runContext.RunSettings);
+
+            var connectionString = settings.GetSetting("TestDatabaseConnectionString");
+            var debug = settings.GetSetting("tSQLt-TestAdapter-Debug")?.ToLowerInvariant() == "true";
+
+
             if (String.IsNullOrEmpty(connectionString))
             {
                 frameworkHandle.SendMessage(TestMessageLevel.Error, @"No connection string found. You need to specify a run setting with the name ""TestDatabaseConnectionString"". Create a .runsettings file a sample is: 
@@ -49,26 +55,39 @@ public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrame
 
             foreach (TestCase test in tests)
             {
-                if (m_cancelled)
+                if (_cancelled)
                     break;
                
                 var testResult = new TestResult(test);
                 var testSession = new tSQLtTestRunner(connectionString);
+
+                Debug(debug, frameworkHandle, $"running test {test.DisplayName}");
+
                 var result = Run(testSession, test);
 
+                Debug(debug, frameworkHandle, $"running test {test.DisplayName}...done");
+
                 if (null == result)
                 {
                     continue;
                 }
 
                 testResult.Outcome = result.Passed() ? TestOutcome.Passed : TestOutcome.Failed;
                 testResult.ErrorMessage += result.FailureMessages();
-
+                
+                Debug(debug, frameworkHandle, $"test passed: {result.Passed()} failureMessages: {result.FailureMessages()}, ErrorMessage: {testResult.ErrorMessage}");
+                
                 frameworkHandle.RecordResult(testResult);
             }
 
         }
 
+        private static void Debug(bool debug, IFrameworkHandle frameworkHandle, string message)
+        {
+            if(debug)
+                frameworkHandle.SendMessage(TestMessageLevel.Informational, message);
+        }
+
         private static TestSuites Run(tSQLtTestRunner testSession, TestCase test)
         {
             if(test.DisplayName.Contains("."))
@@ -79,11 +98,11 @@ private static TestSuites Run(tSQLtTestRunner testSession, TestCase test)
 
         public void Cancel()
         {
-            m_cancelled = true;
+            _cancelled = true;
         }
 
         public static readonly Uri ExecutorUri = new Uri(Constants.ExecutorUriString);
-        private bool m_cancelled;
+        private bool _cancelled;
     }
 
     public static class Constants

Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,6 @@ public tSQLtExtendedProperty(string schemaName)`
`187`	`187`	`public class TestFinder`
`188`	`188`	`{`
`189`	`189`	`private readonly List<string> _filePaths;`
`190`		`- private readonly string _lookupPath;`
`191`	`190`	`private readonly TSqlParser _parser;`
`192`	`191`
`193`	`192`	`public TestFinder(TSqlParser parser, List<string> filePaths)`
Original file line number	Diff line number	Diff line change
`@@ -11,16 +11,23 @@ namespace tSQLtTestAdapter`
`11`	`11`	`{`
`12`	`12`	`[DefaultExecutorUri(Constants.ExecutorUriString)]`
`13`	`13`	`[FileExtension(Constants.FileExtension)]`
`14`		`- public class XmlTestDiscoverer : ITestDiscoverer`
	`14`	`+ public class tSQLtTestDiscoverer : ITestDiscoverer`
`15`	`15`	`{`
`16`	`16`	`private static readonly object _lock = new object();`
`17`	`17`	`private static readonly TestCache _tests = new TestCache();`
`18`	`18`
`19`	`19`	`private static readonly List<Regex> _includePaths = new List<Regex>();`
	`20`	`+ private IMessageLogger _logger;`
	`21`	`+ private bool _debug;`
`20`	`22`
`21`	`23`	`public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)`
`22`	`24`	`{`
`23`		`- if (string.IsNullOrEmpty(new RunSettings(discoveryContext.RunSettings).GetSetting("TestDatabaseConnectionString")))`
	`25`	`+ var settings = new RunSettings(discoveryContext.RunSettings);`
	`26`	`+ _logger = logger;`
	`27`	`+`
	`28`	`+ _debug = settings.GetSetting("tSQLt-TestAdapter-Debug")?.ToLowerInvariant() == "true";`
	`29`	`+`
	`30`	`+ if (string.IsNullOrEmpty(settings.GetSetting("TestDatabaseConnectionString")))`
`24`	`31`	`{`
`25`	`32`	`logger.SendMessage(TestMessageLevel.Informational, "No RunSettings TestDatabaseConnectionString set - will not attempt to discover tests..");`
`26`	`33`	`return;`
`@@ -29,11 +36,10 @@ public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discove`
`29`	`36`	`logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...");`
`30`	`37`
`31`	`38`	`var includePath = new RunSettings(discoveryContext.RunSettings).GetSetting("IncludePath");`
`32`		`- SetPathFilter(includePath);`
`33`		`-`
	`39`	`+`
`34`	`40`	`lock (_lock)`
`35`	`41`	`{`
`36`		`- GetTests(sources, discoverySink);`
	`42`	`+ GetTests(sources, discoverySink, includePath);`
`37`	`43`	`}`
`38`	`44`
`39`	`45`	`if (_tests != null)`
`@@ -42,7 +48,7 @@ public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discove`
`42`	`48`	`logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...done - none found");`
`43`	`49`	`}`
`44`	`50`
`45`		`- public static void SetPathFilter(string includePath)`
	`51`	`+ public void SetPathFilter(string includePath)`
`46`	`52`	`{`
`47`	`53`	`_includePaths.Clear();`
`48`	`54`
`@@ -52,20 +58,32 @@ public static void SetPathFilter(string includePath)`
`52`	`58`	`{`
`53`	`59`	`foreach (var part in includePath.Split(';'))`
`54`	`60`	`{`
	`61`	`+ Debug($"tSQLt-Test-Adapter: Adding filter: {part}");`
`55`	`62`	`_includePaths.Add(new Regex(part));`
`56`	`63`	`}`
`57`	`64`	`}`
`58`	`65`	`else`
`59`	`66`	`{`
	`67`	`+ Debug($"tSQLt-Test-Adapter: Adding filter: {includePath}");`
`60`	`68`	`_includePaths.Add(new Regex(includePath));`
`61`	`69`	`}`
`62`	`70`	`}`
`63`	`71`	`}`
`64`	`72`
`65`		`- public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink)`
	`73`	`+ private void Debug(string message)`
	`74`	`+ {`
	`75`	`+ if (_debug)`
	`76`	`+ _logger.SendMessage(TestMessageLevel.Informational, message);`
	`77`	`+ }`
	`78`	`+`
	`79`	`+`
	`80`	`+ public List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink, string filter)`
`66`	`81`	`{`
`67`	`82`	`lock (_lock)`
`68`	`83`	`{`
	`84`	`+ if(!String.IsNullOrEmpty(filter))`
	`85`	`+ SetPathFilter(filter);`
	`86`	`+`
`69`	`87`	`var tests = new List<TestCase>();`
`70`	`88`
`71`	`89`	`foreach (var source in sources)`
`@@ -81,15 +99,15 @@ public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDisc`
`81`	`99`	`foreach (var test in testClass.Tests)`
`82`	`100`	`{`
`83`	`101`	`var testCase = new TestCase(string.Format("{0}.{1}", testClass.Name, test.Name), tSQLtTestExecutor.ExecutorUri, test.Path);`
`84`		`-`
`85`		`-`
	`102`	`+`
`86`	`103`	`testCase.LineNumber = test.Line;`
`87`	`104`	`testCase.CodeFilePath = test.Path;`
`88`	`105`
`89`	`106`	`tests.Add(testCase);`
`90`		`-`
	`107`	`+ Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name}.{test.Name}");`
`91`	`108`	`if (discoverySink != null)`
`92`	`109`	`{`
	`110`	`+ Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name}.{test.Name} - SENDING TO discoverSink");`
`93`	`111`	`discoverySink.SendTestCase(testCase);`
`94`	`112`	`}`
`95`	`113`	`}`
`@@ -101,7 +119,7 @@ public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDisc`
`101`	`119`	`tcClass.CodeFilePath = testClass.Path;`
`102`	`120`
`103`	`121`	`tests.Add(tcClass);`
`104`		`-`
	`122`	`+ Debug($"tSQLt-Test-Adapter Adding test case {testClass.Name} - SENDING test class wrapper");`
`105`	`123`	`discoverySink.SendTestCase(tcClass);`
`106`	`124`	`}`
`107`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,16 +16,22 @@ public class tSQLtTestExecutor : ITestExecutor`
`16`	`16`	`{`
`17`	`17`	`public void RunTests(IEnumerable<string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle)`
`18`	`18`	`{`
`19`		`- XmlTestDiscoverer.SetPathFilter(new RunSettings(runContext.RunSettings).GetSetting("IncludePath"));`
`20`		`- IEnumerable<TestCase> tests = XmlTestDiscoverer.GetTests(sources, null);`
	`19`	`+ var discoverer = new tSQLtTestDiscoverer();`
	`20`	`+ IEnumerable<TestCase> tests = discoverer.GetTests(sources, null, new RunSettings(runContext.RunSettings).GetSetting("IncludePath"));`
`21`	`21`	`RunTests(tests, runContext, frameworkHandle);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)`
`25`	`25`	`{`
`26`		`- m_cancelled = false;`
`27`		`-`
`28`		`- var connectionString =new RunSettings(runContext.RunSettings).GetSetting("TestDatabaseConnectionString");`
	`26`	`+`
	`27`	`+`
	`28`	`+ _cancelled = false;`
	`29`	`+ var settings = new RunSettings(runContext.RunSettings);`
	`30`	`+`
	`31`	`+ var connectionString = settings.GetSetting("TestDatabaseConnectionString");`
	`32`	`+ var debug = settings.GetSetting("tSQLt-TestAdapter-Debug")?.ToLowerInvariant() == "true";`
	`33`	`+`
	`34`	`+`
`29`	`35`	`if (String.IsNullOrEmpty(connectionString))`
`30`	`36`	`{`
`31`	`37`	`frameworkHandle.SendMessage(TestMessageLevel.Error, @"No connection string found. You need to specify a run setting with the name ""TestDatabaseConnectionString"". Create a .runsettings file a sample is:`
`@@ -49,26 +55,39 @@ public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrame`
`49`	`55`
`50`	`56`	`foreach (TestCase test in tests)`
`51`	`57`	`{`
`52`		`- if (m_cancelled)`
	`58`	`+ if (_cancelled)`
`53`	`59`	`break;`
`54`	`60`
`55`	`61`	`var testResult = new TestResult(test);`
`56`	`62`	`var testSession = new tSQLtTestRunner(connectionString);`
	`63`	`+`
	`64`	`+ Debug(debug, frameworkHandle, $"running test {test.DisplayName}");`
	`65`	`+`
`57`	`66`	`var result = Run(testSession, test);`
`58`	`67`
	`68`	`+ Debug(debug, frameworkHandle, $"running test {test.DisplayName}...done");`
	`69`	`+`
`59`	`70`	`if (null == result)`
`60`	`71`	`{`
`61`	`72`	`continue;`
`62`	`73`	`}`
`63`	`74`
`64`	`75`	`testResult.Outcome = result.Passed() ? TestOutcome.Passed : TestOutcome.Failed;`
`65`	`76`	`testResult.ErrorMessage += result.FailureMessages();`
`66`		`-`
	`77`	`+`
	`78`	`+ Debug(debug, frameworkHandle, $"test passed: {result.Passed()} failureMessages: {result.FailureMessages()}, ErrorMessage: {testResult.ErrorMessage}");`
	`79`	`+`
`67`	`80`	`frameworkHandle.RecordResult(testResult);`
`68`	`81`	`}`
`69`	`82`
`70`	`83`	`}`
`71`	`84`
	`85`	`+ private static void Debug(bool debug, IFrameworkHandle frameworkHandle, string message)`
	`86`	`+ {`
	`87`	`+ if(debug)`
	`88`	`+ frameworkHandle.SendMessage(TestMessageLevel.Informational, message);`
	`89`	`+ }`
	`90`	`+`
`72`	`91`	`private static TestSuites Run(tSQLtTestRunner testSession, TestCase test)`
`73`	`92`	`{`
`74`	`93`	`if(test.DisplayName.Contains("."))`
`@@ -79,11 +98,11 @@ private static TestSuites Run(tSQLtTestRunner testSession, TestCase test)`
`79`	`98`
`80`	`99`	`public void Cancel()`
`81`	`100`	`{`
`82`		`- m_cancelled = true;`
	`101`	`+ _cancelled = true;`
`83`	`102`	`}`
`84`	`103`
`85`	`104`	`public static readonly Uri ExecutorUri = new Uri(Constants.ExecutorUriString);`
`86`		`- private bool m_cancelled;`
	`105`	`+ private bool _cancelled;`
`87`	`106`	`}`
`88`	`107`
`89`	`108`	`public static class Constants`