wamblee.org Git - utils/blob - test/enterprise/src/main/java/org/wamblee/support/persistence/JpaTester.java

   1 /*
   2  * Copyright 2005-2010 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.support.persistence;
  17
  18 import javax.naming.InitialContext;
  19 import javax.naming.NamingException;
  20 import javax.sql.DataSource;
  21
  22 import org.dbunit.IDatabaseTester;
  23 import org.wamblee.support.jndi.StubInitialContextFactory;
  24
  25 /**
  26  * This class is the entry point for JPA tests. Test code should construct a
  27  * JpaTester in the <code>@Before</code> method and call {@link #start()} on it
  28  * in that method. Also, test code should call {@link #stop()} on it in the
  29  * <code>@After</code> method.
  30  *
  31  * This class is constructed with a description of the persistence unit to be
  32  * tested. The principle is that an existing <code>persistence.xml</code> can be
  33  * tested without change in unit test code.
  34  *
  35  * It then takes care of the following:
  36  * <ul>
  37  * <li>Creating an inmemory database for testing (default) or connecting to an
  38  * external database. See {@link DatabaseBuilder} for more information on how a
  39  * databse is obtained.</li>
  40  * <li>Drop all database tables that are related to the persistence unit under
  41  * test, including JPA provider specific tables.</li>
  42  * <li>Creating a datasource for the database and make the datasource available
  43  * through JNDI.</li>
  44  * <li>Creating the entity manager factory for JPA and configuring it in such a
  45  * way that schema creation happens. (Typically, schema creation will be
  46  * disabled in the persistence.xml but this utility enables it for unit test).</li>
  47  * <li>Creating a DBUnit database tester which is appropriately configured for
  48  * the persistence unit under test.</li>
  49  * </ul>
  50  *
  51  * The main entry point for all this functionality is the
  52  * {@link PersistenceUnitDescription} which describes the persistence unit and
  53  * must be provided at construction of the <code>JpaTester</code>
  54  *
  55  * NOTE: Persistence XML files should be explicitly configured with the classes
  56  * that are part of the persistence unit since scanning of classes does not work
  57  * correctly in a unit test environment. This is currently the only limitation.
  58  */
  59 public class JpaTester {
  60
  61     private PersistenceUnitDescription persistenceUnit;
  62     private Database db;
  63     private DataSource dataSource;
  64     private DatabaseUtils dbUtils;
  65     private JpaBuilder jpaBuilder;
  66     private IDatabaseTester dbTester;
  67
  68     /**
  69      * Constructs the tester.
  70      *
  71      * @param aPersistenceUnit
  72      *            Persistence unit under test.
  73      */
  74     public JpaTester(PersistenceUnitDescription aPersistenceUnit) {
  75         persistenceUnit = aPersistenceUnit;
  76     }
  77
  78     /**
  79      * Starts the tester. This must be called prior to running the test.
  80      *
  81      * @throws Exception
  82      */
  83     public void start() throws Exception {
  84         db = DatabaseBuilder.getDatabase();
  85         dataSource = db.start();
  86
  87         // NOTE: adding datasource to JNDI is no longer needed for
  88         //       JPA testing, but is nice to have available for other uses.
  89         StubInitialContextFactory.register();
  90         try {
  91             InitialContext ctx = new InitialContext();
  92             ctx.bind(persistenceUnit.getJndiName(), dataSource);
  93         } catch (NamingException e) {
  94             throw new RuntimeException("JNDI problem", e);
  95         }
  96
  97         dbUtils = new DatabaseUtils(dataSource, persistenceUnit.getTables());
  98         dbUtils.start();
  99         dbUtils.dropTables();
 100         dbUtils.dropTables(JpaCustomizerBuilder.getCustomizer().getJpaTables());
 101
 102         jpaBuilder = new JpaBuilder(db.getJdbcUrl(), db.getUsername(), db.getPassword(), persistenceUnit);
 103         jpaBuilder.start();
 104
 105         // db tester should be created after Jpa builder because jpa builder
 106         // creates the
 107         // tables that the tester looks at when it is initialized.
 108         dbTester = dbUtils.createDbTester();
 109     }
 110
 111     /**
 112      * Stops the tester. This must be called after the test.
 113      */
 114     public void stop() {
 115         if (jpaBuilder != null) {
 116             jpaBuilder.stop();
 117         }
 118         if (dbUtils != null) {
 119             dbUtils.stop();
 120         }
 121         if (db != null) {
 122             db.stop();
 123         }
 124     }
 125
 126     public Database getDb() {
 127         return db;
 128     }
 129
 130     public DataSource getDataSource() {
 131         return dataSource;
 132     }
 133
 134     public IDatabaseTester getDbTester() {
 135         return dbTester;
 136     }
 137
 138     public DatabaseUtils getDbUtils() {
 139         return dbUtils;
 140     }
 141
 142     public JpaBuilder getJpaBuilder() {
 143         return jpaBuilder;
 144     }
 145
 146     public PersistenceUnitDescription getPersistenceUnit() {
 147         return persistenceUnit;
 148     }
 149
 150 }