Czy Selenium Webdriver może cicho otwierać okna przeglądarki w tle?

Mam zestaw testów selenu, który przeprowadza wiele testów i przy każdym nowym teście otwiera okno przeglądarki nad wszystkimi innymi otwartymi oknami. Bardzo irytujące podczas pracy w lokalnym środowisku. Czy jest jakiś sposób, aby powiedzieć selenowi lub systemowi operacyjnemu (MAC), aby otwierał okna w tle?

Jest kilka sposobów, ale nie jest to proste „ustawienie wartości konfiguracyjnej”. Jeśli nie zainwestujesz w przeglądarkę bezgłową, która nie spełnia wymagań wszystkich, jest to trochę hack:

Jak ukryć okno przeglądarki Firefox (Selenium WebDriver)?

i

Czy można ukryć przeglądarkę w Selenium RC?

Możesz „rzekomo” przekazać niektóre parametry do Chrome, w szczególności: --no-startup-window

Zwróć uwagę, że w przypadku niektórych przeglądarek, zwłaszcza IE, nie będziesz mieć fokusu na testach.

Możesz także trochę zhakować za pomocą AutoIT, aby ukryć okno po jego otwarciu.

Jeśli używasz sterownika sieciowego Selenium z Pythonem, możesz użyć PyVirtualDisplay, opakowania Pythona dla Xvfb i Xephyr.

PyVirtualDisplay wymaga Xvfb jako zależności. W systemie Ubuntu najpierw zainstaluj Xvfb:

sudo apt-get install xvfb

następnie zainstaluj PyVirtualDisplay z Pypi:

pip install pyvirtualdisplay

Przykładowy skrypt Selenium w Pythonie w trybie headless z PyVirtualDisplay:

    #!/usr/bin/env python

    from pyvirtualdisplay import Display
    from selenium import webdriver

    display = Display(visible=0, size=(800, 600))
    display.start()

    # now Firefox will run in a virtual display. 
    # you will not see the browser.
    browser = webdriver.Firefox()
    browser.get('http://www.google.com')
    print browser.title
    browser.quit()

    display.stop()

EDYTUJ Wstępną odpowiedź opublikowano w 2014 roku, a teraz jesteśmy u progu 2018 roku, podobnie jak wszystkie inne przeglądarki również się rozwinęły. Chrome ma teraz całkowicie bezgłową wersję, która eliminuje potrzebę korzystania z bibliotek innych firm, aby ukryć okno interfejsu użytkownika. Przykładowy kod jest następujący:

    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options

    CHROME_PATH = '/usr/bin/google-chrome'
    CHROMEDRIVER_PATH = '/usr/bin/chromedriver'
    WINDOW_SIZE = "1920,1080"

    chrome_options = Options()  
    chrome_options.add_argument("--headless")  
    chrome_options.add_argument("--window-size=%s" % WINDOW_SIZE)
    chrome_options.binary_location = CHROME_PATH

    driver = webdriver.Chrome(executable_path=CHROMEDRIVER_PATH,
                              chrome_options=chrome_options
                             )  
    driver.get("https://www.google.com")
    driver.get_screenshot_as_file("capture.png")
    driver.close()

Chrome 57 ma opcję przekazania flagi --headless, która sprawia, że ​​okno jest niewidoczne.

Ta flaga różni się od --no-startup-window, ponieważ ostatnia opcja nie uruchamia okna. Służy do hostowania aplikacji działających w tle, jak mówi ta strona .

Kod Java przekazujący flagę do Selenium webdriver (ChromeDriver):

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");
ChromeDriver chromeDriver = new ChromeDriver(options);

Aby uruchomić bez przeglądarki, możesz uruchomić ją w trybie bezgłowym .

Pokażę wam jeden przykład w Pythonie, który teraz pracuje dla mnie

from selenium import webdriver


options = webdriver.ChromeOptions()
options.add_argument("headless")
self.driver = webdriver.Chrome(executable_path='/Users/${userName}/Drivers/chromedriver', chrome_options=options)

Dodam też trochę więcej informacji na ten temat na oficjalnej stronie Google https://developers.google.com/web/updates/2017/04/headless-chrome

Od Chrome 57 masz bezgłowy argument:

var options = new ChromeOptions();
options.AddArguments("headless");
using (IWebDriver driver = new ChromeDriver(options))
{
    // the rest of your test
}

Tryb bezgłowy przeglądarki Chrome działa o 30,97% lepiej niż wersja z interfejsem użytkownika. Drugi sterownik bezgłowy PhantomJS zapewnia o 34,92% lepszą wydajność niż tryb bezgłowy Chrome.

PhantomJSDriver

using (IWebDriver driver = new PhantomJSDriver())
{
     // the rest of your test
}

Tryb bezgłowy przeglądarki Mozilla Firefox działa o 3,68% lepiej niż wersja z interfejsem użytkownika. To rozczarowanie, ponieważ tryb bezgłowy Chrome osiąga> 30% lepszy czas niż tryb UI. Drugi sterownik bezgłowy PhantomJS zapewnia o 34,92% lepszą wydajność niż tryb bezgłowy Chrome. Zaskakujące dla mnie przeglądarka Edge pokonuje je wszystkie.

var options = new FirefoxOptions();
options.AddArguments("--headless");
{
    // the rest of your test
}

Jest to dostępne w przeglądarce Firefox 57+

Tryb bezgłowy przeglądarki Mozilla Firefox działa o 3,68% lepiej niż wersja z interfejsem użytkownika. To rozczarowanie, ponieważ tryb bezgłowy Chrome osiąga> 30% lepszy czas niż tryb UI. Drugi sterownik bezgłowy PhantomJS zapewnia o 34,92% lepszą wydajność niż tryb bezgłowy Chrome. Zaskakujące dla mnie przeglądarka Edge pokonuje je wszystkie.

Uwaga: PhantomJS nie jest już konserwowany!

Sugeruję użycie Phantom Js, aby uzyskać więcej informacji, odwiedź oficjalną stronę Phantom

O ile wiem, PhantomJS działa tylko z przeglądarką Firefox ..

po pobraniu PhantomJs.exe należy zaimportować do swojego projektu jak widać na poniższym obrazku Phantomjs jest wewnątrz wspólnej >> Biblioteka >> phantomjs.exe

Teraz wszystko, co musisz zrobić w kodzie Selenium, to zmienić linię

browser = webdriver.Firefox()

Na coś takiego

import os
path2phantom = os.getcwd() + "\common\Library\phantomjs.exe"
browser = webdriver.PhantomJS(path2phantom)

Droga do phantomjs może być inna ... zmienić, jak chcesz :)

To wszystko, na mnie zadziałało. i na pewno będzie dla ciebie pracował, Pozdrawiam

W systemie Windows możesz użyć win32gui:

import win32gui
import win32con
import subprocess

class HideFox:
    def __init__(self, exe='firefox.exe'):
        self.exe = exe
        self.get_hwnd()


    def get_hwnd(self):
      win_name = get_win_name(self.exe)
      self.hwnd = win32gui.FindWindow(0,win_name)


    def hide(self):
        win32gui.ShowWindow(self.hwnd, win32con.SW_MINIMIZE)
        win32gui.ShowWindow(self.hwnd, win32con.SW_HIDE)

    def show(self):
        win32gui.ShowWindow(self.hwnd, win32con.SW_SHOW)
        win32gui.ShowWindow(self.hwnd, win32con.SW_MAXIMIZE)

def get_win_name(exe):
    '''simple function that gets the window name of the process with the given name'''
    info = subprocess.STARTUPINFO()
    info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    raw=subprocess.check_output('tasklist /v /fo csv', startupinfo=info).split('\n')[1:-1]
    for proc in raw:
        try:
            proc=eval('['+proc+']')
            if proc[0]==exe:
                return proc[8]             
        except:
            pass
    raise ValueError('Could not find a process with name '+exe)

Przykład:

hider=HideFox('firefox.exe')  #can be anything, eq: phantomjs.exe, notepad.exe ...
#To hide the window
hider.hide()
#To show again
hider.show()

Jest jednak jeden problem z tym rozwiązaniem - użycie metody send_keys powoduje wyświetlenie okna. Możesz sobie z tym poradzić używając javascript, który nie wyświetla okna:

def send_keys_without_opening_window(id_of_the_element, keys)
    YourWebdriver.execute_script("document.getElementById('" +id_of_the_element+"').value = '"+keys+"';")

Użyłem tego kodu dla przeglądarki Firefox w systemie Windows i otrzymałem odpowiedź: (odniesienie tutaj )

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

Options = Options()
Options.headless = True

Driver = webdriver.Firefox(options=Options, executable_path='geckodriver.exe')
Driver.get(...)
...

Ale nie testuję tego dla innych przeglądarek.

Może być w opcjach. Oto identyczny kod java.

        ChromeOptions chromeOptions = new ChromeOptions();
        chromeOptions.setHeadless(true);
        WebDriver driver = new ChromeDriver(chromeOptions);

Jest to proste rozwiązanie NodeJS, które działa w nowej wersji 4.x (może także 3.x) Selenium.

Chrom:

const { Builder } = require('selenium-webdriver')
const chrome = require('selenium-webdriver/chrome');

let driver = await new Builder().forBrowser('chrome').setChromeOptions(new chrome.Options().headless()).build()

await driver.get('https://example.com')

Firefox:

const { Builder } = require('selenium-webdriver')
const firefox = require('selenium-webdriver/firefox');

let driver = await new Builder().forBrowser('firefox').setFirefoxOptions(new firefox.Options().headless()).build()

await driver.get('https://example.com')

Całość działa po prostu w tle. Dokładnie to, czego chcemy.

Jeśli używasz sterownika Chrome, możesz użyć tego bardzo prostego kodu: (u mnie zadziałało)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument("--headless")
driver = webdriver.Chrome('chromedriver2_win32/chromedriver.exe', options=chrome_options)
driver.get('https://www.anywebsite.com')

Na * nix możesz także uruchomić bezgłowy serwer X, taki jak Xvfb i wskazać mu zmienną DISPLAY:

Fałszywy serwer X do testów?

Oto rozwiązanie .net, które zadziałało dla mnie:

Pobierz PhantomJs tutaj http://phantomjs.org/download.html

Skopiuj plik .exe z folderu bin w pobranym pliku i wklej go do folderu bin debug / release projektu programu Visual Studio.

Dodaj to za pomocą

using OpenQA.Selenium.PhantomJS;

W swoim kodzie otwórz sterownik w ten sposób:

PhantomJSDriver driver = new PhantomJSDriver();
using (driver)
{
   driver.Navigate().GoToUrl("http://testing-ground.scraping.pro/login");
   //your code here 
}

Jeśli używasz Ubuntu (Gnome), jednym prostym obejściem jest instalacja rozszerzenia Gnome auto-move-window: https://extensions.gnome.org/extension/16/auto-move-windows/

Następnie ustaw przeglądarkę (np. Chrome) na inny obszar roboczy (np. Workspace 2). Przeglądarka będzie po cichu działać w innym obszarze roboczym i nie będzie Ci już przeszkadzać. Nadal możesz bez przerwy korzystać z Chrome w swoim obszarze roboczym.

cześć, miałem ten sam problem z moim chromedriver'em używającym Pythona i options.add_argument ("headless") nie działał dla mnie, ale potem zdałem sobie sprawę, jak to naprawić, więc umieszczam go w kodzie poniżej

opt=webdriver.ChromeOptions()
opt.arguments.append("headless")

Mam nadzieję, że to zadziała dla ciebie.

Jednym ze sposobów osiągnięcia tego jest uruchomienie przeglądarki w trybie bezgłowym. Kolejną zaletą jest to, że testy są wykonywane szybciej.

Proszę znaleźć kod poniżej, aby ustawić tryb bezgłowy w przeglądarce Chrome.

package chrome;
   public class HeadlessTesting {
        public static void main(String[] args) throws IOException{
            System.setProperty("webdriver.chrome.driver",
                    "ChromeDriverPath");
            ChromeOptions options = new ChromeOptions();
            options.addArguments("headless");
            options.addArguments("window-size=1200x600");
            WebDriver driver = new ChromeDriver(options);
            driver.get("https://contentstack.built.io");
            driver.get("https://www.google.co.in/");
            System.out.println("title is: " + driver.getTitle());
            File scrFile = ((TakesScreenshot) driver)
                    .getScreenshotAs(OutputType.FILE);
            FileUtils.copyFile(scrFile, new File("pathTOSaveFile"));
            driver.quit();
        }
    }