| // <copyright file="WebDriver.cs" company="Selenium Committers"> | |
| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in compliance | |
| // with the License. You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, | |
| // software distributed under the License is distributed on an | |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| // KIND, either express or implied. See the License for the | |
| // specific language governing permissions and limitations | |
| // under the License. | |
| // </copyright> | |
| using System.Collections; | |
| using System.Collections.ObjectModel; | |
| using System.Diagnostics.CodeAnalysis; | |
| using System.Globalization; | |
| using OpenQA.Selenium.BiDi; | |
| using OpenQA.Selenium.Interactions; | |
| using OpenQA.Selenium.Internal; | |
| using OpenQA.Selenium.Internal.Logging; | |
| using OpenQA.Selenium.VirtualAuth; | |
| namespace OpenQA.Selenium; | |
| /// <summary> | |
| /// A base class representing a driver for a web browser. | |
| /// </summary> | |
| public class WebDriver : IWebDriver, ISearchContext, IJavaScriptExecutor, IFindsElement, ITakesScreenshot, ISupportsPrint, IActionExecutor, IAllowsFileDetection, IHasCapabilities, IHasCommandExecutor, IHasSessionId, ICustomDriverCommandExecutor, IHasVirtualAuthenticator | |
| { | |
| /// <summary> | |
| /// The default command timeout for HTTP requests in a RemoteWebDriver instance. | |
| /// </summary> | |
| protected static readonly TimeSpan DefaultCommandTimeout = TimeSpan.FromSeconds(60); | |
| private static readonly ILogger _logger = Log.GetLogger<WebDriver>(); | |
| private IFileDetector fileDetector = new DefaultFileDetector(); | |
| private NetworkManager? network; | |
| private IBiDi? bidi; | |
| private Lazy<AccessibilitySnapshotter>? accessibilitySnapshotter; | |
| private WebElementFactory elementFactory; | |
| private readonly List<string> registeredCommands = new List<string>(); | |
| /// <summary> | |
| /// Initializes a new instance of the <see cref="WebDriver"/> class. | |
| /// </summary> | |
| /// <param name="executor">The <see cref="ICommandExecutor"/> object used to execute commands.</param> | |
| /// <param name="capabilities">The <see cref="ICapabilities"/> object used to configure the driver session.</param> | |
| /// <remarks> | |
| /// When the session the driver starts carries a WebSocket URL (see <see cref="DriverOptions.UseWebSocketUrl"/>), | |
| /// the constructor also opens the driver's BiDi connection, shared by every component that works | |
| /// over BiDi and closed with the driver. A connection that cannot be made fails the constructor, | |
| /// which quits the session it started before rethrowing. | |
| /// </remarks> | |
| protected WebDriver(ICommandExecutor executor, ICapabilities capabilities) | |
| { | |
| this.CommandExecutor = executor; | |
| this.elementFactory = new WebElementFactory(this); | |
| this.registeredCommands.AddRange(DriverCommand.KnownCommands); | |
| if (this is ISupportsLogs) | |
| { | |
| // Only add the legacy log commands if the driver supports | |
| // retrieving the logs via the extension end points. | |
| this.RegisterDriverCommand(DriverCommand.GetAvailableLogTypes, new HttpCommandInfo(HttpCommandInfo.GetCommand, "/session/{sessionId}/se/log/types"), true); | |
| this.RegisterDriverCommand(DriverCommand.GetLog, new HttpCommandInfo(HttpCommandInfo.PostCommand, "/session/{sessionId}/se/log"), true); | |
| } | |
| try | |
| { | |
| this.StartSession(capabilities); | |
| Task.Run(() => this.ConnectBiDiAsync()).GetAwaiter().GetResult(); | |
| } | |
| catch (Exception) | |
| { | |
| try | |
| { | |
| // Failed to start driver session, disposing of driver | |
| this.Dispose(); | |
| } | |
| catch | |
| { | |
| // Ignore the clean-up exception. We'll propagate the original failure. | |
| } | |
| throw; | |
| } | |
| } | |
| /// <summary> | |
| /// Gets the <see cref="ICommandExecutor"/> which executes commands for this driver. | |
| /// </summary> | |
| public ICommandExecutor CommandExecutor { get; } | |
| /// <summary> | |
| /// Gets the <see cref="ICapabilities"/> that the driver session was created with, which may be different from those requested. | |
| /// </summary> | |
| public ICapabilities Capabilities { get; private set; } | |
| /// <summary> | |
| /// Gets or sets the URL the browser is currently displaying. | |
| /// </summary> | |
| /// <seealso cref="IWebDriver.Url"/> | |
| /// <seealso cref="INavigation.GoToUrl(string)"/> | |
| /// <seealso cref="INavigation.GoToUrl(System.Uri)"/> | |
| public string Url | |
| { | |
| get | |
| { | |
| Response commandResponse = this.Execute(DriverCommand.GetCurrentUrl, null); | |
| commandResponse.EnsureValueIsNotNull(); | |
| return commandResponse.Value.ToString()!; | |
| } | |
| set => new Navigator(this).GoToUrl(value); | |
| } | |
| /// <summary> | |
| /// Gets the title of the current browser window. | |
| /// </summary> | |
| public string Title | |
| { | |
| get | |
| { | |
| Response commandResponse = this.Execute(DriverCommand.GetTitle, null); | |
| return commandResponse.Value?.ToString() ?? string.Empty; | |
| } | |
| } | |
| /// <summary> | |
| /// Gets the source of the page last loaded by the browser. | |
| /// </summary> | |
| public string PageSource | |
| { | |
| get | |
| { | |
| Response commandResponse = this.Execute(DriverCommand.GetPageSource, null); | |
| commandResponse.EnsureValueIsNotNull(); | |
| return commandResponse.Value.ToString()!; | |
| } | |
| } | |
| /// <summary> | |
| /// Gets the current window handle, which is an opaque handle to this | |
| /// window that uniquely identifies it within this driver instance. | |
| /// </summary> | |
| public string CurrentWindowHandle | |
| { | |
| get | |
| { | |
| Response commandResponse = this.Execute(DriverCommand.GetCurrentWindowHandle, null); | |
| commandResponse.EnsureValueIsNotNull(); | |
| return commandResponse.Value.ToString()!; | |
| } | |
| } | |
| /// <summary> | |
| /// Gets the window handles of open browser windows. | |
| /// </summary> | |
| public ReadOnlyCollection<string> WindowHandles | |
| { | |
| get | |
| { | |
| Response commandResponse = this.Execute(DriverCommand.GetWindowHandles, null); | |
| commandResponse.EnsureValueIsNotNull(); | |
| object?[] handles = (object?[])commandResponse.Value; | |
| List<string> handleList = new List<string>(handles.Length); | |
| foreach (object? handle in handles) | |
| { | |
| handleList.Add(handle!.ToString()!); | |
| } | |
| return handleList.AsReadOnly(); | |
| } | |
| } | |
| /// <summary> | |
| /// Gets a value indicating whether this object is a valid action executor. | |
| /// </summary> | |
| public bool IsActionExecutor => true; | |
| /// <summary> | |
| /// Gets the <see cref="Selenium.SessionId"/> for the current session of this driver. | |
| /// </summary> | |
| public SessionId SessionId { get; private set; } | |
| /// <summary> | |
| /// Gets or sets the <see cref="IFileDetector"/> responsible for detecting | |
| /// sequences of keystrokes representing file paths and names. | |
| /// </summary> | |
| /// <exception cref="ArgumentNullException">If value is set to <see langword="null"/>.</exception> | |
| public virtual IFileDetector FileDetector | |
| { | |
| get => this.fileDetector; | |
| set => this.fileDetector = value ?? throw new ArgumentNullException(nameof(value), "FileDetector cannot be null"); | |
| } | |
| internal INetwork Network => this.network ??= new NetworkManager(this); | |
| /// <summary> | |
| /// Takes an accessibility snapshot of the whole page: the tree of roles, names, states and values | |
| /// computed from the DOM, rooted at the document of the current window's top-level browsing | |
| /// context whatever frame the driver has switched to, with every reachable child frame's tree | |
| /// attached under its <c>iframe</c> node. The snapshot is a copy taken at one point in time. | |
| /// </summary> | |
| /// <remarks>Requires a WebDriver BiDi session; set <see cref="DriverOptions.UseWebSocketUrl"/> before starting the driver.</remarks> | |
| /// <param name="interestingOnly">With <see langword="true"/>, the default, elements of role <c>generic</c>, <c>none</c> or | |
| /// <c>presentation</c> with no name produce no node and their children take their place. With <see langword="false"/> every | |
| /// rendered element produces a node, with the role it has, as Puppeteer's <c>accessibility.snapshot({ interestingOnly: false })</c> does.</param> | |
| /// <param name="cancellationToken">A token to cancel the operation.</param> | |
| /// <returns>A task whose result is the root node of the snapshot, of role <c>document</c>.</returns> | |
| /// <exception cref="UnsupportedOperationException">If the session was started without <see cref="DriverOptions.UseWebSocketUrl"/>. | |
| /// A session that asked for BiDi and could not connect fails in the <see cref="WebDriver"/> constructor instead.</exception> | |
| /// <seealso cref="AccessibilityNode.ToText()"/> | |
| public virtual Task<AccessibilityNode> GetAccessibilitySnapshotAsync(bool interestingOnly = true, CancellationToken cancellationToken = default) | |
| { | |
| return this.Accessibility.SnapshotAsync(null, interestingOnly, cancellationToken); | |
| } | |
| /// <summary> | |
| /// The snapshot runs in a BiDi sandbox realm; a session started without a WebSocket URL cannot | |
| /// take one, and says so before anything is sent. The snapshotter is stateless, so one instance, | |
| /// created on first use, serves the driver for its life. | |
| /// </summary> | |
| internal AccessibilitySnapshotter Accessibility => | |
| (this.accessibilitySnapshotter ?? throw new UnsupportedOperationException("GetAccessibilitySnapshotAsync() requires a WebDriver BiDi session; enable it with options.UseWebSocketUrl = true before starting the driver")).Value; | |
| /// <summary> | |
| /// Gets the driver's BiDi connection, opened as the session started when it carries a WebSocket | |
| /// URL and shared by every component that works over BiDi; it is closed with the driver. | |
| /// </summary> | |
| /// <exception cref="UnsupportedOperationException">If the session was started without a WebSocket URL.</exception> | |
| internal IBiDi BiDi => this.bidi ?? throw new UnsupportedOperationException("This session has no WebDriver BiDi connection; enable it with options.UseWebSocketUrl = true before starting the driver"); | |
| /// <summary> | |
| /// A session started with a WebSocket URL connects to it here, once, so nothing is opened lazily | |
| /// and no caller has to wait on another's connection attempt. A connection that cannot be made | |
| /// fails the constructor, which then quits the session it started. The constructor bridges to | |
| /// this on the thread pool, as <see cref="Execute"/> does, so a caller with a synchronization | |
| /// context does not deadlock on the connection. | |
| /// </summary> | |
| private async Task ConnectBiDiAsync() | |
| { | |
| if (this.Capabilities.GetCapability(CapabilityType.WebSocketUrl) is null) | |
| { | |
| return; | |
| } | |
| IBiDi connection = await this.AsBiDiAsync().ConfigureAwait(false); | |
| this.bidi = connection; | |
| this.accessibilitySnapshotter = new Lazy<AccessibilitySnapshotter>(() => new AccessibilitySnapshotter(connection, () => this.CurrentWindowHandle, this.CreateElementFromReference)); | |
| } | |
| /// <summary> | |
| /// Gets or sets the factory object used to create instances of <see cref="WebElement"/> | |
| /// or its subclasses. | |
| /// </summary> | |
| /// <exception cref="ArgumentNullException">If value is set to <see langword="null"/>.</exception> | |
| protected WebElementFactory ElementFactory | |
| { | |
| get => this.elementFactory; | |
| set => this.elementFactory = value ?? throw new ArgumentNullException(nameof(value)); | |
| } | |
| /// <summary> | |
| /// Closes the Browser | |
| /// </summary> | |
| public void Close() | |
| { | |
| this.Execute(DriverCommand.Close, null); | |
| } | |
| /// <summary> | |
| /// Dispose the WebDriver Instance | |
| /// </summary> | |
| public void Dispose() | |
| { | |
| this.Dispose(true); | |
| GC.SuppressFinalize(this); | |
| } | |
| /// <summary> | |
| /// Asynchronously disposes the WebDriver Instance | |
| /// </summary> | |
| /// <returns>A task representing the asynchronous dispose operation.</returns> | |
| public async ValueTask DisposeAsync() | |
| { | |
| await this.DisposeAsyncCore().ConfigureAwait(false); | |
| this.Dispose(false); | |
| GC.SuppressFinalize(this); | |
| } | |
| /// <summary> | |
| /// Executes JavaScript "asynchronously" in the context of the currently selected frame or window, | |
| /// executing the callback function specified as the last argument in the list of arguments. | |
| /// </summary> | |
| /// <param name="script">The JavaScript code to execute.</param> | |
| /// <param name="args">The arguments to the script.</param> | |
| /// <returns>The value returned by the script.</returns> | |
| public object? ExecuteAsyncScript([StringSyntax(StringSyntaxConstants.JavaScript)] string script, params object?[]? args) | |
| { | |
| return this.ExecuteScriptCommand(script, DriverCommand.ExecuteAsyncScript, args); | |
| } | |
| /// <summary> | |
| /// Executes JavaScript in the context of the currently selected frame or window | |
| /// </summary> | |
| /// <param name="script">The JavaScript code to execute.</param> | |
| /// <param name="args">The arguments to the script.</param> | |
| /// <returns>The value returned by the script.</returns> | |
| public object? ExecuteScript([StringSyntax(StringSyntaxConstants.JavaScript)] string script, params object?[]? args) | |
| { | |
| return this.ExecuteScriptCommand(script, DriverCommand.ExecuteScript, args); | |
| } | |
| /// <summary> | |
| /// Executes JavaScript in the context of the currently selected frame or window | |
| /// </summary> | |
| /// <param name="script">A <see cref="PinnedScript"/> object containing the JavaScript code to execute.</param> | |
| /// <param name="args">The arguments to the script.</param> | |
| /// <returns>The value returned by the script.</returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="script" /> is <see langword="null"/>.</exception> | |
| public object? ExecuteScript(PinnedScript script, params object?[]? args) | |
| { | |
| ArgumentNullException.ThrowIfNull(script); | |
| return this.ExecuteScript(script.MakeExecutionScript(), args); | |
| } | |
| /// <summary> | |
| /// Finds the first element in the page that matches the <see cref="By"/> object | |
| /// </summary> | |
| /// <param name="by">By mechanism to find the object</param> | |
| /// <returns>IWebElement object so that you can interact with that object</returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="by" /> is <see langword="null"/>.</exception> | |
| /// <example> | |
| /// <code> | |
| /// IWebDriver driver = new InternetExplorerDriver(); | |
| /// IWebElement elem = driver.FindElement(By.Name("q")); | |
| /// </code> | |
| /// </example> | |
| public IWebElement FindElement(By by) | |
| { | |
| if (by == null) | |
| { | |
| throw new ArgumentNullException(nameof(@by), "by cannot be null"); | |
| } | |
| return by.FindElement(this); | |
| } | |
| /// <summary> | |
| /// Finds an element matching the given mechanism and value. | |
| /// </summary> | |
| /// <param name="mechanism">The mechanism by which to find the element.</param> | |
| /// <param name="value">The value to use to search for the element.</param> | |
| /// <returns>The first <see cref="IWebElement"/> matching the given criteria.</returns> | |
| public virtual IWebElement FindElement(string mechanism, string value) | |
| { | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("using", mechanism); | |
| parameters.Add("value", value); | |
| Response commandResponse = this.Execute(DriverCommand.FindElement, parameters); | |
| return this.GetElementFromResponse(commandResponse)!; | |
| } | |
| /// <summary> | |
| /// Finds the elements on the page by using the <see cref="By"/> object and returns a ReadOnlyCollection of the Elements on the page | |
| /// </summary> | |
| /// <param name="by">By mechanism to find the element</param> | |
| /// <returns>ReadOnlyCollection of IWebElement</returns> | |
| /// <example> | |
| /// <code> | |
| /// IWebDriver driver = new InternetExplorerDriver(); | |
| /// ReadOnlyCollection<![CDATA[<IWebElement>]]> classList = driver.FindElements(By.ClassName("class")); | |
| /// </code> | |
| /// </example> | |
| public ReadOnlyCollection<IWebElement> FindElements(By by) | |
| { | |
| if (by == null) | |
| { | |
| throw new ArgumentNullException(nameof(@by), "by cannot be null"); | |
| } | |
| return by.FindElements(this); | |
| } | |
| /// <summary> | |
| /// Finds all elements matching the given mechanism and value. | |
| /// </summary> | |
| /// <param name="mechanism">The mechanism by which to find the elements.</param> | |
| /// <param name="value">The value to use to search for the elements.</param> | |
| /// <returns>A collection of all of the <see cref="IWebElement">IWebElements</see> matching the given criteria.</returns> | |
| public virtual ReadOnlyCollection<IWebElement> FindElements(string mechanism, string value) | |
| { | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("using", mechanism); | |
| parameters.Add("value", value); | |
| Response commandResponse = this.Execute(DriverCommand.FindElements, parameters); | |
| return this.GetElementsFromResponse(commandResponse); | |
| } | |
| /// <summary> | |
| /// Gets a <see cref="Screenshot"/> object representing the image of the page on the screen. | |
| /// </summary> | |
| /// <returns>A <see cref="Screenshot"/> object containing the image.</returns> | |
| public Screenshot GetScreenshot() | |
| { | |
| Response screenshotResponse = this.Execute(DriverCommand.Screenshot, null); | |
| screenshotResponse.EnsureValueIsNotNull(); | |
| string base64 = screenshotResponse.Value.ToString()!; | |
| return new Screenshot(base64); | |
| } | |
| /// <summary> | |
| /// Gets a <see cref="PrintDocument"/> object representing a PDF-formatted print representation of the page. | |
| /// </summary> | |
| /// <param name="printOptions">A <see cref="PrintOptions"/> object describing the options of the printed document.</param> | |
| /// <returns>The <see cref="PrintDocument"/> object containing the PDF-formatted print representation of the page.</returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="printOptions"/> is <see langword="null"/>.</exception> | |
| public PrintDocument Print(PrintOptions printOptions) | |
| { | |
| ArgumentNullException.ThrowIfNull(printOptions); | |
| Response commandResponse = this.Execute(DriverCommand.Print, printOptions.ToDictionary()); | |
| commandResponse.EnsureValueIsNotNull(); | |
| string base64 = commandResponse.Value.ToString()!; | |
| return new PrintDocument(base64); | |
| } | |
| /// <summary> | |
| /// Performs the specified list of actions with this action executor. | |
| /// </summary> | |
| /// <param name="actionSequenceList">The list of action sequences to perform.</param> | |
| public void PerformActions(IList<ActionSequence> actionSequenceList) | |
| { | |
| if (actionSequenceList == null) | |
| { | |
| throw new ArgumentNullException(nameof(actionSequenceList), "List of action sequences must not be null"); | |
| } | |
| List<object> objectList = new List<object>(); | |
| foreach (ActionSequence sequence in actionSequenceList) | |
| { | |
| objectList.Add(sequence.ToDictionary()); | |
| } | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters["actions"] = objectList; | |
| this.Execute(DriverCommand.Actions, parameters); | |
| } | |
| /// <summary> | |
| /// Resets the input state of the action executor. | |
| /// </summary> | |
| public void ResetInputState() | |
| { | |
| this.Execute(DriverCommand.CancelActions, null); | |
| } | |
| /// <summary> | |
| /// Close the Browser and Dispose of WebDriver | |
| /// </summary> | |
| public void Quit() | |
| { | |
| this.Dispose(); | |
| } | |
| /// <summary> | |
| /// Method to give you access to switch frames and windows | |
| /// </summary> | |
| /// <returns>Returns an Object that allows you to Switch Frames and Windows</returns> | |
| /// <example> | |
| /// <code> | |
| /// IWebDriver driver = new InternetExplorerDriver(); | |
| /// driver.SwitchTo().Frame("FrameName"); | |
| /// </code> | |
| /// </example> | |
| public ITargetLocator SwitchTo() | |
| { | |
| return new TargetLocator(this); | |
| } | |
| /// <summary> | |
| /// Instructs the driver to change its settings. | |
| /// </summary> | |
| /// <returns>An <see cref="IOptions"/> object allowing the user to change | |
| /// the settings of the driver.</returns> | |
| public IOptions Manage() | |
| { | |
| return new OptionsManager(this); | |
| } | |
| /// <summary> | |
| /// Instructs the driver to navigate the browser to another location. | |
| /// </summary> | |
| /// <returns>An <see cref="INavigation"/> object allowing the user to access | |
| /// the browser's history and to navigate to a given URL.</returns> | |
| public INavigation Navigate() | |
| { | |
| return new Navigator(this); | |
| } | |
| /// <summary> | |
| /// Executes a command with this driver. | |
| /// </summary> | |
| /// <param name="driverCommandToExecute">The name of the command to execute. The command name must be registered with the command executor, and must not be a command name known to this driver type.</param> | |
| /// <param name="parameters">A <see cref="Dictionary{K, V}"/> containing the names and values of the parameters of the command.</param> | |
| /// <returns>A <see cref="Response"/> containing information about the success or failure of the command and any data returned by the command.</returns> | |
| /// <exception cref="WebDriverException">The command returned an exceptional value.</exception> | |
| public object? ExecuteCustomDriverCommand(string driverCommandToExecute, Dictionary<string, object?> parameters) | |
| { | |
| if (this.registeredCommands.Contains(driverCommandToExecute)) | |
| { | |
| throw new WebDriverException(string.Format(CultureInfo.InvariantCulture, "A command named '{0}' is predefined by the driver class and cannot be executed with ExecuteCustomDriverCommand. It should be executed using a named method instead.", driverCommandToExecute)); | |
| } | |
| return this.Execute(driverCommandToExecute, parameters).Value; | |
| } | |
| /// <summary> | |
| /// Registers a set of commands to be executed with this driver instance. | |
| /// </summary> | |
| /// <param name="commands">An <see cref="IReadOnlyDictionary{String, CommandInfo}"/> where the keys are the names of the commands to register, and the values are the <see cref="CommandInfo"/> objects describing the commands.</param> | |
| public void RegisterCustomDriverCommands(IReadOnlyDictionary<string, CommandInfo> commands) | |
| { | |
| foreach (KeyValuePair<string, CommandInfo> entry in commands) | |
| { | |
| this.RegisterCustomDriverCommand(entry.Key, entry.Value); | |
| } | |
| } | |
| /// <summary> | |
| /// Registers a command to be executed with this driver instance. | |
| /// </summary> | |
| /// <param name="commandName">The unique name of the command to register.</param> | |
| /// <param name="commandInfo">The <see cref="CommandInfo"/> object describing the command.</param> | |
| /// <returns><see langword="true"/> if the command was registered; otherwise, <see langword="false"/>.</returns> | |
| public bool RegisterCustomDriverCommand(string commandName, [NotNullWhen(true)] CommandInfo? commandInfo) | |
| { | |
| return this.RegisterDriverCommand(commandName, commandInfo, false); | |
| } | |
| /// <summary> | |
| /// Registers a command to be executed with this driver instance. | |
| /// </summary> | |
| /// <param name="commandName">The unique name of the command to register.</param> | |
| /// <param name="commandInfo">The <see cref="CommandInfo"/> object describing the command.</param> | |
| /// <param name="isInternalCommand"><see langword="true"/> if the registered command is internal to the driver; otherwise <see langword="false"/>.</param> | |
| /// <returns><see langword="true"/> if the command was registered; otherwise, <see langword="false"/>.</returns> | |
| internal bool RegisterDriverCommand(string commandName, [NotNullWhen(true)] CommandInfo? commandInfo, bool isInternalCommand) | |
| { | |
| if (this.CommandExecutor.TryAddCommand(commandName, commandInfo)) | |
| { | |
| if (isInternalCommand) | |
| { | |
| this.registeredCommands.Add(commandName); | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| /// <summary> | |
| /// Creates the element a reference identifies, through the element factory, so a configured | |
| /// custom factory applies to elements that arrive outside a command response. | |
| /// </summary> | |
| /// <param name="elementId">The element's reference id.</param> | |
| /// <returns>The element the reference identifies.</returns> | |
| internal WebElement CreateElementFromReference(string elementId) | |
| { | |
| return this.elementFactory.CreateElement(new Dictionary<string, object?> { [WebElement.ElementReferencePropertyName] = elementId }); | |
| } | |
| internal IWebElement? GetElementFromResponse(Response response) | |
| { | |
| if (response.Value is Dictionary<string, object?> elementDictionary) | |
| { | |
| return this.elementFactory.CreateElement(elementDictionary); | |
| } | |
| return null; | |
| } | |
| /// <summary> | |
| /// Finds the elements that are in the response | |
| /// </summary> | |
| /// <param name="response">Response from the browser</param> | |
| /// <returns>Collection of elements</returns> | |
| internal ReadOnlyCollection<IWebElement> GetElementsFromResponse(Response response) | |
| { | |
| List<IWebElement> toReturn = new List<IWebElement>(); | |
| if (response.Value is object?[] elements) | |
| { | |
| foreach (object? elementObject in elements) | |
| { | |
| if (elementObject is Dictionary<string, object?> elementDictionary) | |
| { | |
| WebElement element = this.elementFactory.CreateElement(elementDictionary); | |
| toReturn.Add(element); | |
| } | |
| } | |
| } | |
| return toReturn.AsReadOnly(); | |
| } | |
| /// <summary> | |
| /// Executes a command with this driver. | |
| /// </summary> | |
| /// <param name="driverCommandToExecute">A <see cref="DriverCommand"/> value representing the command to execute.</param> | |
| /// <param name="parameters">A <see cref="Dictionary{K, V}"/> containing the names and values of the parameters of the command.</param> | |
| /// <returns>A <see cref="Response"/> containing information about the success or failure of the command and any data returned by the command.</returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="driverCommandToExecute"/> is <see langword="null"/>.</exception> | |
| protected internal virtual Response Execute(string driverCommandToExecute, Dictionary<string, object?>? parameters) | |
| { | |
| return Task.Run(() => this.ExecuteAsync(driverCommandToExecute, parameters)).GetAwaiter().GetResult(); | |
| } | |
| /// <summary> | |
| /// Executes a command with this driver. | |
| /// </summary> | |
| /// <param name="driverCommandToExecute">A <see cref="DriverCommand"/> value representing the command to execute.</param> | |
| /// <param name="parameters">A <see cref="Dictionary{K, V}"/> containing the names and values of the parameters of the command.</param> | |
| /// <returns>A <see cref="Response"/> containing information about the success or failure of the command and any data returned by the command.</returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="driverCommandToExecute"/> is <see langword="null"/>.</exception> | |
| protected internal virtual async Task<Response> ExecuteAsync(string driverCommandToExecute, Dictionary<string, object?>? parameters) | |
| { | |
| Command commandToExecute = new Command(SessionId, driverCommandToExecute, parameters); | |
| Response commandResponse = await this.CommandExecutor.ExecuteAsync(commandToExecute).ConfigureAwait(false); | |
| if (commandResponse.Status != WebDriverResult.Success) | |
| { | |
| UnpackAndThrowOnError(commandResponse, driverCommandToExecute); | |
| } | |
| return commandResponse; | |
| } | |
| /// <summary> | |
| /// Starts a session with the driver | |
| /// </summary> | |
| /// <param name="capabilities">Capabilities of the browser</param> | |
| [MemberNotNull(nameof(SessionId))] | |
| [MemberNotNull(nameof(Capabilities))] | |
| protected void StartSession(ICapabilities capabilities) | |
| { | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| // If the object passed into the RemoteWebDriver constructor is a | |
| // RemoteSessionSettings object, it is expected that all intermediate | |
| // and end nodes are compliant with the W3C WebDriver Specification, | |
| // and therefore will already contain all of the appropriate values | |
| // for establishing a session. | |
| if (capabilities is not RemoteSessionSettings remoteSettings) | |
| { | |
| Dictionary<string, object> matchCapabilities = this.GetCapabilitiesDictionary(capabilities); | |
| if (this.CommandExecutor is Remote.HttpCommandExecutor httpExecutor) | |
| { | |
| matchCapabilities["se:remoteUrl"] = httpExecutor.RemoteServerUri.AbsoluteUri; | |
| } | |
| List<object> firstMatchCapabilitiesList = new List<object>(); | |
| firstMatchCapabilitiesList.Add(matchCapabilities); | |
| Dictionary<string, object> specCompliantCapabilitiesDictionary = new Dictionary<string, object>(); | |
| specCompliantCapabilitiesDictionary["firstMatch"] = firstMatchCapabilitiesList; | |
| parameters.Add("capabilities", specCompliantCapabilitiesDictionary); | |
| } | |
| else | |
| { | |
| Dictionary<string, object?> remoteSettingsDictionary = remoteSettings.ToDictionary(); | |
| // Advertise se:remoteUrl on the caller's behalf, as every other binding does. It must be | |
| // nested in alwaysMatch (the Grid drops top-level metadata), built into a fresh copy so | |
| // the caller-owned RemoteSessionSettings is not mutated. Only a matched capability counts | |
| // as explicit here: a se:remoteUrl set via AddMetadataSetting stays top-level, is ignored | |
| // by the Grid, and does not suppress this injection (the executor URL stays authoritative). | |
| // Skip only when se:remoteUrl already lives in alwaysMatch/firstMatch, to preserve that | |
| // value and avoid an alwaysMatch/firstMatch overlap. If only one of several firstMatch | |
| // alternatives sets it explicitly, injection is suppressed for all of them; that | |
| // multi-alternative case is intentionally not supported. | |
| if (this.CommandExecutor is Remote.HttpCommandExecutor remoteHttpExecutor | |
| && !ContainsMatchCapability(remoteSettingsDictionary, "se:remoteUrl")) | |
| { | |
| Dictionary<string, object?> alwaysMatch = new Dictionary<string, object?>(); | |
| if (remoteSettingsDictionary.TryGetValue("alwaysMatch", out object? existingAlwaysMatch) | |
| && existingAlwaysMatch is IDictionary<string, object> existingCapabilities) | |
| { | |
| foreach (KeyValuePair<string, object> capability in existingCapabilities) | |
| { | |
| alwaysMatch[capability.Key] = capability.Value; | |
| } | |
| } | |
| alwaysMatch["se:remoteUrl"] = remoteHttpExecutor.RemoteServerUri.AbsoluteUri; | |
| remoteSettingsDictionary["alwaysMatch"] = alwaysMatch; | |
| } | |
| parameters.Add("capabilities", remoteSettingsDictionary); | |
| } | |
| Response response = this.Execute(DriverCommand.NewSession, parameters); | |
| response.EnsureValueIsNotNull(); | |
| if (response.Value is not Dictionary<string, object> rawCapabilities) | |
| { | |
| string errorMessage = string.Format(CultureInfo.InvariantCulture, "The new session command returned a value ('{0}') that is not a valid JSON object.", response.Value); | |
| throw new WebDriverException(errorMessage); | |
| } | |
| this.Capabilities = new ReturnedCapabilities(rawCapabilities); | |
| string sessionId = response.SessionId ?? throw new WebDriverException($"The remote end did not respond with ID of a session when it was required. {response.Value}"); | |
| this.SessionId = new SessionId(sessionId); | |
| } | |
| private static bool ContainsMatchCapability(Dictionary<string, object?> capabilitiesDictionary, string capabilityName) | |
| { | |
| if (capabilitiesDictionary.TryGetValue("alwaysMatch", out object? alwaysMatch) | |
| && alwaysMatch is IDictionary<string, object> alwaysMatchCapabilities | |
| && alwaysMatchCapabilities.ContainsKey(capabilityName)) | |
| { | |
| return true; | |
| } | |
| if (capabilitiesDictionary.TryGetValue("firstMatch", out object? firstMatch) | |
| && firstMatch is IEnumerable<object> firstMatchCandidates) | |
| { | |
| foreach (object candidate in firstMatchCandidates) | |
| { | |
| if (candidate is IDictionary<string, object> firstMatchCapabilities | |
| && firstMatchCapabilities.ContainsKey(capabilityName)) | |
| { | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| /// <summary> | |
| /// Gets the capabilities as a dictionary. | |
| /// </summary> | |
| /// <param name="capabilitiesToConvert">The dictionary to return.</param> | |
| /// <returns>A Dictionary consisting of the capabilities requested.</returns> | |
| /// <remarks>This method is only transitional. Do not rely on it. It will be removed | |
| /// once browser driver capability formats stabilize.</remarks> | |
| /// <exception cref="ArgumentNullException">If <paramref name="capabilitiesToConvert"/> is <see langword="null"/>.</exception> | |
| protected virtual Dictionary<string, object> GetCapabilitiesDictionary(ICapabilities capabilitiesToConvert) | |
| { | |
| ArgumentNullException.ThrowIfNull(capabilitiesToConvert); | |
| Dictionary<string, object> capabilitiesDictionary = new Dictionary<string, object>(); | |
| foreach (KeyValuePair<string, object> entry in ((IHasCapabilitiesDictionary)capabilitiesToConvert).CapabilitiesDictionary) | |
| { | |
| if (CapabilityType.IsSpecCompliantCapabilityName(entry.Key)) | |
| { | |
| capabilitiesDictionary.Add(entry.Key, entry.Value); | |
| } | |
| } | |
| return capabilitiesDictionary; | |
| } | |
| /// <summary> | |
| /// Registers a command to be executed with this driver instance as an internally known driver command. | |
| /// </summary> | |
| /// <param name="commandName">The unique name of the command to register.</param> | |
| /// <param name="commandInfo">The <see cref="CommandInfo"/> object describing the command.</param> | |
| /// <returns><see langword="true"/> if the command was registered; otherwise, <see langword="false"/>.</returns> | |
| protected bool RegisterInternalDriverCommand(string commandName, [NotNullWhen(true)] CommandInfo? commandInfo) | |
| { | |
| return this.RegisterDriverCommand(commandName, commandInfo, true); | |
| } | |
| /// <summary> | |
| /// Stops the client from running | |
| /// </summary> | |
| /// <param name="disposing">if its in the process of disposing</param> | |
| protected virtual void Dispose(bool disposing) | |
| { | |
| if (disposing) | |
| { | |
| Task.Run(() => this.CloseBiDiAsync().AsTask()).GetAwaiter().GetResult(); | |
| if (this.SessionId is not null) | |
| { | |
| try | |
| { | |
| this.Execute(DriverCommand.Quit, null); | |
| } | |
| catch (NotImplementedException) | |
| { | |
| } | |
| catch (InvalidOperationException) | |
| { | |
| } | |
| catch (WebDriverException) | |
| { | |
| } | |
| finally | |
| { | |
| this.SessionId = null!; | |
| } | |
| } | |
| this.CommandExecutor.Dispose(); | |
| } | |
| } | |
| /// <summary> | |
| /// Asynchronously performs the core dispose logic. | |
| /// </summary> | |
| /// <returns>A task representing the asynchronous dispose operation.</returns> | |
| protected virtual async ValueTask DisposeAsyncCore() | |
| { | |
| await this.CloseBiDiAsync().ConfigureAwait(false); | |
| if (this.SessionId is not null) | |
| { | |
| try | |
| { | |
| await this.ExecuteAsync(DriverCommand.Quit, null).ConfigureAwait(false); | |
| } | |
| catch (NotImplementedException) | |
| { | |
| } | |
| catch (InvalidOperationException) | |
| { | |
| } | |
| catch (WebDriverException) | |
| { | |
| } | |
| finally | |
| { | |
| this.SessionId = null!; | |
| } | |
| } | |
| this.CommandExecutor.Dispose(); | |
| } | |
| /// <summary> | |
| /// Closes the connection the constructor opened, once, and never lets a close failure escape: the | |
| /// driver still has its own session to quit. | |
| /// </summary> | |
| private async ValueTask CloseBiDiAsync() | |
| { | |
| IBiDi? connection = this.bidi; | |
| this.bidi = null; | |
| this.accessibilitySnapshotter = null; | |
| if (connection is null) | |
| { | |
| return; | |
| } | |
| try | |
| { | |
| await connection.DisposeAsync().ConfigureAwait(false); | |
| } | |
| catch (Exception e) | |
| { | |
| _logger.Debug("closing the BiDi connection failed: " + e.Message); | |
| } | |
| } | |
| private static void UnpackAndThrowOnError(Response errorResponse, string commandToExecute) | |
| { | |
| // Check the status code of the error, and only handle if not success. | |
| if (errorResponse.Status != WebDriverResult.Success) | |
| { | |
| if (errorResponse.Value is Dictionary<string, object?> errorAsDictionary) | |
| { | |
| ErrorResponse errorResponseObject = new ErrorResponse(errorAsDictionary); | |
| string errorMessage = errorResponseObject.Message; | |
| switch (errorResponse.Status) | |
| { | |
| case WebDriverResult.NoSuchElement: | |
| throw new NoSuchElementException(errorMessage); | |
| case WebDriverResult.NoSuchFrame: | |
| throw new NoSuchFrameException(errorMessage); | |
| case WebDriverResult.UnknownCommand: | |
| throw new NotImplementedException(errorMessage); | |
| case WebDriverResult.ObsoleteElement: | |
| throw new StaleElementReferenceException(errorMessage); | |
| case WebDriverResult.ElementClickIntercepted: | |
| throw new ElementClickInterceptedException(errorMessage); | |
| case WebDriverResult.ElementNotInteractable: | |
| throw new ElementNotInteractableException(errorMessage); | |
| case WebDriverResult.InvalidElementState: | |
| throw new InvalidElementStateException(errorMessage); | |
| case WebDriverResult.Timeout: | |
| throw new WebDriverTimeoutException(errorMessage); | |
| case WebDriverResult.NoSuchWindow: | |
| throw new NoSuchWindowException(errorMessage); | |
| case WebDriverResult.InvalidCookieDomain: | |
| throw new InvalidCookieDomainException(errorMessage); | |
| case WebDriverResult.UnableToSetCookie: | |
| throw new UnableToSetCookieException(errorMessage); | |
| case WebDriverResult.AsyncScriptTimeout: | |
| throw new WebDriverTimeoutException(errorMessage); | |
| case WebDriverResult.UnexpectedAlertOpen: | |
| // TODO(JimEvans): Handle the case where the unexpected alert setting | |
| // has been set to "ignore", so there is still a valid alert to be | |
| // handled. | |
| string? alertText = null; | |
| if (errorAsDictionary.TryGetValue("alert", out object? alert)) | |
| { | |
| if (alert is Dictionary<string, object?> alertDescription | |
| && alertDescription.TryGetValue("text", out object? text)) | |
| { | |
| alertText = text?.ToString(); | |
| } | |
| } | |
| else if (errorAsDictionary.TryGetValue("data", out object? data)) | |
| { | |
| if (data is Dictionary<string, object?> alertData | |
| && alertData.TryGetValue("text", out object? dataText)) | |
| { | |
| alertText = dataText?.ToString(); | |
| } | |
| } | |
| throw new UnhandledAlertException(errorMessage, alertText ?? string.Empty); | |
| case WebDriverResult.NoAlertPresent: | |
| throw new NoAlertPresentException(errorMessage); | |
| case WebDriverResult.InvalidSelector: | |
| throw new InvalidSelectorException(errorMessage); | |
| case WebDriverResult.NoSuchDriver: | |
| throw new WebDriverException(errorMessage); | |
| case WebDriverResult.InvalidArgument: | |
| throw new WebDriverArgumentException(errorMessage); | |
| case WebDriverResult.UnexpectedJavaScriptError: | |
| throw new JavaScriptException(errorMessage); | |
| case WebDriverResult.MoveTargetOutOfBounds: | |
| throw new MoveTargetOutOfBoundsException(errorMessage); | |
| case WebDriverResult.NoSuchShadowRoot: | |
| throw new NoSuchShadowRootException(errorMessage); | |
| case WebDriverResult.DetachedShadowRoot: | |
| throw new DetachedShadowRootException(errorMessage); | |
| case WebDriverResult.InsecureCertificate: | |
| throw new InsecureCertificateException(errorMessage); | |
| case WebDriverResult.UnknownError: | |
| throw new UnknownErrorException(errorMessage); | |
| case WebDriverResult.UnknownMethod: | |
| throw new UnknownMethodException(errorMessage); | |
| case WebDriverResult.UnsupportedOperation: | |
| throw new UnsupportedOperationException(errorMessage); | |
| case WebDriverResult.NoSuchCookie: | |
| throw new NoSuchCookieException(errorMessage); | |
| default: | |
| throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "{0} ({1})", errorMessage, errorResponse.Status)); | |
| } | |
| } | |
| throw new WebDriverException($"The {commandToExecute} command returned an unexpected error. {errorResponse.Value}"); | |
| } | |
| } | |
| /// <summary> | |
| /// Executes JavaScript in the context of the currently selected frame or window using a specific command. | |
| /// </summary> | |
| /// <param name="script">The JavaScript code to execute.</param> | |
| /// <param name="commandName">The name of the command to execute.</param> | |
| /// <param name="args">The arguments to the script.</param> | |
| /// <returns>The value returned by the script.</returns> | |
| protected object? ExecuteScriptCommand([StringSyntax(StringSyntaxConstants.JavaScript)] string script, string commandName, params object?[]? args) | |
| { | |
| object?[] convertedArgs = ConvertArgumentsToJavaScriptObjects(args); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("script", script); | |
| if (convertedArgs != null && convertedArgs.Length > 0) | |
| { | |
| parameters.Add("args", convertedArgs); | |
| } | |
| else | |
| { | |
| parameters.Add("args", new object[] { }); | |
| } | |
| Response commandResponse = this.Execute(commandName, parameters); | |
| return this.ParseJavaScriptReturnValue(commandResponse.Value); | |
| } | |
| private static object? ConvertObjectToJavaScriptObject(object? arg) | |
| { | |
| IWebDriverObjectReference? argAsObjectReference = arg as IWebDriverObjectReference; | |
| if (argAsObjectReference == null && arg is IWrapsElement argAsWrapsElement) | |
| { | |
| argAsObjectReference = argAsWrapsElement.WrappedElement as IWebDriverObjectReference; | |
| } | |
| object? converted; | |
| if (arg is string || arg is float || arg is double || arg is int || arg is long || arg is bool || arg == null) | |
| { | |
| converted = arg; | |
| } | |
| else if (argAsObjectReference != null) | |
| { | |
| Dictionary<string, object> webDriverObjectReferenceDictionary = argAsObjectReference.ToDictionary(); | |
| converted = webDriverObjectReferenceDictionary; | |
| } | |
| else if (arg is IDictionary argAsDictionary) | |
| { | |
| // Note that we must check for the argument being a dictionary before | |
| // checking for IEnumerable, since dictionaries also implement IEnumerable. | |
| // Additionally, JavaScript objects have property names as strings, so all | |
| // keys will be converted to strings. | |
| Dictionary<string, object?> dictionary = new Dictionary<string, object?>(); | |
| foreach (DictionaryEntry argEntry in argAsDictionary) | |
| { | |
| dictionary.Add(argEntry.Key.ToString()!, ConvertObjectToJavaScriptObject(argEntry.Value)); | |
| } | |
| converted = dictionary; | |
| } | |
| else if (arg is IEnumerable argAsEnumerable) | |
| { | |
| List<object?> objectList = new List<object?>(); | |
| foreach (object? item in argAsEnumerable) | |
| { | |
| objectList.Add(ConvertObjectToJavaScriptObject(item)); | |
| } | |
| converted = objectList.ToArray(); | |
| } | |
| else | |
| { | |
| throw new ArgumentException("Argument is of an illegal type: " + arg.ToString(), nameof(arg)); | |
| } | |
| return converted; | |
| } | |
| /// <summary> | |
| /// Converts the arguments to JavaScript objects. | |
| /// </summary> | |
| /// <param name="args">The arguments.</param> | |
| /// <returns>The list of the arguments converted to JavaScript objects.</returns> | |
| private static object?[] ConvertArgumentsToJavaScriptObjects(object?[]? args) | |
| { | |
| if (args == null) | |
| { | |
| return new object?[] { null }; | |
| } | |
| for (int i = 0; i < args.Length; i++) | |
| { | |
| args[i] = ConvertObjectToJavaScriptObject(args[i]); | |
| } | |
| return args; | |
| } | |
| private object? ParseJavaScriptReturnValue(object? responseValue) | |
| { | |
| object? returnValue; | |
| if (responseValue is Dictionary<string, object?> resultAsDictionary) | |
| { | |
| if (this.elementFactory.ContainsElementReference(resultAsDictionary)) | |
| { | |
| returnValue = this.elementFactory.CreateElement(resultAsDictionary); | |
| } | |
| else if (ShadowRoot.TryCreate(this, resultAsDictionary, out ShadowRoot? shadowRoot)) | |
| { | |
| returnValue = shadowRoot; | |
| } | |
| else | |
| { | |
| // Recurse through the dictionary, re-parsing each value. | |
| string[] keyCopy = new string[resultAsDictionary.Keys.Count]; | |
| resultAsDictionary.Keys.CopyTo(keyCopy, 0); | |
| foreach (string key in keyCopy) | |
| { | |
| resultAsDictionary[key] = this.ParseJavaScriptReturnValue(resultAsDictionary[key]); | |
| } | |
| returnValue = resultAsDictionary; | |
| } | |
| } | |
| else if (responseValue is object?[] resultAsArray) | |
| { | |
| bool allElementsAreWebElements = true; | |
| List<object?> toReturn = new List<object?>(resultAsArray.Length); | |
| foreach (object? item in resultAsArray) | |
| { | |
| object? parsedItem = this.ParseJavaScriptReturnValue(item); | |
| if (parsedItem is not IWebElement) | |
| { | |
| allElementsAreWebElements = false; | |
| } | |
| toReturn.Add(parsedItem); | |
| } | |
| if (toReturn.Count > 0 && allElementsAreWebElements) | |
| { | |
| List<IWebElement> elementList = new List<IWebElement>(resultAsArray.Length); | |
| foreach (object? listItem in toReturn) | |
| { | |
| elementList.Add((IWebElement)listItem!); | |
| } | |
| returnValue = elementList.AsReadOnly(); | |
| } | |
| else | |
| { | |
| returnValue = toReturn.AsReadOnly(); | |
| } | |
| } | |
| else | |
| { | |
| returnValue = responseValue; | |
| } | |
| return returnValue; | |
| } | |
| /// <summary> | |
| /// Creates a Virtual Authenticator. | |
| /// </summary> | |
| /// <param name="options"><see href="https://w3c.github.io/webauthn/#sctn-automation-virtual-authenticators">Virtual Authenticator Options</see>.</param> | |
| /// <returns> Authenticator id as string </returns> | |
| /// <exception cref="ArgumentNullException">If <paramref name="options"/> is <see langword="null"/>.</exception> | |
| public string AddVirtualAuthenticator(VirtualAuthenticatorOptions options) | |
| { | |
| ArgumentNullException.ThrowIfNull(options); | |
| Response commandResponse = this.Execute(DriverCommand.AddVirtualAuthenticator, options.ToDictionary()); | |
| commandResponse.EnsureValueIsNotNull(); | |
| string id = (string)commandResponse.Value; | |
| this.AuthenticatorId = id; | |
| return id; | |
| } | |
| /// <summary> | |
| /// Removes the Virtual Authenticator | |
| /// </summary> | |
| /// <param name="authenticatorId">Id as string that uniquely identifies a Virtual Authenticator.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="authenticatorId"/> is <see langword="null"/>.</exception> | |
| public void RemoveVirtualAuthenticator(string authenticatorId) | |
| { | |
| ArgumentNullException.ThrowIfNull(authenticatorId); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| this.Execute(DriverCommand.RemoveVirtualAuthenticator, parameters); | |
| this.AuthenticatorId = null; | |
| } | |
| /// <summary> | |
| /// Gets the cached virtual authenticator ID, or <see langword="null"/> if no authenticator ID is set. | |
| /// </summary> | |
| public string? AuthenticatorId { get; private set; } | |
| /// <summary> | |
| /// Add a credential to the Virtual Authenticator/ | |
| /// </summary> | |
| /// <param name="credential"> The credential to be stored in the Virtual Authenticator</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="credential"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="InvalidOperationException">If a Virtual Authenticator has not been added yet.</exception> | |
| public void AddCredential(Credential credential) | |
| { | |
| ArgumentNullException.ThrowIfNull(credential); | |
| string authenticatorId = this.AuthenticatorId ?? throw new InvalidOperationException("Virtual Authenticator needs to be added before it can perform operations"); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(credential.ToDictionary()); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| this.Execute(driverCommandToExecute: DriverCommand.AddCredential, parameters); | |
| } | |
| /// <summary> | |
| /// Retrieves all the credentials stored in the Virtual Authenticator | |
| /// </summary> | |
| /// <returns> List of credentials </returns> | |
| /// <exception cref="InvalidOperationException">If a Virtual Authenticator has not been added yet.</exception> | |
| public List<Credential> GetCredentials() | |
| { | |
| string authenticatorId = this.AuthenticatorId ?? throw new InvalidOperationException("Virtual Authenticator needs to be added before it can perform operations"); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| Response getCredentialsResponse = this.Execute(driverCommandToExecute: DriverCommand.GetCredentials, parameters); | |
| getCredentialsResponse.EnsureValueIsNotNull(); | |
| if (getCredentialsResponse.Value is not object?[] credentialsList) | |
| { | |
| throw new WebDriverException($"Get credentials call succeeded, but the response was not a list of credentials: {getCredentialsResponse.Value}"); | |
| } | |
| List<Credential> credentials = new List<Credential>(credentialsList.Length); | |
| foreach (object? dictionary in credentialsList) | |
| { | |
| Credential credential = Credential.FromDictionary((Dictionary<string, object>)dictionary!); | |
| credentials.Add(credential); | |
| } | |
| return credentials; | |
| } | |
| /// <summary> | |
| /// Removes the credential identified by the credentialId from the Virtual Authenticator. | |
| /// </summary> | |
| /// <param name="credentialId"> The id as byte array that uniquely identifies a credential </param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="credentialId"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="InvalidOperationException">If a Virtual Authenticator has not been added yet.</exception> | |
| public void RemoveCredential(byte[] credentialId) | |
| { | |
| RemoveCredential(Base64UrlEncoder.Encode(credentialId)); | |
| } | |
| /// <summary> | |
| /// Removes the credential identified by the credentialId from the Virtual Authenticator. | |
| /// </summary> | |
| /// <param name="credentialId"> The id as string that uniquely identifies a credential </param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="credentialId"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="InvalidOperationException">If a Virtual Authenticator has not been added yet.</exception> | |
| public void RemoveCredential(string credentialId) | |
| { | |
| ArgumentNullException.ThrowIfNull(credentialId); | |
| string authenticatorId = this.AuthenticatorId ?? throw new InvalidOperationException("Virtual Authenticator needs to be added before it can perform operations"); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| parameters.Add("credentialId", credentialId); | |
| this.Execute(driverCommandToExecute: DriverCommand.RemoveCredential, parameters); | |
| } | |
| /// <summary> | |
| /// Removes all the credentials stored in the Virtual Authenticator. | |
| /// </summary> | |
| /// <exception cref="InvalidOperationException">If a Virtual Authenticator has not been added yet.</exception> | |
| public void RemoveAllCredentials() | |
| { | |
| string authenticatorId = this.AuthenticatorId ?? throw new InvalidOperationException("Virtual Authenticator needs to be added before it can perform operations"); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| this.Execute(driverCommandToExecute: DriverCommand.RemoveAllCredentials, parameters); | |
| } | |
| /// <summary> | |
| /// Sets the isUserVerified property for the Virtual Authenticator. | |
| /// </summary> | |
| /// <param name="verified">The boolean value representing value to be set </param> | |
| public void SetUserVerified(bool verified) | |
| { | |
| string authenticatorId = this.AuthenticatorId ?? throw new InvalidOperationException("Virtual Authenticator needs to be added before it can perform operations"); | |
| Dictionary<string, object?> parameters = new Dictionary<string, object?>(); | |
| parameters.Add("authenticatorId", authenticatorId); | |
| parameters.Add("isUserVerified", verified); | |
| this.Execute(driverCommandToExecute: DriverCommand.SetUserVerified, parameters); | |
| } | |
| } |