Proyecto de Aplicación Web

CREATE DATABASE biblioteca;

$ echo "CREATE DATABASE biblioteca" > create.sql
$ mysql -u root -p"expertojava" < create.sql

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.expertojava</groupId>
    <artifactId>jbib-rest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>jbib-rest</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- Añadimos el scope provided para que no de error el
        elemento provider del persistence.xml de runtime -->

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.7.Final</version>
            <scope>test,provided</scope>
        </dependency>

        <!-- Tests -->

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- Logging -->

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.12</version>
        </dependency>

        <!-- JPA -->

        <dependency>
            <groupId>org.dbunit</groupId>
            <artifactId>dbunit</artifactId>
            <version>2.5.0</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.33</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.1-api</artifactId>
            <version>1.0.0.Final</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
            <scope>test</scope>
        </dependency>

        <!-- Hibernate validator -->

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.1.3.Final</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>el-impl</artifactId>
            <version>2.2</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <finalName>${project.name}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.wildfly.plugins</groupId>
                <artifactId>wildfly-maven-plugin</artifactId>
                <version>1.0.2.Final</version>
                <configuration>
                    <hostname>localhost</hostname>
                    <port>9990</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
             xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="
        http://java.sun.com/xml/ns/persistence
        http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="biblioteca-datasource">

        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <jta-data-source>java:/datasources/BibliotecaDS</jta-data-source>

        <class>org.expertojava.jbibrest.modelo.Libro</class>
        <class>org.expertojava.jbibrest.modelo.Recomendacion</class>

        <properties>
            <property name="hibernate.id.new_generator_mappings" value="false"/>
            <property name="hibernate.dialect"
                      value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update" />
            <property name="hibernate.show_sql" value="true" />
        </properties>
    </persistence-unit>
</persistence>

<persistence version="2.1"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence">

    <persistence-unit name="biblioteca-local"
                      transaction-type="RESOURCE_LOCAL">

        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <class>org.expertojava.jbibrest.modelo.Libro</class>
        <class>org.expertojava.jbibrest.modelo.Recomendacion</class>

        <properties>

            <!-- JPA properties -->
            <property name="javax.persistence.jdbc.driver"
                      value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url"
                      value="jdbc:mysql://localhost:3306/biblioteca"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password"
                      value="expertojava"/>

            <!-- Hibernate properties -->
            <property name="hibernate.dialect"
                      value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="false"/>

            <property name="hibernate.hbm2ddl.auto" value="create"/>
        </properties>
    </persistence-unit>
</persistence>

package org.expertojava.jbibrest.modelo;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass
public abstract class ClaseDominio {
    @Id
    @GeneratedValue
    private Long id;

    protected void setId(Long id) { this.id = id; }
    public Long getId() { return id;}

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ClaseDominio that = (ClaseDominio) o;

        return !(id != null ? !id.equals(that.id) : that.id != null);

    }

    @Override
    public int hashCode() {
        return id != null ? id.hashCode() : 0;
    }
}

package org.expertojava.jbibrest.modelo;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Libro extends ClaseDominio {
    @NotNull
    @Column(unique=true, nullable = false)
    private String isbn;
    private String autor;
    private String titulo;
    @Min(0)
    private Integer numPaginas;
    private String portadaURI;
    @OneToMany(mappedBy = "libro", fetch = FetchType.EAGER)
    private Set<Recomendacion> recomendaciones = new HashSet<Recomendacion>();

    private static Log logger = LogFactory.getLog(Libro.class);

    public Libro() {}

    public Libro(String isbn) {
        this.isbn = isbn;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public String getAutor() {
        return autor;
    }

    public void setAutor(String autor) {
        this.autor = autor;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public Integer getNumPaginas() {
        return numPaginas;
    }

    public void setNumPaginas(Integer numPaginas) {
        this.numPaginas = numPaginas;
    }

    public String getPortadaURI() {
        return portadaURI;
    }

    public void setPortadaURI(String portadaURI) {
        this.portadaURI = portadaURI;
    }

    public Set<Recomendacion> getRecomendaciones() {
        return recomendaciones;
    }

    // Actualización de la relación a-muchos recomendaciones
    // No hay que actualizar la relación inversa, porque
    // estamos haciendo una inicialización, no un cambio, y la
    // recomendación ya está creada con el libro
    public void añadeRecomendacion(Recomendacion recomendacion) {
        this.getRecomendaciones().add(recomendacion);
    }

    @Override
    public String toString() {
        return "Libro{" +
                "id=" + this.getId() +
                ", isbn='" + this.getIsbn() + '\'' +
                ", autor='" + this.getAutor() + '\'' +
                ", titulo='" + this.getTitulo() + '\'' +
                ", numPaginas=" + this.getNumPaginas() +
                ", portadaURI='" + this.getPortadaURI() + '\'' +
                '}';
    }
}

package org.expertojava.jbibrest.modelo;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.persistence.*;
import javax.validation.constraints.NotNull;

@Entity
public class Recomendacion extends ClaseDominio {
    @NotNull
    @ManyToOne
    @JoinColumn(nullable = false)
    private Libro libro;
    @NotNull
    @OneToOne
    @JoinColumn(nullable = false)
    private Libro libroRelacionado;
    private String comentario;

    private static Log logger = LogFactory.getLog(Recomendacion.class);

    public Recomendacion() {}

    public Recomendacion(Libro libro, Libro libroRelacionado) {
        String msg;
        if (libro == null) {
            msg = "Error al crear recomendación: libro null";
            logger.error(msg);
            throw new IllegalArgumentException(msg);
        }
        if (libroRelacionado == null) {
            msg = "Error al crear recomendación: libroRelacionado null";
            logger.error(msg);
            throw new IllegalArgumentException(msg);
        }
        this.libro = libro;
        this.libroRelacionado = libroRelacionado;
    }

    public Libro getLibro() {
        return libro;
    }

    public Libro getLibroRelacionado() {
        return libroRelacionado;
    }

    public void setLibroRelacionado(Libro libroRelacionado) {
        this.libroRelacionado = libroRelacionado;
    }

    public String getComentario() {
        return comentario;
    }

    public void setComentario(String comentario) {
        this.comentario = comentario;
    }
}

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
    <Libro id="1" titulo="Patterns Of Enterprise Application Architecture"
           autor="Martin Fowler" isbn="0321127420" numPaginas="533" portadaURI="0321127420.jpg"/>
    <Libro id="2" titulo="Clean Code" autor="Robert C. Martin"
           isbn="0132350882" numPaginas="288" portadaURI="0132350882.jpg"/>
    <Libro id="3" titulo="Test Driven Development" autor="Kent Beck"
           isbn="0321146530" numPaginas="192" portadaURI="0321146530.jpg"/>
    <Libro id="4" titulo="Extreme Programming Explained" autor="Kent Beck"
           isbn="0321278658" numPaginas="224" portadaURI="0321278658.jpg"/>
    <Libro id="5" titulo="The Art of Computer Programming" autor="Donald E. Knuth"
           isbn="0201896834" numPaginas="144" portadaURI="0321278658.jpg"/>

    <Recomendacion id="1" libro_id="2" libroRelacionado_id = "3"/>
    <Recomendacion id="2" libro_id="2" libroRelacionado_id = "1"/>
    <Recomendacion id="3" libro_id="3" libroRelacionado_id = "2"/>
</dataset>

package org.expertojava.jbibrest.persistencia;


import org.dbunit.database.DatabaseConfig;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.ext.mysql.MySqlDataTypeFactory;
import org.dbunit.operation.DatabaseOperation;
import org.expertojava.jbibrest.modelo.Libro;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.validation.ConstraintViolationException;
import java.sql.Connection;
import java.sql.DriverManager;

import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

//
// Tests del aggregate formado por las entidades Libro y Recomendacion
//

public class TestsLibroAggregate {
    private static EntityManagerFactory emf;
    private static IDatabaseConnection connection;
    private static IDataSet dataset;

    @BeforeClass
    public static void initAllTests() {
        try {
            // Inicializamos sólo una vez el emf antes de todos los tests
            emf = Persistence.createEntityManagerFactory("biblioteca-local");

            // Inicializamos la conexión a la BD necesaria para
            // que DBUnit cargue los datos de los tests
            Class.forName("com.mysql.jdbc.Driver");
            Connection jdbcConnection = (Connection) DriverManager
                    .getConnection(
                            "jdbc:mysql://localhost:3306/biblioteca",
                            "root", "expertojava");
            connection = new DatabaseConnection(jdbcConnection);

            // 2 líneas para eliminar el warning
            DatabaseConfig dbConfig = connection.getConfig();
            dbConfig.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new MySqlDataTypeFactory());

            // Inicializamos el dataset
            FlatXmlDataSetBuilder flatXmlDataSetBuilder =
                    new FlatXmlDataSetBuilder();
            flatXmlDataSetBuilder.setColumnSensing(true);
            dataset = flatXmlDataSetBuilder.build(Thread.currentThread()
                    .getContextClassLoader()
                    .getResourceAsStream("dbunit/dataset1.xml"));
        } catch (Exception ex) {
            ex.printStackTrace();
            fail("Excepción al inicializar el emf y DbUnit");
        }
    }

    // Se ejecuta antes de cada test
    @Before
    public void cleanDB() throws Exception {
        // Se hace un "clean insert" de los datos de prueba
        // definidos en el fichero XML. El "clean insert" vacía las
        // tablas de los datos de prueba y después inserta los datos
        DatabaseOperation.CLEAN_INSERT.execute(connection, dataset);
    }

    /*
     * Tests de entidades Libro y Recomendacion
     */

    @Test
    public void findLibroIdTest() {
        EntityManager em = emf.createEntityManager();
        Libro libro = em.find(Libro.class, 2L);
        em.close();

        assertTrue(libro.getIsbn().equals("0132350882"));
        assertTrue(libro.getTitulo().equals("Clean Code"));
        assertTrue(libro.getAutor().equals("Robert C. Martin"));
        assertTrue(libro.getNumPaginas().equals(288));
        assertTrue(libro.getPortadaURI().equals("0132350882.jpg"));
    }

    // Se ejecuta una vez después de todos los tests
    @AfterClass
    public static void closeEntityManagerFactory() throws Exception {
        // Borramos todos los datos y cerramos la conexión
        //DatabaseOperation.DELETE_ALL.execute(connection, dataset);
        if (emf != null)
            emf.close();
    }
}

    @Test
    public void createLibroTest() {
        String isbn = "123456789";

        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        Libro libro = new Libro(isbn);
        em.persist(libro);
        em.getTransaction().commit();

        Long libroId = libro.getId();

        em = emf.createEntityManager();
        Libro libroRecuperado = em.find(Libro.class, libroId);
        assertTrue(libroRecuperado.getIsbn().equals(isbn));
        em.close();
    }

    @Test
    public void numRecomendacionesTest() {

        EntityManager em = emf.createEntityManager();
        Libro libro = em.find(Libro.class, 2L);
        em.close();

        assertTrue(libro.getRecomendaciones().size() == 2);
    }

    @Test(expected = ConstraintViolationException.class)
    public void errorValidacionNumPaginasNegativasTest() {
        Long id = 2L;

        EntityManager em = emf.createEntityManager();
        try {
            em.getTransaction().begin();
            Libro libro = em.find(Libro.class, id);
            libro.setNumPaginas(-1);
            em.flush();
            em.getTransaction().commit();
        } catch (ConstraintViolationException ex){
            em.getTransaction().rollback();
            throw ex;
        }
        em.close();
    }

package org.expertojava.jbibrest.persistencia;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

abstract class Dao<T, K> {

    @PersistenceContext
    EntityManager em;

    public T create(T t) {
        em.persist(t);
        em.flush();
        em.refresh(t);
        return t;
    }

    public T update(T t) {
        return (T) em.merge(t);
    }

    public void delete(T t) {
        t = em.merge(t);
        em.remove(t);
    }

    public abstract T find(K id);
}

package org.expertojava.jbibrest.persistencia;

import org.expertojava.jbibrest.modelo.Libro;

import javax.persistence.Query;
import javax.persistence.TypedQuery;
import java.util.ArrayList;
import java.util.List;

public class LibroDao extends Dao<Libro, Long> {
    String FIND_ALL_LIBROS = "SELECT l FROM Libro l ";

    @Override
    public Libro find(Long id) {
        return em.find(Libro.class, id);
    }

    public List<Libro> listAllLibros() {
        TypedQuery<Libro> query = em.createQuery(FIND_ALL_LIBROS, Libro.class);
        return query.getResultList();
    }
}

package org.expertojava.jbibrest.persistencia;


import org.expertojava.jbibrest.modelo.Recomendacion;

import javax.persistence.Query;
import java.util.List;

public class RecomendacionDao extends Dao<Recomendacion, Long> {
    String FIND_ALL_RECOMENDACIONES = "SELECT r FROM Recomendacion r ";

    @Override
    public Recomendacion find(Long id) {
        return em.find(Recomendacion.class, id);
    }

    public List<Recomendacion> listAllRecomendaciones() {
        Query query = em.createQuery(FIND_ALL_RECOMENDACIONES);
        return (List<Recomendacion>) query.getResultList();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
        bean-discovery-mode="all">
</beans>

    ...

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <version.arquillian-persistence>1.0.0.Alpha7</version.arquillian-persistence>
    </properties>



    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.jboss.arquillian</groupId>
                <artifactId>arquillian-bom</artifactId>
                <version>1.1.10.Final</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>

   ...

        <!-- Arquillian -->

        <dependency>
            <groupId>org.jboss.arquillian.junit</groupId>
            <artifactId>arquillian-junit-container</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.wildfly</groupId>
            <artifactId>wildfly-arquillian-container-remote</artifactId>
            <version>8.1.0.Final</version>
            <scope>test</scope>
        </dependency>

        <!-- Arquillian persistence --> 
(1)
        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-api</artifactId>
            <version>${version.arquillian-persistence}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-core</artifactId>
            <version>${version.arquillian-persistence}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-dbunit</artifactId>
            <version>${version.arquillian-persistence}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-spi</artifactId>
            <version>${version.arquillian-persistence}</version>
            <scope>test</scope>
        </dependency>

        ...

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
             xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="
        http://java.sun.com/xml/ns/persistence
        http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="biblioteca-datasource">

        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <jta-data-source>java:/datasources/BibliotecaDS</jta-data-source>
        <class>org.expertojava.jbibrest.modelo.Libro</class>
        <class>org.expertojava.jbibrest.modelo.Recomendacion</class>

        <properties>
            <property name="hibernate.id.new_generator_mappings" value="false"/>
            <property name="hibernate.dialect"
                      value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="create" /> (1)
            <property name="hibernate.show_sql" value="true" />
        </properties>
    </persistence-unit>
</persistence>

package org.expertojava.jbibrest.persistencia;

import org.expertojava.jbibrest.modelo.Libro;
import org.expertojava.jbibrest.modelo.Recomendacion;
import org.expertojava.jbibrest.utils.BibliotecaException;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.persistence.Cleanup;
import org.jboss.arquillian.persistence.CleanupStrategy;
import org.jboss.arquillian.persistence.TestExecutionPhase;
import org.jboss.arquillian.persistence.UsingDataSet;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.Test;
import org.junit.runner.RunWith;

import javax.inject.Inject;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

@RunWith(Arquillian.class)
public class TestsLibroAggregateArquillian {

    @Inject
    LibroDao libroDao;
    @Inject
    RecomendacionDao recomendacionDao;

    @Deployment
    public static JavaArchive createDeployment() {
        return ShrinkWrap.create(JavaArchive.class)
                .addPackage(Libro.class.getPackage())
                .addPackage(Recomendacion.class.getPackage())
                .addPackage(LibroDao.class.getPackage())
                .addPackage(RecomendacionDao.class.getPackage())
                .addPackage(BibliotecaException.class.getPackage())
                .addAsResource("persistence-datasource.xml",
                        "META-INF/persistence.xml")
                .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
    }

    @Test
    public void libroDaoNoEsNullTest() {
        assertNotNull(libroDao);
    }

    @UsingDataSet("dbunit/dataset1.xml")
    @Cleanup(phase = TestExecutionPhase.BEFORE,  strategy = CleanupStrategy.USED_TABLES_ONLY)
    @Test
    public void findLibroIdTest() {
        Libro libro = libroDao.find(2L);
        assertTrue(libro.getIsbn().equals("0132350882"));
        assertTrue(libro.getTitulo().equals("Clean Code"));
        assertTrue(libro.getAutor().equals("Robert C. Martin"));
        assertTrue(libro.getNumPaginas().equals(288));
        assertTrue(libro.getPortadaURI().equals("0132350882.jpg"));
    }

}

    @UsingDataSet("dbunit/dataset1.xml")
    @Cleanup(phase = TestExecutionPhase.BEFORE,  strategy = CleanupStrategy.USED_TABLES_ONLY)
    @Test
    public void numRecomendacionesTest()  { 
        Libro libro = libroDao.find(2L);(1)
        assertTrue(libro.getRecomendaciones().size() == 2);
    }

    @UsingDataSet("dbunit/dataset1.xml")
    @Cleanup(phase = TestExecutionPhase.BEFORE,  strategy = CleanupStrategy.USED_TABLES_ONLY)
    @Test
    public void createLibroTest() { 
        String isbn = "123456789";(2)

        Libro libro = new Libro(isbn);
        Libro libroCreado = libroDao.create(libro);
        Long libroId = libroCreado.getId();
        Libro libroRecuperado = libroDao.find(libroId);
        assertTrue(libroRecuperado.getIsbn().equals(isbn));
    }

    @UsingDataSet("dbunit/dataset1.xml")
    @Cleanup(phase = TestExecutionPhase.BEFORE,  strategy = CleanupStrategy.USED_TABLES_ONLY)
    @Test
    public void findRecomendacionTest() { 
        Recomendacion recomendacion = recomendacionDao.find(1L);(3)
        assertTrue(recomendacion.getLibro().getTitulo().equals("Clean Code"));
        assertTrue(recomendacion.getLibroRelacionado().getTitulo().equals("Test Driven Development"));
    }

    @UsingDataSet("dbunit/dataset1.xml")
    @Cleanup(phase = TestExecutionPhase.BEFORE,  strategy = CleanupStrategy.USED_TABLES_ONLY)
    @Test
    public void añadeRecomendacionTest() { 
        Libro libro3 = libroDao.find(3L);(4)
        Libro libro1 = libroDao.find(1L);
        Recomendacion recomendacion = new Recomendacion(libro3, libro1);
        recomendacion = recomendacionDao.create(recomendacion);

        // actualizamos la relación en memoria
        libro3.añadeRecomendacion(recomendacion);

        assertTrue(libro3.getRecomendaciones().size() == 2);
        assertTrue(libro3.getRecomendaciones().contains(recomendacion));
    }
}

package org.expertojava.jbibrest.utils;

import java.util.Date;

public interface GeneradorFechaActual {
    public Date getFechaActual();
}

package org.expertojava.jbibrest.utils;

import java.util.Date;

public class GeneradorFechaActualReal implements GeneradorFechaActual {
    public Date getFechaActual() {
        return new Date();
    }
}

package org.expertojava.jbibrest.utils;

import java.util.Date;

public class GeneradorFechaActualStub implements GeneradorFechaActual {
    Date fecha = null;

    public void setFechaActual(Date fecha) {
        this.fecha = fecha;
    }

    public Date getFechaActual()  {
       return fecha;
    }
}

public class BibliotecaBR {

    ...

    // Generador de fecha actual
    GeneradorFechaActual generadorFechaActual = new GeneradorFechaActualReal();

    ...

    public void setGeneradorFechaActual(GeneradorFechaActual generadorFechaActual) {
        this.generadorFechaActual = generadorFechaActual;
    }

    public GeneradorFechaActual getGeneradorFechaActual() {
        return this.generadorFechaActual;
    }
    ...
}

GeneradorFechaActual generadorFechaActual = BibliotecaBR.getInstance().getGeneradorFechaActual();
Date fechaActual = generadorFechaActual.getFechaActual();

GeneradorFechaActualStub generadorFechaActual = new GeneradorFechaActualStub();
generadorFechaActual.setFechaActual(Utils.stringToDate("2014-11-02"));

// Actualizamos el generador de fecha actual en BibliotecaBR para que el
// método de negocio obtenga esa fecha
BibliotecaBR.getInstance().setFechaActualGenerator(generadorFechaActual);

Prestamo prestamo = usuarioServicio.solicitaPrestamo(1L, 1L); (1)
Usuario usuario = usuarioServicio.buscaUsuarioPorId(1L);
assertTrue(prestamo.getEjemplar().getLibroId() == 1);
assertTrue(usuario.getPrestamos().contains(prestamo));