DomainEntityLoaderBeanTest.java from Texai at Krugle
Show DomainEntityLoaderBeanTest.java syntax highlighted
/*
* DomainEntityLoaderBeanTest.java
* JUnit based test
*
* Created on November 6, 2006, 5:15 PM
*
* Copyright (C) 2006 Stephen L. Reed.
*
* This program is free software; you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program;
* if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
package org.texai.kb.ejb.session;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import junit.framework.*;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import net.sf.ehcache.CacheManager;
import org.texai.kb.CacheInitializer;
import org.texai.kb.Constants;
import org.texai.kb.ejb.entity.AbstractReifiedTerm;
import org.texai.kb.ejb.entity.AbstractTerm;
import org.texai.kb.ejb.entity.AtomicTerm;
import org.texai.kb.ejb.entity.BinaryGAF;
import org.texai.kb.ejb.session.shared.AssociationFinderBean;
import org.texai.kb.ejb.session.shared.TermDefinitionAccessorBean;
import org.texai.kb.ejb.session.shared.TermDeleterFacadeBean;
import org.texai.kb.ejb.session.shared.TermFinderFacadeBean;
import org.texai.kb.persistence.lazy.LazyList;
import org.texai.kb.persistence.lazy.LazySet;
import org.texai.kb.persistence.test.TestDomainEntity;
/**
*
* @author reed
*/
public class DomainEntityLoaderBeanTest extends TestCase {
/** the entity manager factory */
private static EntityManagerFactory entityManagerFactory;
/** the entity manager */
private static EntityManager entityManager;
public DomainEntityLoaderBeanTest(String testName) {
super(testName);
}
protected void setUp() throws Exception {
if (entityManager == null) {
System.out.println("oneTimeSetup");
try {
getClass().getClassLoader().setDefaultAssertionStatus(true);
CacheInitializer.initializeCaches();
System.out.println("setUp: creating EntityManager");
entityManagerFactory = Persistence.createEntityManagerFactory("TestPersistenceUnit");
entityManager = entityManagerFactory.createEntityManager();
System.out.println("entityManager created");
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
if (entityManager.getTransaction().isActive()) {
entityManager.getTransaction().rollback();
}
try {
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
protected void tearDown() throws Exception {
}
/**
* Test of loadDomainEntity method, of class org.texai.kb.ejb.session.DomainEntityLoaderBean.
*/
public void testLoadDomainEntity() {
System.out.println("loadDomainEntity");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
// first persist a couple of connected entities
final TestDomainEntity domainEntity1 = new TestDomainEntity();
final TestDomainEntity domainEntity2 = new TestDomainEntity();
domainEntity1.setDontCareField("do not care");
domainEntity1.setFavoriteTestDomainEntityPeer(domainEntity2);
domainEntity1.setMaxNbrOfScooterRiders(2);
List<TestDomainEntity> myPeers = new ArrayList<TestDomainEntity>(1);
myPeers.add(domainEntity2);
domainEntity1.setMyPeers(myPeers);
domainEntity1.setName("TestDomainEntity 1");
domainEntity1.setNumberOfCrew(1);
final String[] comments1 = {"comment 1", "comment 2"};
domainEntity1.setComment(comments1);
domainEntity2.setDontCareField("do not care");
domainEntity2.setFavoriteTestDomainEntityPeer(domainEntity2);
domainEntity2.setMaxNbrOfScooterRiders(2);
myPeers = new ArrayList<TestDomainEntity>(1);
myPeers.add(domainEntity1);
domainEntity2.setMyPeers(myPeers);
domainEntity2.setName("TestDomainEntity 2");
domainEntity2.setNumberOfCrew(1);
final String[] comments2 = {"comment 1", "comment 2"};
domainEntity1.setComment(comments2);
Set<String> cyclistNotes = new HashSet<String>();
cyclistNotes.add("note 1");
cyclistNotes.add("note 2");
domainEntity1.setCyclistNotes(cyclistNotes);
List<String> myListTestStrings = new ArrayList<String>();
myListTestStrings.add("test string 1");
myListTestStrings.add("test string 2");
domainEntity1.setMyListTestStrings(myListTestStrings);
domainEntity1.setMyLazilyLoadedTestDomainEntity(domainEntity2);
domainEntity1.setMyInverseProperty("my inverse property string value");
domainEntity1.setIsTest1(true);
domainEntity1.setIsTest2(false);
DomainEntityPersisterBean domainEntityPersister = new DomainEntityPersisterBean();
domainEntityPersister.setEntityManager(entityManager);
TermFinderFacadeBean termFinderFacade = new TermFinderFacadeBean();
termFinderFacade.setEntityManager(entityManager);
domainEntity1.setMyLazilyLoadedAtomicTerm(termFinderFacade.findAtomicTermByTermName(Constants.TERM_NAME_ISA));
domainEntityPersister.setTermFinderFacade(termFinderFacade);
AssociationFinderBean associationFinder = new AssociationFinderBean();
associationFinder.setEntityManager(entityManager);
domainEntityPersister.setAssociationFinder(associationFinder);
TermDefinitionAccessorBean termDefinitionAccessor = new TermDefinitionAccessorBean();
domainEntityPersister.setTermDefinitionAccessor(termDefinitionAccessor);
TermDeleterFacadeBean termDeleterFacade = new TermDeleterFacadeBean();
termDeleterFacade.setEntityManager(entityManager);
domainEntityPersister.setTermDeleterFacade(termDeleterFacade);
domainEntityPersister.injectSharedBeanDependencies();
AtomicTerm creator = termFinderFacade.findAtomicTermByTermName("SomeCyclist");
AtomicTerm creationPurpose = termFinderFacade.findAtomicTermByTermName("OpenCycProject");
AtomicTerm result = domainEntityPersister.persistDomainEntity(domainEntity1, creator, creationPurpose);
assertNotNull(result);
assertTrue(result.toString().startsWith("org.texai.kb.persistence.test.TestDomainEntity_"));
assertNotNull(result.getTermId());
entityTransaction.commit();
// then test by loading the previously persisted domainEntity1 by its term id
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Long termId = result.getTermId();
DomainEntityLoaderBean instance = new DomainEntityLoaderBean();
instance.setEntityManager(entityManager);
instance.setTermFinderFacade(termFinderFacade);
instance.setAssociationFinder(associationFinder);
instance.setTermDefinitionAccessor(termDefinitionAccessor);
instance.injectSharedBeanDependencies();
Object objResult = instance.loadDomainEntity(termId);
assertTrue(objResult instanceof TestDomainEntity);
TestDomainEntity resultDomainEntity = (TestDomainEntity) objResult;
assertEquals(domainEntity1, resultDomainEntity);
Arrays.sort(domainEntity1.getComment());
Arrays.sort(resultDomainEntity.getComment());
assertTrue(Arrays.equals(domainEntity1.getComment(), resultDomainEntity.getComment()));
assertEquals(domainEntity1.getFavoriteTestDomainEntityPeer(), resultDomainEntity.getFavoriteTestDomainEntityPeer());
assertEquals(domainEntity1.getMaxNbrOfScooterRiders(), resultDomainEntity.getMaxNbrOfScooterRiders());
assertEquals(domainEntity1.getMyPeers(), resultDomainEntity.getMyPeers());
assertEquals(domainEntity1.getName(), resultDomainEntity.getName());
assertEquals(domainEntity1.getNumberOfCrew(), resultDomainEntity.getNumberOfCrew());
assertTrue(resultDomainEntity.getCyclistNotes() instanceof LazySet);
assertEquals(domainEntity1.getCyclistNotes().size(), resultDomainEntity.getCyclistNotes().size());
assertTrue(resultDomainEntity.getCyclistNotes() instanceof HashSet);
assertEquals(domainEntity1.getCyclistNotes().size(), resultDomainEntity.getCyclistNotes().size());
assertTrue(resultDomainEntity.getMyListTestStrings() instanceof LazyList);
assertEquals(domainEntity1.getMyListTestStrings().size(), resultDomainEntity.getMyListTestStrings().size());
assertTrue(resultDomainEntity.getMyListTestStrings() instanceof ArrayList);
assertEquals(domainEntity1.getMyListTestStrings().size(), resultDomainEntity.getMyListTestStrings().size());
assertTrue(resultDomainEntity.getMyLazilyLoadedTestDomainEntity() instanceof TestDomainEntity);
String testString;
testString = resultDomainEntity.getMyLazilyLoadedTestDomainEntity().toString();
assertEquals(domainEntity1.getMyLazilyLoadedTestDomainEntity().toString(), testString);
assertTrue(resultDomainEntity.getMyLazilyLoadedAtomicTerm() instanceof AtomicTerm);
testString = resultDomainEntity.getMyLazilyLoadedAtomicTerm().toString();
assertEquals(domainEntity1.getMyLazilyLoadedAtomicTerm().toString(), testString);
assertNotNull(resultDomainEntity.getMyPeersStrengths());
assertEquals(1, resultDomainEntity.getMyPeersStrengths().size());
assertEquals("[0.984375]", resultDomainEntity.getMyPeersStrengths().toString());
assertEquals(true, resultDomainEntity.isTest1());
assertEquals(false, resultDomainEntity.isTest2());
resultDomainEntity.setMyInversePropertyStrength(Double.valueOf(0.1d));
List<Double> myPeersStrengths = new ArrayList<Double>();
myPeersStrengths.add(Double.valueOf(0.5d));
resultDomainEntity.setMyPeersStrengths(myPeersStrengths);
resultDomainEntity.setIsTest1(false);
domainEntityPersister.persistDomainEntity(resultDomainEntity, creator, creationPurpose);
entityTransaction.commit();
entityTransaction.begin();
AbstractTerm arg1 = termFinderFacade.findPStringByStringValue("my inverse property string value");
BinaryGAF binaryGAF = termFinderFacade.findBinaryGAFByConstituents(
termFinderFacade.findAtomicTermByTermName("myInverseProperty"),
Arrays.asList((AbstractTerm) arg1, entityManager.find(AtomicTerm.class, termId)),
(AbstractReifiedTerm) termFinderFacade.findAtomicTermByTermName("BaseKB"));
assertNotNull(binaryGAF);
assertEquals(Double.valueOf(0.1d), binaryGAF.getStrength());
resultDomainEntity = (TestDomainEntity) instance.loadDomainEntity(termId);
assertEquals(Double.valueOf(0.1d), resultDomainEntity.getMyInversePropertyStrength());
assertEquals("[0.5]", resultDomainEntity.getMyPeersStrengths().toString());
// domainEntityIterator test
Iterator<Object> domainEntityIterator = instance.domainEntityIterator(TestDomainEntity.class);
while (domainEntityIterator.hasNext()) {
Object obj = null;
try {
obj = domainEntityIterator.next();
}
catch (Exception ex) {
System.out.println(ex.getMessage());
}
//assertTrue(obj instanceof TestDomainEntity);
System.out.println("iteration obj: " + obj);
}
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" loadDomainEntity OK");
}
/** Performs one time tear down of test harness. This must be the last test method. */
public void testOneTimeTearDown() {
System.out.println("oneTimeTearDown");
CacheManager.getInstance().shutdown();
entityManager.close();
entityManagerFactory.close();
}
}
See more files for this project here