Cookies tests improvements (#1025)

* Some progress

* Cookies tests improvements

* Codefactor

Author: kblok

lib/PuppeteerSharp.Tests/PageTests/Cookies/CookiesTests.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace PuppeteerSharp.Tests.PageTests.Cookies
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class CookiesTests : PuppeteerPageBaseTest
+    {
+        public CookiesTests(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        [Fact]
+        public async Task ShouldReturnNoCookiesInPristineBrowserContext()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            Assert.Empty(await Page.GetCookiesAsync());
+        }
+
+        [Fact]
+        public async Task ShouldGetACookie()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            Assert.Empty(await Page.GetCookiesAsync());
+
+            await Page.EvaluateExpressionAsync("document.cookie = 'username=John Doe'");
+            var cookie = Assert.Single(await Page.GetCookiesAsync());
+            Assert.Equal("username", cookie.Name);
+            Assert.Equal("John Doe", cookie.Value);
+            Assert.Equal("localhost", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(cookie.Expires, -1);
+            Assert.Equal(16, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.False(cookie.Secure);
+            Assert.True(cookie.Session);
+        }
+
+        [Fact]
+        public async Task ShouldGetMultipleCookies()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            Assert.Empty(await Page.GetCookiesAsync());
+
+            await Page.EvaluateFunctionAsync(@"() => {
+                document.cookie = 'username=John Doe';
+                document.cookie = 'password=1234';
+            }");
+
+            var cookies = (await Page.GetCookiesAsync()).OrderBy(c => c.Name).ToList();
+
+            var cookie = cookies[0];
+            Assert.Equal("password", cookie.Name);
+            Assert.Equal("1234", cookie.Value);
+            Assert.Equal("localhost", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(cookie.Expires, -1);
+            Assert.Equal(12, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.False(cookie.Secure);
+            Assert.True(cookie.Session);
+
+            cookie = cookies[1];
+            Assert.Equal("username", cookie.Name);
+            Assert.Equal("John Doe", cookie.Value);
+            Assert.Equal("localhost", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(cookie.Expires, -1);
+            Assert.Equal(16, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.False(cookie.Secure);
+            Assert.True(cookie.Session);
+        }
+
+        [Fact]
+        public async Task ShouldGetCookiesFromMultipleUrls()
+        {
+            await Page.SetCookieAsync(
+                new CookieParam
+                {
+                    Url = "https://foo.com",
+                    Name = "doggo",
+                    Value = "woofs"
+                },
+                new CookieParam
+                {
+                    Url = "https://bar.com",
+                    Name = "catto",
+                    Value = "purrs"
+                },
+                new CookieParam
+                {
+                    Url = "https://baz.com",
+                    Name = "birdo",
+                    Value = "tweets"
+                }
+            );
+            var cookies = (await Page.GetCookiesAsync("https://foo.com", "https://baz.com")).OrderBy(c => c.Name).ToList();
+
+            Assert.Equal(2, cookies.Count);
+
+            var cookie = cookies[0];
+            Assert.Equal("birdo", cookie.Name);
+            Assert.Equal("tweets", cookie.Value);
+            Assert.Equal("baz.com", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(cookie.Expires, -1);
+            Assert.Equal(11, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.True(cookie.Secure);
+            Assert.True(cookie.Session);
+
+            cookie = cookies[1];
+            Assert.Equal("doggo", cookie.Name);
+            Assert.Equal("woofs", cookie.Value);
+            Assert.Equal("foo.com", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(cookie.Expires, -1);
+            Assert.Equal(10, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.True(cookie.Secure);
+            Assert.True(cookie.Session);
+        }
+    }
+}

lib/PuppeteerSharp.Tests/PageTests/Cookies/DeleteCookiesTests.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace PuppeteerSharp.Tests.PageTests.Cookies
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class DeleteCookiesTests : PuppeteerPageBaseTest
+    {
+        public DeleteCookiesTests(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        [Fact]
+        public async Task ShouldDeleteACookie()
+        {
+            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Name = "cookie1",
+                Value = "1"
+            }, new CookieParam
+            {
+                Name = "cookie2",
+                Value = "2"
+            }, new CookieParam
+            {
+                Name = "cookie3",
+                Value = "3"
+            });
+            Assert.Equal("cookie1=1; cookie2=2; cookie3=3", await Page.EvaluateExpressionAsync<string>("document.cookie"));
+            await Page.DeleteCookieAsync(new CookieParam { Name = "cookie2" });
+            Assert.Equal("cookie1=1; cookie3=3", await Page.EvaluateExpressionAsync<string>("document.cookie"));
+        }
+    }
+}

lib/PuppeteerSharp.Tests/PageTests/CookiesTests.cs renamed to lib/PuppeteerSharp.Tests/PageTests/Cookies/SetCookiesTests.cs

@@ -4,61 +4,130 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace PuppeteerSharp.Tests.PageTests
+namespace PuppeteerSharp.Tests.PageTests.Cookies
 {
     [Collection("PuppeteerLoaderFixture collection")]
-    public class CookiesTests : PuppeteerPageBaseTest
+    public class SetCookiesTests : PuppeteerPageBaseTest
     {
-        public CookiesTests(ITestOutputHelper output) : base(output)
+        public SetCookiesTests(ITestOutputHelper output) : base(output)
         {
         }
 
         [Fact]
-        public async Task ShouldGetAndSetCookies()
+        public async Task ShouldWork()
         {
-            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
-            Assert.Empty(await Page.GetCookiesAsync());
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Name = "password",
+                Value = "123456"
+            });
+            Assert.Equal("password=123456", await Page.EvaluateExpressionAsync<string>("document.cookie"));
+        }
 
-            await Page.EvaluateExpressionAsync("document.cookie = 'username=John Doe'");
-            var cookie = Assert.Single(await Page.GetCookiesAsync());
-            Assert.Equal("username", cookie.Name);
-            Assert.Equal("John Doe", cookie.Value);
-            Assert.Equal("localhost", cookie.Domain);
-            Assert.Equal("/", cookie.Path);
-            Assert.Equal(cookie.Expires, -1);
-            Assert.Equal(16, cookie.Size);
-            Assert.False(cookie.HttpOnly);
-            Assert.False(cookie.Secure);
-            Assert.True(cookie.Session);
+        [Fact]
+        public async Task ShouldIsolateCookiesInBrowserContexts()
+        {
+            var anotherContext = await Browser.CreateIncognitoBrowserContextAsync();
+            var anotherPage = await anotherContext.NewPageAsync();
+
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            await anotherPage.GoToAsync(TestConstants.EmptyPage);
+
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Name = "page1cookie",
+                Value = "page1value"
+            });
+
+            await anotherPage.SetCookieAsync(new CookieParam
+            {
+                Name = "page2cookie",
+                Value = "page2value"
+            });
+
+            var cookies1 = await Page.GetCookiesAsync();
+            var cookies2 = await anotherPage.GetCookiesAsync();
+
+            Assert.Single(cookies1);
+            Assert.Single(cookies2);
+            Assert.Equal("page1cookie", cookies1[0].Name);
+            Assert.Equal("page1value", cookies1[0].Value);
+            Assert.Equal("page2cookie", cookies2[0].Name);
+            Assert.Equal("page2value", cookies2[0].Value);
+
+            await anotherContext.CloseAsync();
+        }
+
+        [Fact]
+        public async Task ShouldSetMultipleCookies()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+
+            await Page.SetCookieAsync(
+                new CookieParam
+                {
+                    Name = "password",
+                    Value = "123456"
+                },
+                new CookieParam
+                {
+                    Name = "foo",
+                    Value = "bar"
+                }
+            );
+
+            Assert.Equal(
+                new[]
+                {
+                    "foo=bar",
+                    "password=123456"
+                },
+                await Page.EvaluateFunctionAsync<string[]>(@"() => {
+                    const cookies = document.cookie.split(';');
+                    return cookies.map(cookie => cookie.trim()).sort();
+                }")
+            );
+        }
+
+        [Fact]
+        public async Task ShouldHaveExpiresSetToMinus1ForSessionCookies()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
 
             await Page.SetCookieAsync(new CookieParam
             {
                 Name = "password",
                 Value = "123456"
             });
-            Assert.Equal("username=John Doe; password=123456", await Page.EvaluateExpressionAsync<string>("document.cookie"));
-            var cookies = (await Page.GetCookiesAsync()).OrderBy(c => c.Name).ToList();
-            Assert.Equal(2, cookies.Count);
-
-            Assert.Equal("password", cookies[0].Name);
-            Assert.Equal("123456", cookies[0].Value);
-            Assert.Equal("localhost", cookies[0].Domain);
-            Assert.Equal("/", cookies[0].Path);
-            Assert.Equal(cookies[0].Expires, -1);
-            Assert.Equal(14, cookies[0].Size);
-            Assert.False(cookies[0].HttpOnly);
-            Assert.False(cookies[0].Secure);
+
+            var cookies = await Page.GetCookiesAsync();
+
             Assert.True(cookies[0].Session);
+            Assert.Equal(-1, cookies[0].Expires);
+        }
+
+        [Fact]
+        public async Task ShouldSetCookieWithReasonableDefaults()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Name = "password",
+                Value = "123456"
+            });
 
-            Assert.Equal("username", cookies[1].Name);
-            Assert.Equal("John Doe", cookies[1].Value);
-            Assert.Equal("localhost", cookies[1].Domain);
-            Assert.Equal("/", cookies[1].Path);
-            Assert.Equal(cookies[1].Expires, -1);
-            Assert.Equal(16, cookies[1].Size);
-            Assert.False(cookies[1].HttpOnly);
-            Assert.False(cookies[1].Secure);
-            Assert.True(cookies[1].Session);
+            var cookie = Assert.Single(await Page.GetCookiesAsync());
+            Assert.Equal("password", cookie.Name);
+            Assert.Equal("123456", cookie.Value);
+            Assert.Equal("localhost", cookie.Domain);
+            Assert.Equal("/", cookie.Path);
+            Assert.Equal(-1, cookie.Expires);
+            Assert.Equal(14, cookie.Size);
+            Assert.False(cookie.HttpOnly);
+            Assert.False(cookie.Secure);
+            Assert.True(cookie.Session);
         }
 
         [Fact]
@@ -81,14 +150,6 @@ await Page.SetCookieAsync(new CookieParam
             Assert.False(cookie.HttpOnly);
             Assert.False(cookie.Secure);
             Assert.True(cookie.Session);
-            Assert.Equal("gridcookie=GRID", await Page.EvaluateExpressionAsync<string>("document.cookie"));
-
-            await Page.GoToAsync(TestConstants.ServerUrl + "/empty.html");
-            Assert.Empty(await Page.GetCookiesAsync());
-            Assert.Equal(string.Empty, await Page.EvaluateExpressionAsync<string>("document.cookie"));
-
-            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
-            Assert.Equal("gridcookie=GRID", await Page.EvaluateExpressionAsync<string>("document.cookie"));
         }
 
         [Fact]
@@ -149,6 +210,38 @@ public async Task ShouldNotSetACookieOnADataURLPage()
             Assert.Equal("Protocol error (Network.deleteCookies): At least one of the url and domain needs to be specified", exception.Message);
         }
 
+        [Fact]
+        public async Task ShouldDefaultToSettingSecureCookieForHttpsWebsites()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            var SecureUrl = "https://example.com";
+
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Url = SecureUrl,
+                Name = "foo",
+                Value = "bar"
+            });
+            var cookie = Assert.Single(await Page.GetCookiesAsync(SecureUrl));
+            Assert.True(cookie.Secure);
+        }
+
+        [Fact]
+        public async Task ShouldBeAbleToSetUnsecureCookieForHttpWebSite()
+        {
+            await Page.GoToAsync(TestConstants.EmptyPage);
+            var SecureUrl = "http://example.com";
+
+            await Page.SetCookieAsync(new CookieParam
+            {
+                Url = SecureUrl,
+                Name = "foo",
+                Value = "bar"
+            });
+            var cookie = Assert.Single(await Page.GetCookiesAsync(SecureUrl));
+            Assert.False(cookie.Secure);
+        }
+
         [Fact]
         public async Task ShouldSetACookieOnADifferentDomain()
         {