Running in Docker and Grid

import os
import sys

import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.file_detector import LocalFileDetector
from selenium.webdriver.support.wait import WebDriverWait


@pytest.mark.skipif(sys.platform == "win32", reason="Gets stuck on Windows, passes locally")
def test_start_remote(grid_url):
    options = get_default_chrome_options()
    driver = webdriver.Remote(command_executor=grid_url, options=options)

    assert "localhost" in driver.command_executor._client_config.remote_server_addr
    driver.quit()


@pytest.mark.skipif(sys.platform == "win32", reason="Gets stuck on Windows, passes locally")
def test_uploads(server):
    options = get_default_chrome_options()
    driver = webdriver.Remote(command_executor=server, options=options)

    driver.get("https://the-internet.herokuapp.com/upload")
    upload_file = os.path.abspath(
        os.path.join(os.path.dirname(__file__), "..", "selenium-snapshot.png"))

    driver.file_detector = LocalFileDetector()
    file_input = driver.find_element(By.CSS_SELECTOR, "input[type='file']")
    file_input.send_keys(upload_file)
    driver.find_element(By.ID, "file-submit").click()

    file_name_element = driver.find_element(By.ID, "uploaded-files")
    file_name = file_name_element.text

    assert file_name == "selenium-snapshot.png"


@pytest.mark.skipif(sys.platform == "win32", reason="Gets stuck on Windows, passes locally")
def test_downloads(server, temp_dir):
    options = get_default_chrome_options()
    options.enable_downloads = True
    driver = webdriver.Remote(command_executor=server, options=options)

    file_names = ["file_1.txt", "file_2.jpg"]
    driver.get('https://www.selenium.dev/selenium/web/downloads/download.html')
    driver.find_element(By.ID, "file-1").click()
    driver.find_element(By.ID, "file-2").click()
    WebDriverWait(driver, 3).until(lambda d: "file_2.jpg" in d.get_downloadable_files())

    files = driver.get_downloadable_files()

    assert sorted(files) == sorted(file_names)
    downloadable_file = file_names[0]
    target_directory = temp_dir

    driver.download_file(downloadable_file, target_directory)

    target_file = os.path.join(target_directory, downloadable_file)
    with open(target_file, "r") as file:
        assert "Hello, World!" in file.read()

    driver.delete_downloadable_files()

    assert not driver.get_downloadable_files()

def get_default_chrome_options():
    options = webdriver.ChromeOptions()
    options.add_argument("--no-sandbox")
    return options

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.IdentityModel.Tokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.Remote;
using OpenQA.Selenium.Support.UI;

namespace SeleniumDocs.Drivers
{
    [TestClass]
    public class RemoteWebDriverTest : BaseTest
    {
        [TestInitialize]
        public async Task Setup()
        {
            await StartServer();
        }

        [TestMethod]
        public void RunRemote()
        {
            var options = new ChromeOptions();
            driver = new RemoteWebDriver(GridUrl, options);

            Assert.IsInstanceOfType(driver, typeof(IHasDownloads));
        }

        [TestMethod]
        public void Uploads()
        {
            var options = new ChromeOptions();
            driver = new RemoteWebDriver(GridUrl, options);

            driver.Url = "https://the-internet.herokuapp.com/upload";

            string baseDirectory = AppContext.BaseDirectory;
            string relativePath = "../../../TestSupport/selenium-snapshot.png";

            string uploadFile = Path.GetFullPath(Path.Combine(baseDirectory, relativePath));

            ((RemoteWebDriver)driver).FileDetector = new LocalFileDetector();
            IWebElement fileInput = driver.FindElement(By.CssSelector("input[type=file]"));
            fileInput.SendKeys(uploadFile);
            driver.FindElement(By.Id("file-submit")).Click();

            IWebElement fileName = driver.FindElement(By.Id("uploaded-files"));
            Assert.AreEqual("selenium-snapshot.png", fileName.Text);
        }

        [TestMethod]
        public void Downloads()
        {
            ChromeOptions options = new ChromeOptions
            {
                EnableDownloads = true
            };

            driver = new RemoteWebDriver(GridUrl, options);

            driver.Url = "https://selenium.dev/selenium/web/downloads/download.html";
            driver.FindElement(By.Id("file-1")).Click();
            driver.FindElement(By.Id("file-2")).Click();
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5));
            wait.Until(d => ((RemoteWebDriver)d).GetDownloadableFiles().Contains("file_2.jpg"));

            IReadOnlyList<string> names = ((RemoteWebDriver)driver).GetDownloadableFiles();

            Assert.IsTrue(names.Contains("file_1.txt"));
            Assert.IsTrue(names.Contains("file_2.jpg"));
            string downloadableFile = names.First(f => f == "file_1.txt");
            string targetDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            ((RemoteWebDriver)driver).DownloadFile(downloadableFile, targetDirectory);

            string fileContent = File.ReadAllText(Path.Combine(targetDirectory, downloadableFile));
            Assert.AreEqual("Hello, World!", fileContent.Trim());

            ((RemoteWebDriver)driver).DeleteDownloadableFiles();

            Assert.IsTrue(((RemoteWebDriver)driver).GetDownloadableFiles().IsNullOrEmpty());
            Directory.Delete(targetDirectory, recursive: true);
        }

        [TestMethod]
        public void CustomExecutor()
        {
            driver = new RemoteWebDriver(GridUrl, new FirefoxOptions());
            driver.Navigate().GoToUrl("https://www.selenium.dev/");

            var customCommandDriver = driver as ICustomDriverCommandExecutor;
            customCommandDriver.RegisterCustomDriverCommands(FirefoxDriver.CustomCommandDefinitions);

            var screenshotResponse = customCommandDriver
                .ExecuteCustomDriverCommand(FirefoxDriver.GetFullPageScreenshotCommand, null);

            Screenshot image = new Screenshot((string)screenshotResponse);

            string targetDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            Directory.CreateDirectory(targetDirectory);
            string targetFile = Path.GetFullPath(Path.Combine(targetDirectory, "fullPage.png"));

            using (var memoryStream = new MemoryStream(image.AsByteArray))
            using (var fileStream = new FileStream(targetFile, FileMode.Create))
            {
                memoryStream.WriteTo(fileStream);
            }

            Assert.IsTrue(File.Exists(targetFile));
            
            Directory.Delete(targetDirectory, true);
        }
    }
}

# frozen_string_literal: true

require 'spec_helper'
require 'selenium/server'

RSpec.describe 'Remote WebDriver' do
  let(:target_directory) { File.join(Dir.tmpdir, SecureRandom.uuid) }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }
  let(:server) do
    Selenium::Server.new(File.expand_path(File.join('..', '..', '..', 'selenium-server-4.52.0.jar'), __dir__),
                         background: true,
                         args: %w[--selenium-manager true --enable-managed-downloads true])
  end
  let(:grid_url) { server.webdriver_url }

  before { server.start }
  after { server.stop }

  it 'starts remotely' do
    options = Selenium::WebDriver::Options.chrome
    driver = Selenium::WebDriver.for :remote, url: grid_url, options: options

    expect { driver.session_id }.not_to raise_exception
  end

  it 'uploads' do
    options = Selenium::WebDriver::Options.chrome
    driver = Selenium::WebDriver.for :remote, url: server.webdriver_url, options: options

    driver.get('https://the-internet.herokuapp.com/upload')
    upload_file = File.expand_path('../spec_support/selenium-snapshot.png', __dir__)

    driver.file_detector = ->((filename, *)) { filename.include?('selenium') && filename }
    file_input = driver.find_element(css: 'input[type=file]')
    file_input.send_keys(upload_file)
    driver.find_element(id: 'file-submit').click

    wait.until { driver.find_element(id: 'uploaded-files') }
    expect(driver.find_element(id: 'uploaded-files').text).to eq 'selenium-snapshot.png'
  end

  it 'downloads' do
    options = Selenium::WebDriver::Options.chrome(enable_downloads: true)
    driver = Selenium::WebDriver.for :remote, url: grid_url, options: options

    file_names = %w[file_1.txt file_2.jpg]
    driver.get('https://www.selenium.dev/selenium/web/downloads/download.html')
    driver.find_element(id: 'file-1').click
    driver.find_element(id: 'file-2').click
    wait.until { driver.downloadable_files.include?('file_2.jpg') && driver.downloadable_files.include?('file_1.txt') }

    files = driver.downloadable_files

    expect(files.sort).to eq file_names.sort
    downloadable_file = 'file_1.txt'

    driver.download_file(downloadable_file, target_directory)

    file_content = File.read("#{target_directory}/#{downloadable_file}").strip
    expect(file_content).to eq('Hello, World!')

    driver.delete_downloadable_files

    expect(driver.downloadable_files).to be_empty
  end
end

const { Browser, Builder, By } = require('selenium-webdriver')
const Chrome = require('selenium-webdriver/chrome')
const remote = require('selenium-webdriver/remote')
const assert = require('node:assert')
const fs = require('node:fs')
const os = require('node:os')
const path = require('node:path')
const { startGrid, stopGrid } = require('./gridServer')

async function waitForFile(filePath, timeout) {
  const deadline = Date.now() + timeout
  while (!fs.existsSync(filePath)) {
    if (Date.now() > deadline) {
      throw new Error(`Timed out waiting for ${filePath} to be written`)
    }
    await new Promise((resolve) => setTimeout(resolve, 100))
  }
}

describe('Remote WebDriver Test', function () {
  let driver
  let gridUrl
  let gridProcess

  beforeEach(async function () {
    const grid = await startGrid()
    gridUrl = grid.url
    gridProcess = grid.process
  })

  afterEach(async function () {
    try {
      if (driver) {
        await driver.quit()
        driver = null
      }
    } finally {
      stopGrid(gridProcess)
    }
  })

  it('Basic Example', async function () {
    const options = new Chrome.Options().addArguments('--no-sandbox')
    driver = new Builder().forBrowser(Browser.CHROME).setChromeOptions(options).usingServer(gridUrl).build()
  })

  it('Uploads', async function () {
    const options = new Chrome.Options().addArguments('--no-sandbox')
    driver = new Builder().forBrowser(Browser.CHROME).setChromeOptions(options).usingServer(gridUrl).build()
    await driver.get('https://the-internet.herokuapp.com/upload')
    const uploadFile = path.resolve('./test/resources/selenium-snapshot.png')

    await driver.setFileDetector(new remote.FileDetector())
    await driver.findElement(By.css('input[type=file]')).sendKeys(uploadFile)
    await driver.findElement(By.id('file-submit')).click()

    const fileName = await driver.findElement(By.id('uploaded-files')).getText()
    assert.strictEqual(fileName, 'selenium-snapshot.png')
  })

  it('Downloads', async function () {
    const options = new Chrome.Options().addArguments('--no-sandbox').enableDownloads()
    driver = new Builder().forBrowser(Browser.CHROME).setChromeOptions(options).usingServer(gridUrl).build()

    const fileNames = ['file_1.txt', 'file_2.jpg']
    await driver.get('https://www.selenium.dev/selenium/web/downloads/download.html')
    await driver.findElement(By.id('file-1')).click()
    await driver.findElement(By.id('file-2')).click()
    await driver.wait(async (d) => {
      const downloaded = await d.getDownloadableFiles()
      return fileNames.every((name) => downloaded.includes(name))
    }, 5000)

    const files = await driver.getDownloadableFiles()
    assert.deepStrictEqual(files.sort(), fileNames.sort())

    const targetDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'downloads-'))
    const downloadableFile = files[0]
    await driver.downloadFile(downloadableFile, targetDirectory)

    const downloadedFilePath = path.join(targetDirectory, downloadableFile)
    await waitForFile(downloadedFilePath, 5000)
    const fileContent = fs.readFileSync(downloadedFilePath, 'utf8')
    assert.strictEqual(fileContent.trim(), 'Hello, World!')

    await driver.deleteDownloadableFiles()
    assert.deepStrictEqual(await driver.getDownloadableFiles(), [])
  })

  it('Browser specific functionalities', async function () {
    const options = new Chrome.Options().addArguments('--no-sandbox')
    driver = new Builder().forBrowser(Browser.CHROME).setChromeOptions(options).usingServer(gridUrl).build()

    assert.ok(driver instanceof Chrome.Driver)
  })
})