public void GetDefinitionWithNoResultsFoundError()
{
ConnectionInfo connInfo = LiveConnectionHelper.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = LiveConnectionHelper.InitLiveServerConnectionForDefinition(connInfo);
Scripter scripter = new Scripter(serverConnection, connInfo);
string objectName = "from";
Position position = new Position()
{
Line = 1,
Character = 14
};
ScriptParseInfo scriptParseInfo = new ScriptParseInfo()
{
IsConnected = true
};
Mock <IBindingContext> bindingContextMock = new Mock <IBindingContext>();
DefinitionResult result = scripter.GetScript(scriptParseInfo.ParseResult, position, bindingContextMock.Object.MetadataDisplayInfoProvider, objectName, null);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
Assert.Equal(SR.PeekDefinitionNoResultsError, result.Message);
}
// [Fact]
public async void GetDefinitionFromProcedures()
{
string queryString = "EXEC master.dbo.sp_MSrepl_startup";
// place the cursor on every token
//cursor on objects
TextDocumentPosition fnDocument = CreateTextDocPositionWithCursor(30, TestUri);
//cursor on sys
TextDocumentPosition dboDocument = CreateTextDocPositionWithCursor(14, TestUri);
//cursor on master
TextDocumentPosition masterDocument = CreateTextDocPositionWithCursor(10, TestUri);
LiveConnectionHelper.TestConnectionResult connectionResult = LiveConnectionHelper.InitLiveConnectionInfo(null, TestUri);
ScriptFile scriptFile = connectionResult.ScriptFile;
ConnectionInfo connInfo = connectionResult.ConnectionInfo;
connInfo.RemoveAllConnections();
var bindingQueue = new ConnectedBindingQueue();
bindingQueue.AddConnectionContext(connInfo);
scriptFile.Contents = queryString;
var service = new LanguageService();
service.RemoveScriptParseInfo(OwnerUri);
service.BindingQueue = bindingQueue;
await service.UpdateLanguageServiceOnConnection(connectionResult.ConnectionInfo);
Thread.Sleep(2000);
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
service.ParseAndBind(scriptFile, connInfo);
scriptInfo.ConnectionKey = bindingQueue.AddConnectionContext(connInfo);
service.ScriptParseInfoMap.Add(TestUri, scriptInfo);
// When I call the language service
var fnResult = service.GetDefinition(fnDocument, scriptFile, connInfo);
var sysResult = service.GetDefinition(dboDocument, scriptFile, connInfo);
var masterResult = service.GetDefinition(masterDocument, scriptFile, connInfo);
// Then I expect the results to be non-null
Assert.NotNull(fnResult);
Assert.NotNull(sysResult);
Assert.NotNull(masterResult);
// And I expect the all results to be the same
Assert.True(CompareLocations(fnResult.Locations, sysResult.Locations));
Assert.True(CompareLocations(fnResult.Locations, masterResult.Locations));
Cleanup(fnResult.Locations);
Cleanup(sysResult.Locations);
Cleanup(masterResult.Locations);
service.ScriptParseInfoMap.Remove(TestUri);
connInfo.RemoveAllConnections();
}
public void GetDefinitionTimeoutTest()
{
// Given a binding queue that will automatically time out
var languageService = new LanguageService();
Mock <ConnectedBindingQueue> queueMock = new Mock <ConnectedBindingQueue>();
languageService.BindingQueue = queueMock.Object;
ManualResetEvent mre = new ManualResetEvent(true); // Do not block
Mock <QueueItem> itemMock = new Mock <QueueItem>();
itemMock.Setup(i => i.ItemProcessed).Returns(mre);
DefinitionResult timeoutResult = null;
queueMock.Setup(q => q.QueueBindingOperation(
It.IsAny <string>(),
It.IsAny <Func <IBindingContext, CancellationToken, object> >(),
It.IsAny <Func <IBindingContext, object> >(),
It.IsAny <int?>(),
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;
})
.Returns(() => itemMock.Object);
TextDocumentPosition textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = OwnerUri
},
Position = new Position
{
Line = 0,
Character = 20
}
};
LiveConnectionHelper.TestConnectionResult connectionResult = LiveConnectionHelper.InitLiveConnectionInfo();
ScriptFile scriptFile = connectionResult.ScriptFile;
ConnectionInfo connInfo = connectionResult.ConnectionInfo;
scriptFile.Contents = "select * from dbo.func ()";
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
languageService.ScriptParseInfoMap.Add(OwnerUri, scriptInfo);
// When I call the language service
var result = languageService.GetDefinition(textDocument, scriptFile, connInfo);
// Then I expect null locations and an error to be reported
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
// Check timeout message
Assert.Equal(SR.PeekDefinitionTimedoutError, result.Message);
}
private void InitializeTestObjects()
{
// initial cursor position in the script file
textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = this.testScriptUri
},
Position = new Position
{
Line = 0,
Character = 0
}
};
// default settings are stored in the workspace service
WorkspaceService <SqlToolsSettings> .Instance.CurrentSettings = new SqlToolsSettings();
// set up file for returning the query
scriptFile = new Mock <ScriptFile>();
scriptFile.SetupGet(file => file.Contents).Returns(QueryExecution.Common.StandardQuery);
scriptFile.SetupGet(file => file.ClientFilePath).Returns(this.testScriptUri);
// set up workspace mock
workspaceService = new Mock <WorkspaceService <SqlToolsSettings> >();
workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny <string>()))
.Returns(scriptFile.Object);
// setup binding queue mock
bindingQueue = new Mock <ConnectedBindingQueue>();
bindingQueue.Setup(q => q.AddConnectionContext(It.IsAny <ConnectionInfo>(), It.IsAny <bool>()))
.Returns(this.testConnectionKey);
// inject mock instances into the Language Service
LanguageService.WorkspaceServiceInstance = workspaceService.Object;
LanguageService.ConnectionServiceInstance = TestObjects.GetTestConnectionService();
ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo();
LanguageService.ConnectionServiceInstance.OwnerToConnectionMap.Add(this.testScriptUri, connectionInfo);
LanguageService.Instance.BindingQueue = bindingQueue.Object;
// setup the mock for SendResult
requestContext = new Mock <RequestContext <CompletionItem[]> >();
requestContext.Setup(rc => rc.SendResult(It.IsAny <CompletionItem[]>()))
.Returns(Task.FromResult(0));
// setup the IBinder mock
binder = new Mock <IBinder>();
binder.Setup(b => b.Bind(
It.IsAny <IEnumerable <ParseResult> >(),
It.IsAny <string>(),
It.IsAny <BindMode>()));
scriptParseInfo = new ScriptParseInfo();
LanguageService.Instance.AddOrUpdateScriptParseInfo(this.testScriptUri, scriptParseInfo);
scriptParseInfo.IsConnected = true;
scriptParseInfo.ConnectionKey = LanguageService.Instance.BindingQueue.AddConnectionContext(connectionInfo);
// setup the binding context object
ConnectedBindingContext bindingContext = new ConnectedBindingContext();
bindingContext.Binder = binder.Object;
bindingContext.MetadataDisplayInfoProvider = new MetadataDisplayInfoProvider();
LanguageService.Instance.BindingQueue.BindingContextMap.Add(scriptParseInfo.ConnectionKey, bindingContext);
}
public async void AutoCompleteWithExtension()
{
var result = GetLiveAutoCompleteTestObjects();
result.TextDocumentPosition.Position.Character = 10;
result.ScriptFile = ScriptFileTests.GetTestScriptFile("select * f");
result.TextDocumentPosition.TextDocument.Uri = result.ScriptFile.FilePath;
var autoCompleteService = LanguageService.Instance;
var requestContext = new Mock <SqlTools.Hosting.Protocol.RequestContext <bool> >();
requestContext.Setup(x => x.SendResult(It.IsAny <bool>()))
.Returns(Task.FromResult(true));
requestContext.Setup(x => x.SendError(It.IsAny <string>(), 0))
.Returns(Task.FromResult(true));
//Create completion extension parameters
var extensionParams = new CompletionExtensionParams()
{
AssemblyPath = Path.Combine(AssemblyDirectory, "Microsoft.SqlTools.Test.CompletionExtension.dll"),
TypeName = "Microsoft.SqlTools.Test.CompletionExtension.CompletionExt",
Properties = new Dictionary <string, object> {
{ "modelPath", "testModel" }
}
};
//load and initialize completion extension, expect a success
await autoCompleteService.HandleCompletionExtLoadRequest(extensionParams, requestContext.Object);
requestContext.Verify(x => x.SendResult(It.IsAny <bool>()), Times.Once);
requestContext.Verify(x => x.SendError(It.IsAny <string>(), 0), Times.Never);
//Try to load the same completion extension second time, expect an error sent
await autoCompleteService.HandleCompletionExtLoadRequest(extensionParams, requestContext.Object);
requestContext.Verify(x => x.SendResult(It.IsAny <bool>()), Times.Once);
requestContext.Verify(x => x.SendError(It.IsAny <string>(), 0), Times.Once);
//Try to load the completion extension with new modified timestamp, expect a success
var assemblyCopyPath = CopyFileWithNewModifiedTime(extensionParams.AssemblyPath);
extensionParams = new CompletionExtensionParams()
{
AssemblyPath = assemblyCopyPath,
TypeName = "Microsoft.SqlTools.Test.CompletionExtension.CompletionExt",
Properties = new Dictionary <string, object> {
{ "modelPath", "testModel" }
}
};
//load and initialize completion extension
await autoCompleteService.HandleCompletionExtLoadRequest(extensionParams, requestContext.Object);
requestContext.Verify(x => x.SendResult(It.IsAny <bool>()), Times.Exactly(2));
requestContext.Verify(x => x.SendError(It.IsAny <string>(), 0), Times.Once);
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
autoCompleteService.ParseAndBind(result.ScriptFile, result.ConnectionInfo);
scriptInfo.ConnectionKey = autoCompleteService.BindingQueue.AddConnectionContext(result.ConnectionInfo);
//Invoke auto completion with extension enabled
var completions = autoCompleteService.GetCompletionItems(
result.TextDocumentPosition,
result.ScriptFile,
result.ConnectionInfo).Result;
//Validate completion list is not empty
Assert.True(completions != null && completions.Length > 0, "The completion list is null or empty!");
//Validate the first completion item in the list is preselected
Assert.True(completions[0].Preselect.HasValue && completions[0].Preselect.Value, "Preselect is not set properly in the first completion item by the completion extension!");
//Validate the Command object attached to the completion item by the extension
Assert.True(completions[0].Command != null && completions[0].Command.CommandStr == "vsintellicode.completionItemSelected", "Command is not set properly in the first completion item by the completion extension!");
//clean up the temp file
File.Delete(assemblyCopyPath);
}
/// <summary>
/// Create new instance
/// </summary>
public ScriptDocumentInfo(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile, ScriptParseInfo scriptParseInfo)
: this(textDocumentPosition, scriptFile)
{
Validate.IsNotNull(nameof(scriptParseInfo), scriptParseInfo);
ScriptParseInfo = scriptParseInfo;
// need to adjust line & column for base-1 parser indices
Token = GetToken(scriptParseInfo, ParserLine, ParserColumn);
}
/// <summary>
/// Returns the token that is used for Peek Definition objects
/// </summary>
internal static Tuple <Stack <Token>, Queue <Token> > GetPeekDefinitionTokens(ScriptParseInfo scriptParseInfo, int startLine, int startColumn)
{
Stack <Token> childrenTokens = new Stack <Token>();
Queue <Token> parentTokens = new Queue <Token>();
if (scriptParseInfo != null &&
scriptParseInfo.ParseResult != null &&
scriptParseInfo.ParseResult.Script != null &&
scriptParseInfo.ParseResult.Script.Tokens != null)
{
var tokenIndex = scriptParseInfo.ParseResult.Script.TokenManager.FindToken(startLine, startColumn);
if (tokenIndex >= 0)
{
// return the current token and the ones to its right
// until we hit a whitespace token
int currentIndex = 0;
foreach (var token in scriptParseInfo.ParseResult.Script.Tokens)
{
if (currentIndex == tokenIndex)
{
// push all parent tokens until we hit whitespace
int parentIndex = currentIndex;
while (true)
{
if (scriptParseInfo.ParseResult.Script.TokenManager.GetToken(parentIndex).Type != "LEX_WHITE")
{
parentTokens.Enqueue(scriptParseInfo.ParseResult.Script.TokenManager.GetToken(parentIndex));
parentIndex--;
}
else
{
break;
}
}
}
else if (currentIndex > tokenIndex)
{
// push all children tokens until we hit whitespace
if (scriptParseInfo.ParseResult.Script.TokenManager.GetToken(currentIndex).Type != "LEX_WHITE")
{
childrenTokens.Push(token);
}
else
{
break;
}
}
++currentIndex;
}
return(Tuple.Create(childrenTokens, parentTokens));
}
}
return(null);
}
public TestScriptDocumentInfo(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile, ScriptParseInfo scriptParseInfo)
: base(textDocumentPosition, scriptFile, scriptParseInfo)
{
}
public TestScriptDocumentInfo(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile, ScriptParseInfo scriptParseInfo,
string tokenText = null)
: base(textDocumentPosition, scriptFile, scriptParseInfo)
{
this.tokenText = string.IsNullOrEmpty(tokenText) ? "doesntmatchanythingintheintellisensedefaultlist" : tokenText;
}
