Temporal Tests/src/tests/FullPersonWithEditionsQueries.java

/*******************************************************************************
 * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
 * accompanying materials are made available under the terms of the Eclipse
 * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
 * this distribution. The Eclipse Public License is available at
 * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
 * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
 * 
 * Contributors: dclarke - Bug 361016: Future Versions Examples
 ******************************************************************************/
package tests;

import static example.PersonModelExample.GOLF;
import static example.PersonModelExample.RUN;
import static example.PersonModelExample.SKI;
import static example.PersonModelExample.T1;
import static example.PersonModelExample.T2;
import static example.PersonModelExample.T3;
import static example.PersonModelExample.T4;
import static example.PersonModelExample.T5;
import static temporal.Effectivity.BOT;
import static temporal.Effectivity.EOT;

import java.sql.Date;
import java.util.List;

import javax.persistence.NoResultException;
import javax.persistence.TypedQuery;

import model.Address;
import model.Person;
import model.Phone;

import org.eclipse.persistence.jpa.JpaHelper;
import org.eclipse.persistence.sessions.CopyGroup;
import org.junit.Assert;
import org.junit.Test;

import temporal.BaseEntity;
import temporal.EditionSet;
import temporal.TemporalEntityManager;
import temporal.TemporalHelper;

/**
 * This test case performs current and edition queries on a simple
 * Person-Address-Phones model both illustrating and verifying query operations.
 * 
 * @author dclarke
 * @since EclipseLink 2.3.1
 */
public class FullPersonWithEditionsQueries extends FullPersonWithEditions {

    @Test
    public void queryAllCurrent() {
        TemporalEntityManager em = getEntityManager();
        List<Person> results = em.createQuery("SELECT p From Person p", Person.class).getResultList();

        System.out.println("QUERY CURRENT:");
        for (Person p : results) {
            System.out.println("\t>" + p);
        }

        Assert.assertEquals(1, results.size());

        Person currentperson = results.get(0);
        Assert.assertSame(currentperson, currentperson.getContinuity());
        Assert.assertEquals(getSample().getId(), currentperson.getId());
    }

    @Test
    public void findCurrent() {
        TemporalEntityManager em = getEntityManager();

        Person current = em.find(Person.class, getSample().getId());

        System.out.println("VERIFY CURRENT: " + current);

        // Verify person
        Assert.assertNotNull(current);
        Assert.assertEquals(current, current.getContinuity());
        Assert.assertEquals(getSample().getId(), current.getId());
        Assert.assertEquals(getSample().getName(), current.getName());
        Assert.assertTrue(current.getEffectivity().isCurrent());
        Assert.assertFalse(current.getEffectivity().isFutureEdition());
        Assert.assertEquals(current.getEffectivity().getStart(), BOT);
        Assert.assertEquals(current.getEffectivity().getEnd(), T2);

        // Address
        Assert.assertNotNull(current.getAddress());
        Assert.assertEquals(getSample().getAddress().getStreet(), current.getAddress().getStreet());
        Assert.assertEquals(getSample().getAddress().getCity(), current.getAddress().getCity());
        Assert.assertEquals(getSample().getAddress().getState(), current.getAddress().getState());
        Assert.assertTrue(current.getAddress().getEffectivity().isCurrent());
        Assert.assertFalse(current.getAddress().getEffectivity().isFutureEdition());
        Assert.assertEquals(current.getAddress().getEffectivity().getStart(), BOT);
        Assert.assertEquals(current.getAddress().getEffectivity().getEnd(), T2);

        // Phone
        Assert.assertEquals(1, current.getPhones().size());
        Phone currentHome = current.getPhone("Home");
        Assert.assertNotNull(currentHome);
        Assert.assertEquals("111-111-1111", currentHome.getNumber());
        Assert.assertSame(current, currentHome.getPerson());
    }

    @Test
    public void queryAllCurrentJoinAddress() {
        TemporalEntityManager em = getEntityManager();
        List<Person> results = em.createQuery("SELECT p From Person p JOIN FETCH p.address", Person.class).getResultList();

        System.out.println("QUERY CURRENT:");
        for (Person p : results) {
            System.out.println("\t>" + p);
        }

        Assert.assertEquals(1, results.size());

        Person currentperson = results.get(0);
        Assert.assertSame(currentperson, currentperson.getContinuity());
        Assert.assertEquals(getSample().getId(), currentperson.getId());
    }

    @Test
    public void querySampleCurrentPerson() {
        TemporalEntityManager em = getEntityManager();

        Person person = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
        Address address = person.getAddress();

        Assert.assertNotNull(person);

        System.out.println("FIND CURRENT: " + person);

        Assert.assertEquals(getSample().getId(), person.getId());
        Assert.assertSame(person, person.getContinuity());
        Assert.assertNotNull(address);
        Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
    }

    @Test
    public void querySampleCurrentPersonJoinAddress() {
        TemporalEntityManager em = getEntityManager();

        Person person = em.createQuery("SELECT p From Person p JOIN FETCH p.address WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
        Address address = person.getAddress();

        Assert.assertNotNull(person);

        System.out.println("FIND CURRENT: " + person);

        Assert.assertEquals(getSample().getId(), person.getId());
        Assert.assertEquals(person, person.getContinuity());
        Assert.assertNotNull(address);
        Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
    }

    @Test
    public void findSampleCurrentPerson() {
        TemporalEntityManager em = getEntityManager();
        Person person = em.find(Person.class, getSample().getId());

        Assert.assertNotNull(person);

        System.out.println("FIND CURRENT: " + person);

        Assert.assertEquals(getSample().getId(), person.getId());
        Assert.assertSame(person, person.getContinuity());
        Assert.assertTrue(person.getEffectivity().isCurrent());
        Assert.assertFalse(person.getEffectivity().isFutureEdition());
        Assert.assertEquals(person.getEffectivity().getStart(), BOT);
        Assert.assertEquals(person.getEffectivity().getEnd(), T2);

        Assert.assertEquals(0, person.getPersonHobbies().size());

        Assert.assertEquals(1, person.getPhones().size());

    }

    @Test
    public void findFuturePersonEntityEditionT2() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T2);

        Person person = em.find(Person.class, getSample().getId());
        Assert.assertNotNull(person);
        System.out.println("FIND Future Edition: " + person);
        Assert.assertEquals(1, person.getPersonHobbies().size());

        Person continuity = person.getContinuity();

        Assert.assertNotNull(continuity);
        System.out.println("\tContinuity: " + continuity);
        Assert.assertTrue("Not an edition entity", TemporalHelper.isEdition(em, person));
        Assert.assertEquals(getSample().getId(), person.getContinuity().getId());

        Assert.assertFalse(person.getEffectivity().isCurrent());
        Assert.assertTrue(person.getEffectivity().isFutureEdition());
        Assert.assertEquals(person.getEffectivity().getStart(), T2);
        Assert.assertEquals(person.getEffectivity().getEnd(), T4);
        Assert.assertNotSame(person, person.getContinuity());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtBOT() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(BOT);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ BOT: " + pEdition);

        Assert.assertNotNull("No edition found at BOT", pEdition);
        Assert.assertTrue(pEdition.getEffectivity().isCurrent());
        Assert.assertFalse(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(BOT, pEdition.getEffectivity().getStart());
        Assert.assertEquals(T2, pEdition.getEffectivity().getEnd());
        Assert.assertNotNull("No Continuity found", pEdition.getContinuity());
        Assert.assertEquals(0, pEdition.getPersonHobbies().size());

        Address address = pEdition.getAddress();

        Assert.assertNotNull(address);
        Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());

        Assert.assertEquals(1, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT1() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T1);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ T1: " + pEdition);

        Assert.assertNotNull("No edition found at T1", pEdition);
        Assert.assertTrue(pEdition.getEffectivity().isCurrent());
        Assert.assertFalse(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(BOT, pEdition.getEffectivity().getStart());
        Assert.assertEquals(T2, pEdition.getEffectivity().getEnd());
        Assert.assertNotNull("No Continuity found", pEdition.getContinuity());

        Assert.assertEquals(0, pEdition.getPersonHobbies().size());
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));

        Address address = pEdition.getAddress();

        Assert.assertNotNull(address);
        Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());

        Assert.assertEquals(1, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT2() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T2);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ T2: " + pEdition);

        Assert.assertNotNull("No edition found at T2", pEdition);
        Assert.assertFalse(pEdition.getEffectivity().isCurrent());
        Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
        Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
        Assert.assertNotSame(pEdition, pEdition.getContinuity());

        Assert.assertEquals(1, pEdition.getPersonHobbies().size());
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));

        Address address = pEdition.getAddress();

        Assert.assertNotNull(address);
        Assert.assertEquals("Toronto", address.getCity());

        Assert.assertEquals(2, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT2JoinFetchAddress() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T2);

        Person pEdition = null;
        try {
            pEdition = em.createQuery("SELECT p From Person p JOIN FETCH p.address WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
        } catch (NoResultException e) {
            Assert.fail("Join returned no result");
        }
        Address address = pEdition.getAddress();

        System.out.println("QUERY EDITION @ T2: " + pEdition);
        System.out.println("\t> " + address);

        Assert.assertNotNull("No edition found", pEdition);
        Assert.assertFalse(pEdition.getEffectivity().isCurrent());
        Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
        Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
        Assert.assertNotNull("No Continuity found", pEdition.getContinuity());
        Assert.assertNotNull(address);
        Assert.assertEquals("Toronto", address.getCity());

        Assert.assertEquals(1, pEdition.getPersonHobbies().size());
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));

        Assert.assertEquals(2, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT3() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T3);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ T3: " + pEdition);

        Assert.assertNotNull("No edition found ", pEdition);
        Assert.assertFalse(pEdition.getEffectivity().isCurrent());
        Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
        Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
        Assert.assertNotSame(pEdition, pEdition.getContinuity());

        Assert.assertEquals(1, pEdition.getPersonHobbies().size());
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));

        Address address = pEdition.getAddress();

        Assert.assertNotNull(address);
        Assert.assertEquals("Toronto", address.getCity());

        Assert.assertEquals(2, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT4() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T4);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ T4: " + pEdition);

        Assert.assertNotNull("No Person Edition Found", pEdition);
        Assert.assertFalse(pEdition.getEffectivity().isCurrent());
        Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
        Assert.assertEquals(EOT, pEdition.getEffectivity().getEnd());
        Assert.assertNotSame(pEdition, pEdition.getContinuity());

        Assert.assertEquals(2, pEdition.getPersonHobbies().size());
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));

        Address address = pEdition.getAddress();

        Assert.assertNotNull(address);

        Assert.assertEquals(2, pEdition.getPhones().size());
    }

    @Test
    public void queryFutureEditionOfCurrentPersonAtT5() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T5);

        Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();

        System.out.println("QUERY EDITION @ T5: " + pEdition);

        Assert.assertNotNull("No edition found at T5", pEdition);
        Assert.assertFalse(pEdition.getEffectivity().isCurrent());
        Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
        Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
        Assert.assertEquals(EOT, pEdition.getEffectivity().getEnd());
        Assert.assertNotSame(pEdition, pEdition.getContinuity());
        Assert.assertEquals(2, pEdition.getPersonHobbies().size());

        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
        Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
        Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));

        Assert.assertEquals(2, pEdition.getPhones().size());
    }

    @Test
    public void nativeQueryForAllEdition() {
        TemporalEntityManager em = getEntityManager();

        TypedQuery<Person> query = em.createNamedQuery("PersonEdition.all", Person.class);
        query.setParameter("CID", getSample().getId());
        List<Person> editions = query.getResultList();

        Assert.assertFalse("No edition found", editions.isEmpty());

        System.out.println("QUERY ALL EDITIONS:");
        for (Person p : editions) {
            System.out.println("\t" + p);
            Assert.assertNotNull("No Continuity found", p.getContinuity());
        }

        Assert.assertEquals(3, editions.size());
    }

    @Test
    public void detachResultUsingCopyPolicy() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T2);

        TypedQuery<Person> query = em.createNamedQuery("PersonEdition.find", Person.class);
        query.setParameter("ID", getSample().getId());

        Person p = query.getSingleResult();

        System.out.println("ORIGINAL: " + p + " HASHCODE: " + System.identityHashCode(p));
        System.out.println("\t" + p.getAddress());

        CopyGroup cg = new CopyGroup();
        cg.cascadeAllParts();

        Person pCopy = (Person) JpaHelper.getEntityManager(em).copy(p, cg);
        System.out.println("COPY: " + pCopy + " HASHSCODE: " + System.identityHashCode(pCopy));
        System.out.println("\t" + pCopy.getAddress());
    }

    /**
     * Verify that the edition creation operation correctly copies values
     * including mutable values and collections.
     */
    @Test
    public void verifyCreateEditionCopying() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T5);
        EditionSet es = em.getEditionSet();

        Person pEdition = em.find(Person.class, getSample().getId());

        Assert.assertNotNull(pEdition);
        Assert.assertTrue(TemporalHelper.isEdition(em, pEdition));
        Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
        Assert.assertNotNull(es);
        Assert.assertTrue(es.getEntries().isEmpty());

        em.getTransaction().begin();
        Person pAtT5 = em.newEdition(pEdition);

        Assert.assertNotNull(pAtT5);
        Assert.assertTrue(TemporalHelper.isEdition(em, pEdition));
        Assert.assertEquals(T5, pAtT5.getEffectivity().getStart());
        Assert.assertFalse(es.getEntries().isEmpty());
        Assert.assertEquals(1, es.getEntries().size());

        // Verify collection/map cloning
        Assert.assertNotSame(pEdition.getPhones(), pAtT5.getPhones());
        Assert.assertNotSame(pEdition.getPersonHobbies(), pAtT5.getPersonHobbies());
        Assert.assertNotSame(pEdition.getNicknames(), pAtT5.getNicknames());

        // Mutable non-temporal values
        Assert.assertSame(pEdition.getDateOfBirth(), pAtT5.getDateOfBirth());

        // TODO: Validate mutable basic copying

        em.getTransaction().rollback();
        em.close();
    }

    @SuppressWarnings("deprecation")
    @Test
    public void testDateOfBirthNonTemporalStorage() {
        TemporalEntityManager em = getEntityManager();

        List<?> results = em.createNativeQuery("SELECT DATEOFBIRTH FROM TPERSON WHERE CID = 1 ORDER BY OID").getResultList();

        Assert.assertNotNull(results);
        Assert.assertEquals(3, results.size());
        Assert.assertEquals(new Date(75, 1, 5), results.get(0));
        Assert.assertNull(results.get(1));
        Assert.assertNull(results.get(2));
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryCurrentHomePhone() {
        TemporalEntityManager em = getEntityManager();

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertFalse(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(phone, phone.getContinuity());
        Assert.assertEquals(BOT, phone.getEffectivity().getStart());
        Assert.assertEquals(T2, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtBOT() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(BOT);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(BOT, phone.getEffectivity().getStart());
        Assert.assertEquals(T2, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtT1() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T1);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(BOT, phone.getEffectivity().getStart());
        Assert.assertEquals(T2, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtT2() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T2);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(T2, phone.getEffectivity().getStart());
        Assert.assertEquals(T4, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtT3() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T3);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(T2, phone.getEffectivity().getStart());
        Assert.assertEquals(T4, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtT4() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T4);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(T4, phone.getEffectivity().getStart());
        Assert.assertEquals(EOT, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }

    /**
     * Verify the query result and relationship to person
     */
    @SuppressWarnings("unchecked")
    @Test
    public void queryHomePhoneAtT5() {
        TemporalEntityManager em = getEntityManager();
        em.setEffectiveTime(T5);

        TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
        Phone phone = query.getSingleResult();

        Assert.assertNotNull(phone);
        Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
        Assert.assertNotNull(phone.getContinuity());
        Assert.assertEquals(T4, phone.getEffectivity().getStart());
        Assert.assertEquals(EOT, phone.getEffectivity().getEnd());

        Assert.assertNotNull(phone.getPerson());
        Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
    }
}