java - tutorial - Al usar @Parameterized de JUnit, puedo hacer que algunas pruebas se ejecuten solo una vez

pruebas unitarias pdf

Question

Esta pregunta ya tiene una respuesta aquí:

• Excluyendo una prueba no param en respuestas de clase 8 de pruebas parametrizadas

Utilizo @Parameterized en muchos casos para ejecutar pruebas en varias permutaciones. Esto funciona muy bien y mantiene el código de prueba simple y limpio.

Sin embargo, a veces me gustaría que algunos de los métodos de prueba se ejecuten solo una vez, ya que no utilizan los parámetros. ¿Hay alguna forma con JUnit de marcar el método de prueba como "singleton" o "run-once"?

Nota: Esto no se refiere a la ejecución de pruebas individuales en Eclipse, sé cómo hacerlo :)

Answer 1

Antes de conocer el enfoque "@RunWith (Enclosed.class)", utilicé la siguiente solución (similar), con clases internas que extendían la clase externa. Sigo usando esta estructura porque me gusta que las pruebas estén en el mismo lugar y comparto algunas propiedades y métodos, y las cosas me parecen más claras. Luego, utilizando Eclipse, en mi configuración de ejecución, elijo esa opción "Ejecutar todas las pruebas en el proyecto, paquete o carpeta de origen seleccionado" y todas estas pruebas se realizarán con solo un clic.

public class TestBooksDAO {

    private static BooksDAO dao;

    @Parameter(0)
    public String title;
    @Parameter(1)
    public String author;

    @Before
    public void init() {
        dao = BooksDAO.getInstancia();
    }

    /** Tests that run only once. */
    public static class SingleTests extends TestBooksDAO {

        @Test(timeout=10000)
        public void testGetAll() {
            List<Book> books = dao.getBooks();
            assertNotNull(books);
            assertTrue(books.size()>0);
        }

        @Test(timeout=10000)
        public void testGetNone() {
            List<Book> books = dao.getBooks(null);
            assertNull(books);
        }
    }

    /** Tests that run for each set of parameters. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests1 extends TestBooksDAO {

        @Parameters(name = "{index}: author=/"{2}/"; title=/"{0}/";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"title1", ""}, 
                {"title2", ""}, 
                {"title3", ""}, 
                {"title4", "author1"}, 
                {"title5", "author2"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetOneBook() {
            Book book = dao.getBook(author, title);
            assertNotNull(book);
        }
    }

    /** Other parameters for different tests. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests2 extends TestBooksDAO {

        @Parameters(name = "{index}: author=/"{2}/";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"", "author1"}, 
                {"", "author2"}, 
                {"", "author3"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetBookList() {
            List<Book> books = dao.getBookByAuthor(author);
            assertNotNull(books);
            assertTrue(books.size()>0);
        }
    }
}

Answer 2

Podrías estructurar tu prueba con el corredor cerrado .

@RunWith(Enclosed.class)
public class TestClass {

    @RunWith(Parameterized.class)
    public static class TheParameterizedPart {

        @Parameters
        public static Object[][] data() {
            ...
        }

        @Test
        public void someTest() {
            ...
        }

        @Test
        public void anotherTest() {
            ...
        }
    }

    public static class NotParameterizedPart {
        @Test
        public void someTest() {
            ...
        }
    }
}

Answer 3

Puede asociar cualquier número de clases de prueba para que se ejecuten juntas utilizando una suite. De esta manera, se ejecutan todas las pruebas cuando prueba su clase y puede mezclar diferentes corredores de prueba.

1. Cree un conjunto de pruebas asociado con la clase que está probando
2. Agregar una referencia a la clase de prueba parametrizada

3. Agregue las otras clases que contienen pruebas no parametrizadas.

   import org.junit.runners.Suite;
   import org.junit.runner.RunWith;
   
   @RunWith(Suite.class)
   @Suite.SuiteClasses({ParameterizedTestClass.class, UnitTests.class, MoreUnitTests.class})
   public class SutTestSuite{
        //Empty...
   }

Answer 4

hay una serie de complementos de Junit que le brindan algunas funciones más / poder con respecto a las pruebas parametrizadas. Compruebe zohhak, junit-parames y junit-dataprovider. Te permiten mezclar pruebas junit parametrizadas y simples.