mirror of
https://github.com/ckaczor/sqltoolsservice.git
synced 2026-01-14 17:23:27 -05:00
584 lines
20 KiB
C#
584 lines
20 KiB
C#
//
|
|
// Copyright (c) Microsoft. All rights reserved.
|
|
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.SqlTools.ServiceLayer.LanguageServices.Contracts;
|
|
using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
|
|
using Microsoft.SqlTools.ServiceLayer.TestDriver.Utility;
|
|
using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
|
|
using Xunit;
|
|
using Xunit.Sdk;
|
|
|
|
namespace Microsoft.SqlTools.ServiceLayer.TestDriver.Tests
|
|
{
|
|
public class PerformanceTests : TestBase
|
|
{
|
|
|
|
private static string ComplexQuery = LoadComplexScript();
|
|
private static string SimpleQuery = "SELECT * FROM sys.all_columns";
|
|
|
|
private static string LoadComplexScript()
|
|
{
|
|
try
|
|
{
|
|
string assemblyLocation = Assembly.GetEntryAssembly().Location;
|
|
string folderName = Path.GetDirectoryName(assemblyLocation);
|
|
string filePath = Path.Combine(folderName, "Scripts/AdventureWorks.sql");
|
|
return File.ReadAllText(filePath);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
Console.WriteLine("Failed to load the sql script. error: " + ex.Message);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task HoverTestOnPrem(string scenarioName = "Hover")
|
|
{
|
|
try
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
string query = SimpleQuery;
|
|
|
|
await ConnectAsync(TestServerType.OnPrem, query, ownerUri);
|
|
Hover hover = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
return await RequestHover(ownerUri, query, 0, 15); ;
|
|
});
|
|
Assert.True(hover != null, "Hover tool-tip is not null");
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SuggestionsTest(string scenarioName = "Suggestions")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
string ownerUri = Path.GetTempFileName();
|
|
|
|
WriteToFile(ownerUri, query);
|
|
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
await ValidateCompletionResponse(ownerUri, query, null);
|
|
|
|
await ValidateCompletionResponse(ownerUri, query, scenarioName);
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DiagnosticsTests(string scenarioName = "Diagnostics")
|
|
{
|
|
try
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
string query = "SELECT * FROM sys.objects";
|
|
|
|
await ConnectAsync(TestServerType.OnPrem, query, ownerUri);
|
|
Thread.Sleep(500);
|
|
|
|
var contentChanges = new TextDocumentChangeEvent[1];
|
|
contentChanges[0] = new TextDocumentChangeEvent()
|
|
{
|
|
Range = new Range()
|
|
{
|
|
Start = new Position()
|
|
{
|
|
Line = 0,
|
|
Character = 5
|
|
},
|
|
End = new Position()
|
|
{
|
|
Line = 0,
|
|
Character = 6
|
|
}
|
|
},
|
|
RangeLength = 1,
|
|
Text = "z"
|
|
};
|
|
|
|
DidChangeTextDocumentParams changeParams = new DidChangeTextDocumentParams()
|
|
{
|
|
ContentChanges = contentChanges,
|
|
TextDocument = new VersionedTextDocumentIdentifier()
|
|
{
|
|
Version = 2,
|
|
Uri = ownerUri
|
|
}
|
|
};
|
|
TestTimer timer = new TestTimer();
|
|
await RequestChangeTextDocumentNotification(changeParams);
|
|
|
|
while (true)
|
|
{
|
|
var completeEvent = await Driver.WaitForEvent(PublishDiagnosticsNotification.Type, 15000);
|
|
if (completeEvent != null && completeEvent.Diagnostics != null && completeEvent.Diagnostics.Length > 0)
|
|
{
|
|
timer.EndAndPrint(scenarioName);
|
|
break;
|
|
}
|
|
if (timer.TotalMilliSecondsUntilNow >= 500000)
|
|
{
|
|
Assert.True(false, "Failed to get Diagnostics");
|
|
break;
|
|
}
|
|
}
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
private async Task ValidateCompletionResponse(string ownerUri, string query, string testName)
|
|
{
|
|
TestTimer timer = new TestTimer();
|
|
CompletionItem completion = null;
|
|
while (true)
|
|
{
|
|
CompletionItem[] completions = await RequestCompletion(ownerUri, query, 0, 15);
|
|
|
|
completion = completions != null ? completions.FirstOrDefault(x => x.Label == "master") : null;
|
|
if (completion != null)
|
|
{
|
|
if (testName != null)
|
|
{
|
|
timer.EndAndPrint(testName);
|
|
}
|
|
break;
|
|
}
|
|
if (timer.TotalMilliSecondsUntilNow >= 500000)
|
|
{
|
|
Assert.True(false, "Failed to get a valid auto-complete list");
|
|
break;
|
|
}
|
|
|
|
Thread.Sleep(50);
|
|
}
|
|
}
|
|
|
|
private async Task VerifyBindingLoadScenario(TestServerType serverType, string query, string testName = null)
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
|
|
WriteToFile(ownerUri, query);
|
|
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
await ValidateCompletionResponse(ownerUri, query, testName);
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheColdAzureSimpleQuery(string scenarioName = "[Simple query][Cold][SQL DB] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
Thread.Sleep(5000);
|
|
await VerifyBindingLoadScenario(TestServerType.Azure, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheColdOnPremSimpleQuery(string scenarioName = "[Simple query][Cold][On-Prem] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
await VerifyBindingLoadScenario(TestServerType.OnPrem, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheWarmAzureSimpleQuery(string scenarioName = "[Simple query][Warm][SQL DB] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.Azure;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
Thread.Sleep(10000);
|
|
await VerifyBindingLoadScenario(serverType, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheWarmOnPremSimpleQuery(string scenarioName = "[Simple query][Warm][On-Prem] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
Thread.Sleep(10000);
|
|
await VerifyBindingLoadScenario(serverType, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheColdAzureComplexQuery(string scenarioName = "[Complex query][Cold][SQL DB] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = ComplexQuery;
|
|
await VerifyBindingLoadScenario(TestServerType.Azure, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheColdOnPremComplexQuery(string scenarioName = "[Complex query][Cold][On-Prem] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = ComplexQuery;
|
|
await VerifyBindingLoadScenario(TestServerType.OnPrem, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheWarmAzureComplexQuery(string scenarioName = "[Complex query][Warm][SQL DB] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = ComplexQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.Azure;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
Thread.Sleep(100000);
|
|
await VerifyBindingLoadScenario(serverType, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task BindingCacheWarmOnPremComplexQuery(string scenarioName = "[Complex query][Warm][On-Prem] Binding cache")
|
|
{
|
|
try
|
|
{
|
|
string query = ComplexQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
Thread.Sleep(10000);
|
|
await VerifyBindingLoadScenario(serverType, query, scenarioName);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ConnectAzureTest(string scenarioName = "Connect SQL DB")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.Azure;
|
|
WriteToFile(ownerUri, query);
|
|
|
|
DidOpenTextDocumentNotification openParams = new DidOpenTextDocumentNotification()
|
|
{
|
|
TextDocument = new TextDocumentItem()
|
|
{
|
|
Uri = ownerUri,
|
|
LanguageId = "enu",
|
|
Version = 1,
|
|
Text = query
|
|
}
|
|
};
|
|
|
|
await RequestOpenDocumentNotification(openParams);
|
|
|
|
Thread.Sleep(500);
|
|
var connected = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
var connectParams = await GetDatabaseConnectionAsync(serverType);
|
|
return await Connect(ownerUri, connectParams);
|
|
});
|
|
Assert.True(connected, "Connection is successful");
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ConnectOnPremTest(string scenarioName = "Connect On-Prem")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
WriteToFile(ownerUri, query);
|
|
|
|
DidOpenTextDocumentNotification openParams = new DidOpenTextDocumentNotification()
|
|
{
|
|
TextDocument = new TextDocumentItem()
|
|
{
|
|
Uri = ownerUri,
|
|
LanguageId = "enu",
|
|
Version = 1,
|
|
Text = query
|
|
}
|
|
};
|
|
|
|
await RequestOpenDocumentNotification(openParams);
|
|
|
|
Thread.Sleep(500);
|
|
var connected = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
var connectParams = await GetDatabaseConnectionAsync(serverType);
|
|
return await Connect(ownerUri, connectParams);
|
|
});
|
|
Assert.True(connected, "Connection is successful");
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DisconnectTest(string scenarioName = "Disconnect On-Prem")
|
|
{
|
|
try
|
|
{
|
|
string query = SimpleQuery;
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
Thread.Sleep(1000);
|
|
var connected = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
return await base.Disconnect(ownerUri);
|
|
});
|
|
Assert.True(connected);
|
|
}
|
|
finally
|
|
{
|
|
WaitForExit();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task QueryResultSummaryOnPremTest(string scenarioName = "Basic Query Result On-Prem")
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
string query = SimpleQuery;
|
|
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
|
|
var queryTask = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
return await RunQuery(ownerUri, query);
|
|
});
|
|
|
|
Assert.NotNull(queryTask);
|
|
Assert.True(queryTask.BatchSummaries.Any(x => x.ResultSetSummaries.Any( r => r.RowCount > 0)));
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task QueryResultFirstOnPremTest(string scenarioName = "Basic Query Result First Rows On-Prem")
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
string query = SimpleQuery;
|
|
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
|
|
var queryResult = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
var queryTask = await RunQuery(ownerUri, query);
|
|
return await ExecuteSubset(ownerUri, 0, 0, 0, 100);
|
|
});
|
|
|
|
Assert.NotNull(queryResult);
|
|
Assert.NotNull(queryResult.ResultSubset);
|
|
Assert.True(queryResult.ResultSubset.Rows.Count() > 0);
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public async Task CancelQueryOnPremTest(string scenarioName = "Cancel Query On-Prem")
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
string query = "WAITFOR DELAY '00:01:00';";
|
|
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
var queryParams = new QueryExecuteParams();
|
|
queryParams.OwnerUri = ownerUri;
|
|
queryParams.QuerySelection = null;
|
|
|
|
var result = await Driver.SendRequest(QueryExecuteRequest.Type, queryParams);
|
|
if (result != null && string.IsNullOrEmpty(result.Messages))
|
|
{
|
|
TestTimer timer = new TestTimer();
|
|
|
|
while (true)
|
|
{
|
|
var queryTask = await CancelQuery(ownerUri);
|
|
if (queryTask != null)
|
|
{
|
|
timer.EndAndPrint(scenarioName);
|
|
break;
|
|
}
|
|
if (timer.TotalMilliSecondsUntilNow >= 100000)
|
|
{
|
|
Assert.True(false, "Failed to cancel query");
|
|
break;
|
|
}
|
|
|
|
Thread.Sleep(10);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert.True(false, "Failed to run the query");
|
|
}
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TestSaveResultsToCsvTest(string scenarioName = "Basic Query Save To CSV")
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
string query = SimpleQuery;
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
string output = Path.GetTempFileName();
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
|
|
// Execute a query
|
|
await RunQuery(ownerUri, query);
|
|
|
|
var saveTask = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
return await SaveAsCsv(ownerUri, output, 0, 0);
|
|
});
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TestSaveResultsToJsonTest(string scenarioName = "Basic Query Save To Json")
|
|
{
|
|
string ownerUri = Path.GetTempFileName();
|
|
string query = SimpleQuery;
|
|
TestServerType serverType = TestServerType.OnPrem;
|
|
await ConnectAsync(serverType, query, ownerUri);
|
|
string output = Path.GetTempFileName();
|
|
// Execute a query
|
|
await RunQuery(ownerUri, query);
|
|
|
|
var saveTask = await CalculateRunTime(scenarioName, async () =>
|
|
{
|
|
return await SaveAsJson(ownerUri, output, 0, 0);
|
|
});
|
|
|
|
await Disconnect(ownerUri);
|
|
}
|
|
|
|
private async Task<bool> ConnectAsync(TestServerType serverType, string query, string ownerUri)
|
|
{
|
|
WriteToFile(ownerUri, query);
|
|
|
|
DidOpenTextDocumentNotification openParams = new DidOpenTextDocumentNotification()
|
|
{
|
|
TextDocument = new TextDocumentItem()
|
|
{
|
|
Uri = ownerUri,
|
|
LanguageId = "enu",
|
|
Version = 1,
|
|
Text = query
|
|
}
|
|
};
|
|
|
|
await RequestOpenDocumentNotification(openParams);
|
|
|
|
Thread.Sleep(500);
|
|
var connectParams = await GetDatabaseConnectionAsync(serverType);
|
|
bool connected = await Connect(ownerUri, connectParams);
|
|
Assert.True(connected, "Connection is successful");
|
|
if (connected)
|
|
{
|
|
Console.WriteLine("Connection is successful");
|
|
}
|
|
|
|
return connected;
|
|
}
|
|
|
|
private async Task<T> CalculateRunTime<T>(string testName, Func<Task<T>> testToRun)
|
|
{
|
|
TestTimer timer = new TestTimer();
|
|
T result = await testToRun();
|
|
timer.EndAndPrint(testName);
|
|
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|