jpauserset now working.
[utils] / test / enterprise / src / main / java / org / wamblee / support / persistence / DatabaseBuilder.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 java.util.ArrayList;
19 import java.util.Arrays;
20 import java.util.List;
21 import java.util.ServiceLoader;
22 import java.util.logging.Logger;
23
24 /**
25  * DatabaseBuilder is used from unit test to obtain a reference to a database
26  * from unit test. This database is either an inmemory database or represents an
27  * external database. Purpose of this utility is to make test code independent
28  * of the particular database used and specifically to be able to run database
29  * tests without any configuration at all (using an inmemory database).
30  * 
31  * The type of database to use can be overridden by specifying either a system
32  * property or an environment variable ({@link #DB_CAPABILITIES_PROP}) that
33  * contains the comma-separated capabilities of the database. Each database type
34  * provides its own capabilities (see {@link DatabaseProvider} implementations}.
35  * 
36  * 
37  * There are currently two database types available:
38  * <ul>
39  * <li>Derby: AN inmemory derby. Provided by {@link DerbyDatabaseProvider}. This
40  * is the default.</li>
41  * <li>External: An arbitrary external database configured using system
42  * properties or environment variables in the usual way using a JDBC URL,
43  * username, and password.</li>
44  * </ul>
45  * 
46  * The <code>DatabaseBuilder</code> uses the {@link ServiceLoader} mechanism to
47  * find implementations of {@link DatabaseProvider} on the classpath. In the
48  * {@link #getDatabase(String...)} method a number of capabilities are passed.
49  * The database providers are then searched in (arbitrary) order and the first
50  * one that has all required capabilities is returned.
51  * 
52  * {@link #getSupportedDatabases()} gives a list of all available databases.
53  */
54 public class DatabaseBuilder {
55
56     private static final Logger LOGGER = Logger.getLogger(DatabaseBuilder.class
57         .getName());
58
59     /**
60      * Environmment variable by which capabilities of the requested database can
61      * be defined
62      */
63     private static final String DB_CAPABILITIES_PROP = "TEST_DB_CAPABILITIES";
64
65     private static ServiceLoader<DatabaseProvider> LOADER = 
66         ServiceLoader.load(DatabaseProvider.class);
67
68     private DatabaseBuilder() {
69         // Empty.
70     }
71
72     private static String[] parseCapabilities(String aValue) {
73         return aValue.split(",");
74     }
75
76     /**
77      * Gets the first database that has all required capabilities.
78      * 
79      * @param aCapabilities
80      *            Capabilities.
81      * @return Database to use.
82      */
83     public static Database getDatabase(String... aCapabilities) {
84         if (aCapabilities.length == 0) {
85             LOGGER.info("Examining database capabilities");
86             LOGGER.info("  Checking system property " + DB_CAPABILITIES_PROP);
87             String capabilities = System.getProperty(DB_CAPABILITIES_PROP);
88             if (capabilities != null) {
89                 aCapabilities = parseCapabilities(capabilities);
90             } else {
91                 LOGGER.info("  Checking environment variable " +
92                     DB_CAPABILITIES_PROP);
93                 capabilities = System.getenv(DB_CAPABILITIES_PROP);
94                 if (capabilities != null) {
95                     aCapabilities = parseCapabilities(capabilities);
96                 } else {
97                     LOGGER.info("  Using default capabilities");
98                     aCapabilities = new String[] { DatabaseProvider.CAPABILITY_IN_MEMORY };
99                 }
100             }
101             LOGGER.info("Using capabilities: " + Arrays.asList(aCapabilities));
102         }
103         synchronized (DatabaseBuilder.class) {
104             for (DatabaseProvider db : LOADER) {
105                 if (db.supportsCapabilities(aCapabilities)) {
106                     return db.create();
107                 }
108             }
109         }
110         throw new RuntimeException(
111             "No database found that satisfies capabilities: " +
112                 Arrays.asList(aCapabilities));
113     }
114
115     /**
116      * Gets a list of available databases.
117      * 
118      * @return List of databases.
119      */
120     public static List<DatabaseDescription> getSupportedDatabases() {
121         List<DatabaseDescription> descriptions = new ArrayList<DatabaseDescription>();
122         for (DatabaseProvider db : LOADER) {
123             descriptions.add(db.getDescription());
124         }
125         return descriptions;
126     }
127
128 }