jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/framework/EmfRunnerInjector.java - eclipselink - Git at Google

 /*
  * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2014, 2021 IBM Corporation. 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:
 //     11/04/2014 - Rick Curtis
 //       - 450010 : Add java se test bucket
 //     01/13/2015 - Rick Curtis
 //       - 438871 : Add support for writing statement terminator character(s) when generating ddl to script.
 package org.eclipse.persistence.jpa.test.framework;

 import java.io.File;
 import java.lang.reflect.Field;
 import java.net.MalformedURLException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.Set;

 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.Persistence;

 import org.eclipse.persistence.config.PersistenceUnitProperties;
 import org.eclipse.persistence.internal.databaseaccess.DatabaseCall;
 import org.eclipse.persistence.internal.jpa.deployment.SEPersistenceUnitInfo;
 import org.eclipse.persistence.jpa.JpaEntityManagerFactory;
 import org.eclipse.persistence.queries.Call;
 import org.eclipse.persistence.sessions.SessionEvent;
 import org.eclipse.persistence.sessions.SessionEventAdapter;

 public class EmfRunnerInjector {
     private boolean _debug = false;
     private final Map<String, EntityManagerFactory> _emfs;

     public EmfRunnerInjector() {
         _emfs = new HashMap<String, EntityManagerFactory>();
     }

     public void close() {
         for (EntityManagerFactory emf : _emfs.values()) {
             try {
                 d("Closing [ " + emf + " ]");
                 emf.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

     /**
      * This method will create / inject EntityManagerFactory and SQLListeners into test instances
      *
      */
     public void inject(Object testInstance) throws Exception {
         if (testInstance == null) {
             return;
         }

         Class<?> cls = testInstance.getClass();
         // Check for duplicate injected EMFs
         Set<EntityManagerFactory> injectedEmfs = new HashSet<EntityManagerFactory>();
         Set<Field> injectedSqlListeneFields = new HashSet<Field>();

         // PU name -> Field
         Map<String, Field> annotatedSqlListenerFields = getSqlListenerFieldMap(cls);
         Map<String, Field> annotatedSqlCallListenerFields = getSqlCallListenerFieldMap(cls);
         for (Field emfField : cls.getDeclaredFields()) {
             Emf emfAnno = emfField.getAnnotation(Emf.class);
             if (emfAnno == null) {
                 continue;
             }
             String emfName = emfAnno.name();

             SqlCollector sqlCollector = null;
             Field sqlListenerField = annotatedSqlListenerFields.get(emfName);
             if (sqlListenerField != null) {
                 sqlCollector = new SqlCollector();
             }

             SqlCallCollector sqlCallCollector = null;
             Field sqlCallListenerField = annotatedSqlCallListenerFields.get(emfName);
             if (sqlCallListenerField != null) {
                 sqlCallCollector = new SqlCallCollector();
             }

             Map<String,Object> props = null;
             if(testInstance instanceof PUPropertiesProvider) {
                 props = ((PUPropertiesProvider)testInstance).getAdditionalPersistenceProperties(emfName);
             }
             EntityManagerFactory factory = getEntityManagerFactory(emfAnno, props);
             if (!injectedEmfs.add(factory)) {
                 throw new RuntimeException("Attempted to inject the same EntityManagerFactory multiple times into "
                     + testInstance + ". Please remove the duplicate @Emf annotation, or change the name so that each "
                     + "annotation is for a distinct EntityManagerFactory.");
             }
             emfField.setAccessible(true);
             emfField.set(testInstance, factory);
             d("Injected " + factory + " into " + testInstance);

             if (sqlCollector != null) {
                 ((JpaEntityManagerFactory) factory).getServerSession().getEventManager().addListener(sqlCollector);
                 sqlCollector.inject(testInstance, sqlListenerField);
                 injectedSqlListeneFields.add(sqlListenerField);
                 d("Injected " + sqlCollector + " into " + sqlListenerField);
             }

             if (sqlCallCollector != null) {
                 ((JpaEntityManagerFactory) factory).getServerSession().getEventManager().addListener(sqlCallCollector);
                 sqlCallCollector.inject(testInstance, sqlCallListenerField);
                 injectedSqlListeneFields.add(sqlCallListenerField);
                 d("Injected " + sqlCallCollector + " into " + sqlCallListenerField);
             }
         }
         // Check for @SQLListeners that weren't injected
         validateSQLListenerAnnotations(annotatedSqlListenerFields, injectedSqlListeneFields);
     }

     private void validateSQLListenerAnnotations(Map<String, Field> sqlListeners, Set<Field> injectedSqlListeners) {
         boolean die = false;
         List<Field> uninjectedSqlFields = new ArrayList<Field>();
         for (Entry<String, Field> entry : sqlListeners.entrySet()) {
             String puName = entry.getKey();
             Field annotatedField = entry.getValue();
             if (!injectedSqlListeners.contains(annotatedField)) {
                 System.err.println("Encountered @SQLListener annotation for pu [" + puName + "] on field ["
                     + annotatedField + "], but did not find a corresponding @Emf annotation for that pu name.");
                 uninjectedSqlFields.add(annotatedField);
                 die = true;
             }
         }
         if (die) {
             throw new RuntimeException("Error injecting @SQLListeners, review previous error messages.");
         }
     }

     private Map<String, Field> getSqlListenerFieldMap(Class<?> cls) {
         Map<String, Field> res = new HashMap<String, Field>();
         for (Field field : cls.getDeclaredFields()) {
             SQLListener listener = field.getAnnotation(SQLListener.class);
             if (listener != null) {
                 if (!List.class.isAssignableFrom(field.getType())) {
                     throw new RuntimeException("@SQLListener anntation can only be placed on a List<String> field. Found on [" + field + "].");
                 }
                 String puName = listener.name();
                 Field old = res.put(puName, field);
                 if (old != null) {
                     // Found two SQLListener annotations for the same PU
                     throw new RuntimeException("Found multiple fields [" + old + ", " + field
                         + "] annotated as a SQLListener for pu [" + puName + "]. Remove one of the anntations.");
                 }
             }
         }
         return res;
     }

     private Map<String, Field> getSqlCallListenerFieldMap(Class<?> cls) {
         Map<String, Field> res = new HashMap<String, Field>();
         for (Field field : cls.getDeclaredFields()) {
             SQLCallListener listener = field.getAnnotation(SQLCallListener.class);
             if (listener != null) {
                 if (!List.class.isAssignableFrom(field.getType())) {
                     throw new RuntimeException("@SQLCallListener anntation can only be placed on a List<String> field. Found on [" + field + "].");
                 }
                 String puName = listener.name();
                 Field old = res.put(puName, field);
                 if (old != null) {
                     // Found two SQLCallListener annotations for the same PU
                     throw new RuntimeException("Found multiple fields [" + old + ", " + field
                         + "] annotated as a SQLCallListener for pu [" + puName + "]. Remove one of the anntations.");
                 }
             }
         }
         return res;
     }

     private EntityManagerFactory getEntityManagerFactory(Emf anno, Map<String, Object> additionalProperties) {
         String name = anno.name();

         // Check cache
         EntityManagerFactory emf = _emfs.get(name);
         if (emf != null) {
             return emf;
         }

         List<String> mappingFiles = Arrays.asList(anno.mappingFiles());
         List<String> classes = new ArrayList<String>();
         Properties persistenceProperties = new Properties();

         for (Class<?> cls : anno.classes()) {
             classes.add(cls.getName());
         }

         for (Property prop : anno.properties()) {
             persistenceProperties.put(prop.name(), prop.value());
         }

         if (additionalProperties != null) {
             persistenceProperties.putAll(additionalProperties);
         }


         if (anno.createTables() != DDLGen.NONE) {
             persistenceProperties.put(PersistenceUnitProperties.DDL_GENERATION, anno.createTables().toString());
         }

         SEPersistenceUnitInfo pu = createSEPUInfo(anno.name(), classes, mappingFiles, persistenceProperties);

         Properties props = new Properties();
         props.put(PersistenceUnitProperties.ECLIPSELINK_SE_PUINFO, pu);

         emf = Persistence.createEntityManagerFactory(name, props);

         _emfs.put(name, emf);

         return emf;
     }

     private SEPersistenceUnitInfo createSEPUInfo(String puName, List<String> classes, List<String> mappingFiles,
         Properties persistenceProperties) {
         SEPersistenceUnitInfo pu = new SEPersistenceUnitInfo();
         pu.setClassLoader(Thread.currentThread().getContextClassLoader());
         pu.setPersistenceUnitName(puName);
         pu.setManagedClassNames(classes);
         pu.setMappingFileNames(mappingFiles);
         try {
             pu.setPersistenceUnitRootUrl(new File(".").toURI().toURL());
         } catch (MalformedURLException e) {
             e.printStackTrace();
         }
         pu.setProperties(persistenceProperties);

         return pu;
     }

     private void d(String msg) {
         if (_debug) {
             System.err.println(msg);
         }
     }

     private class SqlCollector extends SessionEventAdapter {
         private List<String> _sql;

         SqlCollector() {
             _sql = new ArrayList<String>();
         }

         @Override
         public void preExecuteQuery(SessionEvent event) {
             super.preExecuteQuery(event);
             _sql.add(event.getQuery().getSQLString());
         }

         private void inject(Object instance, Field into) {
             into.setAccessible(true);
             try {
                 into.set(instance, _sql);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
     }

     private class SqlCallCollector extends SessionEventAdapter {
         private List<String> _sql;

         SqlCallCollector() {
             _sql = new ArrayList<String>();
         }

         @Override
         public void preExecuteCall(SessionEvent event) {
             super.preExecuteQuery(event);
             Call call = event.getCall();
             if(call instanceof DatabaseCall) {
                 _sql.add(((DatabaseCall)call).getSQLString());
             }
         }

         private void inject(Object instance, Field into) {
             into.setAccessible(true);
             try {
                 into.set(instance, _sql);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
     }
 }
	/*
	* Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2014, 2021 IBM Corporation. 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:
	// 11/04/2014 - Rick Curtis
	// - 450010 : Add java se test bucket
	// 01/13/2015 - Rick Curtis
	// - 438871 : Add support for writing statement terminator character(s) when generating ddl to script.
	package org.eclipse.persistence.jpa.test.framework;

	import java.io.File;
	import java.lang.reflect.Field;
	import java.net.MalformedURLException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Properties;
	import java.util.Set;

	import jakarta.persistence.EntityManagerFactory;
	import jakarta.persistence.Persistence;

	import org.eclipse.persistence.config.PersistenceUnitProperties;
	import org.eclipse.persistence.internal.databaseaccess.DatabaseCall;
	import org.eclipse.persistence.internal.jpa.deployment.SEPersistenceUnitInfo;
	import org.eclipse.persistence.jpa.JpaEntityManagerFactory;
	import org.eclipse.persistence.queries.Call;
	import org.eclipse.persistence.sessions.SessionEvent;
	import org.eclipse.persistence.sessions.SessionEventAdapter;

	public class EmfRunnerInjector {
	private boolean _debug = false;
	private final Map<String, EntityManagerFactory> _emfs;

	public EmfRunnerInjector() {
	_emfs = new HashMap<String, EntityManagerFactory>();
	}

	public void close() {
	for (EntityManagerFactory emf : _emfs.values()) {
	try {
	d("Closing [ " + emf + " ]");
	emf.close();
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}

	/**
	* This method will create / inject EntityManagerFactory and SQLListeners into test instances
	*
	*/
	public void inject(Object testInstance) throws Exception {
	if (testInstance == null) {
	return;
	}

	Class<?> cls = testInstance.getClass();
	// Check for duplicate injected EMFs
	Set<EntityManagerFactory> injectedEmfs = new HashSet<EntityManagerFactory>();
	Set<Field> injectedSqlListeneFields = new HashSet<Field>();

	// PU name -> Field
	Map<String, Field> annotatedSqlListenerFields = getSqlListenerFieldMap(cls);
	Map<String, Field> annotatedSqlCallListenerFields = getSqlCallListenerFieldMap(cls);
	for (Field emfField : cls.getDeclaredFields()) {
	Emf emfAnno = emfField.getAnnotation(Emf.class);
	if (emfAnno == null) {
	continue;
	}
	String emfName = emfAnno.name();

	SqlCollector sqlCollector = null;
	Field sqlListenerField = annotatedSqlListenerFields.get(emfName);
	if (sqlListenerField != null) {
	sqlCollector = new SqlCollector();
	}

	SqlCallCollector sqlCallCollector = null;
	Field sqlCallListenerField = annotatedSqlCallListenerFields.get(emfName);
	if (sqlCallListenerField != null) {
	sqlCallCollector = new SqlCallCollector();
	}

	Map<String,Object> props = null;
	if(testInstance instanceof PUPropertiesProvider) {
	props = ((PUPropertiesProvider)testInstance).getAdditionalPersistenceProperties(emfName);
	}
	EntityManagerFactory factory = getEntityManagerFactory(emfAnno, props);
	if (!injectedEmfs.add(factory)) {
	throw new RuntimeException("Attempted to inject the same EntityManagerFactory multiple times into "
	+ testInstance + ". Please remove the duplicate @Emf annotation, or change the name so that each "
	+ "annotation is for a distinct EntityManagerFactory.");
	}
	emfField.setAccessible(true);
	emfField.set(testInstance, factory);
	d("Injected " + factory + " into " + testInstance);

	if (sqlCollector != null) {
	((JpaEntityManagerFactory) factory).getServerSession().getEventManager().addListener(sqlCollector);
	sqlCollector.inject(testInstance, sqlListenerField);
	injectedSqlListeneFields.add(sqlListenerField);
	d("Injected " + sqlCollector + " into " + sqlListenerField);
	}

	if (sqlCallCollector != null) {
	((JpaEntityManagerFactory) factory).getServerSession().getEventManager().addListener(sqlCallCollector);
	sqlCallCollector.inject(testInstance, sqlCallListenerField);
	injectedSqlListeneFields.add(sqlCallListenerField);
	d("Injected " + sqlCallCollector + " into " + sqlCallListenerField);
	}
	}
	// Check for @SQLListeners that weren't injected
	validateSQLListenerAnnotations(annotatedSqlListenerFields, injectedSqlListeneFields);
	}

	private void validateSQLListenerAnnotations(Map<String, Field> sqlListeners, Set<Field> injectedSqlListeners) {
	boolean die = false;
	List<Field> uninjectedSqlFields = new ArrayList<Field>();
	for (Entry<String, Field> entry : sqlListeners.entrySet()) {
	String puName = entry.getKey();
	Field annotatedField = entry.getValue();
	if (!injectedSqlListeners.contains(annotatedField)) {
	System.err.println("Encountered @SQLListener annotation for pu [" + puName + "] on field ["
	+ annotatedField + "], but did not find a corresponding @Emf annotation for that pu name.");
	uninjectedSqlFields.add(annotatedField);
	die = true;
	}
	}
	if (die) {
	throw new RuntimeException("Error injecting @SQLListeners, review previous error messages.");
	}
	}

	private Map<String, Field> getSqlListenerFieldMap(Class<?> cls) {
	Map<String, Field> res = new HashMap<String, Field>();
	for (Field field : cls.getDeclaredFields()) {
	SQLListener listener = field.getAnnotation(SQLListener.class);
	if (listener != null) {
	if (!List.class.isAssignableFrom(field.getType())) {
	throw new RuntimeException("@SQLListener anntation can only be placed on a List<String> field. Found on [" + field + "].");
	}
	String puName = listener.name();
	Field old = res.put(puName, field);
	if (old != null) {
	// Found two SQLListener annotations for the same PU
	throw new RuntimeException("Found multiple fields [" + old + ", " + field
	+ "] annotated as a SQLListener for pu [" + puName + "]. Remove one of the anntations.");
	}
	}
	}
	return res;
	}

	private Map<String, Field> getSqlCallListenerFieldMap(Class<?> cls) {
	Map<String, Field> res = new HashMap<String, Field>();
	for (Field field : cls.getDeclaredFields()) {
	SQLCallListener listener = field.getAnnotation(SQLCallListener.class);
	if (listener != null) {
	if (!List.class.isAssignableFrom(field.getType())) {
	throw new RuntimeException("@SQLCallListener anntation can only be placed on a List<String> field. Found on [" + field + "].");
	}
	String puName = listener.name();
	Field old = res.put(puName, field);
	if (old != null) {
	// Found two SQLCallListener annotations for the same PU
	throw new RuntimeException("Found multiple fields [" + old + ", " + field
	+ "] annotated as a SQLCallListener for pu [" + puName + "]. Remove one of the anntations.");
	}
	}
	}
	return res;
	}

	private EntityManagerFactory getEntityManagerFactory(Emf anno, Map<String, Object> additionalProperties) {
	String name = anno.name();

	// Check cache
	EntityManagerFactory emf = _emfs.get(name);
	if (emf != null) {
	return emf;
	}

	List<String> mappingFiles = Arrays.asList(anno.mappingFiles());
	List<String> classes = new ArrayList<String>();
	Properties persistenceProperties = new Properties();

	for (Class<?> cls : anno.classes()) {
	classes.add(cls.getName());
	}

	for (Property prop : anno.properties()) {
	persistenceProperties.put(prop.name(), prop.value());
	}

	if (additionalProperties != null) {
	persistenceProperties.putAll(additionalProperties);
	}


	if (anno.createTables() != DDLGen.NONE) {
	persistenceProperties.put(PersistenceUnitProperties.DDL_GENERATION, anno.createTables().toString());
	}

	SEPersistenceUnitInfo pu = createSEPUInfo(anno.name(), classes, mappingFiles, persistenceProperties);

	Properties props = new Properties();
	props.put(PersistenceUnitProperties.ECLIPSELINK_SE_PUINFO, pu);

	emf = Persistence.createEntityManagerFactory(name, props);

	_emfs.put(name, emf);

	return emf;
	}

	private SEPersistenceUnitInfo createSEPUInfo(String puName, List<String> classes, List<String> mappingFiles,
	Properties persistenceProperties) {
	SEPersistenceUnitInfo pu = new SEPersistenceUnitInfo();
	pu.setClassLoader(Thread.currentThread().getContextClassLoader());
	pu.setPersistenceUnitName(puName);
	pu.setManagedClassNames(classes);
	pu.setMappingFileNames(mappingFiles);
	try {
	pu.setPersistenceUnitRootUrl(new File(".").toURI().toURL());
	} catch (MalformedURLException e) {
	e.printStackTrace();
	}
	pu.setProperties(persistenceProperties);

	return pu;
	}

	private void d(String msg) {
	if (_debug) {
	System.err.println(msg);
	}
	}

	private class SqlCollector extends SessionEventAdapter {
	private List<String> _sql;

	SqlCollector() {
	_sql = new ArrayList<String>();
	}

	@Override
	public void preExecuteQuery(SessionEvent event) {
	super.preExecuteQuery(event);
	_sql.add(event.getQuery().getSQLString());
	}

	private void inject(Object instance, Field into) {
	into.setAccessible(true);
	try {
	into.set(instance, _sql);
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	}

	private class SqlCallCollector extends SessionEventAdapter {
	private List<String> _sql;

	SqlCallCollector() {
	_sql = new ArrayList<String>();
	}

	@Override
	public void preExecuteCall(SessionEvent event) {
	super.preExecuteQuery(event);
	Call call = event.getCall();
	if(call instanceof DatabaseCall) {
	_sql.add(((DatabaseCall)call).getSQLString());
	}
	}

	private void inject(Object instance, Field into) {
	into.setAccessible(true);
	try {
	into.set(instance, _sql);
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	}
	}