Examples with DependentHolder org.jpox.samples.dependentfield.DependentHolder used on opensource projects

Example 6 with DependentHolder

use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.

the class DependentFieldTest method testInterfaceDependentFields.

/**
 * Test of dependent fields using interface 1-1 relationship.
 * @throws Exception
 */
public void testInterfaceDependentFields() throws Exception {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        try {
            tx.begin();
            DependentHolder holder1 = new DependentHolder(101, "Holder 1");
            DepInterfaceImpl1 impl1 = new DepInterfaceImpl1("Impl1", 23);
            holder1.setIntf(impl1);
            DependentHolder holder2 = new DependentHolder(102, "Holder 2");
            DepInterfaceImpl2 impl2 = new DepInterfaceImpl2("Impl2", 56.7);
            holder2.setIntf(impl2);
            pm.makePersistent(holder1);
            pm.makePersistent(holder2);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while creating interface dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the numbers of objects created
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            Query q = pm.newQuery(DependentHolder.class);
            List results = (List) q.execute();
            assertEquals("Number of DepInterfaceHolder objects created is incorrect", results.size(), 2);
            q = pm.newQuery(DepInterfaceImpl1.class);
            results = (List) q.execute();
            assertEquals("Number of DepInterfaceImpl1 objects created is incorrect", results.size(), 1);
            q = pm.newQuery(DepInterfaceImpl2.class);
            results = (List) q.execute();
            assertEquals("Number of DepInterfaceImpl2 objects created is incorrect", results.size(), 1);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while checking interface dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Try to delete the implementations (checks if any FKs are created)
        if (storeMgr.getSupportedOptions().contains(StoreManager.OPTION_ORM_FOREIGN_KEYS)) {
            pm = pmf.getPersistenceManager();
            tx = pm.currentTransaction();
            try {
                tx.begin();
                Query q = pm.newQuery(DepInterfaceImpl2.class);
                List results = (List) q.execute();
                Iterator resultsIter = results.iterator();
                while (resultsIter.hasNext()) {
                    DepInterfaceImpl2 sq = (DepInterfaceImpl2) resultsIter.next();
                    pm.deletePersistent(sq);
                }
                tx.commit();
                fail("Managed to delete a DepInterfaceImpl2 object that was referenced by another object. " + "This should not have happened due to FK constraints. Maybe this RDBMS doesnt manage FKs correctly, or not an RDBMS?");
            } catch (Exception e) {
            // Should come through here since it should throw an exception due to FK constraints
            } finally {
                if (tx.isActive()) {
                    tx.rollback();
                }
                pm.close();
            }
        }
        // Delete the holders. This *should* delete the Shapes as well
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            Query q = pm.newQuery(DependentHolder.class);
            List results = (List) q.execute();
            Iterator resultsIter = results.iterator();
            while (resultsIter.hasNext()) {
                DependentHolder holder = (DependentHolder) resultsIter.next();
                pm.deletePersistent(holder);
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while deleting interface dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the numbers of objects persisted
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            Query q = pm.newQuery(DependentHolder.class);
            List results = (List) q.execute();
            assertEquals("Number of DepInterfaceHolder objects persisted is incorrect", results.size(), 0);
            q = pm.newQuery(DepInterfaceImpl1.class);
            results = (List) q.execute();
            assertEquals("Number of DepInterfaceImpl1 objects persisted is incorrect", results.size(), 0);
            q = pm.newQuery(DepInterfaceImpl2.class);
            results = (List) q.execute();
            assertEquals("Number of DepInterfaceImpl2 objects persisted is incorrect", results.size(), 0);
            tx.commit();
        } catch (Exception e) {
            LOG.error("Exception in test", e);
            fail("Exception thrown while checking interface dependent objects : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clearDependentData(pmf);
    }
}

Example 7 with DependentHolder

use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.

the class DependentFieldTest method testRemoveDependentFieldOnDetached.

/**
 * Test of the nulling of a 1-1 relation whilst detached and then re-attaching the relation.
 * Should result in the deletion of the dependent element.
 */
public void testRemoveDependentFieldOnDetached() {
    try {
        // Create the objects
        DependentHolder holder = new DependentHolder(0, "field0");
        DependentElement dependent = new DependentElement(0, "el" + 0);
        holder.setElement(dependent);
        Object holderId = null;
        Object elementId = null;
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        try {
            // Persist the objects
            tx.begin();
            pm.makePersistent(holder);
            tx.commit();
            holderId = pm.getObjectId(holder);
            elementId = pm.getObjectId(dependent);
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            // Detach the field object
            tx.begin();
            DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
            DependentHolder detached = (DependentHolder) pm.detachCopy(loaded);
            tx.commit();
            // Nullify the relation
            detached.setElement(null);
            // Attach the changes. This operation should remove the dependent element
            tx.begin();
            pm.makePersistent(detached);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the results
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
            // Check that the dependent field is null
            assertNull(loaded.getElement());
            // Check that the dependent element has been removed.
            try {
                DependentElement retrievedElement = (DependentElement) pm.getObjectById(elementId);
                if (retrievedElement != null) {
                    fail("Dependent field hasnt been deleted yet should have been since it is dependent and was removed from the 1-1 Relation");
                }
            } catch (JDOObjectNotFoundException e) {
            // Expected result
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clearDependentData(pmf);
    }
}

Example 8 with DependentHolder

use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.

the class DependentFieldTest method runTestDependentFieldsInverse.

public void runTestDependentFieldsInverse(int testType) {
    try {
        Object[] element = new Object[(COLLECTION_SIZE * 4) + 1];
        Object[] elementObjectId = new Object[(COLLECTION_SIZE * 4) + 1];
        boolean[] expectedDelete = new boolean[(COLLECTION_SIZE * 4) + 1];
        initElementsForInverse(element, testType);
        PersistenceManager pm = pmf.getPersistenceManager();
        Object fieldObjectId;
        DependentHolder loaded;
        try {
            // ---------------------------------------------------------------------
            // prepare data
            // ---------------------------------------------------------------------
            DependentHolder holder = new DependentHolder(0, "field0");
            holder.setElement((DependentElement) element[0]);
            prepareDataForInverse(holder, element, expectedDelete, testType);
            pm.currentTransaction().begin();
            pm.makePersistent(holder);
            pm.currentTransaction().commit();
            fieldObjectId = pm.getObjectId(holder);
            for (int i = 0; i < elementObjectId.length; i++) {
                elementObjectId[i] = pm.getObjectId(element[i]);
            }
            // ---------------------------------------------------------------------
            // verify data
            // ---------------------------------------------------------------------
            pm.currentTransaction().begin();
            loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            verifyDataForInverse(loaded, testType);
            // ---------------------------------------------------------------------
            // delete data
            // ---------------------------------------------------------------------
            pm.deletePersistent(loaded);
            pm.currentTransaction().commit();
            // ---------------------------------------------------------------------
            // tests: check owner is deleted
            // ---------------------------------------------------------------------
            pm.currentTransaction().begin();
            boolean success = false;
            try {
                success = false;
                loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            } catch (JDOObjectNotFoundException ex) {
                success = true;
            } finally {
                if (!success) {
                    fail("field should have been deleted");
                }
            }
            // ---------------------------------------------------------------------
            for (int i = 0; i < elementObjectId.length; i++) {
                if (elementObjectId[i] != null) {
                    try {
                        success = false;
                        pm.getObjectById(elementObjectId[i], true);
                        if (!expectedDelete[i]) {
                            success = true;
                        }
                    } catch (JDOObjectNotFoundException ex) {
                        if (expectedDelete[i]) {
                            success = true;
                        }
                    } finally {
                        if (!success && expectedDelete[i]) {
                            fail("dependent field " + i + " should have been deleted.");
                        } else if (!success && !expectedDelete[i]) {
                            fail("dependent field " + i + " should have not been deleted.");
                        }
                    }
                }
            }
            pm.currentTransaction().commit();
        } finally {
            if (pm.currentTransaction().isActive()) {
                pm.currentTransaction().rollback();
            }
            pm.close();
        }
    } finally {
        // Clean out our data
        clearDependentData(pmf);
    }
}

Example 9 with DependentHolder

use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.

the class DependentFieldTest method testNullifyNonPersistent1to1Relation.

/**
 * Test the nullification of a 1-1 relation marked as dependent, when the value is a transient PC.
 */
public void testNullifyNonPersistent1to1Relation() {
    try {
        Object holderId = null;
        // Persist the objects
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        try {
            DependentHolder field = new DependentHolder(0, "field0");
            // Persist the objects
            tx.begin();
            pm.makePersistent(field);
            tx.commit();
            holderId = pm.getObjectId(field);
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Retrieve the object, set a transient PC and nullify the element
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            // This operation should remove the dependent element
            tx.begin();
            DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
            DependentElement dependent = new DependentElement(0, "el" + 0);
            loaded.setElement(dependent);
            loaded.setElement(null);
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the results
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            // Check that the dependent field is empty
            DependentHolder loaded = (DependentHolder) pm.getObjectById(holderId, true);
            assertNull(loaded.getElement());
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        // Clean out our data
        clearDependentData(pmf);
    }
}

Example 10 with DependentHolder

use of org.jpox.samples.dependentfield.DependentHolder in project tests by datanucleus.

the class DependentFieldTest method testDependentElementsRemovalUsingForeignKey.

/**
 * test removal of dependent element from a set/list using ForeignKey.
 */
public void testDependentElementsRemovalUsingForeignKey() {
    try {
        DependentHolder field;
        Object fieldObjectId = null;
        Object[] elements = new Object[COLLECTION_SIZE * 4];
        Object[] elementObjectId = new Object[COLLECTION_SIZE * 4];
        boolean[] expectedDelete = new boolean[COLLECTION_SIZE * 4];
        field = new DependentHolder(200, "field200");
        int elementNumber = 0;
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement1(200 + i, "setDepElement" + i);
            field.getSetDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = true;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement2(200 + i, "setElement" + i);
            field.getSetNonDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = false;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement3(200 + i, "listDepElement" + i);
            field.getListDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = true;
        }
        for (int i = 0; i < COLLECTION_SIZE; i++) {
            elements[elementNumber] = new DependentElement4(200 + i, "listElement" + i);
            field.getListNonDependent2().add(elements[elementNumber]);
            expectedDelete[elementNumber++] = false;
        }
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        DependentHolder loaded;
        try {
            // Persist the objects
            tx.begin();
            pm.makePersistent(field);
            tx.commit();
            // Access the ids of the objects
            fieldObjectId = pm.getObjectId(field);
            for (int i = 0; i < COLLECTION_SIZE * 4; i++) {
                elementObjectId[i] = pm.getObjectId(elements[i]);
            }
            tx.begin();
            loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            // make sure persistence is fine
            assertEquals(COLLECTION_SIZE, loaded.getSetDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getSetNonDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getListDependent2().size());
            assertEquals(COLLECTION_SIZE, loaded.getListNonDependent2().size());
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data using ForeignKey : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            // Remove the elements from each Set/List
            // This operation should remove the dependent elements and leave the non-dependent elements
            tx.begin();
            loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            elementNumber = 0;
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getSetDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getSetNonDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getListDependent2().remove(retrievedElement);
                elementNumber++;
            }
            for (int i = 0; i < COLLECTION_SIZE; i++) {
                Object retrievedElement = pm.getObjectById(elementObjectId[elementNumber]);
                loaded.getListNonDependent2().remove(retrievedElement);
                elementNumber++;
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field ForeignKey set/list data : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the results
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            // Check that the sets/lists are now empty
            loaded = (DependentHolder) pm.getObjectById(fieldObjectId, true);
            assertEquals(0, loaded.getSetDependent2().size());
            assertEquals(0, loaded.getSetNonDependent2().size());
            assertEquals(0, loaded.getListDependent2().size());
            assertEquals(0, loaded.getListNonDependent2().size());
            // Check that the dependent elements have been removed but not the non-dependent elements
            for (int i = 0; i < COLLECTION_SIZE * 4; i++) {
                try {
                    pm.getObjectById(elementObjectId[i]);
                    if (expectedDelete[i]) {
                        fail("Element " + i + " hasnt been deleted yet should have been since it is dependent and was removed from the ForeignKey set/list");
                    }
                } catch (JDOObjectNotFoundException e) {
                    if (!expectedDelete[i]) {
                        fail("Element " + i + " has been deleted yet should only have been nulled when being removed from the ForeignKey set/list");
                    }
                }
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            LOG.error(e);
            fail("Exception thrown while persisting dependent field data using ForeignKey : " + e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        // Clean out our data
        clearDependentData(pmf);
    }
}