/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package cz.muni.fi.pa165;
import cz.muni.fi.pa165.library.backend.Book;
import cz.muni.fi.pa165.library.backend.BookDAOImpl;
import cz.muni.fi.pa165.library.api.Available;
import cz.muni.fi.pa165.library.api.State;
import cz.muni.fi.pa165.library.api.Genre;
import java.sql.DriverManager;
import java.sql.SQLNonTransientConnectionException;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import junit.framework.TestCase;
/**
*
* @author Matúลก Abaffy
*/
public class BookDAOImplTest extends TestCase {
EntityManagerFactory emf;
EntityManager em;
BookDAOImpl bookDAOImpl;
public BookDAOImplTest(String testName) {
super(testName);
}
@Override
protected void setUp() throws Exception {
super.setUp();
try {
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
DriverManager.getConnection("jdbc:derby:memory:testDB;create=true").close();
} catch (Exception ex) {
ex.printStackTrace();
fail("Exception during database startup.");
}
try {
emf = Persistence.createEntityManagerFactory("testPU");
bookDAOImpl = new BookDAOImpl();
em = emf.createEntityManager();
bookDAOImpl.setEntityManager(em);
} catch (Exception e) {
e.printStackTrace();
fail("Exception during JPA EntityManager instanciation.");
}
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
emf.close();
try {
DriverManager.getConnection("jdbc:derby:memory:testDB;drop=true").close();
} catch (SQLNonTransientConnectionException e) {
if (e.getErrorCode() != 45000) {
throw e;
}
}
}
protected Book createCustomBook1() {
return new Book("Kniha1", "Autor1", Genre.ACTION, "1999", "place1",
"pub1", "isbn1", State.NEW, Available.AVAILABLE);
}
protected Book createCustomBook2() {
return new Book("Kniha2", "Autor2", Genre.ADVENTURE, "2000", "place2",
"pub2", "isbn2", State.DAMAGED, Available.AVAILABLE);
}
private void persist(Book book) {
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
em.persist(book);
em.getTransaction().commit();
if (em != null) {
em.close();
}
}
private void createBooks() {
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
//1
em.persist(createCustomBook1());
//2
em.persist(createCustomBook1());
//3
em.persist(createCustomBook2());
//4
Book book = createCustomBook2();
book.setState(State.USED);
book.setAvailability(Available.BORROWED);
em.persist(book);
//5
em.persist(new Book("Kniha3", "Autor1", Genre.ACTION, "2000", "place3",
"pub3", "isbn3", State.NEW, Available.RESERVED));
em.getTransaction().commit();
if (em != null) {
em.close();
}
}
/**
* Test of createBook method, of class BookDAOImpl.
*/
public void testCreateBook() {
try {
bookDAOImpl.createBook(null);
fail("Method should fail on null parameter.");
} catch (IllegalArgumentException e) {
// OK
}
Book book = createCustomBook1();
book.setISBN(null);
try {
bookDAOImpl.createBook(book);
fail("Method should fail on null ISBN.");
} catch (IllegalArgumentException e) {
//OK
}
book = createCustomBook1();
book.setTitle("");
try {
bookDAOImpl.createBook(book);
fail("Method should fail on empty title.");
} catch (IllegalArgumentException e) {
//OK
}
book = createCustomBook1();
book.setId(new Long(1));
try {
bookDAOImpl.createBook(book);
fail("Method should fail on creating book with already set ID.");
} catch (IllegalArgumentException e) {
//OK
}
book = createCustomBook1();
em.getTransaction().begin();
Book book2 = bookDAOImpl.createBook(book);
em.getTransaction().commit();
assertNotNull(book2.getId());
}
/**
* Test of findAllBooks method, of class BookDAOImpl.
*/
public void testFindAllBooks() {
Book book = createCustomBook1();
persist(book);
assertEquals(1, bookDAOImpl.findAllBooks().size());
createBooks();
assertEquals(6, bookDAOImpl.findAllBooks().size());
assertTrue("Created book should be in the list of all books.", bookDAOImpl.findAllBooks().contains(book));
}
/**
* Test of findBookById method, of class BookDAOImpl.
*/
public void testFindBookById() {
try {
bookDAOImpl.findBookById(null);
fail("Method should fail on null ID.");
} catch (IllegalArgumentException e) {
//OK
}
try {
bookDAOImpl.findBookById(Long.MIN_VALUE);
fail("Method should not accept nonpositive ID.");
} catch (IllegalArgumentException e) {
//OK
}
Book book1 = createCustomBook1();
Book book2 = createCustomBook1();
book2.setAuthor("pepa");
em.getTransaction().begin();
em.persist(book1);
em.persist(book2);
em.getTransaction().commit();
Long id1 = new Long(book1.getId());
Long id2 = new Long(book2.getId());
assertEquals(book1, bookDAOImpl.findBookById(id1));
assertEquals(book2, bookDAOImpl.findBookById(id2));
book1.setAuthor("pepa");
bookDAOImpl.setEntityManager(emf.createEntityManager());
assertEquals("Autor1", bookDAOImpl.findBookById(id1).getAuthor());
}
/**
* Test of findBookByAuthor method, of class BookDAOImpl.
*/
public void testFindBookByAuthor() {
try {
bookDAOImpl.findBookByAuthor(null);
fail("Method should fail on null author.");
} catch (IllegalArgumentException e) {
//OK
}
try {
bookDAOImpl.findBookByAuthor("");
fail("Method should fail on empty author.");
} catch (IllegalArgumentException e) {
//OK
}
createBooks();
assertEquals(3, bookDAOImpl.findBookByAuthor("Autor1").size());
assertEquals(2, bookDAOImpl.findBookByAuthor("Autor2").size());
assertEquals(0, bookDAOImpl.findBookByAuthor("pepa").size());
Set<String> expectAutor1Books = new HashSet<String>();
expectAutor1Books.add("Kniha1");
expectAutor1Books.add("Kniha3");
Set<String> actualAutor1Books = new HashSet<String>();
for (Book book : bookDAOImpl.findBookByAuthor("Autor1")) {
actualAutor1Books.add(book.getTitle());
}
assertEquals(expectAutor1Books, actualAutor1Books);
}
/**
* Test of findBookByTitle method, of class BookDAOImpl.
*/
public void testFindBookByTitle() {
try {
bookDAOImpl.findBookByTitle(null);
fail("Method should fail on null title.");
} catch (IllegalArgumentException e) {
//OK
}
try {
bookDAOImpl.findBookByTitle("");
fail("Method should fail on empty title.");
} catch (IllegalArgumentException e) {
//OK
}
createBooks();
assertEquals(2, bookDAOImpl.findBookByTitle("Kniha1").size());
assertEquals(2, bookDAOImpl.findBookByTitle("Kniha2").size());
assertEquals(1, bookDAOImpl.findBookByTitle("Kniha3").size());
Set<State> kniha1States = new HashSet<State>();
Set<State> kniha2States = new HashSet<State>();
Set<State> kniha3States = new HashSet<State>();
for (Book book : bookDAOImpl.findBookByTitle("Kniha1")) {
kniha1States.add(book.getState());
}
for (Book book : bookDAOImpl.findBookByTitle("Kniha2")) {
kniha2States.add(book.getState());
}
for (Book book : bookDAOImpl.findBookByTitle("Kniha3")) {
kniha3States.add(book.getState());
}
assertEquals(2, kniha2States.size());
assertEquals(kniha1States, kniha3States);
Book book = createCustomBook1();
persist(book);
assertTrue("Created book should be in the list of books with it's title.",
bookDAOImpl.findBookByTitle("Kniha1").contains(book));
}
/**
* Test of findBookByGenre method, of class BookDAOImpl.
*/
public void testFindBookByGenre() {
try {
bookDAOImpl.findBookByGenre(null);
fail("Method should fail on null genre.");
} catch (IllegalArgumentException e) {
//OK
}
createBooks();
Book book = createCustomBook2();
persist(book);
Long id1 = new Long(book.getId());
book.setGenre(Genre.DRAMA);
bookDAOImpl.setEntityManager(emf.createEntityManager());
assertEquals(3, bookDAOImpl.findBookByGenre(Genre.ACTION).size());
assertEquals(3, bookDAOImpl.findBookByGenre(Genre.ADVENTURE).size());
assertEquals(0, bookDAOImpl.findBookByGenre(Genre.DRAMA).size());
book = createCustomBook2();
book.setGenre(Genre.DRAMA);
persist(book);
Long id2 = new Long(book.getId());
assertEquals(1, bookDAOImpl.findBookByGenre(Genre.DRAMA).size());
book = new Book();
book.setId(id1);
assertTrue("", bookDAOImpl.findBookByGenre(Genre.ADVENTURE).contains(book));
book.setId(id2);
assertTrue("", bookDAOImpl.findBookByGenre(Genre.DRAMA).contains(book));
}
/**
* Test of findBookByIsbn method, of class BookDAOImpl.
*/
public void testFindBookByIsbn() {
try {
bookDAOImpl.findBookByIsbn(null);
fail("Method should fail on null ISBN.");
} catch (IllegalArgumentException e) {
//OK
}
try {
bookDAOImpl.findBookByIsbn("");
fail("Method should fail on empty ISBN.");
} catch (IllegalArgumentException e) {
//OK
}
createBooks();
assertEquals(2, bookDAOImpl.findBookByIsbn("isbn1").size());
assertEquals(2, bookDAOImpl.findBookByIsbn("isbn2").size());
assertEquals(1, bookDAOImpl.findBookByIsbn("isbn3").size());
assertEquals(0, bookDAOImpl.findBookByIsbn("isbn4").size());
Set<State> isbn1States = new HashSet<State>();
Set<State> isbn2States = new HashSet<State>();
Set<State> isbn3States = new HashSet<State>();
for (Book book : bookDAOImpl.findBookByIsbn("isbn1")) {
isbn1States.add(book.getState());
}
for (Book book : bookDAOImpl.findBookByIsbn("isbn2")) {
isbn2States.add(book.getState());
}
for (Book book : bookDAOImpl.findBookByIsbn("isbn3")) {
isbn3States.add(book.getState());
}
assertEquals(2, isbn2States.size());
assertEquals(isbn1States, isbn3States);
Book book = createCustomBook1();
persist(book);
assertTrue("Created book should be in the list of books with it's isbn.",
bookDAOImpl.findBookByIsbn("isbn1").contains(book));
}
/**
* Test of updateBook method, of class BookDAOImpl.
* Assuming method findBookByID() works properly.
*/
public void testUpdateBook() {
try {
bookDAOImpl.updateBook(null);
fail("Method should fail on null parameter.");
} catch (IllegalArgumentException e) {
// OK
}
Book book = createCustomBook1();
persist(book);
book.setId(book.getId() + 1);
try {
bookDAOImpl.updateBook(book);
fail("Method should fail on updating book with incorrect id"
+ "as it should not be in the database.");
} catch (IllegalArgumentException e) {
// OK
}
book = createCustomBook1();
persist(book);
book.setISBN(null);
try {
bookDAOImpl.updateBook(book);
fail("Method should fail on updating book with incorrect parameters.");
} catch (IllegalArgumentException e) {
//OK
}
book = createCustomBook1();
Book book2 = createCustomBook2();
persist(book);
book2.setId(book.getId());
em.getTransaction().begin();
bookDAOImpl.updateBook(book2);
em.getTransaction().commit();
//if method findBookById() does not work properly, result of this test is irrelevant
assertEquals(book2.getTitle(), bookDAOImpl.findBookById(book2.getId()).getTitle());
assertEquals(1, bookDAOImpl.findBookByAuthor("Autor2").size());
}
/**
* Test of deleteBook method, of class BookDAOImpl.
*/
public void testDeleteBook() {
try {
bookDAOImpl.deleteBook(null);
fail("Method should fail on null parameter.");
} catch (IllegalArgumentException e) {
// OK
}
try {
bookDAOImpl.deleteBook(createCustomBook1());
fail("Method should fail on deleting book withoud ID.");
} catch (IllegalArgumentException e) {
// OK
}
createBooks();
int autor1count = bookDAOImpl.findBookByAuthor("Autor1").size();
int initCount = bookDAOImpl.findAllBooks().size();
for (Book book : bookDAOImpl.findAllBooks()) {
if (book.getAuthor().equals("Autor1")) {
em.getTransaction().begin();
bookDAOImpl.deleteBook(book);
em.getTransaction().commit();
}
}
//all books which should be deleted are deleted
assertEquals(0, bookDAOImpl.findBookByAuthor("Autor1").size());
//books which should not be deleted were not deleted
assertEquals(initCount - autor1count, bookDAOImpl.findAllBooks().size());
}
}