Add tests for javascript callbacks

Author: campersau

CefSharp.Test/Javascript/EvaluateScriptAsyncTests.cs

@@ -36,38 +36,38 @@ public async Task V8Context()
                 await browser.CreateBrowserAsync();
 
                 // no V8 context
-                await Assert.ThrowsAsync<Exception>(() => browser.EvaluateScriptAsync("1+1"));
+                var withoutV8ContextException = await Assert.ThrowsAsync<Exception>(() => browser.EvaluateScriptAsync("1+1"));
+                Assert.StartsWith("Unable to execute javascript at this time", withoutV8ContextException.Message);
 
-                Task evaluateWithoutV8ContextCancelTask;
-                Task<int> evaluateWithoutV8ContextTask;
+                Task<JavascriptResponse> evaluateWithoutV8ContextTask;
                 using (var frame = browser.GetMainFrame())
                 {
-                    evaluateWithoutV8ContextTask = frame.EvaluateScriptAsync<int>("1+2");
-                    evaluateWithoutV8ContextCancelTask = frame.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
+                    evaluateWithoutV8ContextTask = frame.EvaluateScriptAsync("1+2");
                 }
 
                 // V8 context
                 await browser.LoadUrlAsync(CefExample.HelloWorldUrl);
-                var evaluateCancelAfterV8ContextChangeTask = browser.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
+                var evaluateWithoutV8ContextResponse = await evaluateWithoutV8ContextTask;
+                Assert.True(evaluateWithoutV8ContextResponse.Success);
+                Assert.Equal(3, evaluateWithoutV8ContextResponse.Result);
 
-                Assert.Equal(3, await evaluateWithoutV8ContextTask);
-                Assert.Equal(4, await browser.EvaluateScriptAsync<int>("1+3"));
+                var evaluateCancelAfterV8ContextChangeTask = browser.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
 
                 // change V8 context
                 await browser.LoadUrlAsync(CefExample.HelloWorldUrl);
-                evaluateCancelAfterDisposeTask = browser.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
-
-                Assert.Equal(5, await browser.EvaluateScriptAsync<int>("1+4"));
 
                 await Assert.ThrowsAsync<TaskCanceledException>(() => evaluateCancelAfterV8ContextChangeTask);
-                await Assert.ThrowsAsync<TaskCanceledException>(() => evaluateWithoutV8ContextCancelTask);
+
+                evaluateCancelAfterDisposeTask = browser.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
             }
             await Assert.ThrowsAsync<TaskCanceledException>(() => evaluateCancelAfterDisposeTask);
         }
 
         [Fact]
         public async Task CancelEvaluateOnCrash()
         {
+            AssertInitialLoadComplete();
+
             var task = Browser.EvaluateScriptAsync("new Promise(resolve => setTimeout(resolve, 1000))");
             await Browser.LoadUrlAsync("chrome://crash");
             await Assert.ThrowsAsync<TaskCanceledException>(() => task);

CefSharp.Test/Javascript/JavascriptCallbackTests.cs

@@ -6,6 +6,7 @@
 using System.Dynamic;
 using System.Globalization;
 using System.Threading.Tasks;
+using CefSharp.Example;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -23,6 +24,68 @@ public JavascriptCallbackTests(ITestOutputHelper output, CefSharpFixture collect
             this.collectionFixture = collectionFixture;
         }
 
+        [Fact]
+        public async Task V8Context()
+        {
+            Task callbackExecuteCancelAfterDisposeTask;
+            using (var browser = new CefSharp.OffScreen.ChromiumWebBrowser(automaticallyCreateBrowser: false))
+            {
+                await browser.CreateBrowserAsync();
+
+                // no V8 context
+                var withoutV8ContextException = await Assert.ThrowsAsync<Exception>(() => browser.EvaluateScriptAsync("(function() { return 1+1; })"));
+                Assert.StartsWith("Unable to execute javascript at this time", withoutV8ContextException.Message);
+
+                Task<JavascriptResponse> callbackExecuteWithoutV8ContextTask;
+                using (var frame = browser.GetMainFrame())
+                {
+                    callbackExecuteWithoutV8ContextTask = frame.EvaluateScriptAsync("(function() { return 1+2; })");
+                }
+
+                // V8 context
+                await browser.LoadUrlAsync(CefExample.HelloWorldUrl);
+
+                var callbackExecuteWithoutV8ContextResponse = await callbackExecuteWithoutV8ContextTask;
+                Assert.True(callbackExecuteWithoutV8ContextResponse.Success);
+                var callbackExecuteWithoutV8ContextCallback = (IJavascriptCallback)callbackExecuteWithoutV8ContextResponse.Result;
+                var callbackExecuteWithoutV8ContextExecuteResponse = await callbackExecuteWithoutV8ContextCallback.ExecuteAsync();
+                Assert.True(callbackExecuteWithoutV8ContextExecuteResponse.Success);
+                Assert.Equal(3, callbackExecuteWithoutV8ContextExecuteResponse.Result);
+
+                var callbackExecuteCancelAfterV8ContextResponse = await browser.EvaluateScriptAsync("(function() { return new Promise(resolve => setTimeout(resolve, 1000)); })");
+                Assert.True(callbackExecuteCancelAfterV8ContextResponse.Success);
+                var evaluateCancelAfterV8ContextCallback = (IJavascriptCallback)callbackExecuteCancelAfterV8ContextResponse.Result;
+                var evaluateCancelAfterV8ContextTask = evaluateCancelAfterV8ContextCallback.ExecuteAsync();
+
+                // change V8 context
+                await browser.LoadUrlAsync(CefExample.HelloWorldUrl);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => evaluateCancelAfterV8ContextTask);
+
+                var callbackExecuteCancelAfterDisposeResponse = await browser.EvaluateScriptAsync("(function() { return new Promise(resolve => setTimeout(resolve, 1000)); })");
+                Assert.True(callbackExecuteCancelAfterDisposeResponse.Success);
+                var callbackExecuteCancelAfterDisposeCallback = (IJavascriptCallback)callbackExecuteCancelAfterDisposeResponse.Result;
+                callbackExecuteCancelAfterDisposeTask = callbackExecuteCancelAfterDisposeCallback.ExecuteAsync();
+            }
+            await Assert.ThrowsAsync<TaskCanceledException>(() => callbackExecuteCancelAfterDisposeTask);
+        }
+
+        [Fact]
+        public async Task CancelCallbackOnCrash()
+        {
+            AssertInitialLoadComplete();
+
+            var javascriptResponse = await Browser.EvaluateScriptAsync("(function() { return new Promise(resolve => setTimeout(resolve, 1000)); })");
+            Assert.True(javascriptResponse.Success);
+
+            var callback = (IJavascriptCallback)javascriptResponse.Result;
+
+            var task = callback.ExecuteAsync();
+
+            await Browser.LoadUrlAsync("chrome://crash");
+            await Assert.ThrowsAsync<TaskCanceledException>(() => task);
+        }
+
         [Theory]
         [InlineData("(function() { return Promise.resolve(53)})", 53)]
         [InlineData("(function() { return Promise.resolve('53')})", "53")]