public void Resolve_CalculatesAssemblyLocationInLookupText(string lookupText, int assemblyLocation)
{
// Arrange
var errorSink = new ErrorSink();
var tagHelperDescriptorResolver = new InspectableTagHelperDescriptorResolver();
var directiveType = TagHelperDirectiveType.AddTagHelper;
var resolutionContext = new TagHelperDescriptorResolutionContext(
new[]
{
new TagHelperDirectiveDescriptor
{
DirectiveText = lookupText,
Location = SourceLocation.Zero,
DirectiveType = directiveType
}
},
errorSink);
var expectedSourceLocation = new SourceLocation(assemblyLocation, 0, assemblyLocation);
// Act
tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
Assert.Empty(errorSink.Errors);
Assert.Equal(expectedSourceLocation, tagHelperDescriptorResolver.DocumentLocation);
}
public IEnumerable<TagHelperDescriptor> Resolve(TagHelperDescriptorResolutionContext resolutionContext)
{
IEnumerable<TagHelperDescriptor> descriptors = null;
foreach (var directiveDescriptor in resolutionContext.DirectiveDescriptors)
{
if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.RemoveTagHelper)
{
// We don't yet support "typeName, assemblyName" for @removeTagHelper in this test class. Will
// add that ability and add the corresponding end-to-end test verification in:
// https://github.com/aspnet/Razor/issues/222
descriptors = null;
}
else if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.AddTagHelper)
{
descriptors = _tagHelperDescriptors;
}
}
return descriptors ?? Enumerable.Empty<TagHelperDescriptor>();
}
public IEnumerable <TagHelperDescriptor> Resolve(TagHelperDescriptorResolutionContext resolutionContext)
{
DirectiveDescriptors.AddRange(resolutionContext.DirectiveDescriptors);
return(Enumerable.Empty <TagHelperDescriptor>());
}
public void Resolve_ReturnsDescriptorsBasedOnDirectiveDescriptors(
Dictionary<string, IEnumerable<Type>> descriptorAssemblyLookups,
IEnumerable<TagHelperDirectiveDescriptor> directiveDescriptors,
IEnumerable<TagHelperDescriptor> expectedDescriptors)
{
// Arrange
var tagHelperDescriptorResolver =
new TestTagHelperDescriptorResolver(
new LookupBasedTagHelperTypeResolver(descriptorAssemblyLookups));
var resolutionContext = new TagHelperDescriptorResolutionContext(
directiveDescriptors,
new ErrorSink());
// Act
var descriptors = tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
Assert.Equal(expectedDescriptors.Count(), descriptors.Count());
foreach (var expectedDescriptor in expectedDescriptors)
{
Assert.Contains(expectedDescriptor, descriptors, TagHelperDescriptorComparer.Default);
}
}
public void Resolve_AllowsOverridenResolveDescriptorsInAssembly(string lookupText, string expectedAssemblyName)
{
// Arrange
var tagHelperDescriptorResolver = new AssemblyCheckingTagHelperDescriptorResolver();
var context = new TagHelperDescriptorResolutionContext(
new[] { new TagHelperDirectiveDescriptor(lookupText, TagHelperDirectiveType.AddTagHelper) },
new ErrorSink());
// Act
tagHelperDescriptorResolver.Resolve(context);
// Assert
Assert.Equal(expectedAssemblyName, tagHelperDescriptorResolver.CalledWithAssemblyName);
}
public void DescriptorResolver_UnderstandsUnexpectedExceptions_DoesNotThrow()
{
// Arrange
var expectedErrorMessage = "Encountered an unexpected error when attempting to resolve tag helper " +
"directive '@addTagHelper' with value 'A custom, lookup text'. Error: A " +
"custom exception";
var documentLocation = new SourceLocation(1, 2, 3);
var directiveType = TagHelperDirectiveType.AddTagHelper;
var errorSink = new ErrorSink();
var expectedError = new Exception("A custom exception");
var tagHelperDescriptorResolver = new ThrowingTagHelperDescriptorResolver(expectedError);
var resolutionContext = new TagHelperDescriptorResolutionContext(
new[] { new TagHelperDirectiveDescriptor("A custom, lookup text", documentLocation, directiveType) },
errorSink);
// Act
tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
var error = Assert.Single(errorSink.Errors);
Assert.Equal(1, error.Length);
Assert.Equal(documentLocation, error.Location);
Assert.Equal(expectedErrorMessage, error.Message);
}
public void DescriptorResolver_CreatesErrorIfInvalidLookupText_DoesNotThrow(string lookupText)
{
// Arrange
var errorSink = new ErrorSink();
var tagHelperDescriptorResolver =
new TestTagHelperDescriptorResolver(
new TestTagHelperTypeResolver(InvalidTestableTagHelpers));
var documentLocation = new SourceLocation(1, 2, 3);
var directiveType = TagHelperDirectiveType.AddTagHelper;
var expectedErrorMessage = string.Format(
"Invalid tag helper directive look up text '{0}'. The correct look up text " +
"format is: \"typeName, assemblyName\".",
lookupText);
var resolutionContext = new TagHelperDescriptorResolutionContext(
new[] { new TagHelperDirectiveDescriptor(lookupText, documentLocation, directiveType) },
errorSink);
// Act
tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
var error = Assert.Single(errorSink.Errors);
Assert.Equal(1, error.Length);
Assert.Equal(documentLocation, error.Location);
Assert.Equal(expectedErrorMessage, error.Message);
}
public void Resolve_CanReturnEmptyDescriptorsBasedOnDirectiveDescriptors(
Dictionary<string, IEnumerable<Type>> descriptorAssemblyLookups,
IEnumerable<TagHelperDirectiveDescriptor> directiveDescriptors)
{
// Arrange
var tagHelperDescriptorResolver =
new TestTagHelperDescriptorResolver(
new LookupBasedTagHelperTypeResolver(descriptorAssemblyLookups));
var resolutionContext = new TagHelperDescriptorResolutionContext(
directiveDescriptors,
new ErrorSink());
// Act
var descriptors = tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
Assert.Empty(descriptors);
}
private static string ResolveTagHelperPrefix(TagHelperDescriptorResolutionContext context)
{
var prefixDirectiveDescriptors = context.DirectiveDescriptors.Where(
descriptor => descriptor.DirectiveType == TagHelperDirectiveType.TagHelperPrefix);
TagHelperDirectiveDescriptor prefixDirective = null;
foreach (var directive in prefixDirectiveDescriptors)
{
if (prefixDirective == null)
{
prefixDirective = directive;
}
else
{
// For each invalid @tagHelperPrefix we need to create an error.
context.ErrorSink.OnError(
directive.Location,
Resources.FormatTagHelperDescriptorResolver_InvalidTagHelperDirective(
SyntaxConstants.CSharp.TagHelperPrefixKeyword));
}
}
var prefix = prefixDirective?.DirectiveText;
if (prefix != null && !EnsureValidPrefix(prefix, prefixDirective.Location, context.ErrorSink))
{
prefix = null;
}
return prefix;
}
private static IEnumerable<TagHelperDescriptor> PrefixDescriptors(
TagHelperDescriptorResolutionContext context,
IEnumerable<TagHelperDescriptor> descriptors)
{
var tagHelperPrefix = ResolveTagHelperPrefix(context);
if (!string.IsNullOrEmpty(tagHelperPrefix))
{
return descriptors.Select(descriptor =>
new TagHelperDescriptor(
tagHelperPrefix,
descriptor.TagName,
descriptor.TypeName,
descriptor.AssemblyName,
descriptor.Attributes,
descriptor.RequiredAttributes));
}
return descriptors;
}
private static IEnumerable<TagHelperDescriptor> PrefixDescriptors(
TagHelperDescriptorResolutionContext context,
IEnumerable<TagHelperDescriptor> descriptors)
{
var tagHelperPrefix = ResolveTagHelperPrefix(context);
if (!string.IsNullOrEmpty(tagHelperPrefix))
{
return descriptors.Select(descriptor =>
new TagHelperDescriptor
{
Prefix = tagHelperPrefix,
TagName = descriptor.TagName,
TypeName = descriptor.TypeName,
AssemblyName = descriptor.AssemblyName,
Attributes = descriptor.Attributes,
RequiredAttributes = descriptor.RequiredAttributes,
AllowedChildren = descriptor.AllowedChildren,
TagStructure = descriptor.TagStructure,
DesignTimeDescriptor = descriptor.DesignTimeDescriptor
});
}
return descriptors;
}
/// <inheritdoc />
public IEnumerable<TagHelperDescriptor> Resolve(TagHelperDescriptorResolutionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var resolvedDescriptors = new HashSet<TagHelperDescriptor>(TagHelperDescriptorComparer.Default);
// tagHelperPrefix directives do not affect which TagHelperDescriptors are added or removed from the final
// list, need to remove them.
var actionableDirectiveDescriptors = context.DirectiveDescriptors.Where(
directive => directive.DirectiveType != TagHelperDirectiveType.TagHelperPrefix);
foreach (var directiveDescriptor in actionableDirectiveDescriptors)
{
try
{
var lookupInfo = GetLookupInfo(directiveDescriptor, context.ErrorSink);
// Could not resolve the lookup info.
if (lookupInfo == null)
{
return Enumerable.Empty<TagHelperDescriptor>();
}
if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.RemoveTagHelper)
{
resolvedDescriptors.RemoveWhere(descriptor => MatchesLookupInfo(descriptor, lookupInfo));
}
else if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.AddTagHelper)
{
var descriptors = ResolveDescriptorsInAssembly(
lookupInfo.AssemblyName,
lookupInfo.AssemblyNameLocation,
context.ErrorSink);
// Only use descriptors that match our lookup info
descriptors = descriptors.Where(descriptor => MatchesLookupInfo(descriptor, lookupInfo));
resolvedDescriptors.UnionWith(descriptors);
}
}
catch (Exception ex)
{
string directiveName;
_directiveNames.TryGetValue(directiveDescriptor.DirectiveType, out directiveName);
Debug.Assert(!string.IsNullOrEmpty(directiveName));
context.ErrorSink.OnError(
directiveDescriptor.Location,
Resources.FormatTagHelperDescriptorResolver_EncounteredUnexpectedError(
"@" + directiveName,
directiveDescriptor.DirectiveText,
ex.Message),
GetErrorLength(directiveDescriptor.DirectiveText));
}
}
var prefixedDescriptors = PrefixDescriptors(context, resolvedDescriptors);
return prefixedDescriptors;
}
public void Resolve_CreatesExpectedErrorsForTagHelperPrefixDirectives(
Dictionary<string, IEnumerable<Type>> descriptorAssemblyLookups,
IEnumerable<TagHelperDirectiveDescriptor> directiveDescriptors,
IEnumerable<TagHelperDescriptor> expectedDescriptors,
IEnumerable<RazorError> expectedErrors)
{
// Arrange
var tagHelperDescriptorResolver =
new TestTagHelperDescriptorResolver(
new LookupBasedTagHelperTypeResolver(descriptorAssemblyLookups));
var errorSink = new ParserErrorSink();
var resolutionContext = new TagHelperDescriptorResolutionContext(
directiveDescriptors,
errorSink);
// Act
var descriptors = tagHelperDescriptorResolver.Resolve(resolutionContext);
// Assert
Assert.Equal(expectedErrors, errorSink.Errors);
Assert.Equal(expectedDescriptors.Count(), descriptors.Count());
foreach (var expectedDescriptor in expectedDescriptors)
{
Assert.Contains(expectedDescriptor, descriptors, TagHelperDescriptorComparer.Default);
}
}
