Merge branch 'dev' into xunit-split-off

# Conflicts:
#	.editorconfig
#	src/ITestContext.cs
#	src/TestContext.cs
#	src/bunit.core/Extensions/ComponentParameterExtensions.cs
#	src/bunit.web.tests/Builders/ComponentParameterBuilderTests.cs

Author: egil

src/Builders/ComponentParameterBuilder.cs

@@ -0,0 +1,47 @@
+using System;
+using AngleSharp.Dom;
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit
+{
+    /// <summary>
+    /// A test context is a factory that makes it possible to create components under tests.
+    /// </summary>
+    public interface ITestContext : IDisposable
+    {
+        /// <summary>
+        /// Gets the service collection and service provider that is used when a 
+        /// component is rendered by the test context.
+        /// </summary>
+        TestServiceProvider Services { get; }
+
+        /// <summary>
+        /// Gets the renderer used to render the components and fragments in this test context.
+        /// </summary>
+        TestRenderer Renderer { get; }
+
+        /// <summary>
+        /// Parses a markup HTML string using the AngleSharps HTML5 parser
+        /// and returns a list of nodes.
+        /// </summary>
+        /// <param name="markup">The markup to parse.</param>
+        /// <returns>The <see cref="INodeList"/>.</returns>
+        INodeList CreateNodes(string markup);
+
+        /// <summary>
+        /// Instantiates and performs a first render of a component of type <typeparamref name="TComponent"/>.
+        /// </summary>
+        /// <typeparam name="TComponent">Type of the component to render</typeparam>
+        /// <param name="parameters">Parameters to pass to the component when it is rendered</param>
+        /// <returns>The rendered <typeparamref name="TComponent"/></returns>
+        IRenderedComponent<TComponent> RenderComponent<TComponent>(params ComponentParameter[] parameters) where TComponent : class, IComponent;
+
+        /// <summary>
+        /// Instantiates and performs a first render of a component of type <typeparamref name="TComponent"/>.
+        /// </summary>
+        /// <typeparam name="TComponent">Type of the component to render</typeparam>
+        /// <param name="componentParameterBuilderAction">The ComponentParameterBuilder action to add type safe parameters to pass to the component when it is rendered</param>
+        /// <returns>The rendered <typeparamref name="TComponent"/></returns>
+        IRenderedComponent<TComponent> RenderComponent<TComponent>(Action<ComponentParameterBuilder<TComponent>> componentParameterBuilderAction) where TComponent : class, IComponent;
+    }
+}

src/ITestContext.cs

@@ -0,0 +1,100 @@
+using AngleSharp.Dom;
+using Bunit.Diffing;
+using Bunit.Mocking.JSInterop;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.JSInterop;
+using System;
+using System.Linq;
+
+namespace Bunit
+{
+    /// <summary>
+    /// A test context is a factory that makes it possible to create components under tests.
+    /// </summary>
+    public class TestContext : ITestContext, IDisposable
+    {
+        private readonly Lazy<TestRenderer> _renderer;
+        private readonly Lazy<TestHtmlParser> _htmlParser;
+
+        /// <inheritdoc/>
+        public virtual TestRenderer Renderer => _renderer.Value;
+
+        /// <inheritdoc/>
+        public virtual TestServiceProvider Services { get; } = new TestServiceProvider();
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="TestContext"/> class.
+        /// </summary>
+        public TestContext()
+        {
+            Services.AddSingleton<IJSRuntime>(new PlaceholderJsRuntime());
+
+            _renderer = new Lazy<TestRenderer>(() =>
+            {
+                var loggerFactory = Services.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
+                return new TestRenderer(Services, loggerFactory);
+            });
+            _htmlParser = new Lazy<TestHtmlParser>(() =>
+            {
+                return new TestHtmlParser(Renderer, new HtmlComparer());
+            });
+        }
+
+        /// <inheritdoc/>
+        public virtual INodeList CreateNodes(string markup)
+            => _htmlParser.Value.Parse(markup);
+
+        /// <inheritdoc/>
+        public virtual IRenderedComponent<TComponent> RenderComponent<TComponent>(params ComponentParameter[] parameters) where TComponent : class, IComponent
+        {
+            var result = new RenderedComponent<TComponent>(this, parameters);
+            return result;
+        }
+
+        /// <inheritdoc/>
+        public virtual IRenderedComponent<TComponent> RenderComponent<TComponent>(Action<ComponentParameterBuilder<TComponent>> componentParameterBuilderAction) where TComponent : class, IComponent
+        {
+            if (componentParameterBuilderAction is null)
+            {
+                throw new ArgumentNullException(nameof(componentParameterBuilderAction));
+            }
+
+            var builder = new ComponentParameterBuilder<TComponent>();
+            componentParameterBuilderAction(builder);
+
+            return RenderComponent<TComponent>(builder.Build().ToArray());
+        }
+
+        #region IDisposable Support
+        private bool _disposed = false;
+
+        /// <inheritdoc/>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    if (_renderer.IsValueCreated)
+                        _renderer.Value.Dispose();
+                    if (_htmlParser.IsValueCreated)
+                        _htmlParser.Value.Dispose();
+
+                    Services.Dispose();
+                }
+                _disposed = true;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+        #endregion
+    }
+}

src/TestContext.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit
+{
+    /// <summary>
+    /// Helpful extensions for working with <see cref="ComponentParameter"/> and collections of these.
+    /// </summary>
+    internal static class ComponentParameterExtensions
+    {
+        /// <summary>
+        /// Creates a <see cref="RenderFragment"/> that will render a component of <typeparamref name="TComponent"/> type,
+        /// with the provided <paramref name="parameters"/>. If one or more of the <paramref name="parameters"/> include
+        /// a cascading values, the <typeparamref name="TComponent"/> will be wrapped in <see cref="Microsoft.AspNetCore.Components.CascadingValue{TValue}"/> 
+        /// components.
+        /// </summary>
+        /// <typeparam name="TComponent">Type of component to render in the render fragment</typeparam>
+        /// <param name="parameters">Parameters to pass to the component</param>
+        /// <returns>The <see cref="RenderFragment"/>.</returns>
+        public static RenderFragment ToComponentRenderFragment<TComponent>(this IReadOnlyList<ComponentParameter> parameters) where TComponent : class, IComponent
+        {
+            var cascadingParams = new Queue<ComponentParameter>(parameters.Where(x => x.IsCascadingValue));
+
+            if (cascadingParams.Count > 0)
+                return CreateCascadingValueRenderFragment(cascadingParams, parameters);
+            else
+                return CreateComponentRenderFragment(parameters);
+
+            static RenderFragment CreateCascadingValueRenderFragment(Queue<ComponentParameter> cascadingParams, IReadOnlyList<ComponentParameter> parameters)
+            {
+                var cp = cascadingParams.Dequeue();
+                var cascadingValueType = GetCascadingValueType(cp);
+                return builder =>
+                {
+                    builder.OpenComponent(0, cascadingValueType);
+                    if (cp.Name is { })
+                        builder.AddAttribute(1, nameof(CascadingValue<object>.Name), cp.Name);
+
+                    builder.AddAttribute(2, nameof(CascadingValue<object>.Value), cp.Value);
+                    builder.AddAttribute(3, nameof(CascadingValue<object>.IsFixed), true);
+
+                    if (cascadingParams.Count > 0)
+                        builder.AddAttribute(4, nameof(CascadingValue<object>.ChildContent), CreateCascadingValueRenderFragment(cascadingParams, parameters));
+                    else
+                        builder.AddAttribute(4, nameof(CascadingValue<object>.ChildContent), CreateComponentRenderFragment(parameters));
+
+                    builder.CloseComponent();
+                };
+            }
+
+            static RenderFragment CreateComponentRenderFragment(IReadOnlyList<ComponentParameter> parameters)
+            {
+                return builder =>
+                {
+                    builder.OpenComponent(0, typeof(TComponent));
+
+                    foreach (var parameterValue in parameters.Where(x => !x.IsCascadingValue))
+                        builder.AddAttribute(1, parameterValue.Name, parameterValue.Value);
+
+                    builder.CloseComponent();
+                };
+            }
+        }
+
+        private static readonly Type CascadingValueType = typeof(CascadingValue<>);
+
+        private static Type GetCascadingValueType(ComponentParameter parameter)
+        {
+            if (parameter.Value is null) throw new InvalidOperationException("Cannot get the type of a null object");
+            var cascadingValueType = parameter.Value.GetType();
+            return CascadingValueType.MakeGenericType(cascadingValueType);
+        }
+    }
+}