hibernate-commits

[<one...@us...>]

Update of /cvsroot/hibernate/Hibernate2/src/net/sf/hibernate/test
In directory sc8-pr-cvs1:/tmp/cvs-serv2743/sf/hibernate/test

Added Files:
	FumTest.java 
Log Message:
seperated out the composite-id tests

--- NEW FILE: FumTest.java ---
//$Id: FumTest.java,v 1.1 2003/02/15 01:07:32 oneovthafew Exp $
package net.sf.hibernate.test;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import java.util.Set;

import junit.framework.Test;
import junit.framework.TestSuite;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.LockMode;
import net.sf.hibernate.Query;
import net.sf.hibernate.Session;
import net.sf.hibernate.dialect.MckoiDialect;
import net.sf.hibernate.type.DateType;
import net.sf.hibernate.type.EntityType;
import net.sf.hibernate.type.StringType;
import net.sf.hibernate.type.Type;

public class FumTest extends TestCase {
	
	protected static short fumKeyShort = 1;
	
	public FumTest(String arg) {
		super(arg);
	}
		
	public void testListIdentifiers() throws Exception {
		Session s = sessions.openSession();
		Fum fum = new Fum( fumKey("fum") );
		fum.setFum("fo fee fi");
		s.save(fum);
		fum = new Fum( fumKey("fi") );
		fum.setFum("fee fi fo");
		s.save(fum);
		List list = s.find("select fum.id from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'");
		assertTrue( list.size()==2, "list identifiers");
		Iterator iter = s.iterate("select fum.id from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'");
		int i=0;
		while ( iter.hasNext() ) {
			assertTrue( iter.next() instanceof FumCompositeID,  "iterate identifiers");
			i++;
		}
		assertTrue(i==2);
		s.delete( s.load(Fum.class, (Serializable) list.get(0) ) );
		s.delete( s.load(Fum.class, (Serializable) list.get(1) ) );
		s.flush();
		s.connection().commit();
		s.close();
	}
	
	
	static FumCompositeID fumKey(String str) {
		
		return fumKey(str,false);
	}
	
	static FumCompositeID fumKey(String str, boolean aCompositeQueryTest) {
		FumCompositeID id = new FumCompositeID();
		if( dialect instanceof MckoiDialect ) {
			java.util.GregorianCalendar now = new java.util.GregorianCalendar();
			java.util.GregorianCalendar cal
			= new java.util.GregorianCalendar( now.get(java.util.Calendar.YEAR),
			now.get(java.util.Calendar.MONTH),
			now.get(java.util.Calendar.DATE) );
			id.setDate( cal.getTime() );
		}
		else
		id.setDate( new Date() );
		id.setString( new String(str) );
		
		if (aCompositeQueryTest)
		id.setShort( fumKeyShort++ );
		else
		id.setShort((short)12);
		
		return id;
	}
	
	public void testCompositeID() throws Exception {
		Session s = sessions.openSession();
		Fum fum = new Fum( fumKey("fum") );
		fum.setFum("fee fi fo");
		s.save(fum);
		assertTrue( fum==s.load( Fum.class, fumKey("fum") ), "load by composite key" );
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		fum = (Fum) s.load( Fum.class, fumKey("fum"), LockMode.UPGRADE );
		assertTrue( fum!=null, "load by composite key" );
		
		Fum fum2 = new Fum( fumKey("fi") );
		fum2.setFum("fee fo fi");
		fum.setFo(fum2);
		s.save(fum2);
		assertTrue(
			s.find("from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'").size()==2,
			"find composite keyed objects"
		);
		assertTrue(
			s.find("select fum from fum in class net.sf.hibernate.test.Fum where fum.fum='fee fi fo'").get(0)==fum,
			"find composite keyed object"
		);
		fum.setFo(null);
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		Iterator iter = s.iterate("from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'");
		int i = 0;
		while ( iter.hasNext() ) {
			fum = (Fum) iter.next();
			//iter.remove();
			s.delete(fum);
			i++;
		}
		assertTrue( i==2, "iterate on composite key" );
		s.flush();
		s.connection().commit();
		s.close();
	}
	
	public void testCompositeIDOneToOne() throws Exception {
		Session s = sessions.openSession();
		Fum fum = new Fum( fumKey("fum") );
		fum.setFum("fee fi fo");
		//s.save(fum);
		Fumm fumm = new Fumm();
		fumm.setFum(fum);
		s.save(fumm);
		s.flush();
		s.connection().commit();
		s.close();
		s = sessions.openSession();
		fumm = (Fumm) s.load( Fumm.class, fumKey("fum") );
		//s.delete( fumm.getFum() );
		s.delete(fumm);
		s.flush();
		s.connection().commit();
		s.close();
	}
	
	public void testCompositeIDQuery() throws Exception {
		Session s = sessions.openSession();
		Fum fee = new Fum( fumKey("fee",true) );
		fee.setFum("fee");
		s.save(fee);
		Fum fi = new Fum( fumKey("fi",true) );
		fi.setFum("fi");
		short fiShort = fi.getId().getShort();
		s.save(fi);
		Fum fo = new Fum( fumKey("fo",true) );
		fo.setFum("fo");
		s.save(fo);
		Fum fum = new Fum( fumKey("fum",true) );
		fum.setFum("fum");
		s.save(fum);
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		// Try to find the Fum object "fo" that we inserted searching by the string in the id
		List vList = s.find("from fum in class net.sf.hibernate.test.Fum where fum.id.string='fo'"  );
		assertTrue( vList.size() == 1, "find by composite key query (find fo object)" );
		fum = (Fum)vList.get(0);
		assertTrue( fum.getId().getString().equals("fo"), "find by composite key query (check fo object)" );
		
		// Try to find the Fum object "fi" that we inserted searching by the date in the id
		vList = s.find("from fum in class net.sf.hibernate.test.Fum where fum.id.short = ?",new Short(fiShort),Hibernate.SHORT);
		assertTrue( vList.size() == 1, "find by composite key query (find fi object)" );
		fi = (Fum)vList.get(0);
		assertTrue( fi.getId().getString().equals("fi"), "find by composite key query (check fi object)" );
		
		// Make sure we can return all of the objects by searching by the date id
		assertTrue(
			s.find("from fum in class net.sf.hibernate.test.Fum where fum.id.date <= ? and not fum.fum='FRIEND'",new Date(),Hibernate.DATE).size()==4,
			"find by composite key query with arguments"
		);
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		assertTrue(
			s.iterate("select fum.id.short, fum.id.date, fum.id.string from fum in class net.sf.hibernate.test.Fum").hasNext()
		);
		assertTrue(
			s.iterate("select fum.id from fum in class net.sf.hibernate.test.Fum").hasNext()
		);
		Query qu = s.createQuery("select fum.fum, fum , fum.fum, fum.id.date from fum in class net.sf.hibernate.test.Fum");
		Type[] types = qu.getReturnTypes();
		assertTrue(types.length==4);
		for ( int k=0; k<types.length; k++) {
			assertTrue( types[k]!=null );
		}
		assertTrue(types[0] instanceof StringType);
		assertTrue(types[1] instanceof EntityType);
		assertTrue(types[2] instanceof StringType);
		assertTrue(types[3] instanceof DateType);
		Iterator iter = qu.iterate();
		int j = 0;
		while ( iter.hasNext() ) {
			j++;
			assertTrue( ( (Object[]) iter.next() )[1] instanceof Fum );
		}
		assertTrue( j==8, "iterate on composite key" );
		iter = s.iterate("from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'");
		int i = 0;
		while ( iter.hasNext() ) {
			fum = (Fum) iter.next();
			//iter.remove();
			s.delete(fum);
			i++;
		}
		assertTrue( i==4, "iterate on composite key" );
		s.flush();
		
		s.iterate("from fu in class Fum, fo in class Fum where fu.fo.id.string = fo.id.string and fo.fum is not null");
		
		s.connection().commit();
		s.close();
	}
	
	
	public void testCompositeIDCollections() throws Exception {
		Session s = sessions.openSession();
		Fum fum1 = new Fum( fumKey("fum1") );
		Fum fum2 = new Fum( fumKey("fum2") );
		fum1.setFum("fee fo fi");
		fum2.setFum("fee fo fi");
		s.save(fum1);
		s.save(fum2);
		Qux q = new Qux();
		s.save(q);
		Set set = new HashSet();
		List list = new ArrayList();
		set.add(fum1); set.add(fum2);
		list.add(fum1);
		q.setFums(set);
		q.setMoreFums(list);
		fum1.setQuxArray( new Qux[] {q} );
		s.flush();
		s.connection().commit();
		s.close();
		s = sessions.openSession();
		q = (Qux) s.load( Qux.class, q.getKey() );
		assertTrue( q.getFums().size()==2, "collection of fums" );
		assertTrue( q.getMoreFums().size()==1, "collection of fums" );
		assertTrue( ( (Fum) q.getMoreFums().get(0) ).getQuxArray()[0]==q, "unkeyed composite id collection" );
		Iterator iter = q.getFums().iterator();
		iter.hasNext();
		s.delete( (Fum) iter.next() );
		iter.hasNext();
		s.delete( (Fum) iter.next() );
		s.delete(q);
		s.flush();
		s.connection().commit();
		s.close();
	}
	
	
	public void testDeleteOwner() throws Exception {
		Session s = sessions.openSession();
		Qux q = new Qux();
		s.save(q);
		Fum f1 = new Fum( fumKey("f1") );
		Fum f2 = new Fum( fumKey("f2") );
		Set set = new HashSet();
		set.add(f1);
		set.add(f2);
		List list = new LinkedList();
		list.add(f1);
		list.add(f2);
		f1.setFum("f1");
		f2.setFum("f2");
		q.setFums(set);
		q.setMoreFums(list);
		s.save(f1);
		s.save(f2);
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		q = (Qux) s.load( Qux.class, q.getKey(), LockMode.UPGRADE );
		s.lock( q, LockMode.UPGRADE );
		s.delete(q);
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		list = s.find("from fum in class net.sf.hibernate.test.Fum where not fum.fum='FRIEND'");
		assertTrue( list.size()==2, "deleted owner" );
		s.lock( list.get(0), LockMode.UPGRADE );
		s.lock( list.get(1), LockMode.UPGRADE );
		Iterator iter = list.iterator();
		while ( iter.hasNext() ) {
			s.delete( iter.next() );
		}
		s.flush();
		s.connection().commit();
		s.close();
	}
	
	
	public void testCompositeIDs() throws Exception {
		Session s = sessions.openSession();
		Fo fo = new Fo();
		Properties props = new Properties();
		props.setProperty("foo", "bar");
		props.setProperty("bar", "foo");
		fo.setSerial(props);
		fo.setBuf( "abcdefghij1`23%$*^*$*\n\t".getBytes() );
		s.save( fo, fumKey("an instance of fo") );
		s.flush();
		props.setProperty("x", "y");
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		fo = (Fo) s.load( Fo.class, fumKey("an instance of fo") );
		props = (Properties) fo.getSerial();
		assertTrue( props.getProperty("foo").equals("bar") );
		assertTrue( props.getProperty("x").equals("y") );
		assertTrue( fo.getBuf()[0]=='a' );
		fo.getBuf()[1]=(byte)126;
		s.flush();
		s.connection().commit();
		s.close();
		
		s = sessions.openSession();
		fo = (Fo) s.load( Fo.class, fumKey("an instance of fo") );
		assertTrue( fo.getBuf()[1]==126 );
		assertTrue(
			s.iterate("from fo in class net.sf.hibernate.test.Fo where fo.id.string like 'an instance of fo'").next()==fo
		);
		s.delete(fo);
		s.flush();
		try {
			s.save( new Fo() );
			assertTrue(false);
		}
		catch (Exception e) {
			//System.out.println( e.getMessage() );
		}
		s.connection().commit();
		s.close();
	}
		
	public static Test suite() throws Exception {
		try {
			TestCase.exportSchema( new String[] {
				"FooBar.hbm.xml",
				"Baz.hbm.xml",
				"Qux.hbm.xml",
				"Glarch.hbm.xml",
				"Fum.hbm.xml",
				"Fumm.hbm.xml",
				"Fo.hbm.xml",
				"One.hbm.xml",
				"Many.hbm.xml",
				"Immutable.hbm.xml",
				"Fee.hbm.xml",
				"Vetoer.hbm.xml",
				"Holder.hbm.xml",
				"Location.hbm.xml",
				"Stuff.hbm.xml",
				"Container.hbm.xml",
				"Simple.hbm.xml"
			} );
			return new TestSuite(FumTest.class);
		}
		catch (Exception e) {
			e.printStackTrace();
			throw e;
		}
	}
	
}