Examples of org.apache.openjpa.persistence.OpenJPAEntityManagerSPI

org.apache.openjpa.persistence.OpenJPAEntityManagerSPI

     * Validates explicit property access can be applied to all the access
     * strategies from within an entity with explicit field access (except for
     * the id field, which is field default)
     */
    public void testPropertyAccessStrategies() {
        OpenJPAEntityManagerSPI em = emf.createEntityManager();


        PropAccessFieldStratsEntity pa = new PropAccessFieldStratsEntity();
        
        // Load all persistent fields
        EmbedId eid = new EmbedId();
        eid.setId(new Random().nextInt());
        eid.setCode("IdCode");        
        pa.setEmbedId(eid); // embedded id
        
        Collection<EmbedPropAccess> elc = new ArrayList<EmbedPropAccess>();
        EmbedPropAccess epa1 = new EmbedPropAccess("Abe", "Lincoln");
        EmbedPropAccess epa2 = new EmbedPropAccess("John", "Kennedy");
        elc.add(epa1);
        elc.add(epa2);                
        pa.setElementCollection(elc); // element collection of embeddables
        
        EmbedFieldAccess efa = new EmbedFieldAccess();
        efa.setFirstName("The");
        efa.setLastName("President");
        pa.setEmbedField(efa); // embedded
        
        pa.setName("PropAccessFieldStratsEntity");  // basic
        
        PropAccess propa = new PropAccess();
        propa.setStrProp("PropAccess");
        pa.setManyToOne(propa); // many to one
        
        Collection<FieldAccess> fac = new ArrayList<FieldAccess>();
        FieldAccess fa = new FieldAccess();
        fa.setStrField("FieldAccess");
        fac.add(fa);
        pa.setOneToMany(fac); // one to many
        
        PropAccess pa2 = new PropAccess();
        pa2.setStrProp("PropAccess2");
        pa.setOneToOne(pa2); // one to one
       
        em.getTransaction().begin();
        em.persist(pa);
        em.getTransaction().commit();
        
        em.clear();
        // Verify list of persistent fields
        PropAccessFieldStratsEntity newpa = 
            em.find(PropAccessFieldStratsEntity.class, eid);
        assertNotNull(newpa);
        // simple key validation
        assertEquals(newpa.getEmbedId(), eid);


        // Verify the persistent member names
        MetaDataRepository mdr = 
            em.getConfiguration().getMetaDataRepositoryInstance();
        
        ClassMetaData cmd = mdr.getMetaData(PropAccessFieldStratsEntity.class, 
            null, true);
        // Assert expected persistent fields and properties were created
        assertNotNull(cmd.getField("embedId"));
        assertNotNull(cmd.getField("m2one"));
        assertNotNull(cmd.getField("one2m"));
        assertNotNull(cmd.getField("one2one"));
        assertNotNull(cmd.getField("ecoll"));
        assertNotNull(cmd.getField("embed"));
        assertNotNull(cmd.getField("ver"));
        assertNotNull(cmd.getField("m2m"));


        // Name has a matching getter/setter.  Make sure the access type
        // is field & not property
        assertNotNull(cmd.getField("name"));
        assertTrue((cmd.getField("name").getAccessType() & AccessCode.FIELD) == 
            AccessCode.FIELD);


        // Assert mappings were not created for fields or properties which 
        // should not be persistent
        assertNull(cmd.getField("eid"));
        assertNull(cmd.getField("elementCollection"));
        assertNull(cmd.getField("embedField"));
        assertNull(cmd.getField("version"));
        assertNull(cmd.getField("manyToOne"));
        assertNull(cmd.getField("oneToMany"));
        assertNull(cmd.getField("oneToOne"));
        assertNull(cmd.getField("manyToMany"));
        
        em.close();
    }

View Full Code Here

     * Validates explicit field access can be applied to all the access
     * strategies from within an entity with explicit property access (except
     * for the id field, which is property default)
     */
    public void testFieldAccessStrategies() {
        OpenJPAEntityManagerSPI em = emf.createEntityManager();


        FieldAccessPropStratsEntity fa = new FieldAccessPropStratsEntity();
        
        // Load all persistent fields
        EmbedId eid = new EmbedId();
        eid.setId(new Random().nextInt());
        eid.setCode("IdCode");        
        fa.setEmbedId(eid); // embedded id
        
        Collection<EmbedPropAccess> elc = new ArrayList<EmbedPropAccess>();
        EmbedPropAccess epa1 = new EmbedPropAccess("George", "Washington");
        EmbedPropAccess epa2 = new EmbedPropAccess("James", "Carter");
        elc.add(epa1);
        elc.add(epa2);                
        fa.setElementCollection(elc); // element collection of embeddables
        
        EmbedFieldAccess efa = new EmbedFieldAccess();
        efa.setFirstName("The");
        efa.setLastName("President");
        fa.setEmbedField(efa); // embedded
        
        fa.setName("FieldAccessPropStratsEntity");  // basic
        
        PropAccess propa = new PropAccess();
        propa.setStrProp("PropAccess");
        fa.setManyToOne(propa); // many to one
        
        Collection<FieldAccess> fac = new ArrayList<FieldAccess>();
        FieldAccess fae = new FieldAccess();
        fae.setStrField("FieldAccess");
        fac.add(fae);
        fa.setOneToMany(fac); // one to many
        
        PropAccess pa = new PropAccess();
        pa.setStrProp("PropAccess");
        fa.setOneToOne(pa); // one to one
       
        em.getTransaction().begin();
        em.persist(fa);
        em.getTransaction().commit();
        
        em.clear();
        // Verify list of persistent fields
        FieldAccessPropStratsEntity newpa = 
            em.find(FieldAccessPropStratsEntity.class, eid);
        assertNotNull(newpa);
        // simple key validation
        assertEquals(newpa.getEmbedId(), eid);


        // Verify the persistent member names
        MetaDataRepository mdr = 
            em.getConfiguration().getMetaDataRepositoryInstance();
        
        ClassMetaData cmd = mdr.getMetaData(FieldAccessPropStratsEntity.class, 
            null, true);
        // Assert expected persistent fields and properties were created
        assertNotNull(cmd.getField("eid"));
        assertNotNull(cmd.getField("elementCollection"));
        assertNotNull(cmd.getField("embedField"));
        assertNotNull(cmd.getField("version"));
        assertNotNull(cmd.getField("manyToOne"));
        assertNotNull(cmd.getField("oneToMany"));
        assertNotNull(cmd.getField("oneToOne"));
        assertNotNull(cmd.getField("manyToMany"));


        // Name has a matching getter/setter.  Make sure the access type
        // is property & not field
        assertNotNull(cmd.getField("name"));
        assertTrue((cmd.getField("name").getAccessType() & AccessCode.PROPERTY)
            == AccessCode.PROPERTY);


        // Assert mappings were not created for fields or properties which 
        // should not be persistent
        assertNull(cmd.getField("embedId"));
        assertNull(cmd.getField("m2one"));
        assertNull(cmd.getField("one2m"));
        assertNull(cmd.getField("one2one"));
        assertNull(cmd.getField("ecoll"));
        assertNull(cmd.getField("embed"));
        assertNull(cmd.getField("ver"));
        assertNull(cmd.getField("m2m"));
        
        em.close();
    }

View Full Code Here

    /**
     * Verifies the use of a map of embeddables containing a nested
     * mixed access embeddable. 
     */
    public void testMapWithNestedEmbeddable() {
        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        MenuItem mi = new MenuItem();
        mi.setName("PB & J Sandwich");
        
        Map<String, Ingredient> ingredients = new HashMap<String, Ingredient>();
        mi.setIngredients(ingredients);
        
        Ingredient i1 = new Ingredient("Peanut Butter");
        i1.setDescription("Edible brown paste, made from peanuts");
        Quantity q1 = new Quantity(1.0, "Tbsp");
        i1.setQuantity(q1);
        ingredients.put("Peanut Butter", i1);
        
        Ingredient i2 = new Ingredient("Jelly");
        i2.setDescription("Sweet gel, made from fruit");
        Quantity q2 = new Quantity(1.5, "Tbsp");
        i2.setQuantity(q2);
        ingredients.put("Jelly", i2);


        Ingredient i3 = new Ingredient("Bread");
        i3.setDescription("Baked material, made from flour and water");
        Quantity q3 = new Quantity(2.0, "Slice");
        i3.setQuantity(q3);
        ingredients.put("Bread", i3);


        em.getTransaction().begin();
        em.persist(mi);
        em.getTransaction().commit();
        em.clear();
        
        MenuItem mi2 = em.find(MenuItem.class, mi.getId());
        
        assertEquals(mi2.getId(), mi.getId());
        Map<String, Ingredient> ing2 = mi2.getIngredients();
        assertTrue(ing2.containsKey("Peanut Butter"));
        Quantity q = ing2.get("Peanut Butter").getQuantity();
        assertNotNull(q);
        assertEquals(1.0, q.getAmount());
        assertEquals("Tbsp", q.getUnitOfMeasure());
        assertTrue(ing2.containsKey("Jelly"));
        q = ing2.get("Jelly").getQuantity();
        assertNotNull(q);
        assertEquals(1.5, q.getAmount());
        assertEquals("Tbsp", q.getUnitOfMeasure());
        assertTrue(ing2.containsKey("Bread"));
        q = ing2.get("Bread").getQuantity();
        assertNotNull(q);
        assertEquals(2.0, q.getAmount());
        assertEquals("Slice", q.getUnitOfMeasure());


        em.remove(mi2);
        
        em.close();
    }

View Full Code Here

            boolean makeDirtyBeforeRefresh, boolean refreshFromDataCache, 
            String expected) {
        OpenJPAEntityManagerFactorySPI emf = (useDataCache)
            ? emfWithDataCache : emfWithoutDataCache;
        emf.getConfiguration().setRefreshFromDataCache(refreshFromDataCache);
        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        em.getTransaction().begin();
        PObject pc = new PObject();
        pc.setName(useDataCache ? MARKER_DATACACHE : MARKER_CACHE);
        em.persist(pc);
        em.getTransaction().commit();
        
        Object oid = pc.getId();
        StoreCache dataCache = emf.getStoreCache();
        assertEquals(useDataCache, dataCache.contains(PObject.class, oid));
        
        // Modify the record in the database in a separate transaction using
        // native SQL so that the in-memory instance is not altered 
        em.getTransaction().begin();
        String sql = "UPDATE L2_PObject SET NAME='" + MARKER_DATABASE
        + "' WHERE id=" + oid;
        em.createNativeQuery(sql).executeUpdate();
        em.getTransaction().commit();
        
        assertEquals(useDataCache ? MARKER_DATACACHE : MARKER_CACHE,
                pc.getName());
        
        em.getTransaction().begin();
        if (makeDirtyBeforeRefresh) {
            pc.setName(MARKER_DIRTY_CACHE);
        } 
        assertEquals(makeDirtyBeforeRefresh, em.isDirty(pc));


        if (lock != null) {
            ((EntityManagerImpl)em).getFetchPlan().setReadLockMode(lock);
        }
        em.refresh(pc);
        
        assertEquals(expected, pc.getName());
        em.getTransaction().commit();
    }

View Full Code Here

    public void verifyDeleteDetectionOnRefresh(boolean useDataCache, 
            boolean dirty, LockModeType lock, Class<?> expectedExceptionType) {
        OpenJPAEntityManagerFactorySPI emf = (useDataCache)
            ? emfWithDataCache : emfWithoutDataCache;
            
        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        em.getTransaction().begin();
        PObject pc = new PObject();
        pc.setName(useDataCache ? MARKER_DATACACHE : MARKER_CACHE);
        em.persist(pc);
        em.getTransaction().commit();
        
        Object oid = pc.getId();
        StoreCache dataCache = emf.getStoreCache();
        assertEquals(useDataCache, dataCache.contains(PObject.class, oid));
        
        // delete the record in the database in a separate transaction using
        // native SQL so that the in-memory instance is not altered 
        em.getTransaction().begin();
        String sql = "DELETE FROM L2_PObject WHERE id="+oid;
        em.createNativeQuery(sql).executeUpdate();
        em.getTransaction().commit();
        
        // the object cache does not know that the record was deleted
        assertTrue(em.contains(pc));
        // nor does the data cache
        assertEquals(useDataCache, dataCache.contains(PObject.class, oid));
        
        /**
         * refresh behavior no more depends on current lock. Refresh
         * will always attempt to fetch the instance from database 
         * raising EntityNotFoundException.
         *   
         */
        em.getTransaction().begin();
        em.getFetchPlan().setReadLockMode(lock);
        if (dirty) 
            pc.setName("Dirty Name");
        try {
            em.refresh(pc);
            if (expectedExceptionType != null) {
                fail("expected " + expectedExceptionType.getSimpleName() + 
                        " for PObject:" + oid);
            }
        } catch (Exception ex) {
            boolean expectedException = expectedExceptionType != null &&
                expectedExceptionType.isAssignableFrom(ex.getClass());
            if (!expectedException) {
                ex.printStackTrace();
                String error = (expectedExceptionType == null) 
                    ? "no exception" : expectedExceptionType.getName();
                fail("expected " + error + " for PObject:" + oid);
            }
        } finally {
            em.getTransaction().rollback();
        }
    }

View Full Code Here

     * entity, mappedsuperclass, and embeddable at the
     * class level.
     */
    public void testClassSpecifiedFieldAccess() {


        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        FieldAccess fa = new FieldAccess();
        // Set the persistent field through a misnamed setter         
        fa.setStringField("FieldAccess");
        
        em.getTransaction().begin();
        em.persist(fa);
        em.getTransaction().commit();
        em.clear();
        
        // This value of a persistent field was set using the setter
        // above, but this query will use the field name to verify that
        // field access is in use.
        Query qry = em.createNamedQuery("FieldAccess.query");
        qry.setParameter("id", fa.getId());
        qry.setParameter("strVal", "FieldAccess");
        FieldAccess fa2 = (FieldAccess)qry.getSingleResult();
        assertEquals(fa.getId(), fa2.getId());
        
        em.close();
    }

View Full Code Here

     * entity, mappedsuperclass, and embeddable at the
     * class level.
     */
    public void testClassSpecifiedPropertyAccess() {


        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        PropAccess pa = new PropAccess();
        // Set the persistent field through a misnamed setter         
        pa.setStrProp("PropertyAccess");
        
        em.getTransaction().begin();
        em.persist(pa);
        em.getTransaction().commit();
        em.clear();
        
        // This value of a persistent field was set using the setter
        // above, but this query will use the field name to verify that
        // field access is in use.
        Query qry = em.createNamedQuery("PropertyAccess.query");
        qry.setParameter("id", pa.getId());
        qry.setParameter("strVal", "PropertyAccess");
        PropAccess pa2 = (PropAccess)qry.getSingleResult();
        assertEquals(pa, pa2);
        em.close();
    }

View Full Code Here

     * defined at the class level and field access defined
     * on specific methods. 
     */    
    public void testClassSpecifiedMixedSinglePCFieldAccess() {


        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        DefFieldMixedPropAccess dfmpa = new DefFieldMixedPropAccess();
        // Call non-PC setter
        dfmpa.setStrField("NonPCSetter");
        // Call setter with property access
        dfmpa.setStringField("DFMPA");
        
        em.getTransaction().begin();
        em.persist(dfmpa);
        em.getTransaction().commit();
        em.clear();
        
        // This value of a persistent property was set using the setter
        // above, but this query will use the property name to verify that
        // propety access is in use.
        Query qry = em.createNamedQuery("DFMPA.query");
        qry.setParameter("id", dfmpa.getId());
        qry.setParameter("strVal", "DFMPA");
        DefFieldMixedPropAccess dfmpa2 = 
            (DefFieldMixedPropAccess)qry.getSingleResult();
        assertEquals(dfmpa, dfmpa2);
        assertEquals(dfmpa2.getStringField(), "DFMPA");


        try {
            qry = em.createNamedQuery("DFMPA.badQuery");
            qry.setParameter("id", dfmpa.getId());
            qry.setParameter("strVal", "DFMPA");
            qry.getSingleResult();
            fail("Usage of this query should have thrown an exception");
        }
        catch (Exception e) {
            assertExceptionMessage(e, ArgumentException.class,
                "No field named \"strField\" in \"DefFieldMixedPropAccess\"",
                "[id, stringField, version]");
        }


        em.close();
    }

View Full Code Here

    public void overridePropertyOnEM(String name, String value) {
        // use the default JndiName for the base EntityManagerFactory
        OpenJPAEntityManagerFactorySPI emf1 = (OpenJPAEntityManagerFactorySPI)getEmf(name, defaultJndiName);
        assertNotNull(emf1);
        try {
            OpenJPAEntityManagerSPI em = emf1.createEntityManager();
            assertNotNull(em);


            EntityManager em1 = getEm(emf1, name, value);
            assertNotNull(em1);


            // 'prove' that we're using a different database by inserting the same row
            em.getTransaction().begin();
            em.persist(new Person(1, "em"));
            em.getTransaction().commit();


            em1.getTransaction().begin();
            em1.persist(new Person(1, "em1"));
            em1.getTransaction().commit();


            em.clear();
            em1.clear();


            Person p = em.find(Person.class, 1);
            Person p1 = em1.find(Person.class, 1);
            assertNotSame(p, p1);
            assertEquals("em", p.getName());
            assertEquals("em1", p1.getName());


            em.clear();
            em1.clear();


            // make sure inserting the same row again fails.
            em.getTransaction().begin();
            em.persist(new Person(1));
            try {
                em.getTransaction().commit();
                fail("Should not be able to commit the same row a second time");
            } catch (RollbackException rbe) {
                assertTrue("Expected EntityExistsException but found " + rbe.getCause(),
                    rbe.getCause() instanceof EntityExistsException);
                // expected
            }


            em1.getTransaction().begin();
            em1.persist(new Person(1));
            try {
                em1.getTransaction().commit();
                fail("Should not be able to commit the same row a second time");
            } catch (RollbackException rbe) {
                assertTrue(rbe.getCause() instanceof EntityExistsException);
                // expected
            }
            em.close();
            em1.close();
        } finally {
            closeEMF(emf1);
        }
    }

View Full Code Here

     * defined at the class level and property access defined
     * on specific methods. 
     */    
    public void testClassSpecifiedMixedSinglePCPropertyAccess() {


        OpenJPAEntityManagerSPI em = emf.createEntityManager();
        
        DefPropMixedFieldAccess dpmfa = new DefPropMixedFieldAccess();
        // Call setter with underlying field access
        dpmfa.setStrProp("DPMFA");
        
        em.getTransaction().begin();
        em.persist(dpmfa);
        em.getTransaction().commit();
        em.clear();
        
        // This value of a persistent field was set using the setter
        // above, but this query will use the property name to verify that
        // propety access is in use.
        Query qry = em.createNamedQuery("DPMFA.query");
        qry.setParameter("id", dpmfa.getId());
        qry.setParameter("strVal", "DPMFA");
        DefPropMixedFieldAccess dpmfa2 = 
            (DefPropMixedFieldAccess)qry.getSingleResult();
        assertEquals(dpmfa, dpmfa2);
        assertEquals(dpmfa2.getStrProp(), "DPMFA");


        try {
            qry = em.createNamedQuery("DPMFA.badQuery");
            qry.setParameter("id", dpmfa.getId());
            qry.setParameter("strVal", "DPMFA");
            qry.getSingleResult();
            fail("Usage of this query should have thrown an exception");
        }
        catch (Exception e) {
            assertExceptionMessage(e, ArgumentException.class,
                "No field named \"strProp\" in \"DefPropMixedFieldAccess\"",
                "[id, strField, version]");
        }


        em.close();
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.openjpa.persistence.OpenJPAEntityManagerSPI

org.apache.openejb.core.cmp.jpa.JpaCmpEngine

org.apache.openjpa.instrumentation.TestInstrumentationProvider

org.apache.openjpa.integration.jmx.TestJMXPlatformMBeans

org.apache.openjpa.jdbc.kernel.TestJDBCStoreOptSelect

org.apache.openjpa.persistence.access.TestDefaultAccess

org.apache.openjpa.persistence.access.TestExplicitAccess

org.apache.openjpa.persistence.access.xml.TestXMLExplicitAccess

org.apache.openjpa.persistence.cache.jpa.AbstractCacheModeTestCase

org.apache.openjpa.persistence.conf.TestOverrideNonJtaDataSource

org.apache.openjpa.persistence.conf.TestSwitchConnection

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.