Fix FileLoggerProcessorTests (#35305)

wtgodbe · web-flow · commit 028125398184 · 2021-08-16T10:06:13.000-07:00
* Fix FileLoggerProcessorTests

* Fixup

* Whoops

* Fixup

* Feedback
diff --git a/src/Middleware/HttpLogging/test/FileLoggerProcessorTests.cs b/src/Middleware/HttpLogging/test/FileLoggerProcessorTests.cs
@@ -19,6 +19,11 @@ namespace Microsoft.AspNetCore.HttpLogging
 {
     public class FileLoggerProcessorTests
     {
+
+        private string _messageOne = "Message one";
+        private string _messageTwo = "Message two";
+        private string _messageThree = "Message three";
+
         public FileLoggerProcessorTests()
         {
             TempPath = Path.GetTempFileName() + "_";
@@ -41,12 +46,12 @@ public async Task WritesToTextFile()
                 };
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message one");
+                    logger.EnqueueMessage(_messageOne);
                     fileName = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"));
                     // Pause for a bit before disposing so logger can finish logging
                     try
                     {
-                        await WaitForFile(fileName).DefaultTimeout();
+                        await WaitForFile(fileName, _messageOne.Length).DefaultTimeout();
                     }
                     catch
                     {
@@ -60,7 +65,7 @@ public async Task WritesToTextFile()
                 }
                 Assert.True(File.Exists(fileName));
 
-                Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName));
+                Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName));
             }
             finally
             {
@@ -86,14 +91,14 @@ public async Task RollsTextFiles()
                 };
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message one");
-                    logger.EnqueueMessage("Message two");
+                    logger.EnqueueMessage(_messageOne);
+                    logger.EnqueueMessage(_messageTwo);
                     fileName1 = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"));
                     fileName2 = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0001.txt"));
                     // Pause for a bit before disposing so logger can finish logging
                     try
                     {
-                        await WaitForFile(fileName2).DefaultTimeout();
+                        await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();
                     }
                     catch
                     {
@@ -114,8 +119,8 @@ public async Task RollsTextFiles()
                 Assert.True(File.Exists(fileName1));
                 Assert.True(File.Exists(fileName2));
 
-                Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));
-                Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));
+                Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));
+                Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));
             }
             finally
             {
@@ -145,13 +150,13 @@ public async Task RespectsMaxFileCount()
                 {
                     for (int i = 0; i < 10; i++)
                     {
-                        logger.EnqueueMessage("Message");
+                        logger.EnqueueMessage(_messageOne);
                     }
                     lastFileName = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0009.txt"));
                     // Pause for a bit before disposing so logger can finish logging
                     try
                     {
-                        await WaitForFile(lastFileName).DefaultTimeout();
+                        await WaitForFile(lastFileName, _messageOne.Length).DefaultTimeout();
                         for (int i = 0; i < 6; i++)
                         {
                             await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.{i:0000}.txt"))).DefaultTimeout();
@@ -211,23 +216,23 @@ public async Task InstancesWriteToSameDirectory()
                 {
                     for (int i = 0; i < 3; i++)
                     {
-                        logger.EnqueueMessage("Message");
+                        logger.EnqueueMessage(_messageOne);
                     }
                     var filePath = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0002.txt"));
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(filePath).DefaultTimeout();
+                    await WaitForFile(filePath, _messageOne.Length).DefaultTimeout();
                 }
 
                 // Second instance should pick up where first one left off
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
                     for (int i = 0; i < 3; i++)
                     {
-                        logger.EnqueueMessage("Message");
+                        logger.EnqueueMessage(_messageOne);
                     }
                     var filePath = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0005.txt"));
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(filePath).DefaultTimeout();
+                    await WaitForFile(filePath, _messageOne.Length).DefaultTimeout();
                 }
 
                 var actualFiles1 = new DirectoryInfo(path)
@@ -246,9 +251,9 @@ public async Task InstancesWriteToSameDirectory()
                 options.RetainedFileCountLimit = 5;
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message");
+                    logger.EnqueueMessage(_messageOne);
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0006.txt"))).DefaultTimeout();
+                    await WaitForFile(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0006.txt")), _messageOne.Length).DefaultTimeout();
                     await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"))).DefaultTimeout();
                     await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0001.txt"))).DefaultTimeout();
                 }
@@ -298,20 +303,20 @@ public async Task WritesToNewFileOnNewInstance()
 
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message one");
-                    logger.EnqueueMessage("Message two");
+                    logger.EnqueueMessage(_messageOne);
+                    logger.EnqueueMessage(_messageTwo);
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(fileName2).DefaultTimeout();
+                    await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();
                 }
 
                 // Even with a big enough FileSizeLimit, we still won't try to write to files from a previous instance.
                 options.FileSizeLimit = 10000;
 
                 await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message three");
+                    logger.EnqueueMessage(_messageThree);
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(fileName3).DefaultTimeout();
+                    await WaitForFile(fileName3, _messageThree.Length).DefaultTimeout();
                 }
 
                 var actualFiles = new DirectoryInfo(path)
@@ -326,9 +331,9 @@ public async Task WritesToNewFileOnNewInstance()
                 Assert.True(File.Exists(fileName2));
                 Assert.True(File.Exists(fileName3));
 
-                Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));
-                Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));
-                Assert.Equal("Message three" + Environment.NewLine, File.ReadAllText(fileName3));
+                Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));
+                Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));
+                Assert.Equal(_messageThree + Environment.NewLine, File.ReadAllText(fileName3));
             }
             finally
             {
@@ -364,13 +369,13 @@ public async Task WritesToNewFileOnOptionsChange()
 
                 await using (var logger = new FileLoggerProcessor(monitor, new HostingEnvironment(), NullLoggerFactory.Instance))
                 {
-                    logger.EnqueueMessage("Message one");
-                    await WaitForFile(fileName1).DefaultTimeout();
+                    logger.EnqueueMessage(_messageOne);
+                    await WaitForFile(fileName1, _messageOne.Length).DefaultTimeout();
                     options.LoggingFields = W3CLoggingFields.Date;
                     monitor.InvokeChanged();
-                    logger.EnqueueMessage("Message two");
+                    logger.EnqueueMessage(_messageTwo);
                     // Pause for a bit before disposing so logger can finish logging
-                    await WaitForFile(fileName2).DefaultTimeout();
+                    await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();
                 }
 
                 var actualFiles = new DirectoryInfo(path)
@@ -384,21 +389,36 @@ public async Task WritesToNewFileOnOptionsChange()
                 Assert.True(File.Exists(fileName1));
                 Assert.True(File.Exists(fileName2));
 
-                Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));
-                Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));
+                Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));
+                Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));
             }
             finally
             {
                 Helpers.DisposeDirectory(path);
             }
         }
 
-        private async Task WaitForFile(string fileName)
+        private async Task WaitForFile(string fileName, int length)
         {
             while (!File.Exists(fileName))
             {
                 await Task.Delay(100);
             }
+            while (true)
+            {
+                try
+                {
+                    if (File.ReadAllText(fileName).Length >= length)
+                    {
+                        break;
+                    }
+                }
+                catch
+                {
+                    // Continue
+                }
+                await Task.Delay(10);
+            }    
         }
 
         private async Task WaitForRoll(string fileName)

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,11 @@ namespace Microsoft.AspNetCore.HttpLogging`
`19`	`19`	`{`
`20`	`20`	`public class FileLoggerProcessorTests`
`21`	`21`	`{`
	`22`	`+`
	`23`	`+ private string _messageOne = "Message one";`
	`24`	`+ private string _messageTwo = "Message two";`
	`25`	`+ private string _messageThree = "Message three";`
	`26`	`+`
`22`	`27`	`public FileLoggerProcessorTests()`
`23`	`28`	`{`
`24`	`29`	`TempPath = Path.GetTempFileName() + "_";`
`@@ -41,12 +46,12 @@ public async Task WritesToTextFile()`
`41`	`46`	`};`
`42`	`47`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`43`	`48`	`{`
`44`		`- logger.EnqueueMessage("Message one");`
	`49`	`+ logger.EnqueueMessage(_messageOne);`
`45`	`50`	`fileName = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"));`
`46`	`51`	`// Pause for a bit before disposing so logger can finish logging`
`47`	`52`	`try`
`48`	`53`	`{`
`49`		`- await WaitForFile(fileName).DefaultTimeout();`
	`54`	`+ await WaitForFile(fileName, _messageOne.Length).DefaultTimeout();`
`50`	`55`	`}`
`51`	`56`	`catch`
`52`	`57`	`{`
`@@ -60,7 +65,7 @@ public async Task WritesToTextFile()`
`60`	`65`	`}`
`61`	`66`	`Assert.True(File.Exists(fileName));`
`62`	`67`
`63`		`- Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName));`
	`68`	`+ Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName));`
`64`	`69`	`}`
`65`	`70`	`finally`
`66`	`71`	`{`
`@@ -86,14 +91,14 @@ public async Task RollsTextFiles()`
`86`	`91`	`};`
`87`	`92`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`88`	`93`	`{`
`89`		`- logger.EnqueueMessage("Message one");`
`90`		`- logger.EnqueueMessage("Message two");`
	`94`	`+ logger.EnqueueMessage(_messageOne);`
	`95`	`+ logger.EnqueueMessage(_messageTwo);`
`91`	`96`	`fileName1 = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"));`
`92`	`97`	`fileName2 = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0001.txt"));`
`93`	`98`	`// Pause for a bit before disposing so logger can finish logging`
`94`	`99`	`try`
`95`	`100`	`{`
`96`		`- await WaitForFile(fileName2).DefaultTimeout();`
	`101`	`+ await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();`
`97`	`102`	`}`
`98`	`103`	`catch`
`99`	`104`	`{`
`@@ -114,8 +119,8 @@ public async Task RollsTextFiles()`
`114`	`119`	`Assert.True(File.Exists(fileName1));`
`115`	`120`	`Assert.True(File.Exists(fileName2));`
`116`	`121`
`117`		`- Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));`
`118`		`- Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));`
	`122`	`+ Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));`
	`123`	`+ Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));`
`119`	`124`	`}`
`120`	`125`	`finally`
`121`	`126`	`{`
`@@ -145,13 +150,13 @@ public async Task RespectsMaxFileCount()`
`145`	`150`	`{`
`146`	`151`	`for (int i = 0; i < 10; i++)`
`147`	`152`	`{`
`148`		`- logger.EnqueueMessage("Message");`
	`153`	`+ logger.EnqueueMessage(_messageOne);`
`149`	`154`	`}`
`150`	`155`	`lastFileName = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0009.txt"));`
`151`	`156`	`// Pause for a bit before disposing so logger can finish logging`
`152`	`157`	`try`
`153`	`158`	`{`
`154`		`- await WaitForFile(lastFileName).DefaultTimeout();`
	`159`	`+ await WaitForFile(lastFileName, _messageOne.Length).DefaultTimeout();`
`155`	`160`	`for (int i = 0; i < 6; i++)`
`156`	`161`	`{`
`157`	`162`	`await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.{i:0000}.txt"))).DefaultTimeout();`
`@@ -211,23 +216,23 @@ public async Task InstancesWriteToSameDirectory()`
`211`	`216`	`{`
`212`	`217`	`for (int i = 0; i < 3; i++)`
`213`	`218`	`{`
`214`		`- logger.EnqueueMessage("Message");`
	`219`	`+ logger.EnqueueMessage(_messageOne);`
`215`	`220`	`}`
`216`	`221`	`var filePath = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0002.txt"));`
`217`	`222`	`// Pause for a bit before disposing so logger can finish logging`
`218`		`- await WaitForFile(filePath).DefaultTimeout();`
	`223`	`+ await WaitForFile(filePath, _messageOne.Length).DefaultTimeout();`
`219`	`224`	`}`
`220`	`225`
`221`	`226`	`// Second instance should pick up where first one left off`
`222`	`227`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`223`	`228`	`{`
`224`	`229`	`for (int i = 0; i < 3; i++)`
`225`	`230`	`{`
`226`		`- logger.EnqueueMessage("Message");`
	`231`	`+ logger.EnqueueMessage(_messageOne);`
`227`	`232`	`}`
`228`	`233`	`var filePath = Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0005.txt"));`
`229`	`234`	`// Pause for a bit before disposing so logger can finish logging`
`230`		`- await WaitForFile(filePath).DefaultTimeout();`
	`235`	`+ await WaitForFile(filePath, _messageOne.Length).DefaultTimeout();`
`231`	`236`	`}`
`232`	`237`
`233`	`238`	`var actualFiles1 = new DirectoryInfo(path)`
`@@ -246,9 +251,9 @@ public async Task InstancesWriteToSameDirectory()`
`246`	`251`	`options.RetainedFileCountLimit = 5;`
`247`	`252`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`248`	`253`	`{`
`249`		`- logger.EnqueueMessage("Message");`
	`254`	`+ logger.EnqueueMessage(_messageOne);`
`250`	`255`	`// Pause for a bit before disposing so logger can finish logging`
`251`		`- await WaitForFile(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0006.txt"))).DefaultTimeout();`
	`256`	`+ await WaitForFile(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0006.txt")), _messageOne.Length).DefaultTimeout();`
`252`	`257`	`await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0000.txt"))).DefaultTimeout();`
`253`	`258`	`await WaitForRoll(Path.Combine(path, FormattableString.Invariant($"{options.FileName}{now.Year:0000}{now.Month:00}{now.Day:00}.0001.txt"))).DefaultTimeout();`
`254`	`259`	`}`
`@@ -298,20 +303,20 @@ public async Task WritesToNewFileOnNewInstance()`
`298`	`303`
`299`	`304`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`300`	`305`	`{`
`301`		`- logger.EnqueueMessage("Message one");`
`302`		`- logger.EnqueueMessage("Message two");`
	`306`	`+ logger.EnqueueMessage(_messageOne);`
	`307`	`+ logger.EnqueueMessage(_messageTwo);`
`303`	`308`	`// Pause for a bit before disposing so logger can finish logging`
`304`		`- await WaitForFile(fileName2).DefaultTimeout();`
	`309`	`+ await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();`
`305`	`310`	`}`
`306`	`311`
`307`	`312`	`// Even with a big enough FileSizeLimit, we still won't try to write to files from a previous instance.`
`308`	`313`	`options.FileSizeLimit = 10000;`
`309`	`314`
`310`	`315`	`await using (var logger = new FileLoggerProcessor(new OptionsWrapperMonitor<W3CLoggerOptions>(options), new HostingEnvironment(), NullLoggerFactory.Instance))`
`311`	`316`	`{`
`312`		`- logger.EnqueueMessage("Message three");`
	`317`	`+ logger.EnqueueMessage(_messageThree);`
`313`	`318`	`// Pause for a bit before disposing so logger can finish logging`
`314`		`- await WaitForFile(fileName3).DefaultTimeout();`
	`319`	`+ await WaitForFile(fileName3, _messageThree.Length).DefaultTimeout();`
`315`	`320`	`}`
`316`	`321`
`317`	`322`	`var actualFiles = new DirectoryInfo(path)`
`@@ -326,9 +331,9 @@ public async Task WritesToNewFileOnNewInstance()`
`326`	`331`	`Assert.True(File.Exists(fileName2));`
`327`	`332`	`Assert.True(File.Exists(fileName3));`
`328`	`333`
`329`		`- Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));`
`330`		`- Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));`
`331`		`- Assert.Equal("Message three" + Environment.NewLine, File.ReadAllText(fileName3));`
	`334`	`+ Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));`
	`335`	`+ Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));`
	`336`	`+ Assert.Equal(_messageThree + Environment.NewLine, File.ReadAllText(fileName3));`
`332`	`337`	`}`
`333`	`338`	`finally`
`334`	`339`	`{`
`@@ -364,13 +369,13 @@ public async Task WritesToNewFileOnOptionsChange()`
`364`	`369`
`365`	`370`	`await using (var logger = new FileLoggerProcessor(monitor, new HostingEnvironment(), NullLoggerFactory.Instance))`
`366`	`371`	`{`
`367`		`- logger.EnqueueMessage("Message one");`
`368`		`- await WaitForFile(fileName1).DefaultTimeout();`
	`372`	`+ logger.EnqueueMessage(_messageOne);`
	`373`	`+ await WaitForFile(fileName1, _messageOne.Length).DefaultTimeout();`
`369`	`374`	`options.LoggingFields = W3CLoggingFields.Date;`
`370`	`375`	`monitor.InvokeChanged();`
`371`		`- logger.EnqueueMessage("Message two");`
	`376`	`+ logger.EnqueueMessage(_messageTwo);`
`372`	`377`	`// Pause for a bit before disposing so logger can finish logging`
`373`		`- await WaitForFile(fileName2).DefaultTimeout();`
	`378`	`+ await WaitForFile(fileName2, _messageTwo.Length).DefaultTimeout();`
`374`	`379`	`}`
`375`	`380`
`376`	`381`	`var actualFiles = new DirectoryInfo(path)`
`@@ -384,21 +389,36 @@ public async Task WritesToNewFileOnOptionsChange()`
`384`	`389`	`Assert.True(File.Exists(fileName1));`
`385`	`390`	`Assert.True(File.Exists(fileName2));`
`386`	`391`
`387`		`- Assert.Equal("Message one" + Environment.NewLine, File.ReadAllText(fileName1));`
`388`		`- Assert.Equal("Message two" + Environment.NewLine, File.ReadAllText(fileName2));`
	`392`	`+ Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(fileName1));`
	`393`	`+ Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(fileName2));`
`389`	`394`	`}`
`390`	`395`	`finally`
`391`	`396`	`{`
`392`	`397`	`Helpers.DisposeDirectory(path);`
`393`	`398`	`}`
`394`	`399`	`}`
`395`	`400`
`396`		`- private async Task WaitForFile(string fileName)`
	`401`	`+ private async Task WaitForFile(string fileName, int length)`
`397`	`402`	`{`
`398`	`403`	`while (!File.Exists(fileName))`
`399`	`404`	`{`
`400`	`405`	`await Task.Delay(100);`
`401`	`406`	`}`
	`407`	`+ while (true)`
	`408`	`+ {`
	`409`	`+ try`
	`410`	`+ {`
	`411`	`+ if (File.ReadAllText(fileName).Length >= length)`
	`412`	`+ {`
	`413`	`+ break;`
	`414`	`+ }`
	`415`	`+ }`
	`416`	`+ catch`
	`417`	`+ {`
	`418`	`+ // Continue`
	`419`	`+ }`
	`420`	`+ await Task.Delay(10);`
	`421`	`+ }`
`402`	`422`	`}`
`403`	`423`
`404`	`424`	`private async Task WaitForRoll(string fileName)`