Merge pull request #33594 from njr-11/reproduce-33544-with-entitymanager

Reproduce #33544 with EntityManager only

Author: njr-11

dev/io.openliberty.data.internal.persistence/src/io/openliberty/data/internal/persistence/RepositoryImpl.java

@@ -603,9 +603,10 @@ else if ("toString".equals(methodName))
                                     Tr.debug(this, tc, "flush");
                                 em.flush();
                                 // TODO 1.1 only detach if a stateless repository
-                                if (entityInfo != null && !entityInfo.isHibernate) {
+                                if (!entityInfo.isHibernate && // TODO remove this condition once #33544 is fixed
+                                    entityInfo != null) {
                                     // Only valid if flush writes to the database,
-                                    // and Hibernate does not seem to honor flush.
+                                    // and Hibernate does not seem to honor flush. #33544
                                     if (trace && tc.isDebugEnabled())
                                         Tr.debug(this, tc, "clear");
                                     em.clear();

dev/io.openliberty.data.internal_fat_jpa/test-applications/DataJPATestApp/src/test/jakarta/data/jpa/web/hibernate/DataJPAHibernateServlet.java

@@ -146,6 +146,94 @@ public void testCountQuery_WHERE_SELECT_ORDER() {
         assertEquals(10, page1.totalElements());
     }
 
+    /**
+     * Reproduces an issue where updates are made and a flush is requested
+     * during a transaction but not honored, so if the entity is detached
+     * after that point, the updates are lost.
+     */
+    @Test
+    public void testFlushAndDetachDuringTransaction() throws Exception {
+        EntityManagerFactory emf = InitialContext
+                        .doLookup("java:comp/env/persistence/HibernatePersistenceUnitRef");
+        UserTransaction tx = InitialContext
+                        .doLookup("java:comp/UserTransaction");
+
+        SimpleEntity entity = new SimpleEntity();
+        entity.id = 2;
+        entity.value = "new";
+
+        EntityManager em = null;
+
+        tx.begin();
+        try {
+            em = emf.createEntityManager();
+            em.setCacheRetrieveMode(CacheRetrieveMode.BYPASS);
+            assertEquals(true, em.isJoinedToTransaction());
+
+            em.persist(entity);
+        } finally {
+            if (tx.getStatus() == Status.STATUS_ACTIVE)
+                tx.commit();
+            else
+                tx.rollback();
+            em.clear();
+            em.close();
+        }
+
+        tx.begin();
+        try {
+            em = emf.createEntityManager();
+            em.setCacheRetrieveMode(CacheRetrieveMode.BYPASS);
+            assertEquals(true, em.isJoinedToTransaction());
+
+            entity = em.find(SimpleEntity.class, 2);
+            entity.value = "flushed";
+
+            entity = em.merge(entity);
+
+            // JPA 3.2 spec states:
+            // "The flush method can be used by the application to force synchronization."
+            // EntityManager Javadoc states:
+            // "The client may force an immediate flush to occur by calling flush()."
+            // EntityManager.flush is defined as:
+            // "Synchronize changes held in the persistence context to the underlying database."
+
+            em.flush(); // this is ignored
+
+            // EntityManager.detach Javadoc says:
+            // "Unflushed changes made to the entity, if any, including deletion
+            // of the entity, will never be synchronized to the database."
+            // However, we did invoke flush.
+            //em.detach(entity);
+
+            // EntityManager.clear Javadoc says:
+            // "Changes made to entities that have not already been flushed to
+            // the database will never be made persistent."
+            // However, we did invoke flush.
+            em.clear();
+        } finally {
+            if (tx.getStatus() == Status.STATUS_ACTIVE)
+                tx.commit();
+            else
+                tx.rollback();
+            em.clear();
+            em.close();
+        }
+
+        try {
+            em = emf.createEntityManager();
+            em.setCacheRetrieveMode(CacheRetrieveMode.BYPASS);
+
+            entity = em.find(SimpleEntity.class, 2);
+        } finally {
+            em.clear();
+            em.close();
+        }
+
+        // TODO enable once #33544 is fixed
+        // assertEquals("flushed", entity.value);
+    }
+
     /**
      * Reproduces an issue where a previously detached entity is merged to the
      * persistence context in order to make an update, but Hibernate never