Examples with Dealer org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer used on opensource projects

Example 1 with Dealer

use of org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer in project eclipselink by eclipse-ee4j.

the class EntityMappingsAdvancedJUnitTestCase method testUnidirectionalTargetLocking_AddRemoveTarget.

public void testUnidirectionalTargetLocking_AddRemoveTarget() {
    String lastName = "testUnidirectionalTargetLocking_ART";
    EntityManager em = createEntityManager();
    // persist employees
    List<Employee> employeesPersisted = persistEmployeesWithUnidirectionalMappings(lastName, em);
    // remove a dealer from the second employee:
    Dealer dealer;
    beginTransaction(em);
    try {
        Employee emp1 = em.find(Employee.class, employeesPersisted.get(1).getId());
        dealer = emp1.getDealers().remove(1);
        commitTransaction(em);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    String errorMsg = "";
    // verify the version both in the cache and in the db
    int version2 = getVersion(em, dealer);
    if (version2 != 2) {
        errorMsg += "In the cache the removed dealer's version is " + version2 + " (2 was expected); ";
    }
    // add the dealer to the first employee:
    // version2 = getDealerVersionFromDB(em, dealer);
    beginTransaction(em);
    try {
        Dealer dealer2 = em.find(Dealer.class, dealer.getId());
        em.refresh(dealer2);
        version2 = getVersion(em, dealer2);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
        }
    }
    if (version2 != 2) {
        errorMsg += "In the db the removed dealer's version is " + version2 + " (2 was expected); ";
    }
    beginTransaction(em);
    Dealer dealer3;
    try {
        Employee emp2 = em.find(Employee.class, employeesPersisted.get(1).getId());
        dealer3 = em.find(Dealer.class, dealer.getId());
        emp2.getDealers().add(dealer3);
        commitTransaction(em);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    // verify the version both in the cache and in the db
    int version3 = getVersion(em, dealer3);
    if (version3 != 3) {
        errorMsg += "In the cache the added dealer's version is " + version3 + " (3 was expected); ";
    }
    beginTransaction(em);
    try {
        Dealer dealer4 = em.find(Dealer.class, dealer3.getId());
        em.refresh(dealer4);
        version3 = getVersion(em, dealer4);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
        }
    }
    if (version3 != 3) {
        errorMsg += "In the db the added dealer's version is " + version3 + " (3 was expected)";
    }
    closeEntityManager(em);
    // clean-up
    deleteEmployeesWithUnidirectionalMappings(lastName);
    // non-empty error message means the test has failed
    if (errorMsg.length() > 0) {
        fail(errorMsg);
    }
}

Example 2 with Dealer

use of org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer in project eclipselink by eclipse-ee4j.

the class EntityMappingsAdvancedJUnitTestCase method testUnidirectionalUpdate.

public void testUnidirectionalUpdate() {
    String lastName = "testUnidirectionalUpdate";
    // em used for both persist and update
    EntityManager em = createEntityManager();
    // persist employees
    List<Employee> employeesPersisted = persistEmployeesWithUnidirectionalMappings(lastName, em);
    // update persisted employees:
    beginTransaction(em);
    try {
        // add a new dealer to the first employee
        employeesPersisted.get(0).addDealer(new Dealer("New", lastName));
        // remove a dealer from the second employee
        employeesPersisted.get(1).getDealers().remove(1);
        // move a dealer from the first to the second employee
        employeesPersisted.get(1).addDealer(employeesPersisted.get(0).getDealers().remove(0));
        commitTransaction(em);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
    }
    // clear cache
    clearCache();
    em = createEntityManager();
    // read the updated employees back
    List<Employee> employeesRead = em.createQuery("SELECT OBJECT(e) FROM XMLEmployee e WHERE e.lastName = '" + lastName + "'").getResultList();
    // while em is open, cache ServerSession that will be used later for verification
    DatabaseSessionImpl session = getDatabaseSession();
    // verify number persisted and read is the same
    if (employeesPersisted.size() != employeesRead.size()) {
        // clean-up
        deleteEmployeesWithUnidirectionalMappings(lastName);
        fail("Updated " + employeesPersisted.size() + " employees, but read back " + employeesRead.size());
    }
    // verify that the persisted and read objects are equal
    beginTransaction(em);
    String errorMsg = "";
    try {
        for (int i = 0; i < employeesPersisted.size(); i++) {
            for (int j = 0; j < employeesRead.size(); j++) {
                Employee emp1 = em.find(Employee.class, employeesPersisted.get(i).getId());
                Employee emp2 = em.find(Employee.class, employeesRead.get(j).getId());
                if (emp1.getFirstName().equals(emp2.getFirstName())) {
                    if (!session.compareObjects(emp1, emp2)) {
                        errorMsg += "Employee " + emp1.getFirstName() + "  was not updated correctly.";
                    }
                }
            }
        }
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
    }
    // clean-up
    deleteEmployeesWithUnidirectionalMappings(lastName);
    // non-empty error message means the test has failed
    if (errorMsg.length() > 0) {
        fail(errorMsg);
    }
}

Example 3 with Dealer

use of org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer in project eclipselink by eclipse-ee4j.

the class EntityManagerJUnitTestSuite method testSequencePreallocationUsingCallbackTest.

/**
 * Test that sequence numbers allocated but unused in the transaction
 * kept after transaction commits
 * in case SequencingCallback used (that happens if TableSequence is used without
 * using sequencing connection pool).
 */
public void testSequencePreallocationUsingCallbackTest() {
    // setup
    SessionBroker broker = getSessionBroker();
    for (int i = 1; i <= 3; i++) {
        Class<?> cls;
        if (i == 1) {
            // defined in member_1
            cls = Customer.class;
        } else if (i == 2) {
            // defined in member_2
            cls = Employee.class;
        } else {
            // defined in member_3
            cls = Dealer.class;
        }
        ServerSession ss = (ServerSession) broker.getSessionForClass(cls);
        // make sure the sequence has both preallocation and callback
        // (the latter means not using sequencing connection pool,
        // acquiring values before insert and requiring transaction).
        // if(ss.getSequencingControl().shouldUseSeparateConnection()) {
        // fail("setup failure: the test requires serverSession.getSequencingControl().shouldUseSeparateConnection()==false");
        // }
        String seqName = ss.getDescriptor(cls).getSequenceNumberName();
        Sequence sequence = ss.getLogin().getSequence(seqName);
        if (sequence.getPreallocationSize() < 2) {
            fail("setup failure for sequence " + seqName + ": the test requires sequence preallocation size greater than 1");
        }
        if (sequence.shouldAcquireValueAfterInsert()) {
            fail("setup failure for sequence " + seqName + ": the test requires sequence that acquires value before insert, like TableSequence");
        }
        if (!sequence.shouldUseTransaction()) {
            fail("setup failure for sequence " + seqName + ": the test requires sequence that uses transaction, like TableSequence");
        }
        // clear all already allocated sequencing values for seqName
        ss.getSequencingControl().initializePreallocated(seqName);
    }
    // test
    EntityManager em = createEntityManager();
    beginTransaction(em);
    Customer customer1 = new Customer();
    customer1.setFirstName("testSequencePreallocation");
    customer1.setLastName("1");
    Employee employee1 = new Employee();
    employee1.setFirstName("testSequencePreallocation");
    employee1.setLastName("1");
    Dealer dealer1 = new Dealer();
    dealer1.setFirstName("testSequencePreallocation");
    dealer1.setLastName("1");
    em.persist(customer1);
    em.persist(employee1);
    em.persist(dealer1);
    int assignedSequenceNumber_Customer = customer1.getId();
    int assignedSequenceNumber_Employee = employee1.getId();
    int assignedSequenceNumber_Dealer = dealer1.getId();
    commitTransaction(em);
    // verify
    em = createEntityManager();
    beginTransaction(em);
    Customer customer2 = new Customer();
    customer2.setFirstName("testSequencePreallocation");
    customer2.setLastName("2");
    Employee employee2 = new Employee();
    employee2.setFirstName("testSequencePreallocation");
    employee2.setLastName("2");
    Dealer dealer2 = new Dealer();
    dealer2.setFirstName("testSequencePreallocation");
    dealer2.setLastName("2");
    em.persist(customer2);
    em.persist(employee2);
    em.persist(dealer2);
    int nextSequenceNumber_Customer = customer2.getId();
    int nextSequenceNumber_Employee = employee2.getId();
    int nextSequenceNumber_Dealer = dealer2.getId();
    // only need nextSequenceNumber, no need to commit
    rollbackTransaction(em);
    // cleanup
    // remove the object that has been created in setup
    em = createEntityManager();
    beginTransaction(em);
    customer1 = em.find(Customer.class, assignedSequenceNumber_Customer);
    employee1 = em.find(Employee.class, assignedSequenceNumber_Employee);
    dealer1 = em.find(Dealer.class, assignedSequenceNumber_Dealer);
    em.remove(customer1);
    em.remove(employee1);
    em.remove(dealer1);
    commitTransaction(em);
    // report result
    String errorMsg = "";
    if (assignedSequenceNumber_Customer + 1 != nextSequenceNumber_Customer) {
        errorMsg += "Customer: Transaction that assigned sequence number committed, assignedSequenceNumber = " + assignedSequenceNumber_Customer + ", but nextSequenceNumber = " + nextSequenceNumber_Customer + "(" + (assignedSequenceNumber_Customer + 1) + " was expected)\n";
    }
    if (assignedSequenceNumber_Employee + 1 != nextSequenceNumber_Employee) {
        errorMsg += "Employee: Transaction that assigned sequence number committed, assignedSequenceNumber = " + assignedSequenceNumber_Employee + ", but nextSequenceNumber = " + nextSequenceNumber_Employee + "(" + (assignedSequenceNumber_Employee + 1) + " was expected)\n";
    }
    if (assignedSequenceNumber_Dealer + 1 != nextSequenceNumber_Dealer) {
        errorMsg += "Dealer: Transaction that assigned sequence number committed, assignedSequenceNumber = " + assignedSequenceNumber_Dealer + ", but nextSequenceNumber = " + nextSequenceNumber_Dealer + "(" + (assignedSequenceNumber_Dealer + 1) + " was expected)\n";
    }
    if (errorMsg.length() > 0) {
        errorMsg = "\n" + errorMsg;
        fail(errorMsg);
    }
}

Example 4 with Dealer

use of org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer in project eclipselink by eclipse-ee4j.

the class EntityMappingsAdvancedJUnitTestCase method testUnidirectionalTargetLocking_DeleteSource.

public void testUnidirectionalTargetLocking_DeleteSource() {
    String lastName = "testUnidirectionalTargetLocking_DS";
    // persist employees (there should be two of them)
    List<Employee> persistedEmployees = persistEmployeesWithUnidirectionalMappings(lastName);
    // cache their dealers' ids
    ArrayList<Integer> dealersIds = new ArrayList<Integer>();
    for (int i = 0; i < persistedEmployees.size(); i++) {
        Employee emp = persistedEmployees.get(i);
        for (int j = 0; j < emp.getDealers().size(); j++) {
            dealersIds.add(emp.getDealers().get(j).getId());
        }
    }
    // clear cache
    clearCache();
    EntityManager em = createEntityManager();
    beginTransaction(em);
    // read the persisted employees
    List<Employee> readEmployees = em.createQuery("SELECT OBJECT(e) FROM XMLEmployee e WHERE e.lastName = '" + lastName + "'").getResultList();
    // trigger indirection on the second employee's dealers
    readEmployees.get(1).getDealers().size();
    try {
        for (Employee emp : readEmployees) {
            em.remove(emp);
        }
        commitTransaction(em);
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    // find employees' dealers and verify their versions - all should be 2.
    beginTransaction(em);
    String errorMsg = "";
    try {
        for (int i = 0; i < dealersIds.size(); i++) {
            Dealer dealer = em.find(Dealer.class, dealersIds.get(i));
            // verify the version both in the cache and in the db
            int version2 = getVersion(em, dealer);
            if (version2 != 2) {
                errorMsg += "In the cache dealer " + dealer.getFirstName() + "'s version is " + version2 + " (2 was expected); ";
            }
            em.refresh(dealer);
            version2 = getVersion(em, dealer);
            if (version2 != 2) {
                errorMsg += "In the db dealer " + dealer.getFirstName() + "'s version is " + version2 + " (2 was expected); ";
            }
        }
    } finally {
        if (this.isTransactionActive(em)) {
            rollbackTransaction(em);
        }
    }
    closeEntityManager(em);
    // clean-up
    deleteEmployeesWithUnidirectionalMappings(lastName);
    // non-empty error message means the test has failed
    if (errorMsg.length() > 0) {
        fail(errorMsg);
    }
}

Example 5 with Dealer

use of org.eclipse.persistence.testing.models.jpa.xml.composite.advanced.member_3.Dealer in project eclipselink by eclipse-ee4j.

the class EntityMappingsAdvancedJUnitTestCase method createEmployeesWithUnidirectionalMappings.

protected List<Employee> createEmployeesWithUnidirectionalMappings(String lastName) {
    int n = 2;
    List<Employee> employees = new ArrayList<Employee>(n);
    for (int i = 0; i < n; i++) {
        Employee emp = new Employee();
        emp.setGivenName(Integer.toString(i + 1));
        emp.setFamilyName(lastName);
        employees.add(emp);
        for (int j = 0; j < n; j++) {
            Dealer dealer = new Dealer();
            dealer.setFirstName(emp.getFirstName() + "_" + (j + 1));
            dealer.setLastName(lastName);
            emp.addDealer(dealer);
            for (int k = 0; k < n; k++) {
                Customer customer = new Customer();
                customer.setFirstName(dealer.getFirstName() + "_" + (k + 1));
                customer.setLastName(lastName);
                dealer.addCustomer(customer);
            }
        }
    }
    return employees;
}