O que é um cliente quente?

Cliente "quente" no contexto de testes é um cliente (por exemplo, uma janela de navegador, uma aplicação móvel) que foi iniciado e configurado para realizar testes, mas ainda não participou diretamente no cenário de teste. Em essência, é um ambiente de teste pronto a usar.

Diferenças em relação ao cliente "frio":

• Início e inicialização: O cliente "quente" já está em execução, carregou os recursos necessários (páginas, dados), e possivelmente passou por uma autenticação prévia. O cliente "frio" requer uma inicialização completa para cada teste ou conjunto de testes.
• Estado: O cliente "quente" mantém um certo estado entre testes (por exemplo, tokens de autorização, dados em cache), o que permite realizar os testes seguintes mais rapidamente. O cliente "frio" geralmente começa do zero.
• Tempo de execução: O uso de clientes "quentes" permite reduzir significativamente o tempo de execução dos cenários de teste, evitando repetir operações de inicialização longas.

Vantagens do uso de um cliente "quente":

• Economia de tempo: Reduz o tempo de início do navegador/aplicação e o carregamento da página/tela de início.
• Aceleração dos testes: A execução de testes que requerem autenticação é mais rápida, pois não é necessário passar pelo processo de login a cada vez.
• Eficiência: Particularmente relevante para grandes conjuntos de testes de regressão.

Desvantagens:

• Impacto potencial do estado: O estado residual do teste anterior pode afetar o resultado do teste atual (bandeiras, cookies, armazenamento local). É necessário gerir cuidadosamente o estado.
• Configuração mais complexa: Requer desenvolver lógica para manter o estado "quente" e limpá-lo após cada teste para garantir o isolamento.
• Maior consumo de recursos: Um cliente que está em execução constante pode consumir mais recursos do sistema.

Exemplo de uso em testes automatizados (Selenium WebDriver):

Em vez de criar uma nova instância do driver para cada teste:

// Abordagem "fria"
@Test
public void testFeatureA() {
    WebDriver driver = new ChromeDriver(); // Início de um novo navegador
    //... cenário de teste
    driver.quit();
}

@Test
public void testFeatureB() {
    WebDriver driver = new ChromeDriver(); // Início de um novo navegador
    //... cenário de teste
    driver.quit();
}

Utiliza-se uma única instância do driver, que é reutilizada entre os testes (lógica aproximada):

// Abordagem "quente" (usando BeforeAll/AfterAll ou anotações/hooks similares)
private static WebDriver driver;

@BeforeAll // Executa uma vez antes de todos os testes na classe
public static void setup() {
    driver = new ChromeDriver();
    driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
    driver.get("https://your-app.com/login");
    // Lógica de autenticação
}

@AfterAll // Executa uma vez após todos os testes na classe
public static void teardown() {
    if (driver != null) {
        driver.quit();
    }
}

@BeforeEach // Executa antes de cada teste
public void prepareTest() {
    // Lógica para limpar o estado, se necessário (por exemplo, limpar cookies, navegar para a página inicial)
    driver.manage().deleteAllCookies();
    driver.navigate().to("https://your-app.com/dashboard");
}

@Test
public void testFeatureA() {
    // Usa o driver já iniciado e autenticado
    // ... cenário de teste
}

@Test
public void testFeatureB() {
    // Usa o mesmo driver
    // ... cenário de teste
}

Isto evita reiniciar o navegador e fazer login para cada teste.