ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-20 01:25:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

New tool to store SQL connection configs locally (#218)

Browse Source 
* added a new tool to store SQL connections locally. Modified the peek definition tests to create test database before running test


* fixed failing test QueryExecutionPlanInvalidParamsTest

* Fixes based on code review comments

* fixed failing test GetSignatureHelpReturnsNotNullIfParseInfoInitialized
This commit is contained in:
Leila Lali
2017-01-25 16:19:27 -08:00
committed by GitHub
parent 5464e4e63a
commit dcff5dd915
30 changed files with 1176 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Connection/ConnectionServiceTests.cs
View File

@@ -23,14 +23,14 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
public class ConnectionServiceTests
{
[Fact]
public async Task RunningMultipleQueriesCreatesOnlyOneConnection()
public void RunningMultipleQueriesCreatesOnlyOneConnection()
{
// Connect/disconnect twice to ensure reconnection can occur
ConnectionService service = ConnectionService.Instance;
service.OwnerToConnectionMap.Clear();
for (int i = 0; i < 2; i++)
{
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connectionInfo = result.ConnectionInfo;
string uri = connectionInfo.OwnerUri;
@@ -65,11 +65,11 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
}
[Fact]
public async Task DatabaseChangesAffectAllConnections()
public void DatabaseChangesAffectAllConnections()
{
// If we make a connection to a live database
ConnectionService service = ConnectionService.Instance;
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connectionInfo = result.ConnectionInfo;
ConnectionDetails details = connectionInfo.ConnectionDetails;
string uri = connectionInfo.OwnerUri;

52
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Connection/ReliableConnectionTests.cs
View File

@@ -33,8 +33,6 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// </summary>
public class ReliableConnectionTests
{
private TestConnectionProfileService connectionProfileService = new TestConnectionProfileService();
internal class TestDataTransferErrorDetectionStrategy : DataTransferErrorDetectionStrategy
{
public bool InvokeCanRetrySqlException(SqlException exception)
@@ -235,9 +233,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// <summary>
/// Helper method to create an integrated auth connection builder for testing.
/// </summary>
private async Task<SqlConnectionStringBuilder> CreateTestConnectionStringBuilder()
private SqlConnectionStringBuilder CreateTestConnectionStringBuilder()
{
ConnectParams connectParams = await this.connectionProfileService.GetConnectionParametersAsync();
ConnectParams connectParams = TestConnectionProfileService.Instance.GetConnectionParameters(TestServerType.OnPrem);
SqlConnectionStringBuilder csb = new SqlConnectionStringBuilder();
csb.DataSource = connectParams.Connection.ServerName;
csb.IntegratedSecurity = connectParams.Connection.AuthenticationType == AuthenticationType.Integrated.ToString();
@@ -259,9 +257,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// <summary>
/// Helper method to create an integrated auth reliable connection for testing.
/// </summary>
private async Task<DbConnection> CreateTestConnection()
private DbConnection CreateTestConnection()
{
SqlConnectionStringBuilder csb = await CreateTestConnectionStringBuilder();
SqlConnectionStringBuilder csb = CreateTestConnectionStringBuilder();
RetryPolicy connectionRetryPolicy = RetryPolicyFactory.CreateDefaultConnectionRetryPolicy();
RetryPolicy commandRetryPolicy = RetryPolicyFactory.CreateDefaultConnectionRetryPolicy();
@@ -274,10 +272,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Test ReliableConnectionHelper.GetDefaultDatabaseFilePath()
/// </summary>
[Fact]
public async Task TestGetDefaultDatabaseFilePath()
public void TestGetDefaultDatabaseFilePath()
{
var connectionBuilder = await CreateTestConnectionStringBuilder();
var connectionBuilder = CreateTestConnectionStringBuilder();
Assert.NotNull(connectionBuilder);
string filePath = string.Empty;
@@ -301,16 +299,16 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Test ReliableConnectionHelper.GetServerVersion()
/// </summary>
[Fact]
public async Task TestGetServerVersion()
public void TestGetServerVersion()
{
using (var connection = await CreateTestConnection())
using (var connection = CreateTestConnection())
{
Assert.NotNull(connection);
connection.Open();
ReliableConnectionHelper.ServerInfo serverInfo = ReliableConnectionHelper.GetServerVersion(connection);
ReliableConnectionHelper.ServerInfo serverInfo2;
using (var connection2 = await CreateTestConnection())
using (var connection2 = CreateTestConnection())
{
connection2.Open();
serverInfo2 = ReliableConnectionHelper.GetServerVersion(connection);
@@ -346,9 +344,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Tests ReliableConnectionHelper.IsDatabaseReadonly()
/// </summary>
[Fact]
public async Task TestIsDatabaseReadonly()
public void TestIsDatabaseReadonly()
{
var connectionBuilder = await CreateTestConnectionStringBuilder();
var connectionBuilder = CreateTestConnectionStringBuilder();
Assert.NotNull(connectionBuilder);
bool isReadOnly = ReliableConnectionHelper.IsDatabaseReadonly(connectionBuilder);
@@ -368,9 +366,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Verify ANSI_NULL and QUOTED_IDENTIFIER settings can be set and retrieved for a session
/// </summary>
[Fact]
public async Task VerifyAnsiNullAndQuotedIdentifierSettingsReplayed()
public void VerifyAnsiNullAndQuotedIdentifierSettingsReplayed()
{
using (ReliableSqlConnection conn = (ReliableSqlConnection) ReliableConnectionHelper.OpenConnection(await CreateTestConnectionStringBuilder(), useRetry: true))
using (ReliableSqlConnection conn = (ReliableSqlConnection) ReliableConnectionHelper.OpenConnection(CreateTestConnectionStringBuilder(), useRetry: true))
{
VerifySessionSettings(conn, true);
VerifySessionSettings(conn, false);
@@ -477,9 +475,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// ReliableConnectionHelper.IsCloud() should be false for a local server
/// </summary>
[Fact]
public async Task TestIsCloudIsFalseForLocalServer()
public void TestIsCloudIsFalseForLocalServer()
{
using (var connection = await CreateTestConnection())
using (var connection = CreateTestConnection())
{
Assert.NotNull(connection);
@@ -492,9 +490,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Tests that ReliableConnectionHelper.OpenConnection() opens a connection if it is closed
/// </summary>
[Fact]
public async Task TestOpenConnectionOpensConnection()
public void TestOpenConnectionOpensConnection()
{
using (var connection = await CreateTestConnection())
using (var connection = CreateTestConnection())
{
Assert.NotNull(connection);
@@ -508,10 +506,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Tests that ReliableConnectionHelper.ExecuteNonQuery() runs successfully
/// </summary>
[Fact]
public async Task TestExecuteNonQuery()
public void TestExecuteNonQuery()
{
var result = ReliableConnectionHelper.ExecuteNonQuery(
await CreateTestConnectionStringBuilder(),
CreateTestConnectionStringBuilder(),
"SET NOCOUNT ON; SET NOCOUNT OFF;",
ReliableConnectionHelper.SetCommandTimeout,
null,
@@ -524,10 +522,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
/// Test that TryGetServerVersion() gets server information
/// </summary>
[Fact]
public async Task TestTryGetServerVersion()
public void TestTryGetServerVersion()
{
ReliableConnectionHelper.ServerInfo info = null;
var connBuilder = await CreateTestConnectionStringBuilder();
var connBuilder = CreateTestConnectionStringBuilder();
Assert.True(ReliableConnectionHelper.TryGetServerVersion(connBuilder.ConnectionString, out info));
Assert.NotNull(info);
@@ -681,9 +679,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
}
[Fact]
public async Task ReliableConnectionHelperTest()
public void ReliableConnectionHelperTest()
{
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
DbConnection connection = connInfo.ConnectionTypeToConnectionMap[ConnectionType.Default];
@@ -726,9 +724,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Connection
}
[Fact]
public async Task InitReliableSqlConnectionTest()
public void InitReliableSqlConnectionTest()
{
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
DbConnection dbConnection;
connInfo.TryGetConnection(ConnectionType.Default, out dbConnection);

19
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/LanguageServer/LanguageServiceTests.cs
View File

@@ -3,6 +3,7 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System.Threading;
using System.Threading.Tasks;
using Microsoft.SqlServer.Management.SqlParser.Parser;
using Microsoft.SqlTools.ServiceLayer.Connection;
@@ -21,7 +22,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
/// </summary>
public class LanguageServiceTests
{
private async static Task<TestConnectionResult> GetLiveAutoCompleteTestObjects()
private TestConnectionResult GetLiveAutoCompleteTestObjects()
{
var textDocument = new TextDocumentPosition
{
@@ -33,7 +34,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
}
};
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
result.TextDocumentPosition = textDocument;
return result;
}
@@ -46,7 +47,8 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
{
try
{
TestServiceProvider.InitializeTestServices();
TestServiceProvider serviceProvider = TestServiceProvider.Instance;
Assert.NotNull(serviceProvider);
}
catch (System.ArgumentException)
{
@@ -62,9 +64,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
/// Test the service initialization code path and verify nothing throws
/// </summary>
[Fact]
public async Task PrepopulateCommonMetadata()
public void PrepopulateCommonMetadata()
{
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
var connInfo = result.ConnectionInfo;
ScriptParseInfo scriptInfo = new ScriptParseInfo { IsConnected = true };
@@ -76,9 +78,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
// SMO connected metadata provider. Since we don't want a live DB dependency
// in the CI unit tests this scenario is currently disabled.
[Fact]
public async Task AutoCompleteFindCompletions()
public void AutoCompleteFindCompletions()
{
var result = await GetLiveAutoCompleteTestObjects();
var result = GetLiveAutoCompleteTestObjects();
result.TextDocumentPosition.Position.Character = 7;
result.ScriptFile.Contents = "select ";
@@ -102,7 +104,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
{
// When we make a connection to a live database
Hosting.ServiceHost.SendEventIgnoreExceptions = true;
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
// And we place the cursor after a function that should prompt for signature help
string queryWithFunction = "EXEC sys.fn_isrolemember ";
@@ -123,6 +125,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServer
// If the SQL has already been parsed
var service = LanguageService.Instance;
await service.UpdateLanguageServiceOnConnection(result.ConnectionInfo);
Thread.Sleep(2000);
// We should get back a non-null ScriptParseInfo
ScriptParseInfo parseInfo = service.GetScriptParseInfo(result.ScriptFile.ClientFilePath);

397
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/LanguageServer/PeekDefinitionTests.cs
View File

@@ -5,22 +5,17 @@
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.SqlServer.Management.Common;
using Microsoft.SqlServer.Management.SqlParser.Binder;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlServer.Management.SqlParser.MetadataProvider;
using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol;
using Microsoft.SqlTools.ServiceLayer.LanguageServices;
using Microsoft.SqlTools.ServiceLayer.LanguageServices.Completion;
using Microsoft.SqlTools.ServiceLayer.SqlContext;
using Microsoft.SqlTools.ServiceLayer.Workspace;
using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
using Microsoft.SqlTools.Test.Utility;
using Moq;
using Xunit;
using Location = Microsoft.SqlTools.ServiceLayer.Workspace.Contracts.Location;
using Microsoft.SqlServer.Management.SqlParser.Intellisense;
using Microsoft.SqlTools.ServiceLayer.Test.Common;
using static Microsoft.SqlTools.ServiceLayer.LanguageServices.PeekDefinition;
namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
{
@@ -30,15 +25,66 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
public class PeekDefinitionTests
{
private const string OwnerUri = "testFile1";
private const string ReturnTableFunctionName = "pd_returnTable";
private const string ReturnTableTableFunctionQuery = @"
CREATE FUNCTION [dbo].[" + ReturnTableFunctionName + @"] ()
RETURNS TABLE
AS
RETURN
(
select * from master.dbo.spt_monitor
);
GO";
private const string AddTwoFunctionName = "pd_addTwo";
private const string AddTwoFunctionQuery = @"
CREATE FUNCTION[dbo].[" + AddTwoFunctionName + @"](@number int)
RETURNS int
AS
BEGIN
RETURN @number + 2;
END;
GO";
private const string SsnTypeName = "pd_ssn";
private const string SsnTypeQuery = @"
CREATE TYPE [dbo].[" + SsnTypeName + @"] FROM [varchar](11) NOT NULL
GO";
private const string LocationTableTypeName = "pd_locationTableType";
private const string LocationTableTypeQuery = @"
CREATE TYPE [dbo].[" + LocationTableTypeName + @"] AS TABLE(
[LocationName] [varchar](50) NULL,
[CostRate] [int] NULL
)
GO";
private const string TestTableSynonymName = "pd_testTable";
private const string TestTableSynonymQuery = @"
CREATE SYNONYM [dbo].[pd_testTable] FOR master.dbo.spt_monitor
GO";
private const string TableValuedFunctionTypeName = "TableValuedFunction";
private const string ScalarValuedFunctionTypeName = "ScalarValuedFunction";
private const string UserDefinedDataTypeTypeName = "UserDefinedDataType";
private const string UserDefinedTableTypeTypeName = "UserDefinedTableType";
private const string SynonymTypeName = "Synonym";
private const string StoredProcedureTypeName = "StoredProcedure";
private const string ViewTypeName = "View";
private const string TableTypeName = "Table";
/// <summary>
/// Test get definition for a table object with active connection
/// </summary>
[Fact]
public async Task GetValidTableDefinitionTest()
public void GetValidTableDefinitionTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -57,10 +103,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a invalid table object with active connection
/// </summary>
[Fact]
public async Task GetTableDefinitionInvalidObjectTest()
public void GetTableDefinitionInvalidObjectTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -77,10 +123,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a valid table object with schema and active connection
/// </summary>
[Fact]
public async Task GetTableDefinitionWithSchemaTest()
public void GetTableDefinitionWithSchemaTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -99,7 +145,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test GetDefinition with an unsupported type(schema - dbo). Expect a error result.
/// </summary>
[Fact]
public async Task GetUnsupportedDefinitionErrorTest()
public void GetUnsupportedDefinitionErrorTest()
{
TextDocumentPosition textDocument = new TextDocumentPosition
{
@@ -112,7 +158,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
}
};
TestConnectionResult connectionResult = await TestObjects.InitLiveConnectionInfo();
TestConnectionResult connectionResult = TestObjects.InitLiveConnectionInfo();
connectionResult.ScriptFile.Contents = "select * from dbo.func ()";
var languageService = new LanguageService();
ScriptParseInfo scriptInfo = new ScriptParseInfo { IsConnected = true };
@@ -130,9 +176,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Get Definition for a object with no definition. Expect a error result
/// </summary>
[Fact]
public async Task GetDefinitionWithNoResultsFoundError()
public void GetDefinitionWithNoResultsFoundError()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -155,7 +201,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test GetDefinition with a forced timeout. Expect a error result.
/// </summary>
[Fact]
public async Task GetDefinitionTimeoutTest()
public void GetDefinitionTimeoutTest()
{
// Given a binding queue that will automatically time out
var languageService = new LanguageService();
@@ -175,10 +221,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
It.IsAny<int?>()))
.Callback<string, Func<IBindingContext, CancellationToken, object>, Func<IBindingContext, object>, int?, int?>(
(key, bindOperation, timeoutOperation, t1, t2) =>
{
timeoutResult = (DefinitionResult) timeoutOperation((IBindingContext)null);
itemMock.Object.Result = timeoutResult;
})
{
timeoutResult = (DefinitionResult)timeoutOperation((IBindingContext)null);
itemMock.Object.Result = timeoutResult;
})
.Returns(() => itemMock.Object);
TextDocumentPosition textDocument = new TextDocumentPosition
@@ -190,7 +236,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
Character = 20
}
};
TestConnectionResult connectionResult = await TestObjects.InitLiveConnectionInfo();
TestConnectionResult connectionResult = TestObjects.InitLiveConnectionInfo();
ScriptFile scriptFile = connectionResult.ScriptFile;
ConnectionInfo connInfo = connectionResult.ConnectionInfo;
scriptFile.Contents = "select * from dbo.func ()";
@@ -212,9 +258,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a view object with active connection
/// </summary>
[Fact]
public async Task GetValidViewDefinitionTest()
public void GetValidViewDefinitionTest()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -231,10 +277,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for an invalid view object with no schema name and with active connection
/// </summary>
[Fact]
public async Task GetViewDefinitionInvalidObjectTest()
public void GetViewDefinitionInvalidObjectTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -250,10 +296,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a stored procedure object with active connection
/// </summary>
[Fact]
public async Task GetStoredProcedureDefinitionTest()
public void GetStoredProcedureDefinitionTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -271,10 +317,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a stored procedure object that does not exist with active connection
/// </summary>
[Fact]
public async Task GetStoredProcedureDefinitionFailureTest()
public void GetStoredProcedureDefinitionFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -290,10 +336,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a stored procedure object with active connection and no schema
/// </summary>
[Fact]
public async Task GetStoredProcedureDefinitionWithoutSchemaTest()
public void GetStoredProcedureDefinitionWithoutSchemaTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -310,19 +356,76 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a scalar valued function object with active connection and explicit schema name. Expect non-null locations
/// </summary>
[Fact]
public async Task GetScalarValuedFunctionDefinitionWithSchemaNameSuccessTest()
public void GetScalarValuedFunctionDefinitionWithSchemaNameSuccessTest()
{
ExecuteAndValidatePeekTest(AddTwoFunctionQuery, AddTwoFunctionName, ScalarValuedFunctionTypeName);
}
private void ExecuteAndValidatePeekTest(string query, string objectName, string objectType, string schemaName = "dbo")
{
if (!string.IsNullOrEmpty(query))
{
using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, query))
{
ValidatePeekTest(testDb.DatabaseName, objectName, objectType, schemaName, true);
}
}
else
{
ValidatePeekTest(null, objectName, objectType, schemaName, false);
}
}
private void ValidatePeekTest(string databaseName, string objectName, string objectType, string schemaName, bool shouldReturnValidResult)
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition(databaseName);
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_addTwo";
string schemaName = "dbo";
string objectType = "FUNCTION";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetScalarValuedFunctionScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
ScriptGetter sqlScriptGetter = null;
switch (objectType)
{
case SynonymTypeName:
sqlScriptGetter = peekDefinition.GetSynonymScripts;
return;
case ScalarValuedFunctionTypeName:
sqlScriptGetter = peekDefinition.GetScalarValuedFunctionScripts;
objectType = "Function";
return;
case TableValuedFunctionTypeName:
sqlScriptGetter = peekDefinition.GetTableValuedFunctionScripts;
objectType = "Function";
return;
case TableTypeName:
sqlScriptGetter = peekDefinition.GetTableScripts;
return;
case ViewTypeName:
sqlScriptGetter = peekDefinition.GetViewScripts;
return;
case StoredProcedureTypeName:
sqlScriptGetter = peekDefinition.GetStoredProcedureScripts;
return;
case UserDefinedDataTypeTypeName:
sqlScriptGetter = peekDefinition.GetUserDefinedDataTypeScripts;
objectType = "Type";
return;
case UserDefinedTableTypeTypeName:
sqlScriptGetter = peekDefinition.GetUserDefinedTableTypeScripts;
objectType = "Type";
return;
}
Location[] locations = peekDefinition.GetSqlObjectDefinition(sqlScriptGetter, objectName, schemaName, objectType);
if (shouldReturnValidResult)
{
Assert.NotNull(locations);
}
else
{
Assert.Null(locations);
}
Cleanup(locations);
}
@@ -330,98 +433,52 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a table valued function object with active connection and explicit schema name. Expect non-null locations
/// </summary>
[Fact]
public async Task GetTableValuedFunctionDefinitionWithSchemaNameSuccessTest()
public void GetTableValuedFunctionDefinitionWithSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_returnTable";
string schemaName = "dbo";
string objectType = "FUNCTION";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetTableValuedFunctionScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(ReturnTableTableFunctionQuery, ReturnTableFunctionName, TableValuedFunctionTypeName);
}
/// <summary>
/// Test get definition for a scalar valued function object that doesn't exist with active connection. Expect null locations
/// </summary>
[Fact]
public async Task GetScalarValuedFunctionDefinitionWithNonExistentFailureTest()
public void GetScalarValuedFunctionDefinitionWithNonExistentFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "dbo";
string objectType = "FUNCTION";
string objectType = ScalarValuedFunctionTypeName;
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetScalarValuedFunctionScripts, objectName, schemaName, objectType);
Assert.Null(locations);
ExecuteAndValidatePeekTest(null, objectName, objectType, schemaName);
}
/// <summary>
/// Test get definition for a table valued function object that doesn't exist with active connection. Expect null locations
/// </summary>
[Fact]
public async Task GetTableValuedFunctionDefinitionWithNonExistentObjectFailureTest()
public void GetTableValuedFunctionDefinitionWithNonExistentObjectFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "dbo";
string objectType = "FUNCTION";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetTableValuedFunctionScripts, objectName, schemaName, objectType);
Assert.Null(locations);
string objectType = TableValuedFunctionTypeName;
ExecuteAndValidatePeekTest(null, objectName, objectType, schemaName);
}
/// <summary>
/// Test get definition for a scalar valued function object with active connection. Expect non-null locations
/// </summary>
[Fact]
public async Task GetScalarValuedFunctionDefinitionWithoutSchemaNameSuccessTest()
public void GetScalarValuedFunctionDefinitionWithoutSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_addTwo";
string schemaName = null;
string objectType = "FUNCTION";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetScalarValuedFunctionScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(AddTwoFunctionQuery, AddTwoFunctionName, ScalarValuedFunctionTypeName, null);
}
/// <summary>
/// Test get definition for a table valued function object with active connection. Expect non-null locations
/// </summary>
[Fact]
public async Task GetTableValuedFunctionDefinitionWithoutSchemaNameSuccessTest()
public void GetTableValuedFunctionDefinitionWithoutSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_returnTable";
string schemaName = null;
string objectType = "FUNCTION";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetTableValuedFunctionScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(ReturnTableTableFunctionQuery, ReturnTableFunctionName, TableValuedFunctionTypeName, null);
}
@@ -429,138 +486,70 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a user defined data type object with active connection and explicit schema name. Expect non-null locations
/// </summary>
[Fact]
public async Task GetUserDefinedDataTypeDefinitionWithSchemaNameSuccessTest()
public void GetUserDefinedDataTypeDefinitionWithSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_ssn";
string schemaName = "dbo";
string objectType = "Type";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedDataTypeScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(SsnTypeQuery, SsnTypeName, UserDefinedDataTypeTypeName);
}
/// <summary>
/// Test get definition for a user defined data type object with active connection. Expect non-null locations
/// </summary>
[Fact]
public async Task GetUserDefinedDataTypeDefinitionWithoutSchemaNameSuccessTest()
public void GetUserDefinedDataTypeDefinitionWithoutSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_ssn";
string schemaName = null;
string objectType = "Type";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedDataTypeScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(SsnTypeQuery, SsnTypeName, UserDefinedDataTypeTypeName, null);
}
/// <summary>
/// Test get definition for a user defined data type object that doesn't exist with active connection. Expect null locations
/// </summary>
[Fact]
public async Task GetUserDefinedDataTypeDefinitionWithNonExistentFailureTest()
public void GetUserDefinedDataTypeDefinitionWithNonExistentFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "dbo";
string objectType = "Type";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedDataTypeScripts, objectName, schemaName, objectType);
Assert.Null(locations);
string objectType = UserDefinedDataTypeTypeName;
ExecuteAndValidatePeekTest(null, objectName, objectType, schemaName);
}
/// <summary>
/// Test get definition for a user defined table type object with active connection and explicit schema name. Expect non-null locations
/// </summary>
[Fact]
public async Task GetUserDefinedTableTypeDefinitionWithSchemaNameSuccessTest()
public void GetUserDefinedTableTypeDefinitionWithSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_locationTableType";
string schemaName = "dbo";
string objectType = "Type";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedTableTypeScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(LocationTableTypeQuery, LocationTableTypeName, UserDefinedTableTypeTypeName);
}
/// <summary>
/// Test get definition for a user defined table type object with active connection. Expect non-null locations
/// </summary>
[Fact]
public async Task GetUserDefinedTableTypeDefinitionWithoutSchemaNameSuccessTest()
public void GetUserDefinedTableTypeDefinitionWithoutSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_locationTableType";
string schemaName = null;
string objectType = "Type";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedTableTypeScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(LocationTableTypeQuery, LocationTableTypeName, UserDefinedTableTypeTypeName, null);
}
/// <summary>
/// Test get definition for a user defined table type object that doesn't exist with active connection. Expect null locations
/// </summary>
[Fact]
public async Task GetUserDefinedTableTypeDefinitionWithNonExistentFailureTest()
public void GetUserDefinedTableTypeDefinitionWithNonExistentFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "dbo";
string objectType = "Type";
string objectType = UserDefinedTableTypeTypeName;
ExecuteAndValidatePeekTest(null, objectName, objectType, schemaName);
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetUserDefinedTableTypeScripts, objectName, schemaName, objectType);
Assert.Null(locations);
}
/// <summary>
/// Test get definition for a synonym object with active connection and explicit schema name. Expect non-null locations
/// </summary>
[Fact]
public async Task GetSynonymDefinitionWithSchemaNameSuccessTest()
public void GetSynonymDefinitionWithSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_testTable";
string schemaName = "dbo";
string objectType = "Synonym";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetSynonymScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(TestTableSynonymQuery, TestTableSynonymName, SynonymTypeName);
}
@@ -568,39 +557,21 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Test get definition for a Synonym object with active connection. Expect non-null locations
/// </summary>
[Fact]
public async Task GetSynonymDefinitionWithoutSchemaNameSuccessTest()
public void GetSynonymDefinitionWithoutSchemaNameSuccessTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "pd_testTable";
string schemaName = null;
string objectType = "Synonym";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetSynonymScripts, objectName, schemaName, objectType);
Assert.NotNull(locations);
Cleanup(locations);
ExecuteAndValidatePeekTest(TestTableSynonymQuery, TestTableSynonymName, SynonymTypeName, null);
}
/// <summary>
/// Test get definition for a Synonym object that doesn't exist with active connection. Expect null locations
/// </summary>
[Fact]
public async Task GetSynonymDefinitionWithNonExistentFailureTest()
public void GetSynonymDefinitionWithNonExistentFailureTest()
{
// Get live connectionInfo and serverConnection
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "dbo";
string objectType = "Synonym";
Location[] locations = peekDefinition.GetSqlObjectDefinition(peekDefinition.GetSynonymScripts, objectName, schemaName, objectType);
Assert.Null(locations);
ExecuteAndValidatePeekTest(null, objectName, objectType, schemaName);
}
/// <summary>
@@ -608,9 +579,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Expect a non-null result with location
/// </summary>
[Fact]
public async Task GetDefinitionUsingDeclarationTypeWithValidObjectTest()
public void GetDefinitionUsingDeclarationTypeWithValidObjectTest()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -630,9 +601,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Expect a non-null result with location
/// </summary>
[Fact]
public async Task GetDefinitionUsingDeclarationTypeWithNonexistentObjectTest()
public void GetDefinitionUsingDeclarationTypeWithNonexistentObjectTest()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -649,9 +620,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Expect a non-null result with location
/// </summary>
[Fact]
public async Task GetDefinitionUsingQuickInfoTextWithValidObjectTest()
public void GetDefinitionUsingQuickInfoTextWithValidObjectTest()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -672,9 +643,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
/// Expect a non-null result with location
/// </summary>
[Fact]
public async Task GetDefinitionUsingQuickInfoTextWithNonexistentObjectTest()
public void GetDefinitionUsingQuickInfoTextWithNonexistentObjectTest()
{
ConnectionInfo connInfo = await TestObjects.InitLiveConnectionInfoForDefinition();
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
@@ -699,7 +670,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageServices
{
File.Delete(fileUri.LocalPath);
}
catch(Exception)
catch (Exception)
{
}

16
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/QueryExecution/DataStorage/StorageDataReaderTests.cs
View File

@@ -16,9 +16,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
{
public class StorageDataReaderTests
{
private async Task<StorageDataReader> GetTestStorageDataReader(string query)
private StorageDataReader GetTestStorageDataReader(string query)
{
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
DbConnection connection;
result.ConnectionInfo.TryGetConnection(ConnectionType.Default, out connection);
@@ -33,9 +33,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
/// Validate GetBytesWithMaxCapacity
/// </summary>
[Fact]
public async Task GetBytesWithMaxCapacityTest()
public void GetBytesWithMaxCapacityTest()
{
var storageReader = await GetTestStorageDataReader(
var storageReader = GetTestStorageDataReader(
"SELECT CAST([name] as TEXT) As TextName FROM sys.all_columns");
DbDataReader reader = storageReader.DbDataReader;
@@ -50,9 +50,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
/// Validate GetCharsWithMaxCapacity
/// </summary>
[Fact]
public async Task GetCharsWithMaxCapacityTest()
public void GetCharsWithMaxCapacityTest()
{
var storageReader = await GetTestStorageDataReader(
var storageReader = GetTestStorageDataReader(
"SELECT name FROM sys.all_columns");
DbDataReader reader = storageReader.DbDataReader;
@@ -72,9 +72,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
/// Validate GetXmlWithMaxCapacity
/// </summary>
[Fact]
public async Task GetXmlWithMaxCapacityTest()
public void GetXmlWithMaxCapacityTest()
{
var storageReader = await GetTestStorageDataReader(
var storageReader = GetTestStorageDataReader(
"SELECT CAST('<xml>Test XML context</xml>' AS XML) As XmlColumn");
DbDataReader reader = storageReader.DbDataReader;

16
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/QueryExecution/ExecuteTests.cs
View File

@@ -17,12 +17,12 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution
public class ExecuteTests
{
[Fact]
public async Task RollbackTransactionFailsWithoutBeginTransaction()
public void RollbackTransactionFailsWithoutBeginTransaction()
{
const string refactorText = "ROLLBACK TRANSACTION";
// Given a connection to a live database
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
var fileStreamFactory = Common.GetFileStreamFactory(new Dictionary<string, byte[]>());
@@ -36,13 +36,13 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution
}
[Fact]
public async Task TransactionsSucceedAcrossQueries()
public void TransactionsSucceedAcrossQueries()
{
const string beginText = "BEGIN TRANSACTION";
const string rollbackText = "ROLLBACK TRANSACTION";
// Given a connection to a live database
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
var fileStreamFactory = Common.GetFileStreamFactory(new Dictionary<string, byte[]>());
@@ -55,13 +55,13 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution
}
[Fact]
public async Task TempTablesPersistAcrossQueries()
public void TempTablesPersistAcrossQueries()
{
const string createTempText = "CREATE TABLE #someTempTable (id int)";
const string insertTempText = "INSERT INTO #someTempTable VALUES(1)";
// Given a connection to a live database
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
var fileStreamFactory = Common.GetFileStreamFactory(new Dictionary<string, byte[]>());
@@ -74,14 +74,14 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution
}
[Fact]
public async Task DatabaseChangesWhenCallingUseDatabase()
public void DatabaseChangesWhenCallingUseDatabase()
{
const string master = "master";
const string tempdb = "tempdb";
const string useQuery = "USE {0}";
// Given a connection to a live database
var result = await TestObjects.InitLiveConnectionInfo();
var result = TestObjects.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
DbConnection connection;
connInfo.TryGetConnection(ConnectionType.Default, out connection);