Spring Test DBUnit: Unable to load dataset from file

Question

I'm trying to use Spring Test DBUnit for running an integration test that checks if a DAO's services are running correctly. For two similar entities, I was able to create tests that run OK, but for this particular entity, the test can't run properly.
The test will be ignored, and the only Exception I will see in the console is:

java.lang.IllegalArgumentException: Unable to load dataset from "data/offline_message.xml" using class com.github.springtestdbunit.dataset.FlatXmlDataSetLoader

Here are the relevant files. XML file:

<dataset>

    <mp_account id="1" auth_hash="ted.mosby" first_name="Ted" last_name="Mosby" credential="EMAIL" transport_session="someTransportSession"/>
    <mp_account id="2" auth_hash="lily.aldrin" first_name="Lily" last_name="Aldrin" credential="MEH" transport_session="someTransportSession"/>

    <mp_message id="1" recipient_account_id="1" sender_account_id="2"/>

</dataset>

Test class that is failing:

import com.github.springtestdbunit.annotation.DatabaseSetup;
import com.somecompany.messaging.domain.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import java.util.Date;
import java.util.List;

@DatabaseSetup("data/message.xml")
public class MessageDaoTest extends AbstractDaoTest<Message> {

    private static final Long ACCOUNT_ID = 1L;
    public static final long DATE_LONG = 1431018764154L;
    private static final Date LAST_UPDATE_TS = new Date(DATE_LONG);
    @Autowired
    MessageDao MessageDao;

    @BeforeMethod
    public void setUp() throws Exception {
        this.setDao(MessageDao);
    }

    @Test
    @Transactional
    public void testFindMessages() throws Exception {
        List<Message> Messages = this.MessageDao.findMessages(ACCOUNT_ID, LAST_UPDATE_TS);
        Assert.assertNotNull(Messages);
        Assert.assertEquals(Messages.size(), 1);
    }

}

Abstract test class, that extends from TestNG's class:

import com.github.springtestdbunit.DbUnitTestExecutionListener;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
import org.springframework.transaction.annotation.Transactional;

@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class,
        DirtiesContextTestExecutionListener.class,
        TransactionalTestExecutionListener.class,
        DbUnitTestExecutionListener.class })
@ContextConfiguration(locations = { "classpath:test-context.xml" })
public class AbstractDaoTest <T> extends AbstractTestNGSpringContextTests {

    private GenericDao<T> dao;

    @Transactional
    public T create(T t){
        return dao.create(t);
    }

    @Transactional
    public void delete(Object id){
        dao.delete(id);
    }

    @Transactional
    public T find(Object id){
        return dao.find(id);
    }

    @Transactional
    public T update(T t){
        return dao.update(t);
    }

    public void setDao(GenericDao<T> dao) {
        this.dao = dao;
    }
}

Finally, the Entity:

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;

import javax.persistence.*;

@NamedQueries({
        @NamedQuery(
                name = "findMessagesQuery",
                query = "select om from Message om where om.recipientAccount.id=:accountId " +
                        "and om.lastUpdatedTs>:time and om.lastUpdatedTs+om.expirationPeriod>:now " +
                        "order by om.lastUpdatedTs asc"
        ),
        @NamedQuery(
                name = "findExpiredMessagesQuery",
                query =  "select om from Message om where om.lastUpdatedTs+om.expirationPeriod<:now"
        )
})
@Entity
@Table(name="mp_message")
public class Message extends AbstractModel {

    @JoinColumn(name="recipient_account_id", updatable = false)
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Account recipientAccount;

    @JoinColumn(name="sender_account_id", updatable = false)
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Account senderAccount;

    @Column(name="message_body", length=2048)
    private String messageBody;

    @Column(name="expiration_period")
    private Long expirationPeriod;

    // Getters, setters, etc excluded for brevity
}

Just a sidenote: I have "obscured" the Entity name (dammned lawyers!), so there could be some small name mistakes. Please bear with me on this ;)
If you need some additional details, please let me know.
Thanks in advance

Answer 1

try to add classpath: before your path, so:

@DatabaseSetup("classpath:data/message.xml")