Exemple #1
0
        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
        }
Exemple #2
0
    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);
    }
Exemple #3
0
        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));
        }
Exemple #4
0
        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));
        }
Exemple #5
0
        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);
        }
Exemple #6
0
        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);
        }
Exemple #7
0
        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);
        }
Exemple #8
0
        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);
        }
Exemple #9
0
        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());
        }
Exemple #10
0
        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);
        }
Exemple #11
0
    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);
    }
Exemple #12
0
        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());
        }
Exemple #13
0
        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);
        }
Exemple #14
0
        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);
        }
Exemple #15
0
        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);
        }
Exemple #16
0
        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);
        }
Exemple #17
0
        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));
            });
        }
Exemple #18
0
    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);
        }
    }
Exemple #19
0
        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);
        }
Exemple #20
0
        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);
        }
Exemple #21
0
        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);
        }
Exemple #22
0
        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));
        }
Exemple #23
0
        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);
        }
Exemple #24
0
        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);
        }
Exemple #25
0
        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);
        }
Exemple #26
0
        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);
        }
Exemple #27
0
        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);
    }
Exemple #29
0
    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));
    }
Exemple #30
0
        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);
        }