Added to unit testing coverage.

Added Category Traits for No Trait tests.

Author: canhorn

Tests/EventHorizon.Blazor.TypeScript.Interop.Generator.Tests/Identifiers/AliasTypeIdentifierCachedTests.cs

@@ -0,0 +1,70 @@
+namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using EventHorizon.Blazor.TypeScript.Interop.Generator.AstParser.Api;
+    using EventHorizon.Blazor.TypeScript.Interop.Generator.AstParser.Model.Types;
+    using EventHorizon.Blazor.TypeScript.Interop.Generator.Identifiers;
+    using FluentAssertions;
+    using Moq;
+    using Xunit;
+
+    public class AliasTypeIdentifierCachedTests
+    {
+        [Fact]
+        [Trait("Category", "Caching")]
+        public async Task ShoudlOnlyReadFromASTOnceWhenCallingIdentifyAsSecondTime()
+        {
+            // Given
+            var expected = 1;
+            var identifierString = "identifier-string";
+            var mockNode = new NodeMock
+            {
+                IdentifierStr = identifierString,
+            };
+
+            var astMock = new Mock<AbstractSyntaxTree>();
+            var rootNodeMock = new Mock<Node>();
+
+            astMock.Setup(
+                mock => mock.RootNode
+            ).Returns(
+                rootNodeMock.Object
+            );
+
+            rootNodeMock.Setup(
+                mock => mock.OfKind(
+                    SyntaxKind.TypeAliasDeclaration
+                )
+            ).Returns(
+                new List<Node>
+                {
+                    mockNode
+                }
+            );
+
+            // When
+            var alias = new AliasTypeIdentifierCached();
+            var actual = alias.Identify(
+                identifierString,
+                astMock.Object
+            );
+            actual.Should().BeTrue();
+
+            actual = alias.Identify(
+                identifierString,
+                astMock.Object
+            );
+
+            // Then
+            actual.Should().BeTrue();
+
+            rootNodeMock.Verify(
+                mock => mock.OfKind(
+                    SyntaxKind.TypeAliasDeclaration
+                ),
+                Times.Exactly(expected)
+            );
+        }
+    }
+}

Tests/EventHorizon.Blazor.TypeScript.Interop.Generator.Tests/Identifiers/AliasTypeStatementIdentifierTests.cs

@@ -10,6 +10,7 @@ namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
     public class AliasTypeStatementIdentifierTests
     {
         [Fact]
+        [Trait("Category", "EdgeCase")]
         public void ShouldReturnNullWhenNodeIsNotFound()
         {
             // Given

Tests/EventHorizon.Blazor.TypeScript.Interop.Generator.Tests/Identifiers/NodeMock.cs

@@ -0,0 +1,30 @@
+namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
+{
+    using System;
+    using System.Collections.Generic;
+    using EventHorizon.Blazor.TypeScript.Interop.Generator.AstParser.Api;
+
+    public class NodeMock
+        : Node
+    {
+        public Node Parent { get; }
+        public Node First { get; }
+        public Node Last { get; }
+        public string IdentifierStr { get; set; }
+        public string Kind { get; set; }
+        public IEnumerable<Node> Modifiers { get; }
+        public Node Type { get; }
+        public Node ElementType { get; }
+        public IEnumerable<Node> TypeParameters { get; set; }
+        public IEnumerable<Node> HeritageClauses { get; }
+        public IEnumerable<Node> Types { get; }
+        public IEnumerable<Node> TypeArguments { get; }
+        public IEnumerable<Node> Parameters { get; }
+        public IEnumerable<Node> Children { get; }
+
+        public IEnumerable<Node> OfKind(string kind)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Tests/EventHorizon.Blazor.TypeScript.Interop.Generator.Tests/Identifiers/TypeIdentifyTests.cs

@@ -11,6 +11,7 @@ namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
     public class TypeIdentifyTests
     {
         [Fact]
+        [Trait("Category", "EdgeCase")]
         public void ShouldReturnClassMetadataNameWhenNodeIsKindParameter()
         {
             // Given

Tests/EventHorizon.Blazor.TypeScript.Interop.Generator.Tests/Identifiers/TypeParameterIdentifierTests.cs

@@ -1,6 +1,5 @@
 namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
 {
-    using System;
     using System.Collections.Generic;
     using EventHorizon.Blazor.TypeScript.Interop.Generator.AstParser.Api;
     using EventHorizon.Blazor.TypeScript.Interop.Generator.AstParser.Model.Types;
@@ -11,9 +10,10 @@ namespace EventHorizon.Blazor.TypeScript.Interop.Generator.Tests.Identifiers
     public class TypeParameterIdentifierTests
     {
         [Theory]
+        [Trait("Category", "EdgeCase")]
         [InlineData(SyntaxKind.ClassDeclaration)]
         [InlineData(SyntaxKind.InterfaceDeclaration)]
-        public void ShouldReturnListOfTypeParametersOnNodeWhenKindIsClassDeclaration(
+        public void ShouldReturnListOfTypeParametersOnNodeWhenKindIsSyntaxKind(
             string kind
         )
         {
@@ -49,9 +49,10 @@ string kind
         }
 
         [Theory]
+        [Trait("Category", "EdgeCase")]
         [InlineData(SyntaxKind.ClassDeclaration)]
         [InlineData(SyntaxKind.InterfaceDeclaration)]
-        public void ShouldReturnEmptyListWhenClassDeclarationTypeParametersAreNull(
+        public void ShouldReturnEmptyListWhenTypeParametersAreNull(
             string kind
         )
         {
@@ -72,29 +73,5 @@ string kind
             // Then
             actual.Should().BeEmpty();
         }
-
-        public class NodeMock
-            : Node
-        {
-            public Node Parent { get; }
-            public Node First { get; }
-            public Node Last { get; }
-            public string IdentifierStr { get; set; }
-            public string Kind { get; set; }
-            public IEnumerable<Node> Modifiers { get; }
-            public Node Type { get; }
-            public Node ElementType { get; }
-            public IEnumerable<Node> TypeParameters { get; set; }
-            public IEnumerable<Node> HeritageClauses { get; }
-            public IEnumerable<Node> Types { get; }
-            public IEnumerable<Node> TypeArguments { get; }
-            public IEnumerable<Node> Parameters { get; }
-            public IEnumerable<Node> Children { get; }
-
-            public IEnumerable<Node> OfKind(string kind)
-            {
-                throw new NotImplementedException();
-            }
-        }
     }
 }