public void IsAssignable_ReturnsTrueIfAncestorTypeImplementsInterface()
{
// Arrange
var source = @"
namespace TestApp
{
public interface ITestInterface
{
}
public class ITestInterfaceA : ITestInterface
{
}
public class ITestInterfaceB : ITestInterfaceA
{
}
public class TestClass : ITestInterfaceB
{
}";
var compilation = TestCompilation.Create(source);
var sourceType = compilation.GetTypeByMetadataName("TestApp.ITestInterface");
var target = compilation.GetTypeByMetadataName("TestApp.TestClass");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(sourceType, target);
var isAssignableFromDerived = CodeAnalysisExtensions.IsAssignableFrom(target, sourceType);
// Assert
Assert.True(isAssignableFrom);
Assert.False(isAssignableFromDerived); // Inverse shouldn't be true
}
public async Task DetectFeaturesAsync_FindsNoFeatures()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Builder;
namespace Microsoft.AspNetCore.Analyzers.TestFiles.CompilationFeatureDetectorTest
{
public class StartupWithNoFeatures
{
public void Configure(IApplicationBuilder app)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapFallbackToFile(""index.html"");
});
}
}
}";
var compilation = TestCompilation.Create(source);
var symbols = new StartupSymbols(compilation);
var type = (INamedTypeSymbol)compilation.GetSymbolsWithName("StartupWithNoFeatures").Single();
Assert.True(StartupFacts.IsStartupClass(symbols, type));
// Act
var features = await CompilationFeatureDetector.DetectFeaturesAsync(compilation);
// Assert
Assert.Empty(features);
}
public void GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentAction()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace TestApp
{
public class BaseClass
{
[ProducesResponseType(200)]
[ProducesResponseType(404)]
public virtual void Method() { }
}
public class TestClass : BaseClass
{
[ProducesResponseType(400)]
public override void Method() { }
}
}
";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName("TestApp.TestClass");
var method = (IMethodSymbol)testClass.GetMembers("Method").First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: false);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(400, attributeData.ConstructorArguments[0].Value));
}
public void Execute_WithTargetAssembly_Works()
{
// Arrange
var testTagHelper = "TestAssembly.TestTagHelper";
var enumTagHelper = "Microsoft.CodeAnalysis.Razor.Workspaces.Test.EnumTagHelper";
var csharp = @"
using Microsoft.AspNetCore.Razor.TagHelpers;
namespace TestAssembly
{
public class TestTagHelper : TagHelper
{
public override void Process(TagHelperContext context, TagHelperOutput output) {}
}
}";
var compilation = TestCompilation.Create(_assembly, CSharpSyntaxTree.ParseText(csharp));
var descriptorProvider = new DefaultTagHelperDescriptorProvider();
var context = TagHelperDescriptorProviderContext.Create();
context.SetCompilation(compilation);
context.Items.SetTargetAssembly((IAssemblySymbol)compilation.GetAssemblyOrModuleSymbol(compilation.References.First(r => r.Display.Contains("Microsoft.CodeAnalysis.Razor.Test.dll"))));
// Act
descriptorProvider.Execute(context);
// Assert
Assert.NotNull(compilation.GetTypeByMetadataName(testTagHelper));
Assert.NotEmpty(context.Results);
Assert.Empty(context.Results.Where(f => f.GetTypeName() == testTagHelper));
Assert.NotEmpty(context.Results.Where(f => f.GetTypeName() == enumTagHelper));
}
public void HasAttribute_ReturnsTrueForAttributesOnOverridenProperties()
{
// Arrange
var source = @"
using System;
namespace TestApp
{
public class TestAttribute : Attribute { }
public class TestControllerBase
{
[TestAttribute]
public virtual string SomeProperty { get; set; }
}
public class TestController : TestControllerBase
{
public override string SomeProperty { get; set; }
}
}";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName("TestApp.TestAttribute");
var testClass = compilation.GetTypeByMetadataName("TestApp.TestController");
var property = (IPropertySymbol)testClass.GetMembers("SomeProperty").First();
// Act
var hasAttributeWithoutInherit = CodeAnalysisExtensions.HasAttribute(property, attribute, inherit: false);
var hasAttributeWithInherit = CodeAnalysisExtensions.HasAttribute(property, attribute, inherit: true);
// Assert
Assert.False(hasAttributeWithoutInherit);
Assert.True(hasAttributeWithInherit);
}
public void HasAttribute_ReturnsTrueForInterfaceContractOnAttribute()
{
// Arrange
var source = @"
using System;
namespace TestApp
{
public interface ITestInterface { }
public class TestAttribute : Attribute, ITestInterface { }
[TestAttribute]
public class TestController
{
}
}";
var compilation = TestCompilation.Create(source);
var @interface = compilation.GetTypeByMetadataName("TestApp.ITestInterface");
var testClass = compilation.GetTypeByMetadataName("TestApp.TestController");
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(testClass, @interface, inherit: true);
var hasAttributeOnDerived = CodeAnalysisExtensions.HasAttribute(testClass, @interface, inherit: true);
// Assert
Assert.True(hasAttribute);
Assert.True(hasAttributeOnDerived);
}
public void HasAttribute_ReturnsTrueForAttributesOnMethods()
{
// Arrange
var source = @"
using System;
namespace TestApp
{
public class TestAttribute : Attribute { }
public class TestController
{
[TestAttribute]
public void SomeMethod() { }
}
}";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName("TestApp.TestAttribute");
var testClass = compilation.GetTypeByMetadataName("TestApp.TestController");
var method = (IMethodSymbol)testClass.GetMembers("SomeMethod").First();
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(method, attribute, inherit: false);
// Assert
Assert.True(hasAttribute);
}
public void HasAttribute_ReturnsTrueIfBaseTypeHasAttribute()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace TestApp
{
[Controller]
public class TestControllerBase { }
public class TestController : TestControllerBase { }
}";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName("Microsoft.AspNetCore.Mvc.ControllerAttribute");
var testClass = compilation.GetTypeByMetadataName($"TestApp.TestController");
// Act
var hasAttributeWithoutInherit = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: false);
var hasAttributeWithInherit = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: true);
// Assert
Assert.False(hasAttributeWithoutInherit);
Assert.True(hasAttributeWithInherit);
}
public void Execute_WithFilterAssemblyDoesNotDiscoverTagHelpersFromReferences()
{
// Arrange
var typeName = "TestAssembly.TestTagHelper";
var csharp = @"
using Microsoft.AspNetCore.Razor.TagHelpers;
namespace TestAssembly
{
public class TestTagHelper : TagHelper
{
public override void Process(TagHelperContext context, TagHelperOutput output) {}
}
}";
var compilation = TestCompilation.Create(_assembly, CSharpSyntaxTree.ParseText(csharp));
var descriptorProvider = new DefaultTagHelperDescriptorProvider();
var context = TagHelperDescriptorProviderContext.Create();
context.SetCompilation(compilation);
context.Items.SetTagHelperDiscoveryFilter(TagHelperDiscoveryFilter.CurrentCompilation);
// Act
descriptorProvider.Execute(context);
// Assert
Assert.NotNull(compilation.GetTypeByMetadataName(typeName));
var descriptor = Assert.Single(context.Results);
Assert.Equal(typeName, descriptor.GetTypeName());
}
public void DescriptorProvider_FindsVCTH()
{
// Arrange
var code = @"
public class StringParameterViewComponent
{
public string Invoke(string foo, string bar) => null;
}
";
var testCompilation = TestCompilation.Create(_assembly, CSharpSyntaxTree.ParseText(code));
var context = TagHelperDescriptorProviderContext.Create();
context.SetCompilation(testCompilation);
var provider = new ViewComponentTagHelperDescriptorProvider()
{
Engine = RazorEngine.CreateEmpty(b => { }),
ForceEnabled = true,
};
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__StringParameterViewComponentTagHelper",
TestCompilation.AssemblyName)
.TypeName("__Generated__StringParameterViewComponentTagHelper")
.DisplayName("StringParameterViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:string-parameter")
.RequireAttributeDescriptor(attribute => attribute.Name("foo"))
.RequireAttributeDescriptor(attribute => attribute.Name("bar")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("foo")
.PropertyName("foo")
.TypeName(typeof(string).FullName)
.DisplayName("string StringParameterViewComponentTagHelper.foo"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("bar")
.PropertyName("bar")
.TypeName(typeof(string).FullName)
.DisplayName("string StringParameterViewComponentTagHelper.bar"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "StringParameter")
.Build();
// Act
provider.Execute(context);
// Assert
var descriptor = context.Results.FirstOrDefault(d => TagHelperDescriptorComparer.CaseSensitive.Equals(d, expectedDescriptor));
Assert.NotNull(descriptor);
}
public void IsStartupClass_RejectsNotStartupClass(string source)
{
// Arrange
var compilation = TestCompilation.Create(TestSources[source]);
var symbols = new StartupSymbols(compilation);
var type = (INamedTypeSymbol)compilation.GetSymbolsWithName(source).Single();
// Act
var result = StartupFacts.IsStartupClass(symbols, type);
// Assert
Assert.False(result);
}
public void CreateDescriptor_ForViewComponentWithInvokeAsync_UnderstandsNonGenericTask()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(AsyncViewComponentWithNonGenericTask).FullName);
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Empty(descriptor.GetAllDiagnostics());
}
public void CreateDescriptor_AddsDiagnostic_ForViewComponentWithNoPublicInvokeMethod()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(NonPublicInvokeAsyncViewComponent).FullName);
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
var diagnostic = Assert.Single(descriptor.GetAllDiagnostics());
Assert.Equal(RazorExtensionsDiagnosticFactory.ViewComponent_CannotFindMethod.Id, diagnostic.Id);
}
public void CreateDescriptor_ForViewComponentWithInvoke_DoesNotUnderstandGenericTask()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(SyncViewComponentWithGenericTask).FullName);
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
var diagnostic = Assert.Single(descriptor.GetAllDiagnostics());
Assert.Equal(RazorExtensionsDiagnosticFactory.ViewComponent_SyncMethod_CannotReturnTask.Id, diagnostic.Id);
}
public void CreateDescriptor_ForViewComponent_WithAmbiguousMethods()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(DerivedViewComponentWithAmbiguity).FullName);
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
var diagnostic = Assert.Single(descriptor.GetAllDiagnostics());
Assert.Equal(RazorExtensionsDiagnosticFactory.ViewComponent_AmbiguousMethods.Id, diagnostic.Id);
}
public void CreateDescriptor_UnderstandsVariousParameterTypes()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(VariousParameterViewComponent).FullName);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__VariousParameterViewComponentTagHelper",
typeof(VariousParameterViewComponent).GetTypeInfo().Assembly.GetName().Name)
.TypeName("__Generated__VariousParameterViewComponentTagHelper")
.DisplayName("VariousParameterViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:various-parameter")
.RequireAttributeDescriptor(attribute => attribute.Name("test-enum"))
.RequireAttributeDescriptor(attribute => attribute.Name("test-string"))
.RequireAttributeDescriptor(attribute => attribute.Name("baz")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("test-enum")
.PropertyName("testEnum")
.TypeName(typeof(VariousParameterViewComponent).FullName + "." + nameof(VariousParameterViewComponent.TestEnum))
.AsEnum()
.DisplayName(typeof(VariousParameterViewComponent).FullName + "." + nameof(VariousParameterViewComponent.TestEnum) + " VariousParameterViewComponentTagHelper.testEnum"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("test-string")
.PropertyName("testString")
.TypeName(typeof(string).FullName)
.DisplayName("string VariousParameterViewComponentTagHelper.testString"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("baz")
.PropertyName("baz")
.TypeName(typeof(int).FullName)
.DisplayName("int VariousParameterViewComponentTagHelper.baz"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "VariousParameter")
.Build();
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Equal(expectedDescriptor, descriptor, TagHelperDescriptorComparer.CaseSensitive);
}
public void GetAttributes_BaseTypeWithAttributes()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace TestApp
{
[ApiConventionType(typeof(object))]
[ApiController]
[ApiConventionType(typeof(string))]
public class BaseType
{
}
[ApiConventionType(typeof(int))]
public class TestClass : BaseType
{
}
}";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName("TestApp.TestClass");
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(testClass, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Int32));
},
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Object));
},
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_String));
});
}
public void IsConfigure_RejectsNonConfigureMethod(string source, string methodName)
{
// Arrange
var compilation = TestCompilation.Create(TestSources[source]);
var symbols = new StartupSymbols(compilation);
var type = (INamedTypeSymbol)compilation.GetSymbolsWithName(source).Single();
var methods = type.GetMembers(methodName).Cast <IMethodSymbol>();
foreach (var method in methods)
{
// Act
var result = StartupFacts.IsConfigure(symbols, method);
// Assert
Assert.False(result);
}
}
public void IsAssignable_ReturnsFalseIfTypeDoesNotImplementInterface()
{
// Arrange
var source = @"
namespace TestApp
{
public class TypeA { }
}";
var compilation = TestCompilation.Create(source);
var sourceType = compilation.GetTypeByMetadataName("TestApp.TypeA");
var target = compilation.GetTypeByMetadataName("System.IDisposable");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(sourceType, target);
// Assert
Assert.False(isAssignableFrom);
}
public void IsAssignable_ReturnsTrueIfTypesAreExact()
{
// Arrange
var source = @"
namespace TestApp
{
public class TestType { }
}";
var compilation = TestCompilation.Create(source);
var sourceType = compilation.GetTypeByMetadataName("TestApp.TestType");
var target = compilation.GetTypeByMetadataName("TestApp.TestType");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(sourceType, target);
// Assert
Assert.True(isAssignableFrom);
}
public void IsAssignable_ReturnsTrue_IfSourceAndDestinationAreTheSameInterface()
{
// Arrange
var source = @"
namespace TestApp
{
public interface ITestInterface { }
}";
var compilation = TestCompilation.Create(source);
var sourceType = compilation.GetTypeByMetadataName("TestApp.ITestInterface");
var target = compilation.GetTypeByMetadataName("TestApp.ITestInterface");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(sourceType, target);
// Assert
Assert.True(isAssignableFrom);
}
public void GetAttributes_OnNewMethodOfNonVirtualBaseMethod()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace TestApp
{
public class BaseClass
{
[ProducesResponseType(200)]
[ProducesResponseType(404)]
public virtual void VirtualMethod() { }
[ProducesResponseType(200)]
[ProducesResponseType(404)]
public virtual void NotVirtualMethod() { }
}
public class TestClass : BaseClass
{
[ProducesResponseType(400)]
public new void VirtualMethod() { }
[ProducesResponseType(401)]
public new void NotVirtualMethod() { }
}
}";
var compilation = TestCompilation.Create(source);
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName("TestApp.TestClass");
var method = (IMethodSymbol)testClass.GetMembers("NotVirtualMethod").First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(401, attributeData.ConstructorArguments[0].Value));
}
public void GetTagHelpers_DiscoversTagHelpers()
{
// Arrange
var code = $@"
public class TestTagHelper : {typeof(TagHelper).FullName}
{{
}}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = TestCompilation.Create(Assembly, syntaxTree);
var tagHelperResolver = new DefaultTagHelperResolver()
{
ForceEnableViewComponentDiscovery = true
};
// Act
var result = tagHelperResolver.GetTagHelpers(compilation);
// Assert
Assert.Empty(result.Diagnostics);
Assert.Equal(1, result.Descriptors.Count);
}
public void IsAssignable_ReturnsFalseForDifferentTypes()
{
// Arrange
var source = @"
namespace TestApp
{
public class TypeA { }
public class TypeB { }
}";
var compilation = TestCompilation.Create(source);
var sourceType = compilation.GetTypeByMetadataName("TestApp.TypeA");
var target = compilation.GetTypeByMetadataName("TestApp.TypeB");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(sourceType, target);
// Assert
Assert.False(isAssignableFrom);
}
public void Execute_DoesNotAddEditorBrowsableNeverDescriptorsAtDesignTime()
{
// Arrange
var editorBrowsableTypeName = "Microsoft.CodeAnalysis.Razor.Workspaces.Test.EditorBrowsableTagHelper";
var compilation = TestCompilation.Create(_assembly);
var descriptorProvider = new DefaultTagHelperDescriptorProvider();
var context = TagHelperDescriptorProviderContext.Create();
context.SetCompilation(compilation);
context.ExcludeHidden = true;
// Act
descriptorProvider.Execute(context);
// Assert
Assert.NotNull(compilation.GetTypeByMetadataName(editorBrowsableTypeName));
var nullDescriptors = context.Results.Where(descriptor => descriptor == null);
Assert.Empty(nullDescriptors);
var editorBrowsableDescriptor = context.Results.Where(descriptor => descriptor.GetTypeName() == editorBrowsableTypeName);
Assert.Empty(editorBrowsableDescriptor);
}
public void CreateDescriptor_ForSyncViewComponentWithInvokeInBaseType_Works()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__SyncDerivedViewComponentTagHelper",
typeof(SyncDerivedViewComponent).GetTypeInfo().Assembly.GetName().Name)
.TypeName("__Generated__SyncDerivedViewComponentTagHelper")
.DisplayName("SyncDerivedViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:sync-derived")
.RequireAttributeDescriptor(attribute => attribute.Name("foo"))
.RequireAttributeDescriptor(attribute => attribute.Name("bar")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("foo")
.PropertyName("foo")
.TypeName(typeof(string).FullName)
.DisplayName("string SyncDerivedViewComponentTagHelper.foo"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("bar")
.PropertyName("bar")
.TypeName(typeof(string).FullName)
.DisplayName("string SyncDerivedViewComponentTagHelper.bar"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "SyncDerived")
.Build();
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(SyncDerivedViewComponent).FullName);
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Equal(expectedDescriptor, descriptor, TagHelperDescriptorComparer.CaseSensitive);
}
public void CreateDescriptor_UnderstandsGenericParameters()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(GenericParameterViewComponent).FullName);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__GenericParameterViewComponentTagHelper",
typeof(GenericParameterViewComponent).GetTypeInfo().Assembly.GetName().Name)
.TypeName("__Generated__GenericParameterViewComponentTagHelper")
.DisplayName("GenericParameterViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:generic-parameter")
.RequireAttributeDescriptor(attribute => attribute.Name("foo")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("foo")
.PropertyName("Foo")
.TypeName("System.Collections.Generic.List<System.String>")
.DisplayName("System.Collections.Generic.List<System.String> GenericParameterViewComponentTagHelper.Foo"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("bar")
.PropertyName("Bar")
.TypeName("System.Collections.Generic.Dictionary<System.String, System.Int32>")
.AsDictionaryAttribute("bar-", typeof(int).FullName)
.DisplayName("System.Collections.Generic.Dictionary<System.String, System.Int32> GenericParameterViewComponentTagHelper.Bar"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "GenericParameter")
.Build();
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Equal(expectedDescriptor, descriptor, TagHelperDescriptorComparer.CaseSensitive);
}
public void CreateDescriptor_UnderstandsStringParameters()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(StringParameterViewComponent).FullName);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__StringParameterViewComponentTagHelper",
typeof(StringParameterViewComponent).GetTypeInfo().Assembly.GetName().Name)
.TypeName("__Generated__StringParameterViewComponentTagHelper")
.DisplayName("StringParameterViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:string-parameter")
.RequireAttributeDescriptor(attribute => attribute.Name("foo"))
.RequireAttributeDescriptor(attribute => attribute.Name("bar")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("foo")
.PropertyName("foo")
.TypeName(typeof(string).FullName)
.DisplayName("string StringParameterViewComponentTagHelper.foo"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("bar")
.PropertyName("bar")
.TypeName(typeof(string).FullName)
.DisplayName("string StringParameterViewComponentTagHelper.bar"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "StringParameter")
.Build();
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Equal(expectedDescriptor, descriptor, TagHelperDescriptorComparer.Default);
}
public async Task DetectFeatureAsync_StartupWithMapHub_FindsSignalR()
{
var source = @"
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.SignalR;
namespace Microsoft.AspNetCore.Analyzers.TestFiles.CompilationFeatureDetectorTest
{
public class StartupWithMapHub
{
public void Configure(IApplicationBuilder app)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHub<MyHub>("" / test"");
});
}
}
public class MyHub : Hub
{
}
}
";
var compilation = TestCompilation.Create(source);
var symbols = new StartupSymbols(compilation);
var type = (INamedTypeSymbol)compilation.GetSymbolsWithName("StartupWithMapHub").Single();
Assert.True(StartupFacts.IsStartupClass(symbols, type));
// Act
var features = await CompilationFeatureDetector.DetectFeaturesAsync(compilation);
// Assert
Assert.Collection(features, f => Assert.Equal(WellKnownFeatures.SignalR, f));
}
public void GetTagHelpers_DiscoversViewComponentTagHelpers()
{
// Arrange
var code = @"
public class TestViewComponent
{
public string Invoke(string foo, string bar) => null;
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = TestCompilation.Create(Assembly, syntaxTree);
var tagHelperResolver = new DefaultTagHelperResolver()
{
ForceEnableViewComponentDiscovery = true
};
// Act
var result = tagHelperResolver.GetTagHelpers(compilation);
// Assert
Assert.Empty(result.Diagnostics);
Assert.Equal(1, result.Descriptors.Count);
}
