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); } }