Examples with Order org.eclipse.persistence.testing.models.jpa.relationships.Order used on opensource projects

Example 1 with Order

use of org.eclipse.persistence.testing.models.jpa.relationships.Order in project eclipselink by eclipse-ee4j.

the class JUnitJPQLExamplesTestSuite method getOrderForCustomer.

public void getOrderForCustomer() {
    EntityManager em = createEntityManager();
    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause = builder.get("name").equal("Jane Smith");
    ReadAllQuery raq = new ReadAllQuery(Customer.class);
    raq.setSelectionCriteria(whereClause);
    Customer expectedCustomer = (Customer) (((List) getServerSession().executeQuery(raq)).get(0));
    SalesPerson salesPerson = ((Order) (expectedCustomer.getOrders().iterator().next())).getSalesPerson();
    String ejbqlString = "SELECT DISTINCT c FROM Customer c JOIN c.orders o JOIN o.salesPerson s WHERE s.id = " + salesPerson.getId();
    List firstResult = em.createQuery(ejbqlString).getResultList();
    String alternateEjbqlString = "SELECT DISTINCT c FROM Customer c, IN(c.orders) o WHERE o.salesPerson.id = " + salesPerson.getId();
    List secondResuslt = em.createQuery(alternateEjbqlString).getResultList();
    // only 1 order for this customer
    Assert.assertEquals("Get order for customer test failed: data validation error", firstResult.size(), 1);
    Assert.assertTrue("Get order for customer test failed: two equivalent ejb queries return different results", comparer.compareObjects(secondResuslt, firstResult));
    Assert.assertTrue("Get order for customer test failed", comparer.compareObjects(expectedCustomer, firstResult));
}

Example 2 with Order

use of org.eclipse.persistence.testing.models.jpa.relationships.Order in project eclipselink by eclipse-ee4j.

the class RelationshipModelJUnitTestSuite method testOne2OneRelationTables.

/**
 * This tests a couple scenarios:
 * - 1-M mapped by a M-1 using a JoinTable
 * - 1-1 mapped using a JoinTable (uni-directional)
 * - 1-1 mapped using a JoinTable (bi-directional)
 */
public void testOne2OneRelationTables() {
    EntityManager em = createEntityManager();
    beginTransaction(em);
    Order order1 = new Order();
    Order order2 = new Order();
    Auditor auditor = new Auditor();
    try {
        OrderCard order1Card = new OrderCard();
        OrderLabel order1Label = new OrderLabel();
        order1Label.setDescription("I describe order 1");
        order1.setOrderLabel(order1Label);
        order1.setOrderCard(order1Card);
        em.persist(order1);
        OrderCard order2Card = new OrderCard();
        OrderLabel order2Label = new OrderLabel();
        order2Label.setDescription("I describe order 2");
        order2.setOrderLabel(order2Label);
        order2.setOrderCard(order2Card);
        em.persist(order2);
        auditor.setName("Guillaume");
        auditor.addOrder(order1);
        auditor.addOrder(order2);
        em.persist(auditor);
        commitTransaction(em);
    } catch (RuntimeException e) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw e;
    }
    closeEntityManager(em);
    clearCache();
    em = createEntityManager();
    Auditor refreshedAuditor = em.find(Auditor.class, auditor.getId());
    Order refreshedOrder1 = em.find(Order.class, order1.getOrderId());
    Order refreshedOrder2 = em.find(Order.class, order2.getOrderId());
    assertTrue("Auditor read back did not match the original", getServerSession().compareObjects(auditor, refreshedAuditor));
    assertTrue("Order1 read back did not match the original", getServerSession().compareObjects(order1, refreshedOrder1));
    assertTrue("Order2 read back did not match the original", getServerSession().compareObjects(order2, refreshedOrder2));
    closeEntityManager(em);
}

Example 3 with Order

use of org.eclipse.persistence.testing.models.jpa.relationships.Order in project eclipselink by eclipse-ee4j.

the class RelationshipModelJUnitTestSuite method testNamedQueryWithArgumentsTest.

// Bug#4646580 Query arguments are added in EJBQL
public void testNamedQueryWithArgumentsTest() {
    Integer[] cusIDs = new Integer[3];
    Integer[] orderIDs = new Integer[3];
    Integer[] itemIDs = new Integer[3];
    Exception exception = null;
    List list = null;
    Customer cusClone1 = RelationshipsExamples.customerExample1();
    Item item1 = RelationshipsExamples.itemExample1();
    Order order1 = RelationshipsExamples.orderExample1();
    order1.setCustomer(cusClone1);
    order1.setItem(item1);
    EntityManager em = createEntityManager();
    try {
        beginTransaction(em);
        em.persist(cusClone1);
        em.persist(order1);
        commitTransaction(em);
        cusIDs[0] = cusClone1.getCustomerId();
        orderIDs[0] = order1.getOrderId();
        itemIDs[0] = item1.getItemId();
        clearCache();
        try {
            ServerSession ss = getServerSession();
            Vector vec = new Vector();
            vec.add(itemIDs[0]);
            list = (List) ss.executeQuery("findAllOrdersByItem", vec);
        } catch (Exception ex) {
            exception = ex;
        }
        beginTransaction(em);
        Customer cus1 = em.find(Customer.class, cusIDs[0]);
        em.remove(cus1);
        Order ord1 = em.find(Order.class, orderIDs[0]);
        em.remove(ord1);
        Item it1 = em.find(Item.class, itemIDs[0]);
        em.remove(it1);
        commitTransaction(em);
    } finally {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
    }
    if (exception != null) {
        fail("An exception is thrown: " + exception);
    }
    if (list.size() != 1) {
        fail("One order is expected but " + list.size() + " was returned");
    }
}

Example 4 with Order

use of org.eclipse.persistence.testing.models.jpa.relationships.Order in project eclipselink by eclipse-ee4j.

the class RelationshipModelJUnitTestSuite method testChangeSetForNewObject.

// Bug 357103
public void testChangeSetForNewObject() {
    EntityManager em = createEntityManager();
    beginTransaction(em);
    Customer cust = new Customer();
    cust.setName("Joe");
    em.persist(cust);
    Order order = new Order();
    order.setQuantity(1);
    em.persist(order);
    cust.addOrder(order);
    commitTransaction(em);
    RepeatableWriteUnitOfWork uow = null;
    try {
        beginTransaction(em);
        cust = em.find(Customer.class, cust.getCustomerId());
        Order order2 = new Order();
        order2.setQuantity(2);
        order2.setShippingAddress("123 Main St.");
        em.persist(order2);
        cust.addOrder(order2);
        EntityManagerImpl impl = (EntityManagerImpl) JpaHelper.getEntityManager(em);
        uow = impl.getActivePersistenceContext(null);
        em.flush();
        UnitOfWorkChangeSet uowChangeSet = uow.getCumulativeUOWChangeSet();
        ObjectChangeSet customerChangeSet = uowChangeSet.getCloneToObjectChangeSet().get(cust);
        CollectionChangeRecord orderChangeRecord = (CollectionChangeRecord) customerChangeSet.getChangesForAttributeNamed("orders");
        Iterator<ObjectChangeSet> i = orderChangeRecord.getAddObjectList().keySet().iterator();
        while (i.hasNext()) {
            ObjectChangeSet orderChangeSet = i.next();
            assertTrue("There are changes in the change set.  There should be no changes for a new object.", orderChangeSet.getChanges().isEmpty());
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rollbackTransaction(em);
        beginTransaction(em);
        cust = em.find(Customer.class, cust.getCustomerId());
        em.remove(cust);
        commitTransaction(em);
    }
}