fix: jpa working again with external libraries (since entities are no… (#111)

brian-mulier · web-flow · commit f87d007563b9 · 2022-11-21T10:40:01.000+01:00
* fix: jpa working again with external libraries (since entities are not in entity manager managed classes)
diff --git a/tzatziki-common/pom.xml b/tzatziki-common/pom.xml
@@ -102,6 +102,17 @@
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.10.2</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>slf4j-api</artifactId>
+                    <groupId>org.slf4j</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
diff --git a/tzatziki-common/src/main/java/com/decathlon/tzatziki/utils/TypeParser.java b/tzatziki-common/src/main/java/com/decathlon/tzatziki/utils/TypeParser.java
@@ -6,6 +6,9 @@
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+import org.reflections.util.ConfigurationBuilder;
 
 import java.lang.reflect.Type;
 import java.time.Instant;
@@ -23,13 +26,14 @@
 public class TypeParser {
 
     private static final Pattern typePattern = Pattern.compile("((?:[a-z_$][a-z0-9_$]*\\.)*[A-Z_$][A-z0-9_$]*)(?:<(.*)>)?");
-    private static List<ClassPath.ClassInfo> reflections;
+    private static List<ClassPath.ClassInfo> allClasses;
+    private static Reflections reflections;
     private static final Map<String, Type> KNOWN_TYPES = new LinkedHashMap<>();
-    private static String defaultPackage = null;
+    public static String defaultPackage = null;
 
     public static void setDefaultPackage(String defaultPackage) {
         KNOWN_TYPES.clear();
-        reflections = null;
+        allClasses = null;
         TypeParser.defaultPackage = defaultPackage;
     }
 
@@ -84,7 +88,7 @@ private static Type parseType(String name) {
         });
     }
 
-    public static boolean hasClass(String className){
+    public static boolean hasClass(String className) {
         return classes().stream().anyMatch(clazz -> clazz.getName().equals(className) || clazz.getSimpleName().equals(className));
     }
 
@@ -122,8 +126,8 @@ private static List<String> splitNames(String input) {
 
     @SneakyThrows
     public static synchronized List<ClassPath.ClassInfo> classes() {
-        if (reflections == null) {
-            reflections = ClassPath.from(ClassLoader.getSystemClassLoader()).getAllClasses()
+        if (allClasses == null) {
+            allClasses = ClassPath.from(ClassLoader.getSystemClassLoader()).getAllClasses()
                     .stream()
                     .sorted((class1, class2) -> {
                                 if (defaultPackage != null) {
@@ -137,9 +141,15 @@ public static synchronized List<ClassPath.ClassInfo> classes() {
                                 }
                                 return class1.getPackageName().compareTo(class2.getPackageName());
                             }
-                    )
-                    .collect(Collectors.toList());
+                    ).collect(Collectors.toList());
+        }
+        return allClasses;
+    }
+
+    public static synchronized <T> Set<Class<? extends T>> getSubtypesOf(Class<T> clazz) {
+        if (reflections == null) {
+            reflections = new Reflections(new ConfigurationBuilder().forPackage("").setScanners(Scanners.SubTypes));
         }
-        return reflections;
+        return reflections.getSubTypesOf(clazz);
     }
-}
+}
diff --git a/tzatziki-spring-jpa/pom.xml b/tzatziki-spring-jpa/pom.xml
@@ -40,6 +40,10 @@
             <groupId>com.fasterxml.jackson.datatype</groupId>
             <artifactId>jackson-datatype-hibernate5</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-relational</artifactId>
+        </dependency>
 
         <!-- test dependencies -->
         <dependency>
diff --git a/tzatziki-spring-jpa/src/main/java/com/decathlon/tzatziki/steps/SpringJPASteps.java b/tzatziki-spring-jpa/src/main/java/com/decathlon/tzatziki/steps/SpringJPASteps.java
@@ -13,14 +13,13 @@
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 
-import javax.persistence.Entity;
 import javax.persistence.Table;
-import javax.persistence.spi.PersistenceUnitInfo;
 import javax.sql.DataSource;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
-import java.util.*;
-import java.util.function.Function;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
@@ -44,7 +43,8 @@ public class SpringJPASteps {
 
     @Autowired(required = false)
     private List<LocalContainerEntityManagerFactoryBean> entityManagerFactories;
-    private Map<String, Class<?>> entityClassByTableName;
+    private Map<Type, CrudRepository<?, ?>> crudRepositoryByClass;
+    private Map<String, Type> entityClassByTableName;
 
     private boolean disableTriggers = true;
     private final ObjectSteps objects;
@@ -64,15 +64,41 @@ public void before() {
             });
         }
 
+        if (crudRepositoryByClass == null) {
+            crudRepositoryByClass = spring.applicationContext().getBeansOfType(CrudRepository.class).values()
+                    .stream()
+                    .<Map.Entry<Class<?>, CrudRepository<?, ?>>>mapMulti((crudRepository, consumer) -> {
+                        Map<TypeVariable<?>, Type> typeArguments = TypeUtils.getTypeArguments(crudRepository.getClass(), CrudRepository.class);
+                        Type type = typeArguments.get(CrudRepository.class.getTypeParameters()[0]);
+
+                        if (type instanceof TypeVariable<?> typeVariable) {
+                            type = typeVariable.getBounds()[0];
+                            TypeParser.getSubtypesOf((Class<?>) type)
+                                    .forEach(clazz -> consumer.accept(Map.entry(clazz, crudRepository)));
+                        }
+
+                        if (type instanceof Class<?> clazz) consumer.accept(Map.entry(clazz, crudRepository));
+                    })
+                    .collect(Collectors.toMap(
+                            Map.Entry::getKey,
+                            Map.Entry::getValue
+                    ));
+        }
         if (entityClassByTableName == null) {
-            entityClassByTableName = Optional.ofNullable(entityManagerFactories).orElse(Collections.emptyList()).stream()
-                    .map(LocalContainerEntityManagerFactoryBean::getPersistenceUnitInfo)
-                    .map(PersistenceUnitInfo::getManagedClassNames)
-                    .flatMap(Collection::stream)
-                    .map(TypeParser::parse)
+            entityClassByTableName = crudRepositoryByClass.keySet().stream()
                     .map(type -> (Class<?>) type)
-                    .filter(entityClass -> entityClass.isAnnotationPresent(Table.class))
-                    .collect(Collectors.toMap(entityClass -> entityClass.getAnnotation(Table.class).name(), Function.identity()));
+                    .sorted((c1, c2) -> {
+                        if (TypeParser.defaultPackage == null) return 0;
+
+                        if (c1.getPackageName().startsWith(TypeParser.defaultPackage)) return -1;
+
+                        return c2.getPackageName().startsWith(TypeParser.defaultPackage) ? 1 : 0;
+                    })
+                    .<Map.Entry<String, Class<?>>>mapMulti((clazz, consumer) -> {
+                        String tableName = Optional.ofNullable(clazz.getAnnotation(Table.class)).map(Table::name)
+                                .orElse(Optional.ofNullable(clazz.getAnnotation(org.springframework.data.relational.core.mapping.Table.class)).map(org.springframework.data.relational.core.mapping.Table::value).orElse(null));
+                        if (tableName != null) consumer.accept(Map.entry(tableName, clazz));
+                    }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (t1, t2) -> t1));
         }
     }
 
@@ -166,7 +192,7 @@ public <E> void the_repository_will_contain_with_type(Guard guard, CrudRepositor
                         .filter(entityManagerFactory -> entityManagerFactory.getPersistenceUnitInfo() != null)
                         .filter(entityManagerFactory -> entityManagerFactory.getPersistenceUnitInfo().getManagedClassNames().contains(entityClass.getName()))
                         .map(LocalContainerEntityManagerFactoryBean::getDataSource).findFirst()
-                        .orElseThrow();
+                        .orElse(entityManagerFactories.get(0).getDataSource());
                 new JdbcTemplate(dataSource).update("TRUNCATE %s RESTART IDENTITY CASCADE".formatted(table));
             }
             repository.saveAll(Mapper.readAsAListOf(entities, entityClass));
@@ -190,43 +216,20 @@ public <E> void add_repository_content_to_variable(Guard guard, String name, Cru
     }
 
     public <E> CrudRepository<E, ?> getRepositoryForTable(String table) {
-        return getRepositoryForEntity(entityTypeByTableNameOrClassName(table));
+        return getRepositoryForEntity(Optional.ofNullable(this.entityClassByTableName.get(table)).orElseGet(() -> TypeParser.parse(table)));
     }
 
     @Nullable
     private Type entityTypeByTableNameOrClassName(String entityTableOrClass) {
-        return entityClassByTableName.containsKey(entityTableOrClass) ? entityClassByTableName.get(entityTableOrClass) : TypeParser.parse(entityTableOrClass);
+        return Optional.ofNullable(entityClassByTableName.get(entityTableOrClass)).orElseGet(() -> TypeParser.parse(entityTableOrClass));
     }
 
     @SuppressWarnings({"unchecked"})
     public <E> CrudRepository<E, ?> getRepositoryForEntity(Type type) {
-        if (Types.rawTypeOf(type).isAnnotationPresent(Entity.class)) {
-            return spring.applicationContext().getBeansOfType(CrudRepository.class).values()
-                    .stream()
-                    .map(bean -> (CrudRepository<E, ?>) bean)
-                    .filter(r -> {
-                        Map<TypeVariable<?>, Type> typeArguments = TypeUtils.getTypeArguments(r.getClass(), CrudRepository.class);
-                        if (type.equals(TypeUtils.unrollVariables(typeArguments, CrudRepository.class.getTypeParameters()[0])))
-                            return true;
-
-                        if (type instanceof Class<?> clazz
-                                && typeArguments.get(CrudRepository.class.getTypeParameters()[0]) instanceof TypeVariable<?> typeVariable) {
-                            Type handledEntitySuperclass = typeVariable.getBounds()[0];
-
-                            List<Class<?>> superClasses = new ArrayList<>();
-                            while (clazz != Object.class) {
-                                superClasses.add(clazz);
-                                clazz = clazz.getSuperclass();
-                            }
-
-                            return superClasses.contains(handledEntitySuperclass);
-                        }
+        CrudRepository<?, ?> crudRepository = crudRepositoryByClass.get(type);
+        if (crudRepository == null) throw new AssertionError(type + " is not an Entity!");
 
-                        return false;
-                    }).sorted((r1, r2) -> TypeUtils.getTypeArguments(r1.getClass(), CrudRepository.class).values().stream().findFirst().orElse(null) instanceof TypeVariable<?> typeVariable ? 1 : 0)
-                    .findFirst().orElseThrow(() -> new AssertionError("there was no CrudRepository found for entity %s! If you don't need one in your app, you must create one in your tests!".formatted(type.getTypeName())));
-        }
-        throw new AssertionError(type + " is not an Entity!");
+        return (CrudRepository<E, ?>) crudRepository;
     }
 
     public <E> CrudRepository<E, ?> getRepositoryByType(Type type) {
diff --git a/tzatziki-spring-jpa/src/test/java/com/another_org/CorruptedEvilness.java b/tzatziki-spring-jpa/src/test/java/com/another_org/CorruptedEvilness.java
@@ -0,0 +1,20 @@
+package com.another_org;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+
+@NoArgsConstructor
+@Getter
+@Entity
+@Table(name = "evilness")
+public class CorruptedEvilness {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Integer id;
+    @Column(
+            name = "bad_attribute"
+    )
+    boolean badAttribute;
+}
diff --git a/tzatziki-spring-jpa/src/test/java/com/another_org/CorruptedEvilnessDataSpringRepository.java b/tzatziki-spring-jpa/src/test/java/com/another_org/CorruptedEvilnessDataSpringRepository.java
@@ -0,0 +1,7 @@
+package com.another_org;
+
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface CorruptedEvilnessDataSpringRepository extends CrudRepository<CorruptedEvilness, Integer> {}
diff --git a/tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/TestApplication.java b/tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/TestApplication.java
@@ -2,8 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 
 @SpringBootApplication
+@EnableJpaRepositories(basePackages = {"com.another_org", "com.decathlon.tzatziki.app"})
+@EntityScan(basePackages = {"com.another_org", "com.decathlon.tzatziki.app"})
 public class TestApplication {
 
     public static void main(String[] args) {
diff --git a/tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/model/SuperUser.java b/tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/model/SuperUser.java
@@ -10,7 +10,7 @@
 @Getter
 @Entity
 @NoArgsConstructor
-@Table(name = "superusers")
+@Table(name = "super_users")
 public class SuperUser extends User {
     @Column(name = "role")
     String role;
diff --git a/tzatziki-spring-jpa/src/test/resources/com/decathlon/tzatziki/steps/spring-jpa.feature b/tzatziki-spring-jpa/src/test/resources/com/decathlon/tzatziki/steps/spring-jpa.feature
@@ -231,12 +231,28 @@ Feature: to interact with a spring boot service having a persistence layer
       | id | evil  |
       | 1  | false |
 
-  Scenario: we can use extended entities and manage their tables (ex. superusers extends users)
-    Given the superusers table will contain:
+  Scenario: we can use extended entities and manage their tables (ex. super_users extends users)
+    Given the super_users table will contain:
       | id | firstName | lastName  | role  |
       | 1  | Darth     | Vader     | admin |
       | 2  | Anakin    | Skywalker | dummy |
-    Then the superusers table contains:
+    Then the super_users table contains:
       | id | firstName | lastName  | role  |
       | 1  | Darth     | Vader     | admin |
-      | 2  | Anakin    | Skywalker | dummy |
+      | 2  | Anakin    | Skywalker | dummy |
+
+  Scenario: if we have a table which is handled by multiple entities, we should prioritize entity types from default parser package
+    # non-default package, should not be used and throw an exception
+    Given that an UnrecognizedPropertyException is thrown when the evilness table will contain:
+      | badAttribute |
+      | true         |
+    And the evilness table will contain:
+      | evil |
+      | true |
+    Then the evilness table contains only:
+      | id | evil |
+      | 1  | true |
+    # the non-default package was not inserted
+    And it is not true that the evilness table contains:
+      | badAttribute |
+      | true         |
diff --git a/tzatziki-spring-jpa/src/test/resources/db/migration/V0__init.sql b/tzatziki-spring-jpa/src/test/resources/db/migration/V0__init.sql
@@ -8,10 +8,10 @@ create table users
     group_id   INT
 );
 
-create table superusers
+create table super_users
 (
-    id         SERIAL PRIMARY KEY REFERENCES users(id),
-    role       VARCHAR(255) NOT NULL
+    id   SERIAL PRIMARY KEY REFERENCES users (id),
+    role VARCHAR(255) NOT NULL
 );
 
 create table groups
@@ -22,8 +22,9 @@ create table groups
 
 create table evilness
 (
-    id   SERIAL PRIMARY KEY,
-    evil BOOL
+    id            SERIAL PRIMARY KEY,
+    evil          BOOL,
+    bad_attribute BOOL
 );
 
 CREATE OR REPLACE FUNCTION update_timestamp()
