/*
 * 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 javax.persistence.EntityManager;

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.DatabaseUtils;
import org.wamblee.test.persistence.JpaBuilder;
import org.wamblee.test.persistence.JpaTester;
import org.wamblee.test.persistence.JpaBuilder.JpaUnitOfWork;

/**
 * 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"));

    }

}