@Test

public void testEqualsAndHashCode() {

DBRef ref = new DBRef(getDatabase(), "foo.bar", 4);

DBRef other = new DBRef(getDatabase(), "foo.bar", 4);

assertEquals(ref, ref);

assertEquals(ref, other);

assertNotEquals(ref, new DBRefBase(getDatabase(), "foo.bar", 4));

assertEquals(ref.hashCode(), other.hashCode());

}

@Test

public void testDBRefBaseToString(){

ObjectId id = new ObjectId("123456789012345678901234");

DBRefBase ref = new DBRefBase(getDatabase(), "foo.bar", id);

assertEquals("{ \"$ref\" : \"foo.bar\", \"$id\" : \"123456789012345678901234\" }", ref.toString());

}

@Test

public void testDBRef(){

DBRef ref = new DBRef(getDatabase(), "hello", "world");

DBObject o = new BasicDBObject("!", ref);

DBEncoder encoder = DefaultDBEncoder.FACTORY.create();

OutputBuffer buf = new BasicOutputBuffer();

encoder.writeObject(buf, o);

DefaultDBCallback cb = new DefaultDBCallback( null );

BSONDecoder decoder = new BasicBSONDecoder();

decoder.decode( buf.toByteArray() , cb );

DBObject read = cb.dbget();

assertEquals("{\"!\":{\"$ref\":\"hello\",\"$id\":\"world\"}}", read.toString().replaceAll( " +" , "" ));

}

@Test

public void testDBRefFetches(){

DBCollection coll = collection;

BasicDBObject obj = new BasicDBObject("_id", 321325243);

coll.save(obj);

DBRef ref = new DBRef(getDatabase(), coll.getName(), 321325243);

DBObject deref = ref.fetch();

assertTrue(deref != null);

assertEquals(321325243, ((Number)deref.get("_id")).intValue());

DBObject refobj = BasicDBObjectBuilder.start().add("$ref", coll.getName()).add("$id", 321325243).get();

deref = DBRef.fetch(getDatabase(), refobj);

assertTrue(deref != null);

assertEquals(321325243, ((Number)deref.get("_id")).intValue());

}

@SuppressWarnings("unchecked")

@Test

public void testRefListRoundTrip(){

DBCollection a = collection;

List<DBRef> refs = new ArrayList<DBRef>();

refs.add(new DBRef(getDatabase(), "other", 12));

refs.add(new DBRef(getDatabase(), "other", 14));

refs.add(new DBRef(getDatabase(), "other", 16));

a.save( BasicDBObjectBuilder.start( "refs" , refs).get() );

DBObject loaded = a.findOne();

assertNotNull( loaded );

List<DBRef> refsLoaded = (List<DBRef>) loaded.get("refs");

assertNotNull( refsLoaded );

assertEquals(3, refsLoaded.size());

assertEquals(DBRef.class, refsLoaded.get(0).getClass());

assertEquals(12, refsLoaded.get(0).getId());

assertEquals(14, refsLoaded.get(1).getId());

assertEquals(16, refsLoaded.get(2).getId());

}

@Test

public void testRoundTrip(){

DBCollection a = getDatabase().getCollection( collection.getName() + ".refroundtripa" );

DBCollection b = getDatabase().getCollection( collection.getName() + ".refroundtripb" );

a.drop();

b.drop();

a.save( BasicDBObjectBuilder.start( "_id" , 17 ).add( "n" , 111 ).get() );

b.save( BasicDBObjectBuilder.start( "n" , 12 ).add( "l" , new DBRef( getDatabase() , a.getName() , 17 ) ).get() );

assertEquals( 12 , b.findOne().get( "n" ) );

assertEquals( DBRef.class , b.findOne().get( "l" ).getClass() );

assertEquals( 111 , ((DBRef)(b.findOne().get( "l" ))).fetch().get( "n" ) );

}

@Test

public void testFindByDBRef(){

DBCollection b = getDatabase().getCollection( "b" );

b.drop();

DBRef ref = new DBRef( getDatabase() , "fake" , 17 );

b.save( BasicDBObjectBuilder.start( "n" , 12 ).add( "l" , ref ).get() );

assertEquals( 12 , b.findOne().get( "n" ) );

assertEquals( DBRef.class , b.findOne().get( "l" ).getClass() );

DBObject loaded = b.findOne(BasicDBObjectBuilder.start( "l" , ref ).get() );

assertEquals( 12 , loaded.get( "n" ) );

assertEquals( DBRef.class , loaded.get( "l" ).getClass() );

assertEquals( ref.getId(), ((DBRef)loaded.get( "l" )).getId());

assertEquals( ref.getRef(), ((DBRef)loaded.get( "l" )).getRef());

assertEquals( ref.getDB(), ((DBRef)loaded.get( "l" )).getDB());

}

@Test

public void testGetEntityWithSingleDBRefWithCompoundId() {

DBCollection a = getDatabase().getCollection("a");

a.drop();

BasicDBObject compoundId = new BasicDBObject("name", "someName").append("email", "test@example.com");

BasicDBObject entity = new BasicDBObject("_id", "testId").append("ref", new DBRef(getDatabase(), "fake", compoundId));

a.save(entity);

DBObject fetched = a.findOne(new BasicDBObject("_id", "testId"));

assertNotNull(fetched);

assertFalse(fetched.containsField("$id"));

assertEquals(fetched, entity);

}

@Test

public void testGetEntityWithArrayOfDBRefsWithCompoundIds() {

DBCollection a = getDatabase().getCollection("a");

a.drop();

BasicDBObject compoundId1 = new BasicDBObject("name", "someName").append("email", "test@example.com");

BasicDBObject compoundId2 = new BasicDBObject("name", "someName2").append("email", "test2@example.com");

BasicDBList listOfRefs = new BasicDBList();

listOfRefs.add(new DBRef(getDatabase(), "fake", compoundId1));

listOfRefs.add(new DBRef(getDatabase(), "fake", compoundId2));

BasicDBObject entity = new BasicDBObject("_id", "testId").append("refs", listOfRefs);

a.save(entity);

DBObject fetched = a.findOne(new BasicDBObject("_id", "testId"));

assertNotNull(fetched);

assertEquals(fetched, entity);

}

@Test

public void testGetEntityWithMapOfDBRefsWithCompoundIds() {

DBCollection base = getDatabase().getCollection("basecollection");

base.drop();

BasicDBObject compoundId1 = new BasicDBObject("name", "someName").append("email", "test@example.com");

BasicDBObject compoundId2 = new BasicDBObject("name", "someName2").append("email", "test2@example.com");

BasicDBObject mapOfRefs = new BasicDBObject()

.append("someName", new DBRef(getDatabase(), "compoundkeys", compoundId1))

.append("someName2", new DBRef(getDatabase(), "compoundkeys", compoundId2));

BasicDBObject entity = new BasicDBObject("_id", "testId").append("refs", mapOfRefs);

base.save(entity);

DBObject fetched = base.findOne(new BasicDBObject("_id", "testId"));

assertNotNull(fetched);

DBObject fetchedRefs = (DBObject) fetched.get("refs");

assertFalse(fetchedRefs.keySet().contains("$id"));

assertEquals(fetched, entity);

}