/*
 * Copyright 2005-2010 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wamblee.test.persistence;

import static junit.framework.Assert.*;
import static org.mockito.Mockito.*;

import javax.persistence.EntityManager;
import javax.transaction.UserTransaction;

import junit.framework.AssertionFailedError;

import org.dbunit.IDatabaseTester;
import org.dbunit.dataset.ITable;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.wamblee.test.persistence.JpaBuilder.JpaUnitOfWork;
import org.wamblee.test.transactions.DefaultUserTransactionFactory;
import org.wamblee.test.transactions.SimpleTransactionManager;
import org.wamblee.test.transactions.TransactionResult;

/**
 * This class shows an example of how to test an entity using jpa.
 */
public class MyEntityExampleTestBase {

    // This is the magical object that does all the test setup.
    private JpaTester jpaTester;

    // The jpa tester initializes a lot for us....

    // A JPA builder that provides a transaction scoped entity manager for us.
    private JpaBuilder builder;

    // The database tester for dbunit which is appropriately configured for our
    // persistence unit.
    private IDatabaseTester dbtester;

    // Database utilities with some additional functionality for working with
    // the databse
    // such as dropping tables, cleaning tables, etc.
    private DatabaseUtils dbutils;

    @Before
    public void setUp() throws Exception {

        // First we create the JpaTester by telling us which persistence unit we
        // are going to test
        jpaTester = new JpaTester(new MyPersistenceUnit());
        jpaTester.start();

        // Retrieve some useful objects fromt he jpa tester. It also provides
        // direct access to the datasource
        // but we don't need it. We can use datbase utils if we want to execute
        // straight JDBC calls.
        builder = jpaTester.getJpaBuilder();
        dbtester = jpaTester.getDbUtils().createDbTester(new MyTables());
        dbutils = jpaTester.getDbUtils();
    }

    @After
    public void tearDown() {
        dbutils.stop();
        jpaTester.stop();
    }

    @Test
    public void testEntityPersistence() throws Exception {

        // Use the JPA builder to create a transaction scoped entity manager for
        // as and execute the
        // unit of work.
        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                return null;
            }
        });

        // Verify one row is written (using Db unit)
        ITable table = dbtester.getDataSet().getTable("XYZ_MYENTITY");
        assertEquals(1, table.getRowCount());

        assertEquals("a", table.getValue(0, "SLEUTELTJE"));
        assertEquals("b", table.getValue(0, "VALUE"));

        // For this simple test, it can also be done through DatabaseUtils
        assertEquals(1, dbutils.getTableSize("XYZ_MYENTITY"));

    }

    @Test
    public void testEntityPersistenceWithBasicApi() throws Exception {

        // Use the JPA builder to create a transaction scoped entity manager for
        // as and execute the
        // unit of work.
        EntityManager em = builder.begin();

        MyEntity entity = new MyEntity("a", "b");
        em.persist(entity);

        builder.commit(em);

        // Verify one row is written (using Db unit)
        ITable table = dbtester.getDataSet().getTable("XYZ_MYENTITY");
        assertEquals(1, table.getRowCount());

        assertEquals("a", table.getValue(0, "SLEUTELTJE"));
        assertEquals("b", table.getValue(0, "VALUE"));

        // For this simple test, it can also be done through DatabaseUtils
        assertEquals(1, dbutils.getTableSize("XYZ_MYENTITY"));

    }

    @Test
    public void testEntityPersistenceWithContextualEntityManager()
        throws Exception {

        // Use the JPA builder to create a transaction scoped entity manager for
        // as and execute the
        // unit of work.
        builder.begin();

        EntityManager em = builder.getContextualEntityManager();
        MyEntity entity = new MyEntity("a", "b");
        em.persist(entity);

        builder.commit(em);

        // Verify one row is written (using Db unit)
        ITable table = dbtester.getDataSet().getTable("XYZ_MYENTITY");
        assertEquals(1, table.getRowCount());

        assertEquals("a", table.getValue(0, "SLEUTELTJE"));
        assertEquals("b", table.getValue(0, "VALUE"));

        // For this simple test, it can also be done through DatabaseUtils
        assertEquals(1, dbutils.getTableSize("XYZ_MYENTITY"));

    }

    @Test
    public void testEntityPersistenceWithUserTransactions() throws Exception {

        SimpleTransactionManager manager = new SimpleTransactionManager(
            new DefaultUserTransactionFactory());
        manager.addResource(jpaTester.getJpaBuilder());

        UserTransaction transaction = manager.getTransaction();
        transaction.begin();

        EntityManager em = builder.getContextualEntityManager();
        MyEntity entity = new MyEntity("a", "b");
        em.persist(entity);

        transaction.commit();

        // Verify one row is written (using Db unit)
        ITable table = dbtester.getDataSet().getTable("XYZ_MYENTITY");
        assertEquals(1, table.getRowCount());

        assertEquals("a", table.getValue(0, "SLEUTELTJE"));
        assertEquals("b", table.getValue(0, "VALUE"));

        // For this simple test, it can also be done through DatabaseUtils
        assertEquals(1, dbutils.getTableSize("XYZ_MYENTITY"));

    }

    @Test
    public void testTransactionCommittedCallback() throws Exception {
        TransactionResultCallback callback = mock(TransactionResultCallback.class);
        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                return null;
            }
        }, callback);
        verify(callback).status(TransactionResult.COMMIT);
        verifyNoMoreInteractions(callback);
    }

    @Test
    public void testTransactionMarkedForRollback() throws Exception {
        TransactionResultCallback callback = mock(TransactionResultCallback.class);

        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                aEm.getTransaction().setRollbackOnly();
                return null;
            }
        }, callback);
        verify(callback).status(TransactionResult.ROLLBACK);
        verifyNoMoreInteractions(callback);
    }

    @Test
    public void testTransactionRolledBack() throws Exception {
        TransactionResultCallback callback = mock(TransactionResultCallback.class);

        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                aEm.getTransaction().rollback();
                return null;
            }
        }, callback);
        verify(callback).status(TransactionResult.UNKNOWN);
        verifyNoMoreInteractions(callback);
    }

    @Test
    public void testTransactionCommitted() throws Exception {
        TransactionResultCallback callback = mock(TransactionResultCallback.class);

        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                aEm.getTransaction().commit();
                return null;
            }
        }, callback);
        verify(callback).status(TransactionResult.UNKNOWN);
        verifyNoMoreInteractions(callback);
    }

    @Test(expected = AssertionFailedError.class)
    public void testTransactionNotCommittedUnexpectedly() throws Exception {
        builder.execute(new JpaUnitOfWork<Void>() {
            public Void execute(EntityManager aEm) {
                MyEntity entity = new MyEntity("a", "b");
                aEm.persist(entity);
                aEm.getTransaction().rollback();
                return null;
            }
        });
    }

}