Added tests for anglesharp extensions, JsRuntimeInvocation and ComponentParameter

egil · egil · commit 26be4679bdc9 · 2020-01-16T12:51:13.000Z
diff --git a/sample/tests/Assembly.cs b/sample/tests/Assembly.cs
@@ -0,0 +1 @@
+﻿[assembly: System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
diff --git a/src/Extensions/AngleSharpExtensions.cs b/src/Extensions/AngleSharpExtensions.cs
@@ -194,7 +194,6 @@ public static IEnumerable<INode> AsEnumerable(this INode node)
             yield return node;
         }
 
-
         /// <summary>
         /// Gets the <see cref="TestHtmlParser"/> stored in the <paramref name="node"/>s
         /// owning context, if one is available. 
diff --git a/src/Mocking/JSInterop/JsRuntimeInvocation.cs b/src/Mocking/JSInterop/JsRuntimeInvocation.cs
@@ -27,26 +27,53 @@ namespace Egil.RazorComponents.Testing
         /// <summary>
         /// Creates an instance of the <see cref="JsRuntimeInvocation"/>.
         /// </summary>
-        public JsRuntimeInvocation(string identifier, CancellationToken? cancellationToken, object[] args)
+        public JsRuntimeInvocation(string identifier, CancellationToken cancellationToken, object[] args)
         {
             Identifier = identifier;
-            CancellationToken = cancellationToken ?? CancellationToken.None;
+            CancellationToken = cancellationToken;
             Arguments = args;
         }
 
         /// <inheritdoc/>
-        public bool Equals(JsRuntimeInvocation other) => Identifier.Equals(other.Identifier, StringComparison.Ordinal) && CancellationToken == other.CancellationToken && Arguments == other.Arguments;
+        public bool Equals(JsRuntimeInvocation other)
+            => Identifier.Equals(other.Identifier, StringComparison.Ordinal)
+            && CancellationToken == other.CancellationToken
+            && ArgumentsEqual(Arguments, other.Arguments);
 
         /// <inheritdoc/>
         public override bool Equals(object obj) => obj is JsRuntimeInvocation other && Equals(other);
 
         /// <inheritdoc/>
-        public override int GetHashCode() => (Identifier, CancellationToken, Arguments).GetHashCode();
+        public override int GetHashCode()
+        {
+            var hash = new HashCode();
+            hash.Add(Identifier);
+            hash.Add(CancellationToken);
+
+            for (int i = 0; i < Arguments.Count; i++)
+            {
+                hash.Add(Arguments[i]);
+            }
+
+            return hash.ToHashCode();
+        }
 
         /// <inheritdoc/>
         public static bool operator ==(JsRuntimeInvocation left, JsRuntimeInvocation right) => left.Equals(right);
 
         /// <inheritdoc/>
         public static bool operator !=(JsRuntimeInvocation left, JsRuntimeInvocation right) => !(left == right);
+
+        private static bool ArgumentsEqual(IReadOnlyList<object> left, IReadOnlyList<object> right)
+        {
+            if (left.Count != right.Count) return false;
+
+            for (int i = 0; i < left.Count; i++)
+            {
+                if (!left[i].Equals(right[i])) return false;
+            }
+
+            return true;
+        }
     }
 }
diff --git a/src/Rendering/ComponentParameter.cs b/src/Rendering/ComponentParameter.cs
@@ -34,7 +34,7 @@ private ComponentParameter(string? name, object? value, bool isCascadingValue)
             if (isCascadingValue && value is null)
                 throw new ArgumentNullException(nameof(value), "Cascading values cannot be set to null");
 
-            if(!isCascadingValue && name is null)
+            if (!isCascadingValue && name is null)
                 throw new ArgumentNullException(nameof(name), "A parameters name cannot be set to null");
 
             Name = name;
@@ -47,46 +47,45 @@ private ComponentParameter(string? name, object? value, bool isCascadingValue)
         /// </summary>
         /// <param name="name">Name of the parameter to pass to the component</param>
         /// <param name="value">Value or null to pass the component</param>
-        public static ComponentParameter CreateParameter(string name, object? value) => new ComponentParameter(name, value, false);
+        public static ComponentParameter CreateParameter(string name, object? value) 
+            => new ComponentParameter(name, value, false);
 
         /// <summary>
         /// Create a Cascading Value parameter for a component under test.
         /// </summary>
         /// <param name="name">A optional name for the cascading value</param>
         /// <param name="value">The cascading value</param>
-        public static ComponentParameter CreateCascadingValue(string? name, object value) => new ComponentParameter(name, value, true);
+        public static ComponentParameter CreateCascadingValue(string? name, object value) 
+            => new ComponentParameter(name, value, true);
 
         /// <summary>
         /// Create a parameter for a component under test.
         /// </summary>
         /// <param name="input">A name/value pair for the parameter</param>
-        public static implicit operator ComponentParameter((string name, object? value) input) => CreateParameter(input.name, input.value);
+        public static implicit operator ComponentParameter((string name, object? value) input) 
+            => CreateParameter(input.name, input.value);
 
         /// <summary>
         /// Create a parameter or cascading value for a component under test.
         /// </summary>
         /// <param name="input">A name/value/isCascadingValue triple for the parameter</param>
-        public static implicit operator ComponentParameter((string? name, object? value, bool isCascadingValue) input) => new ComponentParameter(input.name, input.value, input.isCascadingValue);
+        public static implicit operator ComponentParameter((string? name, object? value, bool isCascadingValue) input) 
+            => new ComponentParameter(input.name, input.value, input.isCascadingValue);
 
         /// <inheritdoc/>
-        public bool Equals(ComponentParameter other) => Name == other.Name && Value == other.Value && IsCascadingValue == other.IsCascadingValue;
+        public bool Equals(ComponentParameter other)
+            => string.Equals(Name, other.Name, StringComparison.Ordinal) && Value == other.Value && IsCascadingValue == other.IsCascadingValue;
 
         /// <inheritdoc/>
         public override bool Equals(object obj) => obj is ComponentParameter other && Equals(other);
 
         /// <inheritdoc/>
-        public override int GetHashCode() => (Name, Value, IsCascadingValue).GetHashCode();
+        public override int GetHashCode() => HashCode.Combine(Name, Value, IsCascadingValue);
 
         /// <inheritdoc/>
-        public static bool operator ==(ComponentParameter left, ComponentParameter right)
-        {
-            return left.Equals(right);
-        }
+        public static bool operator ==(ComponentParameter left, ComponentParameter right) => left.Equals(right);
 
         /// <inheritdoc/>
-        public static bool operator !=(ComponentParameter left, ComponentParameter right)
-        {
-            return !(left == right);
-        }
+        public static bool operator !=(ComponentParameter left, ComponentParameter right) => !(left == right);
     }
 }
diff --git a/template/Razor.Components.Testing.Library.Template.csproj b/template/Razor.Components.Testing.Library.Template.csproj
@@ -26,6 +26,10 @@ This library's goal is to make it easy to write comprehensive, stable unit tests
   <ItemGroup>
     <Content Include="template\**\*" Exclude="template\**\bin\**;template\**\obj\**;template\**\.vs\**" />
     <Compile Remove="**\*" />
+    <Compile Remove="template\obj\**" />
+    <Content Remove="template\obj\**" />
+    <EmbeddedResource Remove="template\obj\**" />
+    <None Remove="template\obj\**" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/Assembly.cs b/tests/Assembly.cs
@@ -0,0 +1 @@
+﻿[assembly: System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
diff --git a/tests/Egil.RazorComponents.Testing.Library.Tests.csproj b/tests/Egil.RazorComponents.Testing.Library.Tests.csproj
@@ -7,6 +7,17 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Remove="TestResults\**" />
+    <Content Remove="TestResults\**" />
+    <EmbeddedResource Remove="TestResults\**" />
+    <None Remove="TestResults\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.msbuild" Version="2.8.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
     <PackageReference Include="Moq" Version="4.13.1" />
diff --git a/tests/GlobalSuppressions.cs b/tests/GlobalSuppressions.cs
@@ -3,3 +3,4 @@
 [assembly: SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "<Pending>")]
 [assembly: SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "<Pending>")]
 [assembly: SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "<Pending>")]
+[assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "In tests its ok to catch the general exception type")]
diff --git a/tests/Mocking/JSInterop/JsRuntimeInvocationTest.cs b/tests/Mocking/JSInterop/JsRuntimeInvocationTest.cs
@@ -0,0 +1,59 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Egil.RazorComponents.Testing.Mocking.JSInterop
+{
+    public class JsRuntimeInvocationTest
+    {
+        public static IEnumerable<object[]> GetEqualsTestData()
+        {
+            var token = new CancellationToken(true);
+            var args = new object[] { 1, "baz" };
+
+            var i1 = new JsRuntimeInvocation("foo", token, args);
+            var i2 = new JsRuntimeInvocation("foo", token, args);
+            var i3 = new JsRuntimeInvocation("bar", token, args);
+            var i4 = new JsRuntimeInvocation("foo", CancellationToken.None, args);
+            var i5 = new JsRuntimeInvocation("foo", token, Array.Empty<object>());
+            var i6 = new JsRuntimeInvocation("foo", token, new object[] { 2, "woop" });
+
+            yield return new object[] { i1, i1, true };
+            yield return new object[] { i1, i2, true };
+            yield return new object[] { i1, i3, false };
+            yield return new object[] { i1, i4, false };
+            yield return new object[] { i1, i5, false };
+            yield return new object[] { i1, i6, false };
+        }
+
+        [Theory(DisplayName = "Equals operator works as expected")]
+        [MemberData(nameof(GetEqualsTestData))]
+        public void Test002(JsRuntimeInvocation left, JsRuntimeInvocation right, bool expectedResult)
+        {
+            left.Equals(right).ShouldBe(expectedResult);
+            right.Equals(left).ShouldBe(expectedResult);
+            (left == right).ShouldBe(expectedResult);
+            (left != right).ShouldNotBe(expectedResult);
+            left.Equals((object)right).ShouldBe(expectedResult);
+            right.Equals((object)left).ShouldBe(expectedResult);
+        }
+
+        [Fact(DisplayName = "Equals operator works as expected with non compatible types")]
+        public void Test003()
+        {
+            new JsRuntimeInvocation().Equals(new object()).ShouldBeFalse();
+        }
+
+        [Theory(DisplayName = "GetHashCode returns same result for equal JsRuntimeInvocations")]
+        [MemberData(nameof(GetEqualsTestData))]
+        public void Test004(JsRuntimeInvocation left, JsRuntimeInvocation right, bool expectedResult)
+        {
+            left.GetHashCode().Equals(right.GetHashCode()).ShouldBe(expectedResult);
+        }
+    }
+}
diff --git a/tests/Mocking/JSInterop/MockJsRuntimeInvokeHandlerTest.cs b/tests/Mocking/JSInterop/MockJsRuntimeInvokeHandlerTest.cs
diff --git a/tests/Mocking/MockHttpExtensionsTest.cs b/tests/Mocking/MockHttpExtensionsTest.cs
@@ -0,0 +1,56 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using RichardSzalay.MockHttp;
+using Shouldly;
+using Xunit;
+
+namespace Egil.RazorComponents.Testing.Mocking
+{
+    public class MockHttpExtensionsTest
+    {
+        [Fact(DisplayName = "AddMockHttp throws if the service provider is null")]
+        public void Test001()
+        {
+            TestServiceProvider provider = default!;
+
+            Should.Throw<ArgumentNullException>(() => provider.AddMockHttp());
+        }
+
+        [Fact(DisplayName = "AddMockHttp registers a mock HttpClient in the service provider")]
+        public void Test002()
+        {
+            using var provider = new TestServiceProvider();
+
+            var mock = provider.AddMockHttp();
+
+            provider.GetService<HttpClient>().ShouldNotBeNull();
+        }
+
+        [Fact(DisplayName = "Capture  throws if the handler is null")]
+        public void Test003()
+        {
+            MockHttpMessageHandler handler = default!;
+
+            Should.Throw<ArgumentNullException>(() => handler.Capture(""));
+        }
+
+        [Fact(DisplayName = "Capture returns a task, that when completed, " +
+                            "provides a response to the captured url")]
+        public async Task Test004()
+        {
+            using var provider = new TestServiceProvider();
+            var mock = provider.AddMockHttp();
+            var httpClient = provider.GetService<HttpClient>();
+            var captured = mock.Capture("/ping");
+
+            captured.SetResult("pong");
+
+            var actual = await httpClient.GetStringAsync("/ping");
+            actual.ShouldBe("\"pong\"");
+        }
+    }
+}
diff --git a/tests/Rendering/ComponentParameterTest.cs b/tests/Rendering/ComponentParameterTest.cs
@@ -0,0 +1,72 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Egil.RazorComponents.Testing.Rendering
+{
+    public class ComponentParameterTest
+    {
+        public static IEnumerable<object[]> GetEqualsTestData()
+        {
+            var name = "foo";
+            var value = "bar";
+            var p1 = ComponentParameter.CreateParameter(name, value);
+            var p2 = ComponentParameter.CreateParameter(name, value);
+            var p3 = ComponentParameter.CreateCascadingValue(name, value);
+            var p4 = ComponentParameter.CreateParameter(string.Empty, value);
+            var p5 = ComponentParameter.CreateParameter(name, string.Empty);
+
+            yield return new object[] { p1, p1, true };
+            yield return new object[] { p1, p2, true };
+            yield return new object[] { p3, p3, true };
+            yield return new object[] { p1, p3, false };
+            yield return new object[] { p1, p4, false };
+            yield return new object[] { p1, p5, false };
+        }
+
+        [Fact(DisplayName = "Creating a cascading value throws")]
+        public void Test001()
+        {
+            Should.Throw<ArgumentNullException>(() => ComponentParameter.CreateCascadingValue(null, null!));
+            Should.Throw<ArgumentNullException>(() => { ComponentParameter p = (null, null, true); });
+        }
+
+        [Fact(DisplayName = "Creating a regular parameter without a name throws")]
+        public void Test002()
+        {
+            Should.Throw<ArgumentNullException>(() => ComponentParameter.CreateParameter(null!, null));
+            Should.Throw<ArgumentNullException>(() => { ComponentParameter p = (null, null, false); });
+        }
+
+        [Theory(DisplayName = "Equals compares correctly")]
+        [MemberData(nameof(GetEqualsTestData))]
+        public void Test003(ComponentParameter left, ComponentParameter right, bool expectedResult)
+        {
+            left.Equals(right).ShouldBe(expectedResult);
+            right.Equals(left).ShouldBe(expectedResult);
+            (left == right).ShouldBe(expectedResult);
+            (left != right).ShouldNotBe(expectedResult);
+            left.Equals((object)right).ShouldBe(expectedResult);
+            right.Equals((object)left).ShouldBe(expectedResult);
+        }
+
+        [Fact(DisplayName = "Equals operator works as expected with non compatible types")]
+        public void Test004()
+        {
+            ComponentParameter.CreateParameter(string.Empty, string.Empty)
+                .Equals(new object())
+                .ShouldBeFalse();
+        }
+
+        [Theory(DisplayName = "GetHashCode returns same result for equal ComponentParameter")]
+        [MemberData(nameof(GetEqualsTestData))]
+        public void Test005(ComponentParameter left, ComponentParameter right, bool expectedResult)
+        {
+            left.GetHashCode().Equals(right.GetHashCode()).ShouldBe(expectedResult);
+        }
+    }
+}
diff --git a/tests/TestUtililities/MockingHelpers.cs b/tests/TestUtililities/MockingHelpers.cs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+[assembly: System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,6 @@ public static IEnumerable<INode> AsEnumerable(this INode node)`
`194`	`194`	`yield return node;`
`195`	`195`	`}`
`196`	`196`
`197`		`-`
`198`	`197`	`/// <summary>`
`199`	`198`	`/// Gets the <see cref="TestHtmlParser"/> stored in the <paramref name="node"/>s`
`200`	`199`	`/// owning context, if one is available.`