org.springframework.orm.jpa.domain.Person Java Examples

@Test
public void testReuseInNewTransaction() {
	EntityManager em = createContainerManagedEntityManager();
	doInstantiateAndSave(em);
	endTransaction();

	//assertFalse(em.getTransaction().isActive());

	startNewTransaction();
	// Call any method: should cause automatic tx invocation
	assertFalse(em.contains(new Person()));
	//assertTrue(em.getTransaction().isActive());

	doInstantiateAndSave(em);
	setComplete();
	endTransaction();	// Should rollback
	assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));

	// Now clean up the database
	deleteFromTables("person");
}
 

@Test
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
	EntityManager em = createContainerManagedEntityManager();
	assertTrue(Proxy.isProxyClass(em.getClass()));
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertTrue(people.isEmpty());

	assertTrue("Should be open to start with", em.isOpen());
	try {
		em.close();
		fail("Close should not work on container managed EM");
	}
	catch (IllegalStateException ex) {
		// OK
	}
	assertTrue(em.isOpen());
}
 

@Test
@SuppressWarnings("unchecked")
public void testQueryNoPersonsNotTransactional() {
	endTransaction();

	EntityManager em = entityManagerFactory.createEntityManager();
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(0, people.size());
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

@Test
public void testReuseInNewTransaction() {
	EntityManager em = createContainerManagedEntityManager();
	doInstantiateAndSave(em);
	endTransaction();

	//assertFalse(em.getTransaction().isActive());

	startNewTransaction();
	// Call any method: should cause automatic tx invocation
	assertFalse(em.contains(new Person()));
	//assertTrue(em.getTransaction().isActive());

	doInstantiateAndSave(em);
	setComplete();
	endTransaction();	// Should rollback
	assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));

	// Now clean up the database
	deleteFromTables("person");
}
 

@Test
public void testLazyLoading() {
	try {
		Person tony = new Person();
		tony.setFirstName("Tony");
		tony.setLastName("Blair");
		tony.setDriversLicense(new DriversLicense("8439DK"));
		sharedEntityManager.persist(tony);
		setComplete();
		endTransaction();

		startNewTransaction();
		sharedEntityManager.clear();
		Person newTony = entityManagerFactory.createEntityManager().getReference(Person.class, tony.getId());
		assertNotSame(newTony, tony);
		endTransaction();

		assertNotNull(newTony.getDriversLicense());

		newTony.getDriversLicense().getSerialNumber();
	}
	finally {
		deleteFromTables("person", "drivers_license");
	}
}
 

public void testLazyLoading() {
	try {
		Person tony = new Person();
		tony.setFirstName("Tony");
		tony.setLastName("Blair");
		tony.setDriversLicense(new DriversLicense("8439DK"));
		sharedEntityManager.persist(tony);
		setComplete();
		endTransaction();

		startNewTransaction();
		sharedEntityManager.clear();
		Person newTony = entityManagerFactory.createEntityManager().getReference(Person.class, tony.getId());
		assertNotSame(newTony, tony);
		endTransaction();

		assertNotNull(newTony.getDriversLicense());

		newTony.getDriversLicense().getSerialNumber();
	}
	finally {
		deleteFromTables("person", "drivers_license");
	}
}
 

@Test
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
	EntityManager em = createContainerManagedEntityManager();
	assertTrue(Proxy.isProxyClass(em.getClass()));
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertTrue(people.isEmpty());

	assertTrue("Should be open to start with", em.isOpen());
	try {
		em.close();
		fail("Close should not work on container managed EM");
	}
	catch (IllegalStateException ex) {
		// OK
	}
	assertTrue(em.isOpen());
}
 

@Test
@SuppressWarnings("unchecked")
public void testQueryNoPersonsNotTransactional() {
	endTransaction();

	EntityManager em = entityManagerFactory.createEntityManager();
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(0, people.size());
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

public void testReuseInNewTransaction() {
	EntityManager em = createContainerManagedEntityManager();
	doInstantiateAndSave(em);
	endTransaction();

	//assertFalse(em.getTransaction().isActive());

	startNewTransaction();
	// Call any method: should cause automatic tx invocation
	assertFalse(em.contains(new Person()));
	//assertTrue(em.getTransaction().isActive());

	doInstantiateAndSave(em);
	setComplete();
	endTransaction();	// Should rollback
	assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));

	// Now clean up the database
	deleteFromTables("person");
}
 

@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
	EntityManager em = createContainerManagedEntityManager();
	assertTrue(Proxy.isProxyClass(em.getClass()));
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertTrue(people.isEmpty());

	assertTrue("Should be open to start with", em.isOpen());
	try {
		em.close();
		fail("Close should not work on container managed EM");
	}
	catch (IllegalStateException ex) {
		// Ok
	}
	assertTrue(em.isOpen());
}
 

@Test
public void testLazyLoading() {
	try {
		Person tony = new Person();
		tony.setFirstName("Tony");
		tony.setLastName("Blair");
		tony.setDriversLicense(new DriversLicense("8439DK"));
		sharedEntityManager.persist(tony);
		setComplete();
		endTransaction();

		startNewTransaction();
		sharedEntityManager.clear();
		Person newTony = entityManagerFactory.createEntityManager().getReference(Person.class, tony.getId());
		assertNotSame(newTony, tony);
		endTransaction();

		assertNotNull(newTony.getDriversLicense());

		newTony.getDriversLicense().getSerialNumber();
	}
	finally {
		deleteFromTables("person", "drivers_license");
	}
}
 

public void doInstantiateAndSave(EntityManager em) {
	testStateClean();
	Person p = new Person();

	p.setFirstName("Tony");
	p.setLastName("Blair");
	em.persist(p);

	em.flush();
	assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
}
 

public void doInstantiateAndSave(EntityManager em) {
	assertEquals("Should be no people from previous transactions", 0, countRowsInTable(em, "person"));
	Person p = new Person();

	p.setFirstName("Tony");
	p.setLastName("Blair");
	em.persist(p);

	em.flush();
	assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
}
 

protected void doInstantiateAndSave(EntityManager em) {
	assertEquals("Should be no people from previous transactions", 0, countRowsInTable(em, "person"));
	Person p = new Person();

	p.setFirstName("Tony");
	p.setLastName("Blair");
	em.persist(p);

	em.flush();
	assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
}
 

@Test
@SuppressWarnings("unchecked")
public void testEntityListener() {
	String firstName = "Tony";
	insertPerson(firstName);

	List<Person> people = sharedEntityManager.createQuery("select p from Person as p").getResultList();
	assertEquals(1, people.size());
	assertEquals(firstName, people.get(0).getFirstName());
	assertSame(applicationContext, people.get(0).postLoaded);
}
 

@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testCurrentSession() {
	String firstName = "Tony";
	insertPerson(firstName);

	Query q = sessionFactory.getCurrentSession().createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(1, people.size());
	assertEquals(firstName, people.get(0).getFirstName());
	assertSame(applicationContext, people.get(0).postLoaded);
}
 

@Transactional(readOnly = true)
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
	EntityManager em = entityManagerFactory.createEntityManager();
	assertTrue(Proxy.isProxyClass(em.getClass()));
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertNotNull(people);

	assertTrue("Should be open to start with", em.isOpen());
	em.close();
	assertFalse("Close should work on application managed EM", em.isOpen());
}
 

@SuppressWarnings("unchecked")
public void testQueryNoPersons() {
	EntityManager em = entityManagerFactory.createEntityManager();
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(0, people.size());
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

public void testReuseInNewTransaction() {
	EntityManager em = entityManagerFactory.createEntityManager();
	em.joinTransaction();

	doInstantiateAndSave(em);
	endTransaction();

	assertFalse(em.getTransaction().isActive());

	startNewTransaction();
	// Call any method: should cause automatic tx invocation
	assertFalse(em.contains(new Person()));

	assertFalse(em.getTransaction().isActive());
	em.joinTransaction();

	assertTrue(em.getTransaction().isActive());

	doInstantiateAndSave(em);
	setComplete();
	endTransaction();	// Should rollback
	assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));

	// Now clean up the database
	startNewTransaction();
	em.joinTransaction();
	deleteAllPeopleUsingEntityManager(em);
	assertEquals("People have been killed", 0, countRowsInTable(em, "person"));
	setComplete();
}
 

@SuppressWarnings({ "unused", "unchecked" })
public void testEntityManagerProxyIsProxy() {
	assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass()));
	Query q = sharedEntityManager.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();

	assertTrue("Should be open to start with", sharedEntityManager.isOpen());
	sharedEntityManager.close();
	assertTrue("Close should have been silently ignored", sharedEntityManager.isOpen());
}
 

public void testGetReferenceWhenNoRow() {
	try {
		Person notThere = sharedEntityManager.getReference(Person.class, 666);

		// We may get here (as with Hibernate).
		// Either behaviour is valid: throw exception on first access
		// or on getReference itself.
		notThere.getFirstName();
		fail("Should have thrown an EntityNotFoundException");
	}
	catch (EntityNotFoundException e) {
		/* expected */
	}
}
 

@Test
@SuppressWarnings("unchecked")
public void testQueryNoPersons() {
	EntityManager em = entityManagerFactory.createEntityManager();
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(0, people.size());
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

@SuppressWarnings({ "unused", "unchecked" })
public void testQueryNoPersonsShared() {
	EntityManager em = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
	Query q = em.createQuery("select p from Person as p");
	q.setFlushMode(FlushModeType.AUTO);
	List<Person> people = q.getResultList();
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

@Transactional(propagation = Propagation.NOT_SUPPORTED)
@SuppressWarnings("unchecked")
public void testQueryNoPersonsNotTransactional() {
	EntityManager em = entityManagerFactory.createEntityManager();
	Query q = em.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();
	assertEquals(0, people.size());
	try {
		assertNull(q.getSingleResult());
		fail("Should have thrown NoResultException");
	}
	catch (NoResultException ex) {
		// expected
	}
}
 

@SuppressWarnings("unchecked")
public void testMultipleResults() {
	// Add with JDBC
	String firstName = "Tony";
	insertPerson(firstName);

	assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass()));
	Query q = sharedEntityManager.createQuery("select p from Person as p");
	List<Person> people = q.getResultList();

	assertEquals(1, people.size());
	assertEquals(firstName, people.get(0).getFirstName());
}
 

protected void testInstantiateAndSave(EntityManager em) {
	assertEquals("Should be no people from previous transactions", 0, countRowsInTable("person"));
	Person p = new Person();
	p.setFirstName("Tony");
	p.setLastName("Blair");
	em.persist(p);

	em.flush();
	assertEquals("1 row must have been inserted", 1, countRowsInTable("person"));
}
 

@Test
@SuppressWarnings("unchecked")
public void testEntityListener() {
	String firstName = "Tony";
	insertPerson(firstName);

	List<Person> people = sharedEntityManager.createQuery("select p from Person as p").getResultList();
	assertEquals(1, people.size());
	assertEquals(firstName, people.get(0).getFirstName());
	assertSame(applicationContext, people.get(0).postLoaded);
}
 

protected void doInstantiateAndSave(EntityManager em) {
	testStateClean();
	Person p = new Person();

	p.setFirstName("Tony");
	p.setLastName("Blair");
	em.persist(p);

	em.flush();
	assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
}
 

@Test
public void testReuseInNewTransaction() {
	EntityManager em = entityManagerFactory.createEntityManager();
	em.joinTransaction();

	doInstantiateAndSave(em);
	endTransaction();

	assertFalse(em.getTransaction().isActive());

	startNewTransaction();
	// Call any method: should cause automatic tx invocation
	assertFalse(em.contains(new Person()));

	assertFalse(em.getTransaction().isActive());
	em.joinTransaction();

	assertTrue(em.getTransaction().isActive());

	doInstantiateAndSave(em);
	setComplete();
	endTransaction();	// Should rollback
	assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));

	// Now clean up the database
	startNewTransaction();
	em.joinTransaction();
	deleteAllPeopleUsingEntityManager(em);
	assertEquals("People have been killed", 0, countRowsInTable(em, "person"));
	setComplete();
}
 

@Test
public void testGetReferenceWhenNoRow() {
	try {
		Person notThere = sharedEntityManager.getReference(Person.class, 666);

		// We may get here (as with Hibernate). Either behaviour is valid:
		// throw exception on first access or on getReference itself.
		notThere.getFirstName();
		fail("Should have thrown an EntityNotFoundException or ObjectNotFoundException");
	}
	catch (Exception ex) {
		assertTrue(ex.getClass().getName().endsWith("NotFoundException"));
	}
}