Merge dev to master for 0.0.7 release (#86)

* Disable failing test while investigating

* Made connection errors more user-friendly (#57)

* Bug/negativeOneRowsAffected strings file fix (#61)

* Adding changes to sr.strings files

* Fixing bug by changing valid filename check to fail on whitespace (#55)

Fixing a bug from the unit tests on OSX/Unix where attempting to create a file with a name that's all whitespace succeeds when it should fail. This was passing in Windows because File.Open throws an ArgumentException when an all whitespace name is provided. In Unix systems, File.Open does not throw, causing the test to fail.

Solution is to check for whitespace in the sanity check.

* Format Cell Values (#62)

* WIP for ability to localize cell values

* Changing how DateTimeOffsets are stored, getting unit tests going

* Reworking BufferFileStreamWriter to use dictionary approach

* Plumbing the DbCellValue type the rest of the way through

* Removing unused components to simplify contract

* Cleanup and making sure byte[] appears in parity with SSMS

* CR comments, small tweaks for optimizing LINQ

* Feature/batch line info (#56)

* inital pipe of line numbers and getting text from workspace services

* tests compile

* Fixed bug regarding tests using connections on mac

* updated tests

* fixed workspace service and fixed tests

* integrated feedback

* Remove deleted file with whitespace name

* Feature/autocomp options (#63)

* Enable IntelliSense settings

* Fix up some bugs in the IntelliSense settings.

* Code cleans for PR

* Fix a couple exceptions that are breaks query execute and intellisense.

* Add useLowerCase flag and settings tests

* Remove task.wait from test to avoid break on build machine. (#67)

This is to fix test breaks so I'll merge now.  Please let me know if there are comments on this commit.

* Do not use ReliableCommand in the query execution service (#66)

* Do not use ReliableCommand in the query execution service.

* Fixing the logic to remove InfoMessage handlers from ReliableSqlConnection

* Adding test to query UDT

* Bump SMO to 140.1.6 to pick up perf fixes (#69)

* Enable Quick Info hover tooltips (#65)

Pushing to include in tomorrow's partner release build.  Please send me any feedback and I'll address in the next Intellisense PR.

* Added grouping between system/user dbs when listing (#70)

* Feature/timestamp messages (#68)

* added support for timestamps

* fixed tests

* Moved message class to own file; added 'z' to end of date strings

* added default time constructor

* removed unnecessary z

* added time string format info in comment

* changed from utc time to using local time

* Feature/save selection (#64)

* Save selection

* Add tests

* Change filename in test

* Code cleanup

* Refactor handler

* Code cleanup

* Modify tests to have query selection

* Change variable declaration

* Bump SMO to 14.0.7 to pick Batchparser updates (#72)

...bumping versions.  No review needed.

* Lingering File Handles (#71)

Fixing a bug where in various situations, the files used for temporary storage of query results would be leftover. In particular, the following changes were made:
* When the dispose query request is submitted, the corresponding query is now disposed in addition from being removed from the list of active queries
* When a query is cancelled, it is disposed after it is cancelled
* If a query already exists for a given ownerURI, the existing query is disposed before creating a new query
* All queries are disposed when the query execution service is disposed (ie, at shutdown of the service)

A unit test to verify the action of the dispose method for a ResultSet was added.

* Ensuring queries are disposed

Adding logic to dispose any queries when:
* URI that already has a query executes another query
* A request to dispose a query is submitted
* A request to cancel a query is submitted

* Small tweaks for cleanup of query execution service

* Add IntelliSense binding queue (#73)

* Initial code for binding queue

* Fix-up some of the timeout wait code

* Add some initial test code

* Add missing test file

* Update the binding queue tests

* Add more test coverage and refactor a bit.  Disable reliabile connection until we can fix it..it's holding an open data reader connection.

* A few more test updates

* Initial integrate queue with language service.

* Hook up the connected binding queue into al binding calls.

* Cleanup comments and remove dead code

* More missing comments

* Fix build break.  Reenable ReliabileConnection.

* Revert all changes to SqlConnectionFactory

* Resolve merge conflicts

* Cleanup some more of the timeouts and sync code

* Address code review feedback

* Address more code review feedback

* Feature/connect cancel (#74)

* Implemented connection cancellation

* Made connect requests return immediately and created a separate connection complete notification

* Fix spelling

* Fix sorting

* Add separate lock for cancellation source map

* Fix an issue with queue deadlocks causing test failures (#77)

* Fixed issue where connecting could take very long and cancellation would not work (#78)

* Fixed issue where connecting could take very long and cancellation would not work

* Addressing feedback

* Remove warning suppression

* Adding unlimited timeout for query execution (#76)

Adding explicitly setting the timeout for command execution to unlimited. We can change this to be user configurable at a later time

* Support 'for XML and for JSON' queries (#75)

* Set isXMl and isJson for 'for xml/json' resultSets

* Change string comparison

* Modify if-else

* VSTS 8499785. Close SqlToolsService after VS Code exits. (#80)

VSTS 8499785. Close SqlToolsService after VS Code exits.

* Remove extra level of tasks in binding queue (#79)

* Remove extra layer of tasks in binding queue

* Change order of assigning result to avoid race condition

* Add timeout log for the metadata lock event

* Fix test cases

test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs

@@ -8,6 +8,7 @@ using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
@@ -52,6 +53,214 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
             return connectionMock.Object;
         }
 
+        [Fact]
+        public void CanCancelConnectRequest()
+        {
+            var testFile = "file:///my/test/file.sql";
+
+            // Given a connection that times out and responds to cancellation
+            var mockConnection = new Mock<DbConnection> { CallBase = true };
+            CancellationToken token;
+            bool ready = false;
+            mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny<CancellationToken>()))
+                .Callback<CancellationToken>(t => 
+                {
+                    // Pass the token to the return handler and signal the main thread to cancel
+                    token = t;
+                    ready = true;
+                })
+                .Returns(() => 
+                {
+                    if (TestUtils.WaitFor(() => token.IsCancellationRequested))
+                    {
+                        throw new OperationCanceledException();
+                    }
+                    else
+                    {
+                        return Task.FromResult(true);
+                    }
+                });
+
+            var mockFactory = new Mock<ISqlConnectionFactory>();
+            mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny<string>()))
+                .Returns(mockConnection.Object);
+
+
+            var connectionService = new ConnectionService(mockFactory.Object);
+
+            // Connect the connection asynchronously in a background thread
+            var connectionDetails = TestObjects.GetTestConnectionDetails();
+            var connectTask = Task.Run(async () => 
+            {
+                return await connectionService
+                    .Connect(new ConnectParams()
+                    {
+                        OwnerUri = testFile,
+                        Connection = connectionDetails
+                    });
+            });
+
+            // Wait for the connection to call OpenAsync()
+            Assert.True(TestUtils.WaitFor(() => ready));
+
+            // Send a cancellation request
+            var cancelResult = connectionService
+                .CancelConnect(new CancelConnectParams()
+                {
+                    OwnerUri = testFile
+                });
+
+            // Wait for the connection task to finish
+            connectTask.Wait();
+            
+            // Verify that the connection was cancelled (no connection was created)
+            Assert.Null(connectTask.Result.ConnectionId);
+
+            // Verify that the cancel succeeded
+            Assert.True(cancelResult);
+        }
+
+        [Fact]
+        public async void CanCancelConnectRequestByConnecting()
+        {
+            var testFile = "file:///my/test/file.sql";
+
+            // Given a connection that times out and responds to cancellation
+            var mockConnection = new Mock<DbConnection> { CallBase = true };
+            CancellationToken token;
+            bool ready = false;
+            mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny<CancellationToken>()))
+                .Callback<CancellationToken>(t => 
+                {
+                    // Pass the token to the return handler and signal the main thread to cancel
+                    token = t;
+                    ready = true;
+                })
+                .Returns(() => 
+                {
+                    if (TestUtils.WaitFor(() => token.IsCancellationRequested))
+                    {
+                        throw new OperationCanceledException();
+                    }
+                    else
+                    {
+                        return Task.FromResult(true);
+                    }
+                });
+            
+            // Given a second connection that succeeds
+            var mockConnection2 = new Mock<DbConnection> { CallBase = true };
+            mockConnection2.Setup(x => x.OpenAsync(Moq.It.IsAny<CancellationToken>()))
+                .Returns(() => Task.Run(() => {}));
+
+            var mockFactory = new Mock<ISqlConnectionFactory>();
+            mockFactory.SetupSequence(factory => factory.CreateSqlConnection(It.IsAny<string>()))
+                .Returns(mockConnection.Object)
+                .Returns(mockConnection2.Object);
+
+
+            var connectionService = new ConnectionService(mockFactory.Object);
+
+            // Connect the first connection asynchronously in a background thread
+            var connectionDetails = TestObjects.GetTestConnectionDetails();
+            var connectTask = Task.Run(async () => 
+            {
+                return await connectionService
+                    .Connect(new ConnectParams()
+                    {
+                        OwnerUri = testFile,
+                        Connection = connectionDetails
+                    });
+            });
+
+            // Wait for the connection to call OpenAsync()
+            Assert.True(TestUtils.WaitFor(() => ready));
+
+            // Send a cancellation by trying to connect again
+            var connectResult = await connectionService
+                .Connect(new ConnectParams()
+                {
+                    OwnerUri = testFile,
+                    Connection = connectionDetails
+                });
+
+            // Wait for the first connection task to finish
+            connectTask.Wait();
+            
+            // Verify that the first connection was cancelled (no connection was created)
+            Assert.Null(connectTask.Result.ConnectionId);
+
+            // Verify that the second connection succeeded
+            Assert.NotEmpty(connectResult.ConnectionId);
+        }
+
+        [Fact]
+        public void CanCancelConnectRequestByDisconnecting()
+        {
+            var testFile = "file:///my/test/file.sql";
+
+            // Given a connection that times out and responds to cancellation
+            var mockConnection = new Mock<DbConnection> { CallBase = true };
+            CancellationToken token;
+            bool ready = false;
+            mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny<CancellationToken>()))
+                .Callback<CancellationToken>(t => 
+                {
+                    // Pass the token to the return handler and signal the main thread to cancel
+                    token = t;
+                    ready = true;
+                })
+                .Returns(() => 
+                {
+                    if (TestUtils.WaitFor(() => token.IsCancellationRequested))
+                    {
+                        throw new OperationCanceledException();
+                    }
+                    else
+                    {
+                        return Task.FromResult(true);
+                    }
+                });
+
+            var mockFactory = new Mock<ISqlConnectionFactory>();
+            mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny<string>()))
+                .Returns(mockConnection.Object);
+
+
+            var connectionService = new ConnectionService(mockFactory.Object);
+
+            // Connect the first connection asynchronously in a background thread
+            var connectionDetails = TestObjects.GetTestConnectionDetails();
+            var connectTask = Task.Run(async () => 
+            {
+                return await connectionService
+                    .Connect(new ConnectParams()
+                    {
+                        OwnerUri = testFile,
+                        Connection = connectionDetails
+                    });
+            });
+
+            // Wait for the connection to call OpenAsync()
+            Assert.True(TestUtils.WaitFor(() => ready));
+
+            // Send a cancellation by trying to disconnect
+            var disconnectResult = connectionService
+                .Disconnect(new DisconnectParams()
+                {
+                    OwnerUri = testFile
+                });
+
+            // Wait for the first connection task to finish
+            connectTask.Wait();
+            
+            // Verify that the first connection was cancelled (no connection was created)
+            Assert.Null(connectTask.Result.ConnectionId);
+
+            // Verify that the disconnect failed (since it caused a cancellation)
+            Assert.False(disconnectResult);
+        }
+
         /// <summary>
         /// Verify that we can connect to the default database when no database name is
         /// provided as a parameter.
@@ -59,12 +268,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         [Theory]
         [InlineDataAttribute(null)]
         [InlineDataAttribute("")]
-        public void CanConnectWithEmptyDatabaseName(string databaseName)
+        public async void CanConnectWithEmptyDatabaseName(string databaseName)
         {
             // Connect
             var connectionDetails = TestObjects.GetTestConnectionDetails();
             connectionDetails.DatabaseName = databaseName;
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(new ConnectParams()
                 {
@@ -83,7 +292,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         [Theory]
         [InlineDataAttribute("master")]
         [InlineDataAttribute("nonMasterDb")]
-        public void ConnectToDefaultDatabaseRespondsWithActualDbName(string expectedDbName)
+        public async void ConnectToDefaultDatabaseRespondsWithActualDbName(string expectedDbName)
         {
             // Given connecting with empty database name will return the expected DB name
             var connectionMock = new Mock<DbConnection> { CallBase = true };
@@ -99,7 +308,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
             var connectionDetails = TestObjects.GetTestConnectionDetails();
             connectionDetails.DatabaseName = string.Empty;
 
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -118,14 +327,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// connection, we disconnect first before connecting.
         /// </summary>
         [Fact]
-        public void ConnectingWhenConnectionExistCausesDisconnectThenConnect()
+        public async void ConnectingWhenConnectionExistCausesDisconnectThenConnect()
         {
             bool callbackInvoked = false;
 
             // first connect
             string ownerUri = "file://my/sample/file.sql";
             var connectionService = TestObjects.GetTestConnectionService();
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -146,7 +355,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
             );
 
             // send annother connect request
-            connectionResult =
+            connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -165,7 +374,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that when connecting with invalid credentials, an error is thrown.
         /// </summary>
         [Fact]
-        public void ConnectingWithInvalidCredentialsYieldsErrorMessage()
+        public async void ConnectingWithInvalidCredentialsYieldsErrorMessage()
         {
             var testConnectionDetails = TestObjects.GetTestConnectionDetails();
             var invalidConnectionDetails = new ConnectionDetails();
@@ -175,7 +384,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
             invalidConnectionDetails.Password = "invalidPassword";
 
             // Connect to test db with invalid credentials
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(new ConnectParams()
                 {
@@ -204,10 +413,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         [InlineData("Integrated", "file://my/sample/file.sql", null, "test", "sa", "123456")]
         [InlineData("Integrated", "", "my-server", "test", "sa", "123456")]
         [InlineData("Integrated", "file://my/sample/file.sql", "", "test", "sa", "123456")]
-        public void ConnectingWithInvalidParametersYieldsErrorMessage(string authType, string ownerUri, string server, string database, string userName, string password)
+        public async void ConnectingWithInvalidParametersYieldsErrorMessage(string authType, string ownerUri, string server, string database, string userName, string password)
         {
             // Connect with invalid parameters
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(new ConnectParams()
                 {
@@ -238,10 +447,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         [InlineData("sa", "")]
         [InlineData(null, "12345678")]
         [InlineData("", "12345678")]
-        public void ConnectingWithNoUsernameOrPasswordWorksForIntegratedAuth(string userName, string password)
+        public async void ConnectingWithNoUsernameOrPasswordWorksForIntegratedAuth(string userName, string password)
         {
             // Connect
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(new ConnectParams()
                 {
@@ -263,10 +472,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that when connecting with a null parameters object, an error is thrown.
         /// </summary>
         [Fact]
-        public void ConnectingWithNullParametersObjectYieldsErrorMessage()
+        public async void ConnectingWithNullParametersObjectYieldsErrorMessage()
         {
             // Connect with null parameters
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(null);
             
@@ -330,7 +539,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that a connection changed event is fired when the database context changes.
         /// </summary>
         [Fact]
-        public void ConnectionChangedEventIsFiredWhenDatabaseContextChanges()
+        public async void ConnectionChangedEventIsFiredWhenDatabaseContextChanges()
         {
             var serviceHostMock = new Mock<IProtocolEndpoint>();
 
@@ -339,7 +548,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
 
             // Set up an initial connection
             string ownerUri = "file://my/sample/file.sql";
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -364,11 +573,11 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that the SQL parser correctly detects errors in text
         /// </summary>
         [Fact]
-        public void ConnectToDatabaseTest()
+        public async void ConnectToDatabaseTest()
         {
             // connect to a database instance 
             string ownerUri = "file://my/sample/file.sql";
-            var connectionResult =
+            var connectionResult = await
                 TestObjects.GetTestConnectionService()
                 .Connect(new ConnectParams()
                 {
@@ -384,12 +593,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that we can disconnect from an active connection succesfully
         /// </summary>
         [Fact]
-        public void DisconnectFromDatabaseTest()
+        public async void DisconnectFromDatabaseTest()
         {
             // first connect
             string ownerUri = "file://my/sample/file.sql";
             var connectionService = TestObjects.GetTestConnectionService();
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -414,14 +623,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Test that when a disconnect is performed, the callback event is fired
         /// </summary>
         [Fact]
-        public void DisconnectFiresCallbackEvent()
+        public async void DisconnectFiresCallbackEvent()
         {
             bool callbackInvoked = false;
 
             // first connect
             string ownerUri = "file://my/sample/file.sql";
             var connectionService = TestObjects.GetTestConnectionService();
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -458,12 +667,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Test that disconnecting an active connection removes the Owner URI -> ConnectionInfo mapping
         /// </summary>
         [Fact]
-        public void DisconnectRemovesOwnerMapping()
+        public async void DisconnectRemovesOwnerMapping()
         {
             // first connect
             string ownerUri = "file://my/sample/file.sql";
             var connectionService = TestObjects.GetTestConnectionService();
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -498,12 +707,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         [InlineDataAttribute(null)]
         [InlineDataAttribute("")]
 
-        public void DisconnectValidatesParameters(string disconnectUri)
+        public async void DisconnectValidatesParameters(string disconnectUri)
         {
             // first connect
             string ownerUri = "file://my/sample/file.sql";
             var connectionService = TestObjects.GetTestConnectionService();
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -530,7 +739,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verifies the the list databases operation lists database names for the server used by a connection.
         /// </summary>
         [Fact]
-        public void ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames()
+        public async void ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames()
         {
             // Result set for the query of database names
             Dictionary<string, string>[] data =
@@ -550,7 +759,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
 
             // connect to a database instance 
             string ownerUri = "file://my/sample/file.sql";
-            var connectionResult =
+            var connectionResult = await
                 connectionService
                 .Connect(new ConnectParams()
                 {
@@ -579,7 +788,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify that the SQL parser correctly detects errors in text
         /// </summary>
         [Fact]
-        public void OnConnectionCallbackHandlerTest()
+        public async void OnConnectionCallbackHandlerTest()
         {
             bool callbackInvoked = false;
 
@@ -593,7 +802,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
             );
             
             // connect to a database instance 
-            var connectionResult = connectionService.Connect(TestObjects.GetTestConnectionParams());
+            var connectionResult = await connectionService.Connect(TestObjects.GetTestConnectionParams());
 
             // verify that a valid connection id was returned
             Assert.True(callbackInvoked);
@@ -603,14 +812,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
         /// Verify when a connection is created that the URI -> Connection mapping is created in the connection service.
         /// </summary>
         [Fact]
-        public void TestConnectRequestRegistersOwner()
+        public async void TestConnectRequestRegistersOwner()
         {
             // Given a request to connect to a database
             var service = TestObjects.GetTestConnectionService();
             var connectParams = TestObjects.GetTestConnectionParams();
 
             // connect to a database instance 
-            var connectionResult = service.Connect(connectParams);
+            var connectionResult = await service.Connect(connectParams);
 
             // verify that a valid connection id was returned
             Assert.NotNull(connectionResult.ConnectionId);