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