public void CreateDescriptor_BuildsDescriptorsWithConventionNames() { // Arrange var errorSink = new ParserErrorSink(); var intProperty = typeof(SingleAttributeTagHelper).GetProperty(nameof(SingleAttributeTagHelper.IntAttribute)); var expectedDescriptor = new TagHelperDescriptor( "single-attribute", typeof(SingleAttributeTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("int-attribute", intProperty) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(SingleAttributeTagHelper), new ParserErrorSink()); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_GetsTagNamesFromMultipleAttributes() { // Arrange var expectedDescriptors = new[] { new TagHelperDescriptor( "span", typeof(MultipleAttributeTagHelper).FullName, AssemblyName, ContentBehavior.None), new TagHelperDescriptor( "p", typeof(MultipleAttributeTagHelper).FullName, AssemblyName, ContentBehavior.None), new TagHelperDescriptor( "div", typeof(MultipleAttributeTagHelper).FullName, AssemblyName, ContentBehavior.None) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(MultipleAttributeTagHelper)); // Assert Assert.Equal(expectedDescriptors, descriptors, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_ResolvesMultipleTagHelperDescriptorsFromSingleType() { // Arrange var errorSink = new ParserErrorSink(); var validProp = typeof(MultiTagTagHelper).GetProperty(nameof(MultiTagTagHelper.ValidAttribute)); var expectedDescriptors = new[] { new TagHelperDescriptor( "p", typeof(MultiTagTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("valid-attribute", validProp) }), new TagHelperDescriptor( "div", typeof(MultiTagTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("valid-attribute", validProp) }) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(MultiTagTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_WithPrefixes_ReturnsExpectedAttributeDescriptors( Type tagHelperType, IEnumerable <TagHelperAttributeDescriptor> expectedAttributeDescriptors, string[] expectedErrorMessages) { // Arrange var errorSink = new ErrorSink(); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), designTime: false, errorSink: errorSink); // Assert var errors = errorSink.Errors.ToArray(); Assert.Equal(expectedErrorMessages.Length, errors.Length); for (var i = 0; i < errors.Length; i++) { Assert.Equal(0, errors[i].Length); Assert.Equal(SourceLocation.Zero, errors[i].Location); Assert.Equal(expectedErrorMessages[i], errors[i].Message, StringComparer.Ordinal); } var descriptor = Assert.Single(descriptors); Assert.Equal( expectedAttributeDescriptors, descriptor.Attributes, TagHelperAttributeDescriptorComparer.Default); }
public void CreateDescriptor_DoesNotInheritOverridenAttributeName() { // Arrange var validProperty1 = typeof(InheritedOverriddenAttributeTagHelper).GetProperty( nameof(InheritedOverriddenAttributeTagHelper.ValidAttribute1)); var validProperty2 = typeof(InheritedOverriddenAttributeTagHelper).GetProperty( nameof(InheritedOverriddenAttributeTagHelper.ValidAttribute2)); var expectedDescriptors = new[] { new TagHelperDescriptor( "InheritedOverriddenAttribute", typeof(InheritedOverriddenAttributeTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(InheritedOverriddenAttributeTagHelper.ValidAttribute1), validProperty1), new TagHelperAttributeDescriptor("Something-Else", validProperty2) }) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(InheritedOverriddenAttributeTagHelper)); // Assert Assert.Equal(expectedDescriptors, descriptors, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_AllowsOverridenAttributeNameOnUnimplementedVirtual() { // Arrange var errorSink = new ParserErrorSink(); var validProperty1 = typeof(InheritedNotOverriddenAttributeTagHelper).GetProperty( nameof(InheritedNotOverriddenAttributeTagHelper.ValidAttribute1)); var validProperty2 = typeof(InheritedNotOverriddenAttributeTagHelper).GetProperty( nameof(InheritedNotOverriddenAttributeTagHelper.ValidAttribute2)); var expectedDescriptors = new[] { new TagHelperDescriptor( "inherited-not-overridden-attribute", typeof(InheritedNotOverriddenAttributeTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("SomethingElse", validProperty1), new TagHelperAttributeDescriptor("Something-Else", validProperty2) }) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(InheritedNotOverriddenAttributeTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_IgnoresDuplicateTagNamesFromAttribute() { // Arrange var errorSink = new ParserErrorSink(); var expectedDescriptors = new[] { new TagHelperDescriptor( "p", typeof(DuplicateTagNameTagHelper).FullName, AssemblyName), new TagHelperDescriptor( "div", typeof(DuplicateTagNameTagHelper).FullName, AssemblyName) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(DuplicateTagNameTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
/// <summary> /// Instantiates a new instance of <see cref="TagHelperDescriptorResolver"/> class with the /// specified <paramref name="typeResolver"/>. /// </summary> /// <param name="typeResolver">The <see cref="TagHelperTypeResolver"/>.</param> /// <param name="descriptorFactory">The <see cref="TagHelperDescriptorFactory"/>.</param> public TagHelperDescriptorResolver( TagHelperTypeResolver typeResolver, TagHelperDescriptorFactory descriptorFactory) { _typeResolver = typeResolver; _descriptorFactory = descriptorFactory; }
public void CreateDescriptor_ResolvesMultipleTagHelperDescriptorsFromSingleType() { // Arrange var validProp = typeof(MultiTagTagHelper).GetProperty(nameof(MultiTagTagHelper.ValidAttribute)); var expectedDescriptors = new[] { new TagHelperDescriptor( "div", typeof(MultiTagTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(MultiTagTagHelper.ValidAttribute), validProp) }), new TagHelperDescriptor( "p", typeof(MultiTagTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(MultiTagTagHelper.ValidAttribute), validProp) }) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(MultiTagTagHelper)); // Assert Assert.Equal(expectedDescriptors, descriptors, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_WithPrefixes_ReturnsExpectedAttributeDescriptors( Type tagHelperType, IEnumerable<TagHelperAttributeDescriptor> expectedAttributeDescriptors, string[] expectedErrorMessages) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), errorSink: errorSink); // Assert var errors = errorSink.Errors.ToArray(); Assert.Equal(expectedErrorMessages.Length, errors.Length); for (var i = 0; i < errors.Length; i++) { Assert.Equal(0, errors[i].Length); Assert.Equal(SourceLocation.Zero, errors[i].Location); Assert.Equal(expectedErrorMessages[i], errors[i].Message, StringComparer.Ordinal); } var descriptor = Assert.Single(descriptors); Assert.Equal( expectedAttributeDescriptors, descriptor.Attributes, TagHelperAttributeDescriptorComparer.Default); }
public void CreateDescriptor_DoesntResolveInheritedTagNames() { // Arrange var errorSink = new ParserErrorSink(); var validProp = typeof(InheritedMultiTagTagHelper).GetProperty(nameof(InheritedMultiTagTagHelper.ValidAttribute)); var expectedDescriptor = new TagHelperDescriptor( "inherited-multi-tag", typeof(InheritedMultiTagTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("valid-attribute", validProp) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(InheritedMultiTagTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_OnlyAcceptsPropertiesWithPublicGetAndSet() { // Arrange var errorSink = new ParserErrorSink(); var validProperty = typeof(PrivateAccessorTagHelper).GetProperty( nameof(PrivateAccessorTagHelper.ValidAttribute)); var expectedDescriptor = new TagHelperDescriptor( "private-accessor", typeof(PrivateAccessorTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor( "valid-attribute", validProperty) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(PrivateAccessorTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void GetCommaSeparatedValues_OutputsEmptyArrayForNullValue() { // Act var result = TagHelperDescriptorFactory.GetCommaSeparatedValues(text: null); // Assert Assert.Empty(result); }
public void GetCommaSeparatedValues_OutputsCommaSeparatedListOfNames( string name, IEnumerable <string> expectedNames) { // Act var result = TagHelperDescriptorFactory.GetCommaSeparatedValues(name); // Assert Assert.Equal(expectedNames, result); }
public void CreateDescriptor_BuildsDescriptorsFromSimpleTypes() { // Arrange var expectedDescriptor = new TagHelperDescriptor("Object", "System.Object", ContentBehavior.None); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(object)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
/// <summary> /// Resolves all <see cref="TagHelperDescriptor"/>s for <see cref="Razor.TagHelpers.ITagHelper"/>s from the /// given <paramref name="assemblyName"/>. /// </summary> /// <param name="assemblyName"> /// The name of the assembly to resolve <see cref="TagHelperDescriptor"/>s from. /// </param> /// <param name="documentLocation">The <see cref="SourceLocation"/> of the directive.</param> /// <param name="errorSink">Used to record errors found when resolving <see cref="TagHelperDescriptor"/>s /// within the given <paramref name="assemblyName"/>.</param> /// <returns><see cref="TagHelperDescriptor"/>s for <see cref="Razor.TagHelpers.ITagHelper"/>s from the given /// <paramref name="assemblyName"/>.</returns> // This is meant to be overridden by tooling to enable assembly level caching. protected virtual IEnumerable <TagHelperDescriptor> ResolveDescriptorsInAssembly( string assemblyName, SourceLocation documentLocation, ErrorSink errorSink) { // Resolve valid tag helper types from the assembly. var tagHelperTypes = _typeResolver.Resolve(assemblyName, documentLocation, errorSink); // Convert types to TagHelperDescriptors var descriptors = tagHelperTypes.SelectMany( type => TagHelperDescriptorFactory.CreateDescriptors(assemblyName, type, _designTime, errorSink)); return(descriptors); }
public void CreateDescriptor_IgnoresDuplicateTagNamesFromAttribute() { // Arrange var expectedDescriptors = new[] { new TagHelperDescriptor("p", typeof(DuplicateTagNameTagHelper).FullName, ContentBehavior.None), new TagHelperDescriptor("div", typeof(DuplicateTagNameTagHelper).FullName, ContentBehavior.None) }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(DuplicateTagNameTagHelper)); // Assert Assert.Equal(expectedDescriptors, descriptors, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_BuildsDescriptorsFromSimpleTypes() { // Arrange var objectAssemblyName = typeof(object).GetTypeInfo().Assembly.GetName().Name; var expectedDescriptor = new TagHelperDescriptor("object", "System.Object", objectAssemblyName); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(object)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_OverridesTagNameFromAttribute() { // Arrange var expectedDescriptors = new[] { new TagHelperDescriptor("data-condition", typeof(OverrideNameTagHelper).FullName, ContentBehavior.None), }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(OverrideNameTagHelper)); // Assert Assert.Equal(expectedDescriptors, descriptors, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_HtmlCasesTagNameAndAttributeName( Type tagHelperType, string expectedTagName, string expectedAttributeName) { // Arrange & Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(tagHelperType); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedTagName, descriptor.TagName, StringComparer.Ordinal); var attributeDescriptor = Assert.Single(descriptor.Attributes); Assert.Equal(expectedAttributeName, attributeDescriptor.Name); }
public void CreateDescriptor_ResolvesCustomContentBehavior() { // Arrange var expectedDescriptor = new TagHelperDescriptor( "CustomContentBehavior", typeof(CustomContentBehaviorTagHelper).FullName, ContentBehavior.Append); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(CustomContentBehaviorTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_WithPrefixes_ReturnsExpectedAttributeDescriptors( Type tagHelperType, IEnumerable<TagHelperAttributeDescriptor> expectedAttributeDescriptors, string[] expectedErrorMessages) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), errorSink: errorSink); // Assert var errors = errorSink.Errors.ToArray(); Assert.Equal(expectedErrorMessages.Length, errors.Length); for (var i = 0; i < errors.Length; i++) { Assert.Equal(0, errors[i].Length); Assert.Equal(SourceLocation.Zero, errors[i].Location); Assert.Equal(expectedErrorMessages[i], errors[i].Message, StringComparer.Ordinal); } var descriptor = Assert.Single(descriptors); #if DNXCORE50 // In CoreCLR type forwarding of System.Runtime types causes issues with comparing FullNames for generic types. // We'll work around this by sanitizing the type names so that the assembly qualification is removed. foreach (var attributeDescriptor in expectedAttributeDescriptors) { attributeDescriptor.TypeName = RuntimeTypeInfo.SanitizeFullName(attributeDescriptor.TypeName); } foreach (var attributeDescriptor in descriptor.Attributes) { attributeDescriptor.TypeName = RuntimeTypeInfo.SanitizeFullName(attributeDescriptor.TypeName); } #endif Assert.Equal( expectedAttributeDescriptors, descriptor.Attributes, TagHelperAttributeDescriptorComparer.Default); }
public void CreateDescriptors_ReturnsExpectedDescriptors( Type tagHelperType, IEnumerable <TagHelperDescriptor> expectedDescriptors) { // Arrange var errorSink = new ParserErrorSink(); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, tagHelperType, errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_DoesNotResolveInheritedCustomContentBehavior() { // Arrange var expectedDescriptor = new TagHelperDescriptor( "InheritedCustomContentBehavior", typeof(InheritedCustomContentBehaviorTagHelper).FullName, AssemblyName, ContentBehavior.None); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( typeof(InheritedCustomContentBehaviorTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void ValidTargetElementAttributeNames_CreatesErrorOnInvalidNames( string name, string[] expectedErrorMessages) { // Arrange var errorSink = new ParserErrorSink(); var attribute = new TargetElementAttribute(name); // Act TagHelperDescriptorFactory.ValidTargetElementAttributeNames(attribute, errorSink); // Assert var errors = errorSink.Errors.ToArray(); for (var i = 0; i < errors.Length; i++) { Assert.Equal(expectedErrorMessages[i], errors[i].Message); Assert.Equal(SourceLocation.Zero, errors[i].Location); } }
public void CreateDescriptors_BuildsDescriptorsFromSimpleTypes() { // Arrange var errorSink = new ErrorSink(); var objectAssemblyName = typeof(object).GetTypeInfo().Assembly.GetName().Name; var expectedDescriptor = CreateTagHelperDescriptor("object", "System.Object", objectAssemblyName); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( objectAssemblyName, GetTypeInfo(typeof(object)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_BuildsDescriptorsWithConventionNames() { // Arrange var intProperty = typeof(SingleAttributeTagHelper).GetProperty(nameof(SingleAttributeTagHelper.IntAttribute)); var expectedDescriptor = new TagHelperDescriptor( "SingleAttribute", typeof(SingleAttributeTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(SingleAttributeTagHelper.IntAttribute), intProperty) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(SingleAttributeTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_OverridesTagNameFromAttribute() { // Arrange var errorSink = new ParserErrorSink(); var expectedDescriptors = new[] { new TagHelperDescriptor("data-condition", typeof(OverrideNameTagHelper).FullName, AssemblyName), }; // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, typeof(OverrideNameTagHelper), errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_DoesntResolveInheritedTagNames() { // Arrange var validProp = typeof(InheritedMultiTagTagHelper).GetProperty(nameof(InheritedMultiTagTagHelper.ValidAttribute)); var expectedDescriptor = new TagHelperDescriptor( "InheritedMultiTag", typeof(InheritedMultiTagTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(InheritedMultiTagTagHelper.ValidAttribute), validProp) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(InheritedMultiTagTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_BuildsDescriptorsFromSimpleTypes() { // Arrange var errorSink = new ParserErrorSink(); var objectAssemblyName = typeof(object).GetTypeInfo().Assembly.GetName().Name; var expectedDescriptor = new TagHelperDescriptor("object", "System.Object", objectAssemblyName); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( objectAssemblyName, typeof(object), errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_OnlyAcceptsPropertiesWithGetAndSet() { // Arrange var validProperty = typeof(MissingAccessorTagHelper).GetProperty( nameof(MissingAccessorTagHelper.ValidAttribute)); var expectedDescriptor = new TagHelperDescriptor( "MissingAccessor", typeof(MissingAccessorTagHelper).FullName, ContentBehavior.None, new[] { new TagHelperAttributeDescriptor(nameof(MissingAccessorTagHelper.ValidAttribute), validProperty) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(MissingAccessorTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_BuildsDescriptorsWithInheritedProperties() { // Arrange var intProperty = typeof(InheritedSingleAttributeTagHelper).GetProperty( nameof(InheritedSingleAttributeTagHelper.IntAttribute)); var expectedDescriptor = new TagHelperDescriptor( "inherited-single-attribute", typeof(InheritedSingleAttributeTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor("int-attribute", intProperty) }); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors(typeof(InheritedSingleAttributeTagHelper)); // Assert var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CompleteTagHelperDescriptorComparer.Default); }
public void CreateDescriptor_HtmlCasesTagNameAndAttributeName( Type tagHelperType, string expectedTagName, string expectedAttributeName) { // Arrange var errorSink = new ParserErrorSink(); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, tagHelperType, errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedTagName, descriptor.TagName, StringComparer.Ordinal); var attributeDescriptor = Assert.Single(descriptor.Attributes); Assert.Equal(expectedAttributeName, attributeDescriptor.Name); }
public void CreateDescriptors_CreatesDesignTimeDescriptorsWithOutputElementHint( Type tagHelperType, TagHelperDescriptor[] expectedDescriptors) { // Arrange var errorSink = new ErrorSink(); // Act var descriptors = TagHelperDescriptorFactory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), designTime: true, errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); // We don't care about order. Mono returns reflected attributes differently so we need to ensure order // doesn't matter by sorting. descriptors = descriptors.OrderBy(descriptor => descriptor.TagName); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_AllowsOverridenAttributeNameOnUnimplementedVirtual() { // Arrange var errorSink = new ErrorSink(); var validProperty1 = typeof(InheritedNotOverriddenAttributeTagHelper).GetProperty( nameof(InheritedNotOverriddenAttributeTagHelper.ValidAttribute1)); var validProperty2 = typeof(InheritedNotOverriddenAttributeTagHelper).GetProperty( nameof(InheritedNotOverriddenAttributeTagHelper.ValidAttribute2)); var expectedDescriptors = new[] { CreateTagHelperDescriptor( "inherited-not-overridden-attribute", typeof(InheritedNotOverriddenAttributeTagHelper).FullName, AssemblyName, new[] { CreateTagHelperAttributeDescriptor("SomethingElse", validProperty1), CreateTagHelperAttributeDescriptor("Something-Else", validProperty2) }) }; var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(InheritedNotOverriddenAttributeTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_ResolvesMultipleTagHelperDescriptorsFromSingleType() { // Arrange var errorSink = new ErrorSink(); var expectedDescriptors = new[] { CreateTagHelperDescriptor( "div", typeof(MultiTagTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor { Name = "valid-attribute", PropertyName = nameof(MultiTagTagHelper.ValidAttribute), TypeName = typeof(string).FullName, IsStringProperty = true } }), CreateTagHelperDescriptor( "p", typeof(MultiTagTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor { Name = "valid-attribute", PropertyName = nameof(MultiTagTagHelper.ValidAttribute), TypeName = typeof(string).FullName, IsStringProperty = true } }) }; var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(MultiTagTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); // We don't care about order. Mono returns reflected attributes differently so we need to ensure order // doesn't matter by sorting. descriptors = descriptors.OrderBy(descriptor => descriptor.TagName).ToArray(); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_AddsErrorForTagHelperWithDuplicateAttributeNames() { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(DuplicateAttributeNameTagHelper)), errorSink: errorSink); // Assert Assert.Empty(descriptors); var error = Assert.Single(errorSink.Errors); }
public void CreateDescriptors_IgnoresDuplicateTagNamesFromAttribute() { // Arrange var errorSink = new ErrorSink(); var expectedDescriptors = new[] { CreateTagHelperDescriptor( "div", typeof(DuplicateTagNameTagHelper).FullName, AssemblyName), CreateTagHelperDescriptor( "p", typeof(DuplicateTagNameTagHelper).FullName, AssemblyName) }; var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(DuplicateTagNameTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); // We don't care about order. Mono returns reflected attributes differently so we need to ensure order // doesn't matter by sorting. descriptors = descriptors.OrderBy(descriptor => descriptor.TagName).ToArray(); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_DoesNotResolveInheritedTagNames() { // Arrange var errorSink = new ErrorSink(); var validProp = typeof(InheritedMultiTagTagHelper).GetProperty(nameof(InheritedMultiTagTagHelper.ValidAttribute)); var expectedDescriptor = CreateTagHelperDescriptor( "inherited-multi-tag", typeof(InheritedMultiTagTagHelper).FullName, AssemblyName, new[] { CreateTagHelperAttributeDescriptor("valid-attribute", validProp) }); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(InheritedMultiTagTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_DoesNotAllowDataDashAttributes( Type type, IEnumerable<TagHelperAttributeDescriptor> expectedAttributeDescriptors, string[] expectedErrors) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(type), errorSink: errorSink); // Assert var actualErrors = errorSink.Errors.ToArray(); Assert.Equal(expectedErrors.Length, actualErrors.Length); for (var i = 0; i < actualErrors.Length; i++) { var actualError = actualErrors[i]; Assert.Equal(0, actualError.Length); Assert.Equal(SourceLocation.Zero, actualError.Location); Assert.Equal(expectedErrors[i], actualError.Message, StringComparer.Ordinal); } var actualDescriptor = Assert.Single(descriptors); Assert.Equal( expectedAttributeDescriptors, actualDescriptor.Attributes, TagHelperAttributeDescriptorComparer.Default); }
public void CreateDescriptors_OverridesTagNameFromAttribute() { // Arrange var errorSink = new ErrorSink(); var expectedDescriptors = new[] { CreateTagHelperDescriptor( "data-condition", typeof(OverrideNameTagHelper).FullName, AssemblyName), }; var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(OverrideNameTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_UnderstandsEditorBrowsableAttribute( Type tagHelperType, bool designTime, TagHelperDescriptor[] expectedDescriptors) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), errorSink); // Assert Assert.Empty(errorSink.Errors); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_BuildsDescriptorsWithConventionNames() { // Arrange var errorSink = new ErrorSink(); var intProperty = typeof(SingleAttributeTagHelper).GetProperty(nameof(SingleAttributeTagHelper.IntAttribute)); var expectedDescriptor = CreateTagHelperDescriptor( "single-attribute", typeof(SingleAttributeTagHelper).FullName, AssemblyName, new[] { CreateTagHelperAttributeDescriptor("int-attribute", intProperty) }); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(SingleAttributeTagHelper)), errorSink: new ErrorSink()); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_DoesNotIncludePropertiesWithNotBound() { // Arrange var errorSink = new ErrorSink(); var expectedDescriptor = CreateTagHelperDescriptor( "not-bound-attribute", typeof(NotBoundAttributeTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor { Name = "bound-property", PropertyName = nameof(NotBoundAttributeTagHelper.BoundProperty), TypeName = typeof(object).FullName } }); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(NotBoundAttributeTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_HtmlCasesTagNameAndAttributeName( Type tagHelperType, string expectedTagName, string expectedAttributeName) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedTagName, descriptor.TagName, StringComparer.Ordinal); var attributeDescriptor = Assert.Single(descriptor.Attributes); Assert.Equal(expectedAttributeName, attributeDescriptor.Name); }
public void CreateDescriptors_IsEnumIsSetCorrectly( Type tagHelperType, TagHelperDescriptor[] expectedDescriptors) { // Arrange var errorSink = new ErrorSink(); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(tagHelperType), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); // We don't care about order. Mono returns reflected attributes differently so we need to ensure order // doesn't matter by sorting. descriptors = descriptors.OrderBy(descriptor => descriptor.TagName); Assert.Equal(expectedDescriptors, descriptors, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_OnlyAcceptsPropertiesWithPublicGetAndSet() { // Arrange var errorSink = new ErrorSink(); var validProperty = typeof(NonPublicAccessorTagHelper).GetProperty( nameof(NonPublicAccessorTagHelper.ValidAttribute)); var expectedDescriptor = CreateTagHelperDescriptor( "non-public-accessor", typeof(NonPublicAccessorTagHelper).FullName, AssemblyName, new[] { CreateTagHelperAttributeDescriptor("valid-attribute", validProperty) }); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(NonPublicAccessorTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }
public void CreateDescriptors_BuildsDescriptorsWithInheritedProperties() { // Arrange var errorSink = new ErrorSink(); var expectedDescriptor = CreateTagHelperDescriptor( "inherited-single-attribute", typeof(InheritedSingleAttributeTagHelper).FullName, AssemblyName, new[] { new TagHelperAttributeDescriptor { Name = "int-attribute", PropertyName = nameof(InheritedSingleAttributeTagHelper.IntAttribute), TypeName = typeof(int).FullName } }); var factory = new TagHelperDescriptorFactory(designTime: false); // Act var descriptors = factory.CreateDescriptors( AssemblyName, GetTypeInfo(typeof(InheritedSingleAttributeTagHelper)), errorSink: errorSink); // Assert Assert.Empty(errorSink.Errors); var descriptor = Assert.Single(descriptors); Assert.Equal(expectedDescriptor, descriptor, CaseSensitiveTagHelperDescriptorComparer.Default); }