| /* |
| * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved. |
| * Copyright (c) 1998, 2015 SAP. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation from Oracle TopLink |
| // SAP - use in eclipselink.jpa.wdf.test package |
| package org.eclipse.persistence.testing.framework.junit; |
| |
| import java.util.Hashtable; |
| import java.util.Map; |
| |
| import jakarta.persistence.EntityManager; |
| import jakarta.persistence.EntityManagerFactory; |
| import jakarta.persistence.Persistence; |
| |
| import org.eclipse.persistence.internal.databaseaccess.Platform; |
| import org.eclipse.persistence.sessions.server.ServerSession; |
| import org.eclipse.persistence.testing.framework.server.JEEPlatform; |
| import org.eclipse.persistence.testing.framework.server.ServerPlatform; |
| |
| /** |
| * This is the superclass for all TopLink JUnit tests Provides convenience methods for transactional access as well as to access |
| * login information and to create any sessions required for setup. |
| * |
| * Assumes the existence of a test.properties file on the classpath that defines the following properties: |
| * |
| * db.platform db.user db.pwd db.url db.driver |
| * |
| * If you are using the TestingBrowser, these properties come from the login panel instead. If you are running the test in JEE |
| * the properties come from the server config. This class should be used for all EntityManager operations to allow tests to be |
| * run in the server. |
| */ |
| public abstract class JUnitTestCase { |
| |
| private static Map<String, EntityManagerFactory> emfNamedPersistenceUnits = null; |
| |
| /** Determine if the test is running on a JEE server, or in JSE. */ |
| protected static boolean isOnServer = false; |
| |
| /** Allow a JEE server platform to be set. */ |
| protected static ServerPlatform serverPlatform; |
| |
| // /** Sets if the test should be run on the client or server. */ |
| // public Boolean shouldRunTestOnServer; |
| // |
| // /** System variable to set the tests to run on the server. */ |
| // public static final String RUN_ON_SERVER = "server.run"; |
| // |
| static { |
| emfNamedPersistenceUnits = new Hashtable<String, EntityManagerFactory>(); |
| } |
| |
| /** |
| * Return if the test is running on a JEE server, or in JSE. |
| */ |
| public static boolean isOnServer() { |
| return isOnServer; |
| } |
| |
| /** |
| * Return the server platform if running in JEE. |
| */ |
| public static ServerPlatform getServerPlatform() { |
| if (serverPlatform == null) { |
| serverPlatform = new JEEPlatform(); |
| } |
| return serverPlatform; |
| } |
| |
| /** |
| * Close the entity manager. This allows the same code to be used on the server where managed entity managers are not |
| * closed. |
| */ |
| public void closeEntityManager(EntityManager entityManager) { |
| if (!isOnServer()) { |
| entityManager.close(); |
| } |
| } |
| |
| /** |
| * Return if the transaction is active. This allows the same code to be used on the server where JTA is used. |
| */ |
| public boolean isTransactionActive(EntityManager entityManager) { |
| if (isOnServer()) { |
| return getServerPlatform().isTransactionActive(); |
| } else { |
| return entityManager.getTransaction().isActive(); |
| } |
| } |
| |
| /** |
| * Return if the transaction is roll back only. This allows the same code to be used on the server where JTA is used. |
| */ |
| public boolean getRollbackOnly(EntityManager entityManager) { |
| if (isOnServer()) { |
| return getServerPlatform().getRollbackOnly(); |
| } else { |
| return entityManager.getTransaction().getRollbackOnly(); |
| } |
| } |
| |
| /** |
| * Begin a transaction on the entity manager. This allows the same code to be used on the server where JTA is used. |
| */ |
| public void beginTransaction(EntityManager entityManager) { |
| if (isOnServer()) { |
| getServerPlatform().beginTransaction(); |
| } else { |
| entityManager.getTransaction().begin(); |
| } |
| } |
| |
| /** |
| * Commit a transaction on the entity manager. This allows the same code to be used on the server where JTA is used. |
| */ |
| public void commitTransaction(EntityManager entityManager) { |
| if (isOnServer()) { |
| getServerPlatform().commitTransaction(); |
| } else { |
| entityManager.getTransaction().commit(); |
| } |
| } |
| |
| /** |
| * Rollback a transaction on the entity manager. This allows the same code to be used on the server where JTA is used. |
| */ |
| public void rollbackTransaction(EntityManager entityManager) { |
| if (isOnServer()) { |
| getServerPlatform().rollbackTransaction(); |
| } else { |
| entityManager.getTransaction().rollback(); |
| } |
| } |
| |
| /** |
| * Create a new entity manager for the "default" persistence unit. If in JEE this will create or return the active managed |
| * entity manager. |
| */ |
| public static EntityManager createEntityManager() { |
| if (isOnServer()) { |
| return getServerPlatform().getEntityManager("default"); |
| } else { |
| return getEntityManagerFactory().createEntityManager(); |
| } |
| } |
| |
| /** |
| * Create a new entity manager for the persistence unit using the properties. The properties will only be used the first |
| * time this entity manager is accessed. If in JEE this will create or return the active managed entity manager. |
| */ |
| public static EntityManager createEntityManager(String persistenceUnitName, Map<String, String> properties) { |
| if (isOnServer()) { |
| return getServerPlatform().getEntityManager(persistenceUnitName); |
| } else { |
| return getEntityManagerFactory(persistenceUnitName, properties).createEntityManager(); |
| } |
| } |
| |
| public static ServerSession getServerSession() { |
| return ((org.eclipse.persistence.jpa.JpaEntityManager) getEntityManagerFactory().createEntityManager()) |
| .getServerSession(); |
| } |
| |
| public static ServerSession getServerSession(String persistenceUnitName) { |
| return ((org.eclipse.persistence.jpa.JpaEntityManager) getEntityManagerFactory(persistenceUnitName) |
| .createEntityManager()).getServerSession(); |
| } |
| |
| public static EntityManagerFactory getEntityManagerFactory(String persistenceUnitName) { |
| return getEntityManagerFactory(persistenceUnitName, JUnitTestCaseHelper.getDatabaseProperties()); |
| } |
| |
| public static EntityManagerFactory getEntityManagerFactory(String persistenceUnitName, Map<String, String> properties) { |
| if (isOnServer()) { |
| return getServerPlatform().getEntityManagerFactory(persistenceUnitName); |
| } else { |
| EntityManagerFactory emfNamedPersistenceUnit = emfNamedPersistenceUnits |
| .get(persistenceUnitName); |
| if (emfNamedPersistenceUnit == null) { |
| emfNamedPersistenceUnit = Persistence.createEntityManagerFactory(persistenceUnitName, properties); |
| emfNamedPersistenceUnits.put(persistenceUnitName, emfNamedPersistenceUnit); |
| |
| if (getServerSession(persistenceUnitName).getPlatform().isPostgreSQL()) { |
| getServerSession(persistenceUnitName).getLogin().setShouldForceFieldNamesToUpperCase(true); |
| } |
| } |
| return emfNamedPersistenceUnit; |
| } |
| } |
| |
| public static EntityManagerFactory getEntityManagerFactory() { |
| return getEntityManagerFactory("default"); |
| } |
| |
| public static void closeEntityManagerFactory() { |
| closeEntityManagerFactory("default"); |
| } |
| |
| public static void closeEntityManagerFactory(String persistenceUnitName) { |
| EntityManagerFactory emfNamedPersistenceUnit = emfNamedPersistenceUnits.get(persistenceUnitName); |
| if (emfNamedPersistenceUnit != null) { |
| if (emfNamedPersistenceUnit.isOpen()) { |
| emfNamedPersistenceUnit.close(); |
| } |
| emfNamedPersistenceUnits.remove(persistenceUnitName); |
| } |
| } |
| |
| public static Platform getDbPlatform() { |
| return getServerSession().getDatasourcePlatform(); |
| } |
| } |