Tests doesn't running

Question

I have a problem.

I'm using junit and dbunit for testing my dao.

If I run tests one by one everything is fine, but if I run all tests I have two failed. I can't understand why it happens.

public class VacancyDaoImplTest {
private VacancyDao vacancyDao;

@BeforeClass
public static void createSchema() throws Exception {
    String db = "src\\test\\resources\\schema.sql";
    RunScript.execute("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
            "sa", "", db, UTF8, false);
}


@Before
public void setUp() {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    vacancyDao = new VacancyDaoImpl(connectionFactory);
}

@Test
public void whenFindById_ThenReturnRightResult() {
    Date date = new GregorianCalendar(2018, Calendar.APRIL, 1).getTime();
    Vacancy microsoftVacancy = new Vacancy(1, "www.somewhere.org", "C# developer",
            "from 3000 usd", "Microsoft", "Los Angele's, California, USA", date);

    vacancyDao.insert(microsoftVacancy);

    Vacancy result = vacancyDao.findById(1);

    assertThat(microsoftVacancy, is(result));
}

@Test
public void whenInsertNewVacancy_ThenItInserted() {
    Date jobDate = new GregorianCalendar(2018, Calendar.APRIL, 2).getTime();
    Vacancy oracleVacancy = new Vacancy(1, "www.somewhere.org", "Java developer",
            "from 3000 usd", "Oracle", "Redwood City, California, USA", jobDate);

    vacancyDao.insert(oracleVacancy);
    assertNotNull(vacancyDao.getAll());
}

@Test
public void whenGetAll_ThenGetAllVacancies() {
    List<Vacancy> vacancyList = new ArrayList<>();
    Date date = new GregorianCalendar(2018, Calendar.APRIL, 1).getTime();
    Vacancy microsoftVacancy = new Vacancy(1,"www.somewhere.org", "C# developer",
            "from 3000 usd", "Microsoft", "Los Angele's, California, USA", date);
    vacancyList.add(microsoftVacancy);

    vacancyDao.insert(microsoftVacancy);
    List<Vacancy> result = vacancyDao.getAll();

    assertArrayEquals(vacancyList.toArray(), result.toArray());
}

@Test
public void whenDeleteById_ThenItDeleted() {
    Date date = new GregorianCalendar(2018, Calendar.APRIL, 1).getTime();
    Vacancy microsoftVacancy = new Vacancy( 1,"www.somewhere.org", "C# developer",
            "from 3000 usd", "Microsoft", "Los Angele's, California, USA", date);

    vacancyDao.insert(microsoftVacancy);
    vacancyDao.deleteById(1);

    assertTrue(vacancyDao.getAll().isEmpty());
}

@Test
public void whenDeleteAll_ThenItEmpty() {
    Date date = new GregorianCalendar(2018, Calendar.APRIL, 1).getTime();
    Vacancy microsoftVacancy = new Vacancy( 1,"www.somewhere.org", "C# developer",
            "from 3000 usd", "Microsoft", "Los Angele's, California, USA", date);
    Vacancy oracleVacancy = new Vacancy(2,"www.somewhere.org", "Java developer",
            "from 3000 usd", "Oracle", "Redwood City, California, USA", date);

    vacancyDao.insert(microsoftVacancy);
    vacancyDao.insert(oracleVacancy);

    vacancyDao.deleteAll();

    assertTrue(vacancyDao.getAll().isEmpty());
}

}

stacktrace for whenFindById_ThenReturnRightResult():

java.lang.AssertionError: 
Expected: is null
 but: was <Job{id=1, url='www.somewhere.org', title='C# developer', 
salary='from 3000 usd', companyName='Microsoft', location='Los Angele's, 
California, USA', date=Sun Apr 01 00:00:00 YEKT 2018}>

stacktrace for whenDeleteById_ThenItDeleted():

java.lang.AssertionError
at org.junit.Assert.fail(Assert.java:86)
at org.junit.Assert.assertTrue(Assert.java:41)
at org.junit.Assert.assertTrue(Assert.java:52)
at 

ru.skilanov.database.VacancyDaoImplTest.whenDeleteById_ThenItDeleted(VacancyDaoImplTest.java:106)

UPDATE:

Ok, I checked and it runs in a different order and if I remove all tests that checks deleting methods it works. So how I can make right order of tests running?

My DAO:

public class VacancyDaoImpl implements VacancyDao {

private static final String FIND_BY_COMPANY_NAME = "SELECT * FROM job WHERE company_name=?";
private static final String FIND_BY_ID = "SELECT * FROM job WHERE id=?";
private static final String DELETE_ALL = "DELETE FROM job";
private static final String DELETE_BY_ID = "DELETE FROM job WHERE id=?";
private static final String GET_ALL = "SELECT * FROM job";
private static final String INSERT = "INSERT INTO job (url, title, salary, company_name, location, create_date)" +
        " VALUES (?,?,?,?,?,?)";

private ConnectionFactory connectionFactory;

public VacancyDaoImpl(ConnectionFactory connectionFactory) {
    this.connectionFactory = connectionFactory;
}

@Override
public void insert(Vacancy vacancy) {
    try (Connection connection = connectionFactory.getConnection();
        PreparedStatement ps = connection.prepareStatement(INSERT)){
        connection.setAutoCommit(false);
        ps.setString(1, vacancy.getUrl());
        ps.setString(2, vacancy.getTitle());
        ps.setString(3, vacancy.getSalary());
        ps.setString(4, vacancy.getCompanyName());
        ps.setString(5, vacancy.getLocation());
        ps.setDate(6, new Date(vacancy.getDate().getTime()));
        ps.executeUpdate();
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method insert has thrown an exception", sqle);
    }
}

@Override
public List<Vacancy> getAll() {
    List<Vacancy> jobsList = new ArrayList<>();
    try (Connection connection = connectionFactory.getConnection();
        Statement st = connection.createStatement()){
        connection.setAutoCommit(false);
        ResultSet rs = st.executeQuery(GET_ALL);
        while (rs.next()) {
            jobsList.add(new Vacancy(rs.getInt(Vacancy.ID),
                    rs.getString(Vacancy.COLUMN_URL),
                    rs.getString(Vacancy.COLUMN_TITLE),
                    rs.getString(Vacancy.COLUMN_SALARY),
                    rs.getString(Vacancy.COLUMN_COMPANY_NAME),
                    rs.getString(Vacancy.COLUMN_LOCATION),
                    rs.getTimestamp(Vacancy.COLUMN_CREATE_DATE)));
        }
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method getAll has thrown an exception", sqle);
    }
    return jobsList;
}

@Override
public List<Vacancy> findByCompanyName(String name) {
    List<Vacancy> jobsList = new ArrayList<>();
    try (Connection connection = connectionFactory.getConnection();
        PreparedStatement ps = connection.prepareStatement(FIND_BY_COMPANY_NAME)){
        connection.setAutoCommit(false);
        ps.setString(1, name);
        ResultSet rs = ps.executeQuery();

        while (rs.next()) {
            jobsList.add(new Vacancy(rs.getInt(Vacancy.ID),
                    rs.getString(Vacancy.COLUMN_URL),
                    rs.getString(Vacancy.COLUMN_TITLE),
                    rs.getString(Vacancy.COLUMN_SALARY),
                    rs.getString(Vacancy.COLUMN_COMPANY_NAME),
                    rs.getString(Vacancy.COLUMN_LOCATION),
                    rs.getTimestamp(Vacancy.COLUMN_CREATE_DATE)));
        }
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method findByCompanyName has thrown an exception", sqle);
    }
    return jobsList;
}

@Override
public Vacancy findById(int id) {
    try (Connection connection = connectionFactory.getConnection();
        PreparedStatement ps = connection.prepareStatement(FIND_BY_ID)){
        connection.setAutoCommit(false);
        ps.setInt(1, id);
        ResultSet rs = ps.executeQuery();

        while (rs.next()) {
            return new Vacancy(rs.getInt(Vacancy.ID),
                    rs.getString(Vacancy.COLUMN_URL),
                    rs.getString(Vacancy.COLUMN_TITLE),
                    rs.getString(Vacancy.COLUMN_SALARY),
                    rs.getString(Vacancy.COLUMN_COMPANY_NAME),
                    rs.getString(Vacancy.COLUMN_LOCATION),
                    rs.getTimestamp(Vacancy.COLUMN_CREATE_DATE));
        }
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method findById has thrown an exception", sqle);

    }
    return null;
}

@Override
public void deleteById(int id) {
    try (Connection connection = connectionFactory.getConnection();
        PreparedStatement ps = connection.prepareStatement(DELETE_BY_ID)){
        connection.setAutoCommit(false);
        ps.setInt(1, id);
        ps.executeUpdate();
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method deleteById has thrown an exception", sqle);
    }
}

@Override
public void deleteAll() {
    try (Connection connection = connectionFactory.getConnection();
        PreparedStatement ps = connection.prepareStatement(DELETE_ALL)){
        connection.setAutoCommit(false);
        ps.executeUpdate();
        connection.commit();
    } catch (SQLException sqle) {
        throw new DaoException("Method deleteAll has thrown an exception", sqle);
    }
}

}

Answer 1

Thank you for your answers.

SOLUTION

It happened because my id increased after each test. And when i tried to find job by id it wasn't an expected value.

So I reset counter after each test:

@After
public void tearDown() throws Exception {
    vacancyDao.deleteAll();
    try (Connection connection = new ConnectionFactory().getConnection()) {
        Statement statement = connection.createStatement();
        statement.executeUpdate("ALTER TABLE job ALTER COLUMN id RESTART WITH 1");
    }
}

Answer 2

The problem is not the order of the tests in itself but that some of them are creating records and not removing them and then you are checking if there are records, which obviously fails. The best would be for you to empty all the records before each test execution:

@Before
public void setUp() {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    vacancyDao = new VacancyDaoImpl(connectionFactory);
    vacancyDao.deleteAll();
}

Or, if the test is responsible for creating and deleting a single record then you should only assert that a single record has been removed, not all records like in this case:

@Test
public void whenDeleteById_ThenItDeleted() {
    Date date = new GregorianCalendar(2018, Calendar.APRIL, 1).getTime();
    Vacancy microsoftVacancy = new Vacancy( 1,"www.somewhere.org", "C# developer",
            "from 3000 usd", "Microsoft", "Los Angele's, California, USA", date);

    vacancyDao.insert(microsoftVacancy);
    vacancyDao.deleteById(1);

    //assertTrue(vacancyDao.getAll().isEmpty());
    assertNull(vacancyDao.get(id)); // Assuming you have a DAO method that returns null if a record is not present in the DB
}

Answer 3

I would not deal with test order, instead, set up schema per test method with different DB name.