Added unit tests.

Author: MackinnonBuck

src/Components/Web/test/Virtualization/VirtualizeTest.cs

@@ -3,53 +3,130 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.AspNetCore.Components.Test.Helpers;
 using Microsoft.AspNetCore.Components.Web;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.JSInterop;
+using Moq;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Components.Virtualization
 {
     public class VirtualizeTest
     {
-        // TODO: Functional tests.
         [Fact]
-        public void Virtualize_ThrowsWhenGivenNonPositiveItemSize()
+        public async void Virtualize_ThrowsWhenGivenNonPositiveItemSize()
         {
             var rootComponent = new VirtualizeTestHostcomponent
             {
-                InnerContent = BuildVirtualize(
-                    i => builder => { },
-                    null,
-                    context => builder => { },
-                    0f,
-                    null,
-                    new List<int>())
+                InnerContent = BuildVirtualize(0f, EmptyItemsProvider<int>, null)
             };
 
-            var testRenderer = new TestRenderer();
+            var serviceProvider = new ServiceCollection()
+                .AddTransient((sp) => Mock.Of<IJSRuntime>())
+                .BuildServiceProvider();
+
+            var testRenderer = new TestRenderer(serviceProvider);
+            var componentId = testRenderer.AssignRootComponentId(rootComponent);
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId));
+            Assert.Contains("requires a positive value for parameter", ex.Message);
+        }
+
+        [Fact]
+        public async void Virtualize_ThrowsWhenGivenMultipleItemSources()
+        {
+            var rootComponent = new VirtualizeTestHostcomponent
+            {
+                InnerContent = BuildVirtualize(10f, EmptyItemsProvider<int>, new List<int>())
+            };
+
+            var serviceProvider = new ServiceCollection()
+                .AddTransient((sp) => Mock.Of<IJSRuntime>())
+                .BuildServiceProvider();
+
+            var testRenderer = new TestRenderer(serviceProvider);
+            var componentId = testRenderer.AssignRootComponentId(rootComponent);
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId));
+            Assert.Contains("can only accept one item source from its parameters", ex.Message);
+        }
+
+        [Fact]
+        public async void Virtualize_ThrowsWhenGivenNoItemSources()
+        {
+            var rootComponent = new VirtualizeTestHostcomponent
+            {
+                InnerContent = BuildVirtualize<int>(10f, null, null)
+            };
+
+            var serviceProvider = new ServiceCollection()
+                .AddTransient((sp) => Mock.Of<IJSRuntime>())
+                .BuildServiceProvider();
+
+            var testRenderer = new TestRenderer(serviceProvider);
+            var componentId = testRenderer.AssignRootComponentId(rootComponent);
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId));
+            Assert.Contains("parameters to be specified and non-null", ex.Message);
+        }
+
+        [Fact]
+        public async void Virtualize_DispatchesExceptionsFromItemsProviderThroughRenderer()
+        {
+            Virtualize<int> renderedVirtualize = null;
+
+            var rootComponent = new VirtualizeTestHostcomponent
+            {
+                InnerContent = BuildVirtualize(10f, AlwaysThrowsItemsProvider<int>, null, virtualize => renderedVirtualize = virtualize)
+            };
+
+            var serviceProvider = new ServiceCollection()
+                .AddTransient((sp) => Mock.Of<IJSRuntime>())
+                .BuildServiceProvider();
+
+            var testRenderer = new TestRenderer(serviceProvider);
             var componentId = testRenderer.AssignRootComponentId(rootComponent);
 
-            var ex = Assert.Throws<InvalidOperationException>(() => testRenderer.RenderRootComponent(componentId));
+            // Render to populate the component reference.
+            await testRenderer.RenderRootComponentAsync(componentId);
+
+            Assert.NotNull(renderedVirtualize);
+
+            // Simulate a JS spacer callback.
+            ((IVirtualizeJsCallbacks)renderedVirtualize).OnAfterSpacerVisible(10f, 100f);
+
+            // Validate that the exception is dispatched through the renderer.
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId));
+            Assert.Equal("Thrown from items provider.", ex.Message);
         }
 
-        public RenderFragment BuildVirtualize<TItem>(
-            RenderFragment<TItem> childContent,
-            RenderFragment<TItem> item,
-            RenderFragment<PlaceholderContext> placeholder,
+        private ValueTask<ItemsProviderResult<TItem>> EmptyItemsProvider<TItem>(ItemsProviderRequest request)
+            => ValueTask.FromResult(new ItemsProviderResult<TItem>(Enumerable.Empty<TItem>(), 0));
+
+        private ValueTask<ItemsProviderResult<TItem>> AlwaysThrowsItemsProvider<TItem>(ItemsProviderRequest request)
+            => throw new InvalidOperationException("Thrown from items provider.");
+
+        private RenderFragment BuildVirtualize<TItem>(
             float itemSize,
             ItemsProviderDelegate<TItem> itemsProvider,
-            ICollection<TItem> items)
+            ICollection<TItem> items,
+            Action<Virtualize<TItem>> captureRenderedVirtualize = null)
             => builder =>
         {
             builder.OpenComponent<Virtualize<TItem>>(0);
-            builder.AddAttribute(1, "ChildContent", childContent);
-            builder.AddAttribute(2, "Item", item);
-            builder.AddAttribute(3, "Placeholder", placeholder);
-            builder.AddAttribute(4, "ItemSize", itemSize);
-            builder.AddAttribute(5, "ItemsProvider", itemsProvider);
-            builder.AddAttribute(6, "Items", items);
+            builder.AddAttribute(1, "ItemSize", itemSize);
+            builder.AddAttribute(2, "ItemsProvider", itemsProvider);
+            builder.AddAttribute(3, "Items", items);
+
+            if (captureRenderedVirtualize != null)
+            {
+                builder.AddComponentReferenceCapture(4, component => captureRenderedVirtualize(component as Virtualize<TItem>));
+            }
+
             builder.CloseComponent();
         };
 
@@ -61,7 +138,7 @@ protected override void BuildRenderTree(RenderTreeBuilder builder)
             {
                 builder.OpenElement(0, "div");
                 builder.AddAttribute(1, "style", "overflow: auto; height: 800px;");
-                builder.AddAttribute(2, "ChildContent", InnerContent);
+                builder.AddContent(2, InnerContent);
                 builder.CloseElement();
             }
         }

src/Components/test/testassets/TestServer/PrerenderedStartup.cs

@@ -23,7 +23,7 @@ public void ConfigureServices(IServiceCollection services)
             services.AddMvc();
             services.AddServerSideBlazor();
             services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie();
-            //services.AddSingleton<LazyAssemblyLoader>();
+            services.AddSingleton<LazyAssemblyLoader>();
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.