Esempio n. 1
0
        internal Task <ResponseChannel> GoToAsync(string url, int?timeout, LifecycleEvent?waitUntil, string referer, bool isPage)
        {
            var args = new Dictionary <string, object>
            {
                ["url"]    = url,
                ["isPage"] = isPage,
            };

            if (timeout != null)
            {
                args["timeout"] = timeout;
            }

            if (waitUntil != null)
            {
                args["waitUntil"] = waitUntil;
            }

            if (waitUntil != null)
            {
                args["waitUntil"] = waitUntil;
            }

            if (referer != null)
            {
                args["referer"] = referer;
            }

            return(Connection.SendMessageToServerAsync <ResponseChannel>(Guid, "goto", args));
        }
Esempio n. 2
0
        internal async Task <IResponse> WaitForNavigationAsync(
            LifecycleEvent?waitUntil = null,
            string url  = null,
            Regex regex = null,
            Func <string, bool> match = null,
            int?timeout = null)
        {
            waitUntil ??= LifecycleEvent.Load;
            var    waiter = SetupNavigationWaiter(timeout);
            string toUrl  = !string.IsNullOrEmpty(url) ? $" to \"{url}\"" : string.Empty;

            waiter.Log($"waiting for navigation{toUrl} until \"{waitUntil}\"");

            var navigatedEvent = await waiter.WaitForEventAsync <FrameNavigatedEventArgs>(
                this,
                "Navigated",
                e =>
            {
                // Any failed navigation results in a rejection.
                if (e.Error != null)
                {
                    return(true);
                }

                waiter.Log($"  navigated to \"{e.Url}\"");
                return(UrlMatches(e.Url, url, regex, match));
            }).ConfigureAwait(false);

            if (navigatedEvent.Error != null)
            {
                var ex  = new NavigationException(navigatedEvent.Error);
                var tcs = new TaskCompletionSource <bool>();
                tcs.TrySetException(ex);
                await waiter.WaitForPromiseAsync(tcs.Task).ConfigureAwait(false);
            }

            if (!_loadStates.Contains(waitUntil.Value))
            {
                await waiter.WaitForEventAsync <LoadStateEventArgs>(
                    this,
                    "LoadState",
                    e =>
                {
                    waiter.Log($"  \"{e.LifecycleEvent}\" event fired");
                    return(e.LifecycleEvent == waitUntil);
                }).ConfigureAwait(false);
            }

            var request  = navigatedEvent.NewDocument?.Request?.Object;
            var response = request != null
                ? await waiter.WaitForPromiseAsync(request.FinalRequest.GetResponseAsync()).ConfigureAwait(false)
                : null;

            waiter.Dispose();
            return(response);
        }
Esempio n. 3
0
        internal Task <ResponseChannel> ReloadAsync(int?timeout, LifecycleEvent?waitUntil)
        {
            var args = new Dictionary <string, object>();

            if (timeout != null)
            {
                args["timeout"] = timeout;
            }

            if (waitUntil != null)
            {
                args["waitUntil"] = waitUntil;
            }

            return(Connection.SendMessageToServer <ResponseChannel>(Guid, "reload", args));
        }
Esempio n. 4
0
        internal Task SetContentAsync(string html, int?timeout, LifecycleEvent?waitUntil, bool isPage)
        {
            var args = new Dictionary <string, object>
            {
                ["html"]   = html,
                ["isPage"] = isPage,
            };

            if (timeout != null)
            {
                args["timeout"] = timeout;
            }

            if (waitUntil != null)
            {
                args["waitUntil"] = waitUntil;
            }

            return(Connection.SendMessageToServerAsync(Guid, "setContent", args));
        }
Esempio n. 5
0
        internal Task WaitForLoadStateAsync(LifecycleEvent?state, int?timeout, bool isPage)
        {
            var param = new Dictionary <string, object>
            {
                ["isPage"] = isPage,
            };

            if (timeout != null)
            {
                param["timeout"] = timeout;
            }

            if (state != null)
            {
                param["state"] = state;
            }

            return(Connection.SendMessageToServerAsync(
                       Guid,
                       "waitForLoadState",
                       param));
        }
Esempio n. 6
0
        internal Task <ResponseChannel> WaitForNavigationAsync(LifecycleEvent?waitUntil, string url, int?timeout, bool isPage)
        {
            var param = new Dictionary <string, object>
            {
                ["isPage"] = isPage,
            };

            if (timeout != null)
            {
                param["timeout"] = timeout;
            }

            if (url != null)
            {
                param["url"] = url;
            }

            if (waitUntil != null)
            {
                param["waitUntil"] = waitUntil;
            }

            return(Connection.SendMessageToServerAsync <ResponseChannel>(Guid, "waitForNavigation", param));
        }
Esempio n. 7
0
 internal async Task <IResponse> GoToAsync(bool isPage, string url, LifecycleEvent?waitUntil, string referer, int?timeout)
 => (await _channel.GoToAsync(url, timeout, waitUntil, referer, isPage).ConfigureAwait(false))?.Object;
Esempio n. 8
0
 internal Task SetContentAsync(bool isPageCall, string html, LifecycleEvent?waitUntil, int?timeout)
 => _channel.SetContentAsync(html, timeout, waitUntil, isPageCall);
Esempio n. 9
0
 /// <inheritdoc />
 public Task <IResponse> WaitForNavigationAsync(Func <string, bool> url, LifecycleEvent?waitUntil = null, int?timeout = null)
 => WaitForNavigationAsync(waitUntil: waitUntil, url: null, regex: null, match: url, timeout: timeout);
Esempio n. 10
0
 /// <inheritdoc />
 public Task SetContentAsync(string html, LifecycleEvent?waitUntil = null, int?timeout = null) => SetContentAsync(false, html, waitUntil, timeout);
Esempio n. 11
0
 /// <inheritdoc />
 public Task <IResponse> GoToAsync(string url, LifecycleEvent?waitUntil = null, string referer = null, int?timeout = null)
 => GoToAsync(false, url, waitUntil, referer, timeout);