Exemplo n.º 1
0
    public void DefaultRazorDiagnostic_HashCodesEqual()
    {
        // Arrange
        var descriptor = new RazorDiagnosticDescriptor("RZ0000", () => "this is an {0}", RazorDiagnosticSeverity.Error);
        var span       = new SourceSpan("test.cs", 15, 1, 8, 5);

        var diagnostic1 = new DefaultRazorDiagnostic(descriptor, span, new object[0]);
        var diagnostic2 = new DefaultRazorDiagnostic(descriptor, span, new object[0]);

        // Act
        var result = diagnostic1.GetHashCode() == diagnostic2.GetHashCode();

        // Assert
        Assert.True(result);
    }
Exemplo n.º 2
0
    public void Create_WithDescriptor_AndArgs_CreatesDefaultRazorDiagnostic()
    {
        // Arrange
        var descriptor = new RazorDiagnosticDescriptor("RZ0001", () => "a", RazorDiagnosticSeverity.Error);
        var span       = new SourceSpan("test.cs", 15, 1, 8, 5);

        // Act
        var diagnostic = RazorDiagnostic.Create(descriptor, span, "Hello", "World");

        // Assert
        var defaultDiagnostic = Assert.IsType <DefaultRazorDiagnostic>(diagnostic);

        Assert.Equal("RZ0001", defaultDiagnostic.Id);
        Assert.Equal(RazorDiagnosticSeverity.Error, defaultDiagnostic.Severity);
        Assert.Equal(span, diagnostic.Span);
    }
Exemplo n.º 3
0
    public void DefaultRazorDiagnostic_NotEquals_DifferentId()
    {
        // Arrange
        var descriptor1 = new RazorDiagnosticDescriptor("RZ0001", () => "this is an {0}", RazorDiagnosticSeverity.Error);
        var descriptor2 = new RazorDiagnosticDescriptor("RZ0002", () => "this is an {0}", RazorDiagnosticSeverity.Error);
        var span        = new SourceSpan("test.cs", 15, 1, 8, 5);

        var diagnostic1 = new DefaultRazorDiagnostic(descriptor1, span, new object[0]);
        var diagnostic2 = new DefaultRazorDiagnostic(descriptor2, span, new object[0]);

        // Act
        var result = diagnostic1.Equals(diagnostic2);

        // Assert
        Assert.False(result);
    }
        private static RazorCodeActionContext CreateRazorCodeActionContext(
            CodeActionParams request,
            SourceLocation location,
            string filePath,
            string text,
            SourceSpan componentSourceSpan,
            bool supportsFileCreation      = true,
            bool supportsCodeActionResolve = true)
        {
            var shortComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");

            shortComponent.TagMatchingRule(rule => rule.TagName = "Component");
            var fullyQualifiedComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");

            fullyQualifiedComponent.TagMatchingRule(rule => rule.TagName = "Fully.Qualified.Component");

            var tagHelpers = new[] { shortComponent.Build(), fullyQualifiedComponent.Build() };

            var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
            var projectEngine  = RazorProjectEngine.Create(builder =>
            {
                builder.AddTagHelpers(tagHelpers);
                builder.AddDirective(InjectDirective.Directive);
            });
            var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);

            var cSharpDocument               = codeDocument.GetCSharpDocument();
            var diagnosticDescriptor         = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
            var diagnostic                   = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
            var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });

            codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);

            var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
                                                              document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
                                                              document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
                                                              document.Project.TagHelpers == tagHelpers, MockBehavior.Strict);

            var sourceText = SourceText.From(text);

            var context = new RazorCodeActionContext(request, documentSnapshot, codeDocument, location, sourceText, supportsFileCreation, supportsCodeActionResolve: supportsCodeActionResolve);

            return(context);
        }
Exemplo n.º 5
0
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType != JsonToken.StartObject)
        {
            return(null);
        }
        JObject jObject        = JObject.Load(reader);
        string  id             = jObject["Id"].Value <string>();
        int     severity       = jObject["Severity"].Value <int>();
        string  message        = jObject["Message"].Value <string>();
        JObject jObject2       = jObject["Span"].Value <JObject>();
        string  filePath       = jObject2["FilePath"].Value <string>();
        int     absoluteIndex  = jObject2["AbsoluteIndex"].Value <int>();
        int     lineIndex      = jObject2["LineIndex"].Value <int>();
        int     characterIndex = jObject2["CharacterIndex"].Value <int>();
        int     length         = jObject2["Length"].Value <int>();
        RazorDiagnosticDescriptor descriptor = new RazorDiagnosticDescriptor(id, () => message, (RazorDiagnosticSeverity)severity);
        SourceSpan span = new SourceSpan(filePath, absoluteIndex, lineIndex, characterIndex, length);

        return(RazorDiagnostic.Create(descriptor, span));
    }
Exemplo n.º 6
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType != JsonToken.StartObject)
            {
                return(null);
            }

            var diagnostic     = JObject.Load(reader);
            var span           = diagnostic[nameof(RazorDiagnostic.Span)].Value <JObject>();
            var absoluteIndex  = span[nameof(SourceSpan.AbsoluteIndex)].Value <int>();
            var lineIndex      = span[nameof(SourceSpan.LineIndex)].Value <int>();
            var characterIndex = span[nameof(SourceSpan.CharacterIndex)].Value <int>();
            var length         = span[nameof(SourceSpan.Length)].Value <int>();
            var filePath       = span[nameof(SourceSpan.FilePath)].Value <string>();
            var message        = diagnostic[RazorDiagnosticMessageKey].Value <string>();
            var id             = diagnostic[nameof(RazorDiagnostic.Id)].Value <string>();
            var severity       = diagnostic[nameof(RazorDiagnostic.Severity)].Value <int>();

            var descriptor = new RazorDiagnosticDescriptor(id, () => message, (RazorDiagnosticSeverity)severity);
            var sourceSpan = new SourceSpan(filePath, absoluteIndex, lineIndex, characterIndex, length);

            return(RazorDiagnostic.Create(descriptor, sourceSpan));
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType != JsonToken.StartObject)
            {
                return(null);
            }

            var diagnostic     = JObject.Load(reader);
            var span           = diagnostic[nameof(RazorDiagnostic.Span)].Value <JObject>();
            var absoluteIndex  = span[nameof(SourceSpan.AbsoluteIndex)].Value <int>();
            var lineIndex      = span[nameof(SourceSpan.LineIndex)].Value <int>();
            var characterIndex = span[nameof(SourceSpan.CharacterIndex)].Value <int>();
            var length         = span[nameof(SourceSpan.Length)].Value <int>();
            var filePath       = span[nameof(SourceSpan.FilePath)].Value <string>();
            var message        = diagnostic[RazorDiagnosticMessageKey].Value <string>();
            var typeName       = diagnostic[RazorDiagnosticTypeNameKey].Value <string>();

            if (string.Equals(typeName, typeof(DefaultRazorDiagnostic).FullName, StringComparison.Ordinal))
            {
                var id       = diagnostic[nameof(RazorDiagnostic.Id)].Value <string>();
                var severity = diagnostic[nameof(RazorDiagnostic.Severity)].Value <int>();

                var descriptor = new RazorDiagnosticDescriptor(id, () => message, (RazorDiagnosticSeverity)severity);
                var sourceSpan = new SourceSpan(filePath, absoluteIndex, lineIndex, characterIndex, length);

                return(RazorDiagnostic.Create(descriptor, sourceSpan));
            }
            else if (string.Equals(typeName, typeof(LegacyRazorDiagnostic).FullName, StringComparison.Ordinal))
            {
                var error = new RazorError(message, absoluteIndex, lineIndex, characterIndex, length);

                return(RazorDiagnostic.Create(error));
            }

            return(null);
        }
Exemplo n.º 8
0
 internal DefaultRazorDiagnostic(RazorDiagnosticDescriptor descriptor, SourceSpan span, object[] args)
 {
     Descriptor = descriptor;
     Span       = span;
     Args       = args;
 }