Test changes

Author: pranavkm

src/Microsoft.AspNet.Mvc.Razor/RazorTextWriter.cs

@@ -274,7 +274,7 @@ public override async Task FlushAsync()
         public void CopyTo(TextWriter writer)
         {
             var targetRazorTextWriter = writer as RazorTextWriter;
-            if (targetRazorTextWriter != null)
+            if (targetRazorTextWriter != null && targetRazorTextWriter.IsBuffered)
             {
                 targetRazorTextWriter.Buffer.Add(Buffer);
             }
@@ -292,7 +292,7 @@ public void CopyTo(TextWriter writer)
         public Task CopyToAsync(TextWriter writer)
         {
             var targetRazorTextWriter = writer as RazorTextWriter;
-            if (targetRazorTextWriter != null)
+            if (targetRazorTextWriter != null && targetRazorTextWriter.IsBuffered)
             {
                 targetRazorTextWriter.Buffer.Add(Buffer);
             }

test/Microsoft.AspNet.Mvc.FunctionalTests/FlushPointTest.cs

@@ -2,9 +2,14 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.IO;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNet.Builder;
 using Microsoft.AspNet.TestHost;
+using Microsoft.Framework.DependencyInjection;
+using Microsoft.Framework.DependencyInjection.Fallback;
 using RazorWebSite;
 using Xunit;
 
@@ -16,43 +21,91 @@ public class FlushPointTest
         private readonly Action<IBuilder> _app = new Startup().Configure;
 
         [Fact]
-        public async Task FlushPointsAreExecutedForPagesWithLayouts()
+        public void FlushPointsAreExecutedForPagesWithLayouts()
         {
-            var expected =
-@"<title>Page With Layout</title>
+            var waitService = new WaitService();
+            var serviceProvider = GetServiceProvider(waitService);
+            var server = TestServer.Create(serviceProvider, _app);
+            var client = server.CreateClient();
+            var invoked = false;
 
+            // Act
+            var result = client.GetStreamAsync("http://localhost/FlushPoint/PageWithLayout");
+            var thread = new Thread(() =>
+            {
+                waitService.WaitForServer();
+                var stream = result.Result;
 
-RenderBody content
+                // Assert - 1
+                Assert.Equal(@"<title>Page With Layout</title>", GetTrimmedString(stream));
 
+                waitService.WaitForServer();
 
-    <span>Content that takes time to produce</span>";
-            var server = TestServer.Create(_provider, _app);
-            var client = server.Handler;
+                // Assert - 2
+                Assert.Equal(@"RenderBody content", GetTrimmedString(stream));
 
-            // Act
-            var result = await client.GetAsync("http://localhost/FlushPoint/PageWithLayout");
+                invoked = true;
+            });
+            thread.Start();
 
             // Assert
-            var body = await result.HttpContext.Response.ReadBodyAsStringAsync();
-            Assert.Equal(expected, body.Trim());
+            thread.Join();
+            Assert.True(invoked);
+            Assert.Equal(@"<span>Content that takes time to produce</span>",
+                        GetTrimmedString(result.Result));
         }
 
         [Fact]
-        public async Task FlushPointsAreExecutedForPagesWithoutLayouts()
+        public void FlushPointsAreExecutedForPagesWithoutLayouts()
         {
-            var expected =
-@"Initial content
+            var expected1 = "Initial content";
+            var expected2 = "Secondary content";
+            var expected3 = "Final content";
+            var waitService = new WaitService();
+            var serviceProvider = GetServiceProvider(waitService);
 
-Final content";
-            var server = TestServer.Create(_provider, _app);
-            var client = server.Handler;
+            var server = TestServer.Create(serviceProvider, _app);
+            var client = server.CreateClient();
+            var invoked = false;
 
             // Act
-            var result = await client.GetAsync("http://localhost/FlushPoint/PageWithoutLayout");
+            var result = client.GetStreamAsync("http://localhost/FlushPoint/PageWithoutLayout");
 
-            // Assert
-            var body = await result.HttpContext.Response.ReadBodyAsStringAsync();
-            Assert.Equal(expected, body.Trim());
+            var thread = new Thread(() =>
+            {
+                waitService.WaitForServer();
+                var stream = result.Result;
+
+                // Assert - 1
+                Assert.Equal(expected1, GetTrimmedString(stream));
+
+                waitService.WaitForServer();
+
+                // Assert - 2
+                Assert.Equal(expected2, GetTrimmedString(stream));
+
+                invoked = true;
+            });
+            thread.Start();
+
+            // Assert - 2
+            thread.Join();
+            Assert.True(invoked);
+            Assert.Equal(expected3, GetTrimmedString(result.Result));
+        }
+
+        private IServiceProvider GetServiceProvider(WaitService waitService)
+        {
+            var services = new ServiceCollection();
+            services.AddInstance(waitService);
+            return services.BuildServiceProvider(_provider);
+        }
+
+        private string GetTrimmedString(Stream stream)
+        {
+            var buffer = new byte[1024];
+            var count = stream.Read(buffer, 0, buffer.Length);
+            return Encoding.UTF8.GetString(buffer, 0, count).Trim();
         }
     }
-}
+}

test/Microsoft.AspNet.Mvc.Razor.Test/RazorTextWriterTest.cs

@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.AspNet.Testing;
+using Moq;
 using Xunit;
 
 namespace Microsoft.AspNet.Mvc.Razor.Test
@@ -19,7 +20,7 @@ public void Write_WritesDataTypes_ToBuffer()
         {
             // Arrange
             var expected = new[] { "True", "3", "18446744073709551615", "Hello world", "3.14", "2.718", "m" };
-            var writer = new RazorTextWriter(Encoding.UTF8);
+            var writer = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             writer.Write(true);
@@ -34,14 +35,81 @@ public void Write_WritesDataTypes_ToBuffer()
             Assert.Equal<object>(expected, writer.Buffer.BufferEntries);
         }
 
+        [Fact]
+        [ReplaceCulture]
+        public void Write_WritesDataTypes_ToUnderlyingStream_WhenNotBuffering()
+        {
+            // Arrange
+            var expected = new[] { "True", "3", "18446744073709551615", "Hello world", "3.14", "2.718" };
+            var unbufferedWriter = new Mock<TextWriter>();
+            var writer = new RazorTextWriter(unbufferedWriter.Object, Encoding.UTF8);
+            var testClass = new TestClass();
+
+            // Act
+            writer.Flush();
+            writer.Write(true);
+            writer.Write(3);
+            writer.Write(ulong.MaxValue);
+            writer.Write(testClass);
+            writer.Write(3.14);
+            writer.Write(2.718m);
+
+            // Assert
+            Assert.Empty(writer.Buffer.BufferEntries);
+            foreach (var item in expected)
+            {
+                unbufferedWriter.Verify(v => v.Write(item), Times.Once());
+            }
+        }
+
+        [Fact]
+        [ReplaceCulture]
+        public void Write_WritesCharValues_ToUnderlyingStream_WhenNotBuffering()
+        {
+            // Arrange
+            var unbufferedWriter = new Mock<TextWriter> { CallBase = true };
+            var writer = new RazorTextWriter(unbufferedWriter.Object, Encoding.UTF8);
+            var buffer = new[] { 'a', 'b', 'c' };
+
+            // Act
+            writer.Flush();
+            writer.Write('a');
+            writer.Write(buffer, 1, 2);
+
+            // Assert
+            Assert.Empty(writer.Buffer.BufferEntries);
+            unbufferedWriter.Verify(v => v.Write('a'), Times.Once());
+            unbufferedWriter.Verify(v => v.Write(buffer, 1, 2), Times.Once());
+        }
+
+        [Fact]
+        [ReplaceCulture]
+        public async Task Write_WritesStringValues_ToUnbufferedStream_WhenNotBuffering()
+        {
+            // Arrange
+            var unbufferedWriter = new Mock<TextWriter>();
+            var writer = new RazorTextWriter(unbufferedWriter.Object, Encoding.UTF8);
+            var buffer = new[] { 'a', 'b', 'c' };
+
+            // Act
+            await writer.FlushAsync();
+            writer.Write("a");
+            writer.WriteLine("ab");
+
+            // Assert
+            Assert.Empty(writer.Buffer.BufferEntries);
+            unbufferedWriter.Verify(v => v.WriteLine("a"), Times.Once());
+            unbufferedWriter.Verify(v => v.WriteLine("ab"), Times.Once());
+        }
+
         [Fact]
         [ReplaceCulture]
         public void WriteLine_WritesDataTypes_ToBuffer()
         {
             // Arrange 
             var newLine = Environment.NewLine;
             var expected = new List<object> { "False", newLine, "1.1", newLine, "3", newLine };
-            var writer = new RazorTextWriter(Encoding.UTF8);
+            var writer = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             writer.WriteLine(false);
@@ -52,14 +120,36 @@ public void WriteLine_WritesDataTypes_ToBuffer()
             Assert.Equal(expected, writer.Buffer.BufferEntries);
         }
 
+        [Fact]
+        [ReplaceCulture]
+        public void WriteLine_WritesDataTypes_ToUnbufferedStream_WhenNotBuffering()
+        {
+            // Arrange
+            var unbufferedWriter = new Mock<TextWriter>();
+            var writer = new RazorTextWriter(unbufferedWriter.Object, Encoding.UTF8);
+
+            // Act
+            writer.Flush();
+            writer.WriteLine(false);
+            writer.WriteLine(1.1f);
+            writer.WriteLine(3L);
+
+            // Assert
+            Assert.Empty(writer.Buffer.BufferEntries);
+            unbufferedWriter.Verify(v => v.Write("False"), Times.Once());
+            unbufferedWriter.Verify(v => v.Write(1.1f), Times.Once());
+            unbufferedWriter.Verify(v => v.Write(3L), Times.Once());
+            unbufferedWriter.Verify(v => v.WriteLine(), Times.Exactly(3));
+        }
+
         [Fact]
         public async Task Write_WritesCharBuffer()
         {
             // Arrange
             var input1 = new ArraySegment<char>(new char[] { 'a', 'b', 'c', 'd' }, 1, 3);
             var input2 = new ArraySegment<char>(new char[] { 'e', 'f' }, 0, 2);
             var input3 = new ArraySegment<char>(new char[] { 'g', 'h', 'i', 'j' }, 3, 1);
-            var writer = new RazorTextWriter(Encoding.UTF8);
+            var writer = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             writer.Write(input1.Array, input1.Offset, input1.Count);
@@ -80,7 +170,7 @@ public async Task WriteLines_WritesCharBuffer()
         {
             // Arrange
             var newLine = Environment.NewLine;
-            var writer = new RazorTextWriter(Encoding.UTF8);
+            var writer = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             writer.WriteLine();
@@ -100,7 +190,7 @@ public async Task Write_WritesStringBuffer()
             var input2 = "from";
             var input3 = "ASP";
             var input4 = ".Net";
-            var writer = new RazorTextWriter(Encoding.UTF8);
+            var writer = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             writer.Write(input1);
@@ -117,8 +207,8 @@ public async Task Write_WritesStringBuffer()
         public void Copy_CopiesContent_IfTargetTextWriterIsARazorTextWriter()
         {
             // Arrange
-            var source = new RazorTextWriter(Encoding.UTF8);
-            var target = new RazorTextWriter(Encoding.UTF8);
+            var source = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
+            var target = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             source.Write("Hello world");
@@ -136,7 +226,7 @@ public void Copy_CopiesContent_IfTargetTextWriterIsARazorTextWriter()
         public void Copy_WritesContent_IfTargetTextWriterIsNotARazorTextWriter()
         {
             // Arrange
-            var source = new RazorTextWriter(Encoding.UTF8);
+            var source = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
             var target = new StringWriter();
             var expected = @"Hello world
 abc";
@@ -154,8 +244,8 @@ public void Copy_WritesContent_IfTargetTextWriterIsNotARazorTextWriter()
         public async Task CopyAsync_WritesContent_IfTargetTextWriterIsARazorTextWriter()
         {
             // Arrange
-            var source = new RazorTextWriter(Encoding.UTF8);
-            var target = new RazorTextWriter(Encoding.UTF8);
+            var source = new RazorTextWriter(TextWriter.Null,Encoding.UTF8);
+            var target = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
 
             // Act
             source.WriteLine("Hello world");
@@ -172,7 +262,7 @@ public async Task CopyAsync_WritesContent_IfTargetTextWriterIsARazorTextWriter()
         public async Task CopyAsync_WritesContent_IfTargetTextWriterIsNotARazorTextWriter()
         {
             // Arrange
-            var source = new RazorTextWriter(Encoding.UTF8);
+            var source = new RazorTextWriter(TextWriter.Null, Encoding.UTF8);
             var target = new StringWriter();
             var expected = @"Hello world
 ";

test/WebSites/RazorWebSite/Services/WaitService.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Threading;
+
+namespace RazorWebSite
+{
+    public class WaitService
+    {
+        private readonly ManualResetEventSlim _serverResetEvent = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _clientResetEvent = new ManualResetEventSlim();
+
+        public void WaitForClient()
+        {
+            _clientResetEvent.Set();
+            _serverResetEvent.Reset();
+            _serverResetEvent.Wait(TimeSpan.FromSeconds(10));
+        }
+
+        public void WaitForServer()
+        {
+            _serverResetEvent.Set();
+            _clientResetEvent.Reset();
+
+            _clientResetEvent.Wait(TimeSpan.FromSeconds(10));
+        }
+    }
+}

test/WebSites/RazorWebSite/Views/FlushPoint/PageWithLayout.cshtml

@@ -1,9 +1,14 @@
-@{
+@inject WaitService WaitService
+@{
     Layout = "/Views/Shared/_LayoutWithFlush.cshtml";
     ViewBag.Title = "Page With Layout";
 }
 RenderBody content
 @section content
 {
+    @{
+        FlushAsync().Wait();
+        WaitService.WaitForClient();
+    }
     <span>Content that takes time to produce</span>
 }