Como escrever autotestes de maneira eficaz - testes subcutâneos

A essência do problema

• Os testes de interface do usuário são lentos. Não há como escapar disso. Eles podem ser executados em paralelo, arquivados e executados um pouco mais rápido, mas permanecerão lentos.
• Os testes de interface do usuário são instáveis. Em parte porque são lentos. E também porque o navegador da Web e a interface do usuário não foram criados para serem controlados por um computador (essa tendência está mudando atualmente, mas não o fato de que isso é bom).
• UI- — . . ( , , , «» - , ).
• , , , UI- . . ID XPath . , «» - - . , , — - , .
• Alguém dirá que algumas funcionalidades simplesmente não podem ser testadas de outra forma. Eu direi que, se houver funcionalidade que possa ser testada apenas por testes de interface do usuário (com exceção da própria lógica da interface do usuário), isso pode ser um bom sinal de problemas de arquitetura no produto.

Solução alternativa

public class LoginFormTest {

    SelenideMainPage sut = SelenideMainPage.INSTANCE;
    private static final String APPLICATION_URL = "http://localhost:4567/index";

    @BeforeClass
    public static void setUpClass() {
        final String[] args = {};
        Main.main(args);
        Configuration.browser = "firefox";
    }

    @Before
    public void setUp() {
        open(APPLICATION_URL);
    }

    @After
    public void tearDown() {
        close();
    }

    @Test
    public void shouldBeAbleToAddNewUser() {
        sut.setUserName("MyCoolNewUser");
        sut.clickSubmit();
        Assert.assertEquals("Status: user MyCoolNewUser was created", sut.getStatus());
        Assert.assertTrue(sut.getUsers().contains("Name: MyCoolNewUser"));
    }

    @Test
    public void shouldNotBeAbleToAddEmptyUseName() {
        final int numberOfUsersBeforeTheTest = sut.getUsers().size();
        sut.clickSubmit();
        Assert.assertEquals("Status: Login cannot be empty", sut.getStatus());
        Assert.assertEquals(numberOfUsersBeforeTheTest, sut.getUsers().size());
    }
}

public class UserApplication {

    private static IUserRepository repository = new InMemoryUserRepository();
    private static UserService service = new UserService(); {
        service.setUserRepository(repository);
    }

    public Map<String, Object> getUsersList() {
        return getUsersList("N/A");
    }

    public Map<String, Object> addUser(final String username) {
        final String status = service.addUser(username);
        final Map<String, Object> model = getUsersList(status);
        return model;
    }

    private Map<String, Object> getUsersList(String status) {
        final Map<String, Object> model = new HashMap<>();
        model.put("status", status);
        model.put("users", service.getUserInfoList());
        return model;
    }
}

public class UserApplicationTest {

    private UserApplication sut;

    @Before
    public void setUp() {
       sut = new UserApplication();
    }

    @Test
    public void shouldBeAbleToAddNewUser() {
        final Map<String, Object> myCoolNewUser = sut.addUser("MyCoolNewUser");
        Assert.assertEquals("user MyCoolNewUser was created", myCoolNewUser.get("status"));
        Assert.assertTrue(((List) myCoolNewUser.get("users")).contains("Name: MyCoolNewUser"));
    }

    @Test
    public void shouldNotBeAbleToAddEmptyUseName() {
        final Map<String, Object> usersBeforeTest = sut.getUsersList();
        final int numberOfUsersBeforeTheTest = ((List) usersBeforeTest.get("users")).size();
        final Map<String, Object> myCoolNewUser = sut.addUser("");
        Assert.assertEquals("Login cannot be empty", myCoolNewUser.get("status"));
        Assert.assertEquals(numberOfUsersBeforeTheTest, ((List) myCoolNewUser.get("users")).size());
    }
}

git checkout subctests

Perdemos um pouco de cobertura, mas a velocidade dos testes aumentou 600 vezes !!!

• Adicione um teste de interface do usuário para verificar o código de cola ou
• Se não esperamos mudanças frequentes no código de cola - deixe-o sem autoteste ou
• Se tivermos algum tipo de teste "manual", há uma grande chance de que os problemas com o código de cola sejam notados pelo testador, ou
• Crie outra coisa (a mesma implantação do Canary)

Eventualmente

• Os autotestes funcionais não precisam ser gravados no nível da interface do usuário ou da API REST / SOAP. O uso de “testes subcutâneos” em muitas situações testará a mesma funcionalidade com maior velocidade e estabilidade.
• Uma das desvantagens da abordagem é uma certa perda de cobertura.
• Uma maneira de evitar a perda de cobertura é o " Modelo de testes de recursos "
• Mas mesmo com a perda de cobertura, o aumento de velocidade e estabilidade é significativo.