private DefinitionResult GetSymbolResults(Request request, IEnumerable <LanguageSymbol> symbols)
{
var results = new DefinitionResult();
results.RequestId = request.Id;
results.Definitions = new List <Definition>();
foreach (var symbol in symbols)
{
var def = new Definition();
def.FilePath = request.Path;
def.RawType = "";
def.Text = symbol.Name;
def.Kind = symbol.Type;
def.Container = symbol.Container ?? "";
def.Type = request.Lookup;
def.Range = new Range
{
StartLine = symbol.StartLine,
EndLine = symbol.EndLine,
StartColumn = symbol.StartColumn,
EndColumn = symbol.EndColumn
};
results.Definitions.Add(def);
}
return(results);
}
/// <summary>
/// Script a object using the type extracted from declarationItem
/// </summary>
/// <param name="declarationItem">The Declaration object that matched with the selected token</param>
/// <param name="tokenText">The text of the selected token</param>
/// <param name="schemaName">Schema name</param>
/// <returns></returns>
internal DefinitionResult GetDefinitionUsingDeclarationType(DeclarationType type, string databaseQualifiedName, string tokenText, string schemaName)
{
if (sqlObjectTypes.ContainsKey(type))
{
// With SqlLogin authentication, the defaultSchema property throws an Exception when accessed.
// This workaround ensures that a schema name is present by attempting
// to get the schema name from the declaration item.
// If all fails, the default schema name is assumed to be "dbo"
if ((connectionInfo != null && connectionInfo.ConnectionDetails.AuthenticationType.Equals(Constants.SqlLoginAuthenticationType)) && string.IsNullOrEmpty(schemaName))
{
string fullObjectName = databaseQualifiedName;
schemaName = this.GetSchemaFromDatabaseQualifiedName(fullObjectName, tokenText);
}
Location[] locations = GetSqlObjectDefinition(
tokenText,
schemaName,
sqlObjectTypes[type]
);
DefinitionResult result = new DefinitionResult
{
IsErrorResult = this.error,
Message = this.errorMessage,
Locations = locations
};
return(result);
}
// If a type was found but is not in sqlScriptGetters, then the type is not supported
return(GetDefinitionErrorResult(SR.PeekDefinitionTypeNotSupportedError));
}
private DefinitionResult ProvideDefinition(Request request)
{
var matches = _ctx.Symbols
.Include(t => t.File)
.Where(t => t.Name.ToUpper() == request.PossibleWord.ToUpper());
if (!matches.Any())
{
return(null);
}
var results = new DefinitionResult();
results.RequestId = request.Id;
results.Definitions = new List <Definition>();
foreach (var match in matches)
{
var def = new Definition();
def.FilePath = match.File.FilePath;
def.RawType = "";
def.Text = "";
def.Type = request.Lookup;
def.Range = new Range
{
StartLine = match.StartLine,
EndLine = match.EndLine,
StartColumn = match.StartColumn,
EndColumn = match.EndColumn
};
results.Definitions.Add(def);
}
return(results);
}
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
}
};
TestConnectionResult connectionResult = TestObjects.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);
}
public void GetDefinitionUsingQuickInfoWithoutConnectionTest()
{
Scripter peekDefinition = new Scripter(null, null);
string objectName = "tableName";
string quickInfoText = "table master.dbo.tableName";
DefinitionResult result = peekDefinition.GetDefinitionUsingQuickInfoText(quickInfoText, objectName, null);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
public void GetDefinitionUsingDeclarationItemWithoutConnectionTest()
{
Scripter peekDefinition = new Scripter(null, null);
string objectName = "tableName";
string fullObjectName = "master.dbo.tableName";
DefinitionResult result = peekDefinition.GetDefinitionUsingDeclarationType(DeclarationType.Table, fullObjectName, objectName, null);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
public DefinitionResult Map(Definition definition)
{
var date = FormatLastModifiedDate(definition.CreationDate);
var definitionResult = new DefinitionResult()
{
Id = definition.DefinitionId,
Text = definition.Text,
Likes = definition.Likes,
Date = date
};
return(definitionResult);
}
private static void run(string type)
{
var project = type.ToProject();
// list all definitions
var definitions = DefinitionResult.List(project);
Console.WriteLine($"{definitions.Count} definitions");
// list all latest failed builds each definition
foreach (var build in BuildResult.List(project, definitions.Select(d => d.Id).ToList(), true)
.Where(b => b.Result == "failed"))
{
runByBuild(project, build);
}
}
public void GetDefinitionUsingDeclarationTypeWithNonexistentObjectTest()
{
ConnectionInfo connInfo = LiveConnectionHelper.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = LiveConnectionHelper.InitLiveServerConnectionForDefinition(connInfo);
Scripter scripter = new Scripter(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "sys";
DefinitionResult result = scripter.GetDefinitionUsingDeclarationType(DeclarationType.View, "master.sys.objects", objectName, schemaName);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
public void GetDefinitionWithNoResultsFoundError()
{
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "from";
List <Declaration> declarations = new List <Declaration>();
DefinitionResult result = peekDefinition.GetScript(declarations, objectName, null);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
Assert.Equal(SR.PeekDefinitionNoResultsError, result.Message);
}
public void GetUnsupportedDefinitionErrorTest()
{
ConnectionInfo connInfo = LiveConnectionHelper.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = LiveConnectionHelper.InitLiveServerConnectionForDefinition(connInfo);
Scripter scripter = new Scripter(serverConnection, connInfo);
string objectName = "objects";
string schemaName = "sys";
// When I try to get definition for 'Collation'
DefinitionResult result = scripter.GetDefinitionUsingDeclarationType(DeclarationType.Collation, "master.sys.objects", objectName, schemaName);
// Then I expect non null result with error flag set
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
public void GetDefinitionUsingQuickInfoTextWithNonexistentObjectTest()
{
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "doesNotExist";
string schemaName = "sys";
string quickInfoText = "view master.sys.objects";
DefinitionResult result = peekDefinition.GetDefinitionUsingQuickInfoText(quickInfoText, objectName, schemaName);
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
public void GetDefinitionUsingDeclarationTypeWithValidObjectTest()
{
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = TestObjects.InitLiveServerConnectionForDefinition(connInfo);
PeekDefinition peekDefinition = new PeekDefinition(serverConnection, connInfo);
string objectName = "objects";
string schemaName = "sys";
DefinitionResult result = peekDefinition.GetDefinitionUsingDeclarationType(DeclarationType.View, "master.sys.objects", objectName, schemaName);
Assert.NotNull(result);
Assert.NotNull(result.Locations);
Assert.False(result.IsErrorResult);
Cleanup(result.Locations);
}
public void GetDefinitionUsingQuickInfoTextWithValidObjectTest()
{
ConnectionInfo connInfo = LiveConnectionHelper.InitLiveConnectionInfoForDefinition();
ServerConnection serverConnection = LiveConnectionHelper.InitLiveServerConnectionForDefinition(connInfo);
Scripter scripter = new Scripter(serverConnection, connInfo);
string objectName = "objects";
string schemaName = "sys";
string quickInfoText = "view master.sys.objects";
DefinitionResult result = scripter.GetDefinitionUsingQuickInfoText(quickInfoText, objectName, schemaName);
Assert.NotNull(result);
Assert.NotNull(result.Locations);
Assert.False(result.IsErrorResult);
Cleanup(result.Locations);
}
/// <summary>
/// Script an object using the type extracted from quickInfo Text
/// </summary>
/// <param name="quickInfoText">the text from the quickInfo for the selected token</param>
/// <param name="tokenText">The text of the selected token</param>
/// <param name="schemaName">Schema name</param>
/// <returns></returns>
internal DefinitionResult GetDefinitionUsingQuickInfoText(string quickInfoText, string tokenText, string schemaName)
{
if (this.Database == null)
{
return(GetDefinitionErrorResult(SR.PeekDefinitionDatabaseError));
}
StringComparison caseSensitivity = this.Database.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
string tokenType = GetTokenTypeFromQuickInfo(quickInfoText, tokenText, caseSensitivity);
if (tokenType != null)
{
if (sqlScriptGettersFromQuickInfo.ContainsKey(tokenType.ToLowerInvariant()))
{
// With SqlLogin authentication, the defaultSchema property throws an Exception when accessed.
// This workaround ensures that a schema name is present by attempting
// to get the schema name from the declaration item.
// If all fails, the default schema name is assumed to be "dbo"
if ((connectionInfo != null && connectionInfo.ConnectionDetails.AuthenticationType.Equals(Constants.SqlLoginAuthenticationType)) && string.IsNullOrEmpty(schemaName))
{
string fullObjectName = this.GetFullObjectNameFromQuickInfo(quickInfoText, tokenText, caseSensitivity);
schemaName = this.GetSchemaFromDatabaseQualifiedName(fullObjectName, tokenText);
}
Location[] locations = GetSqlObjectDefinition(
sqlScriptGettersFromQuickInfo[tokenType.ToLowerInvariant()],
tokenText,
schemaName,
sqlObjectTypesFromQuickInfo[tokenType.ToLowerInvariant()]
);
DefinitionResult result = new DefinitionResult
{
IsErrorResult = this.error,
Message = this.errorMessage,
Locations = locations
};
return(result);
}
else
{
// If a type was found but is not in sqlScriptGettersFromQuickInfo, then the type is not supported
return(GetDefinitionErrorResult(SR.PeekDefinitionTypeNotSupportedError));
}
}
// no definition found
return(GetDefinitionErrorResult(SR.PeekDefinitionNoResultsError));
}
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);
}
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 <Func <Exception, object> >(),
It.IsAny <int?>(),
It.IsAny <int?>()))
.Callback <string, Func <IBindingContext, CancellationToken, object>, Func <IBindingContext, object>, Func <Exception, object>, int?, int?>(
(key, bindOperation, timeoutOperation, errHandler, t1, t2) =>
{
if (timeoutOperation != null)
{
timeoutResult = (DefinitionResult)timeoutOperation(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;
scriptFile.Contents = "select * from dbo.func ()";
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
languageService.ScriptParseInfoMap.Add(scriptFile.ClientUri, scriptInfo);
// Pass in null connection info to force doing a local parse since that hits the BindingQueue timeout
// before we want it to (this is testing the timeout trying to fetch the definitions after the parse)
var result = languageService.GetDefinition(textDocument, scriptFile, null);
// 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);
}
