return the trace from tracing.stop (#433)

Author: kblok

lib/PuppeteerSharp.Tests/TracingTests/TracingTests.cs

@@ -14,8 +14,8 @@ namespace PuppeteerSharp.Tests.TracingTests
     [Collection("PuppeteerLoaderFixture collection")]
     public class TracingTests : PuppeteerPageBaseTest
     {
-        private string _file;
-        
+        private readonly string _file;
+
         public TracingTests(ITestOutputHelper output) : base(output)
         {
             _file = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
@@ -25,7 +25,7 @@ protected override async Task DisposeAsync()
         {
             await base.DisposeAsync();
 
-            int attempts = 0;
+            var attempts = 0;
             const int maxAttempts = 5;
 
             while (true)
@@ -93,19 +93,45 @@ public async Task ShouldThrowIfTracingOnTwoPages()
         {
             await Page.Tracing.StartAsync(new TracingOptions
             {
-                Path = _file,
+                Path = _file
             });
             var newPage = await Browser.NewPageAsync();
             var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
             {
                 await Page.Tracing.StartAsync(new TracingOptions
                 {
-                    Path = _file,
+                    Path = _file
                 });
             });
 
             await newPage.CloseAsync();
             await Page.Tracing.StopAsync();
         }
+
+        [Fact]
+        public async Task ShouldReturnABuffer()
+        {
+            await Page.Tracing.StartAsync(new TracingOptions
+            {
+                Screenshots = true,
+                Path = _file
+            });
+            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
+            var trace = await Page.Tracing.StopAsync();
+            var buf = File.ReadAllText(_file);
+            Assert.Equal(trace, buf);
+        }
+
+        [Fact]
+        public async Task ShouldSupportABufferWithoutAPath()
+        {
+            await Page.Tracing.StartAsync(new TracingOptions
+            {
+                Screenshots = true
+            });
+            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
+            var trace = await Page.Tracing.StopAsync();
+            Assert.Contains("screenshot", trace);
+        }
     }
-}
+}

lib/PuppeteerSharp/Tracing.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 using System.Threading.Tasks;
 using PuppeteerSharp.Messaging;
 
@@ -25,7 +26,7 @@ public class Tracing
         private readonly CDPSession _client;
         private bool _recording;
         private string _path;
-        private static readonly List<string> _defaultCategories = new List<string>()
+        private static readonly List<string> _defaultCategories = new List<string>
         {
             "-*",
             "devtools.timeline",
@@ -57,12 +58,6 @@ public async Task StartAsync(TracingOptions options)
                 throw new InvalidOperationException("Cannot start recording trace while already recording trace.");
             }
 
-            if (string.IsNullOrEmpty(options.Path))
-            {
-                throw new ArgumentException("Must specify a path to write trace file to.");
-            }
-
-
             var categories = options.Categories ?? _defaultCategories;
 
             if (options.Screenshots)
@@ -84,15 +79,15 @@ public async Task StartAsync(TracingOptions options)
         /// Stops tracing
         /// </summary>
         /// <returns>Stop task</returns>
-        public async Task StopAsync()
+        public async Task<string> StopAsync()
         {
-            var taskWrapper = new TaskCompletionSource<bool>();
+            var taskWrapper = new TaskCompletionSource<string>();
 
             async void EventHandler(object sender, TracingCompleteEventArgs e)
             {
-                await ReadStream(e.Stream, _path);
+                var tracingData = await ReadStream(e.Stream, _path);
                 _client.TracingComplete -= EventHandler;
-                taskWrapper.SetResult(true);
+                taskWrapper.SetResult(tracingData);
             }
 
             _client.TracingComplete += EventHandler;
@@ -101,31 +96,40 @@ async void EventHandler(object sender, TracingCompleteEventArgs e)
 
             _recording = false;
 
-            await taskWrapper.Task;
+            return await taskWrapper.Task;
         }
 
-        private async Task ReadStream(string stream, string path)
+        private async Task<string> ReadStream(string stream, string path)
         {
-            using (var fs = new StreamWriter(path))
-            {
-                bool eof = false;
+            var result = new StringBuilder();
+            var eof = false;
 
-                while (!eof)
+            while (!eof)
+            {
+                var response = await _client.SendAsync<IOReadResponse>("IO.read", new
                 {
-                    var response = await _client.SendAsync<IOReadResponse>("IO.read", new
-                    {
-                        handle = stream
-                    });
+                    handle = stream
+                });
 
-                    eof = response.Eof;
+                eof = response.Eof;
+
+                result.Append(response.Data);
+            }
 
-                    await fs.WriteAsync(response.Data);
-                }
-            }
+            if (!string.IsNullOrEmpty(path))
+            {
+                using (var fs = new StreamWriter(path))
+                {
+                    await fs.WriteAsync(result.ToString());
+                }
+            }
+
             await _client.SendAsync("IO.close", new
             {
                 handle = stream
             });
+
+            return result.ToString();
         }
     }
 }