feat(page): introduce Page.Video (#958)

src/PlaywrightSharp.Tests/ScreencastTests.cs

@@ -45,6 +45,50 @@ public async Task ShouldCaptureStaticPage()
             Assert.NotEmpty(new DirectoryInfo(tempDirectory.Path).GetFiles("*.webm"));
         }
 
+        ///<playwright-file>screencast.spec.js</playwright-file>     
+        ///<playwright-it>should expose video path</playwright-it>
+        [Fact(Timeout = PlaywrightSharp.Playwright.DefaultTimeout)]
+        public async Task ShouldExposeVideoPath()
+        {
+            using var tempDirectory = new TempDirectory();
+            var context = await Browser.NewContextAsync(
+                videosPath: tempDirectory.Path,
+                videoSize: new ViewportSize { Width = 100, Height = 100 });
+
+            var page = await context.NewPageAsync();
+            await page.EvaluateAsync("() => document.body.style.backgroundColor = 'red'");
+            string path = await page.Video.GetPathAsync();
+            Assert.Contains(tempDirectory.Path, path);
+            await context.CloseAsync();
+
+            Assert.True(new FileInfo(path).Exists);
+        }
+
+        ///<playwright-file>screencast.spec.js</playwright-file>     
+        ///<playwright-it>should expose video path blank page</playwright-it>
+        [Fact(Timeout = PlaywrightSharp.Playwright.DefaultTimeout)]
+        public async Task ShouldExposeVideoPathBlankPage()
+        {
+            using var tempDirectory = new TempDirectory();
+            var context = await Browser.NewContextAsync(
+                videosPath: tempDirectory.Path,
+                videoSize: new ViewportSize { Width = 100, Height = 100 });
+
+            var page = await context.NewPageAsync();
+            string path = await page.Video.GetPathAsync();
+            Assert.Contains(tempDirectory.Path, path);
+            await context.CloseAsync();
+
+            Assert.True(new FileInfo(path).Exists);
+        }
+
+        ///<playwright-file>screencast.spec.js</playwright-file>     
+        ///<playwright-it>should expose video path blank popup</playwright-it>
+        [Fact(Skip = "We don't need to test video details")]
+        public void ShouldExposeVideoPathBlankPopup()
+        {
+        }
+
         ///<playwright-file>screencast.spec.js</playwright-file>     
         ///<playwright-it>should capture navigation</playwright-it>
         [Fact(Skip = "We don't need to test video details")]

src/PlaywrightSharp/Browser.cs

@@ -147,6 +147,7 @@ public Task<IBrowserContext> NewContextAsync(
         public async Task<IBrowserContext> NewContextAsync(BrowserContextOptions options)
         {
             var context = (await Channel.NewContextAsync(options ?? new BrowserContextOptions()).ConfigureAwait(false)).Object;
+            context.Options = options;
             BrowserContextsList.Add(context);
             return context;
         }

src/PlaywrightSharp/BrowserContext.cs

@@ -95,6 +95,8 @@ public int DefaultNavigationTimeout
 
         internal string BrowserName => _initializer.BrowserName;
 
+        internal BrowserContextOptions Options { get; set; }
+
         /// <inheritdoc />
         public async Task<IPage> NewPageAsync(string url = null)
         {

src/PlaywrightSharp/IPage.cs

@@ -229,6 +229,11 @@ public interface IPage
         /// </summary>
         ICoverage Coverage { get; }
 
+        /// <summary>
+        /// Video object associated with this page.
+        /// </summary>
+        IVideo Video { get; }
+
         /// <summary>
         /// Returns page's title.
         /// </summary>

src/PlaywrightSharp/IVideo.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+namespace PlaywrightSharp
+{
+    /// <summary>
+    /// When browser context is created with the videosPath option, each page has a video object associated with it.
+    /// </summary>
+    public interface IVideo
+    {
+        /// <summary>
+        /// Returns the file system path this video will be recorded to.
+        /// The video is guaranteed to be written to the filesystem upon closing the browser context.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> that completes when the path has been resolved.</returns>
+        Task<string> GetPathAsync();
+    }
+}

src/PlaywrightSharp/Page.cs

@@ -25,6 +25,7 @@ public class Page : ChannelOwnerBase, IChannelOwner<Page>, IPage
         private List<RouteSetting> _routes = new List<RouteSetting>();
         private EventHandler<FileChooserEventArgs> _fileChooserEventHandler;
         private bool _fileChooserIntercepted;
+        private IVideo _video;
 
         internal Page(IChannelOwner parent, string guid, PageInitializer initializer) : base(parent, guid)
         {
@@ -68,6 +69,14 @@ internal Page(IChannelOwner parent, string guid, PageInitializer initializer) :
             _channel.Download += (sender, e) => Download?.Invoke(this, e);
             _channel.PageError += (sender, e) => PageError?.Invoke(this, e);
             _channel.Load += (sender, e) => Load?.Invoke(this, e);
+            _channel.Video += (sender, e) =>
+            {
+                if (Video != null)
+                {
+                    ((Video)Video).SetRelativePath(e.RelativePath);
+                }
+            };
+
             _channel.FileChooser += (sender, e) =>
             {
                 _fileChooserEventHandler?.Invoke(this, new FileChooserEventArgs(this, e.Element.Object, e.IsMultiple));
@@ -234,6 +243,26 @@ public int DefaultNavigationTimeout
         /// <inheritdoc />
         public ICoverage Coverage { get; }
 
+        /// <inheritdoc />
+        public IVideo Video
+        {
+            get
+            {
+                if (_video != null)
+                {
+                    return _video;
+                }
+
+                if (string.IsNullOrEmpty(BrowserContext.Options?.VideosPath))
+                {
+                    return null;
+                }
+
+                _video = new Video(this);
+                return _video;
+            }
+        }
+
         internal BrowserContext OwnedContext { get; set; }
 
         internal Dictionary<string, Delegate> Bindings { get; } = new Dictionary<string, Delegate>();

src/PlaywrightSharp/Transport/Channels/PageChannel.cs

@@ -53,6 +53,8 @@ public PageChannel(string guid, Connection connection, Page owner) : base(guid,
 
         internal event EventHandler<WorkerChannelEventArgs> Worker;
 
+        internal event EventHandler<VideoEventArgs> Video;
+
         internal override void OnMessage(string method, JsonElement? serverParams)
         {
             switch (method)
@@ -125,6 +127,9 @@ internal override void OnMessage(string method, JsonElement? serverParams)
                 case "download":
                     Download?.Invoke(this, new DownloadEventArgs() { Download = serverParams?.GetProperty("download").ToObject<DownloadChannel>(Connection.GetDefaultJsonSerializerOptions()).Object });
                     break;
+                case "video":
+                    Video?.Invoke(this, new VideoEventArgs() { RelativePath = serverParams?.GetProperty("relativePath").ToString() });
+                    break;
                 case "worker":
                     Worker?.Invoke(
                         this,

src/PlaywrightSharp/Transport/Channels/VideoEventArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace PlaywrightSharp.Transport.Channels
+{
+    internal class VideoEventArgs : EventArgs
+    {
+        public string RelativePath { get; set; }
+    }
+}

src/PlaywrightSharp/Video.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using PlaywrightSharp.Transport;
+using PlaywrightSharp.Transport.Channels;
+
+namespace PlaywrightSharp
+{
+    internal class Video : IVideo
+    {
+        private readonly Page _page;
+        private readonly TaskCompletionSource<string> _pathTask = new TaskCompletionSource<string>();
+
+        public Video(Page page) => _page = page;
+
+        /// <inheritdoc/>
+        public Task<string> GetPathAsync() => _pathTask.Task;
+
+        internal void SetRelativePath(string relativePath)
+            => _pathTask.TrySetResult(Path.Combine(_page.BrowserContext.Options.VideosPath, relativePath));
+    }
+}