Configurando o Selenium WebDriver

Este tutorial mostra como criar um aplicativo Selenium WebDriver simples que é configurado para acessar uma página da Web carregada em um aplicativo Java desktop usando o JxBrowser.

Este tutorial é aplicável apenas ao sistema operacional Windows.

Pré-requisitos

Para realizar este tutorial, vamos precisar de:

Git.
Java 8 ou superior.
Uma licença válida do JxBrowser. Pode ser de avaliação ou comercial. Para mais informações sobre o licenciamento, consulte o guia Licenciamento.
ChromeDriver baixado para Selenium. Uma vez que o JxBrowser se baseia no motor Chromium, não podemos utilizar outro driver Web (por exemplo, Firefox WebDriver). Neste tutorial, foi utilizado o ChromeDriver 88.0.4324.96.

Obtendo o código

Para ver aplicações completas criadas neste tutorial, consulte a nossa coleção de exemplos:

    $ git clone https://github.com/TeamDev-IP/JxBrowser-Examples
$ cd JxBrowser-Examples/tutorials/selenium

Aplicação JxBrowser

Criando a Aplicação

Criar uma aplicação JxBrowser simples.

Adicionar a licença

Para avançar, coloque a chave de licença na aplicação.

Configurando o motor Chromium

Quando o Selenium inicia nosso aplicativo, ChromeDriver passa o argumento --remote-debugging-port=<port> para os argumentos da linha de comando.

Na nossa aplicação, primeiro obtemos o argumento --remote-debugging-port a partir dos argumentos da linha de comando:

    private static Optional<Integer> remoteDebuggingPortFromCommandLine(String[] args) {
    if (args.length > 0) {
        for (String arg : args) {
            if (arg.startsWith(REMOTE_DEBUGGING_PORT_ARG)) {
                String port = arg.substring(REMOTE_DEBUGGING_PORT_ARG.length());
                return Optional.of(Integer.parseInt(port));
            }
        }
    }
    return Optional.empty();
}

  

Em seguida, reencaminhe-o para o motor Chromium lançado pelo JxBrowser:

    // Criar um construtor para EngineOptions.
EngineOptions.Builder builder = EngineOptions.newBuilder(HARDWARE_ACCELERATED);

// Configure o Engine com a porta de depuração remota obtida da linha de comando args.
remoteDebuggingPortFromCommandLine(args).ifPresent(builder::remoteDebuggingPort);

Agora, podemos criar uma instância Browser e carregar uma página web que o Selenium WebDriver irá detectar e trabalhar com ela através do ChromeDriver.

    import static com.teamdev.jxbrowser.engine.RenderingMode.HARDWARE_ACCELERATED;

import com.teamdev.jxbrowser.browser.Browser;
import com.teamdev.jxbrowser.engine.Engine;
import com.teamdev.jxbrowser.engine.EngineOptions;
import com.teamdev.jxbrowser.view.swing.BrowserView;
import java.awt.BorderLayout;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Optional;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;

/**
 * Este exemplo demonstra como criar uma aplicação Swing simples com uma página Web carregada no
 * BrowserView e ligar o motor Chromium do JxBrowser ao Selenium através da porta de depuração remota
 * obtida a partir da linha de comandos.
 */
public final class TargetApp {

    private static final String REMOTE_DEBUGGING_PORT_ARG = "--remote-debugging-port=";

    public static void main(String[] args) {
        // Defina sua chave de licença do JxBrowser.
        System.setProperty("jxbrowser.license.key", "your_license_key");

        // Cria um construtor para EngineOptions.
        EngineOptions.Builder builder = EngineOptions.newBuilder(HARDWARE_ACCELERATED);

        // Configurar o Engine com a porta de depuração remota obtida a partir da linha de comando args.
        remoteDebuggingPortFromCommandLine(args).ifPresent(builder::remoteDebuggingPort);

        // Criar o motor Chromium.
        Engine engine = Engine.newInstance(builder.build());
        Browser browser = engine.newBrowser();

        SwingUtilities.invokeLater(() -> {
            // Criando o componente Swing para renderizar o conteúdo web
            // carregado na instância do Browser dado.
            BrowserView view = BrowserView.newInstance(browser);

            // Criando e exibindo o frame da aplicação Swing.
            JFrame frame = new JFrame();
            frame.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    engine.close();
                }
            });
            frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            frame.add(view, BorderLayout.CENTER);
            frame.setSize(800, 700);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);

            browser.navigation().loadUrl("https://google.com");
        });
    }

    private static Optional<Integer> remoteDebuggingPortFromCommandLine(String[] args) {
        if (args.length > 0) {
            for (String arg : args) {
                if (arg.startsWith(REMOTE_DEBUGGING_PORT_ARG)) {
                    String port = arg.substring(REMOTE_DEBUGGING_PORT_ARG.length());
                    return Optional.of(Integer.parseInt(port));
                }
            }
        }
        return Optional.empty();
    }
}

  

Consultar a aplicação completa.

Criando o arquivo executável

Para criar um arquivo executável do nosso programa, utilize o plug-in Gradle launch4j ou crie-o manualmente em qualquer caminho que lhe seja conveniente.

Aplicação Selenium

Instalando as dependências do Selenium

Crie um projeto separado e instale as dependências para executar testes Selenium com o ChromeDriver.

Configurando o Selenium WebDriver

Para dizer ao Selenium onde encontrar a aplicação, forneça um caminho absoluto/relativo para um arquivo executável da aplicação, como mostrado abaixo:

    ChromeOptions options = new ChromeOptions();

// Definir um caminho para o executável da sua aplicação JxBrowser.
options.setBinary(
        new File("tutorials/selenium/target-app/build/executable/TargetApp.exe"));

Em seguida, especifique a porta de depuração remota para comunicar com a aplicação baseada no JxBrowser:

    // Defina uma porta para comunicar.
options.addArguments("--remote-debugging-port=9222");

A porta não deve ser utilizada por outras aplicações. Neste tutorial, utilizamos a porta 9222, mas você pode utilizar qualquer outra porta disponível.

A aplicação completa a executar:

    import java.io.File;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

/**
 * Uma aplicação que configura o Selenium WebDriver (ChromeDriver) para ser executado nos binários da aplicação
 * baseada no JxBrowser e obter acesso ao conteúdo HTML carregado no JxBrowser.
 */
public final class SeleniumLauncher {

    public static void main(String[] args) {
        // Definir um caminho para o executável do ChromeDriver.
        System.setProperty("webdriver.chrome.driver",
                "tutorials/selenium/launcher/src/main/resources/chromedriver.exe");

        ChromeOptions options = new ChromeOptions();

        // Defina um caminho para o executável do aplicativo JxBrowser.
        options.setBinary(
                new File("tutorials/selenium/target-app/build/executable/TargetApp.exe"));
        // Defina uma porta para comunicação.
        options.addArguments("--remote-debugging-port=9222");

        WebDriver driver = new ChromeDriver(options);

        // Agora você pode usar o WebDriver.
        System.out.printf("URL atual: %s\n", driver.getCurrentUrl());

        driver.quit();
    }
}

  

Consultar a aplicação completa.

Executando o Selenium

Execute o Selenium e, se tudo estiver configurado corretamente, você verá uma janela Java com a página Web do Google:

Aplicação

No console, você deverá ver o seguinte resultado:

URL atual: https://www.google.com/

Isto significa que o Selenium WebDriver conseguiu executar com êxito a nossa aplicação, estabelecer uma conexão com o motor Chromium do JxBrowser e acessar a página Web carregada para imprimir o seu URL.

Ao iniciar o Selenium pela primeira vez, o próprio aplicativo baseado em JxBrowser pode ser iniciado com êxito, mas você pode ver a seguinte mensagem de erro do ChromeDriver: O processo iniciado a partir da localização do Chrome path\to\application.exe já não está em execução, pelo que o ChromeDriver está a assumir que o Chrome falhou. Isso indica que o ChromeDriver não conseguiu encontrar o aplicativo em execução. Ainda não sabemos como resolver este problema, mas se você não fechar a aplicação lançada e executar novamente o Selenium, o driver detectará os binários da aplicação em execução e iniciará com êxito.

Resumo

Neste tutorial, nós:

Criamos duas aplicações: a aplicação em que integramos o JxBrowser para apresentar uma página Web e a aplicação com o Selenium ChromeDriver que se liga à primeira aplicação e acessar a página Web carregada no JxBrowser.
Mostramos como tornar a aplicação com o JxBrowser “visível” para o Selenium.
Executar a aplicação Selenium nos binários da aplicação baseada em JxBrowser para demonstrar o seu funcionamento.

Go Top