AutoIncIDTest.java

package org.jooby.internal.mongodb;

import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;

import java.lang.reflect.Field;

import org.jooby.mongodb.GeneratedValue;
import org.jooby.mongodb.IdGen;
import org.jooby.test.MockUnit;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mongodb.morphia.Datastore;
import org.mongodb.morphia.annotations.Id;
import org.mongodb.morphia.mapping.MappedClass;
import org.mongodb.morphia.mapping.Mapper;
import org.mongodb.morphia.query.Query;
import org.mongodb.morphia.query.UpdateOperations;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import com.mongodb.DBObject;

@RunWith(PowerMockRunner.class)
@PrepareForTest({AutoIncID.class, Field.class, StoredId.class })
public class AutoIncIDTest {

  public static class MonDoc {
    @Id
    public Long id;
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void prePersitInit() throws Exception {
    Object entity = new Object();
    new MockUnit(Datastore.class, DBObject.class, Mapper.class, MappedClass.class, Field.class,
        GeneratedValue.class)
            .expect(unit -> {
              GeneratedValue genval = unit.get(GeneratedValue.class);

              Field idField = unit.get(Field.class);
              expect(idField.getAnnotation(GeneratedValue.class)).andReturn(genval);
            })
            .expect(unit -> {
              Field idField = unit.get(Field.class);
              idField.setAccessible(true);
              idField.set(entity, null);

              MappedClass mclass = unit.get(MappedClass.class);
              expect(mclass.getIdField()).andReturn(idField);
              Class clazz = MonDoc.class;
              expect(mclass.getClazz()).andReturn(clazz);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getMappedClass(entity)).andReturn(mclass);

              Query<StoredId> query = unit.mock(Query.class);

              UpdateOperations<StoredId> uops = unit.mock(UpdateOperations.class);
              expect(uops.inc("value")).andReturn(uops);

              StoredId storedId = unit.mockConstructor(StoredId.class, MonDoc.class.getName());

              Datastore ds = unit.get(Datastore.class);
              expect(ds.find(StoredId.class, "_id", MonDoc.class.getName())).andReturn(query);
              expect(ds.createUpdateOperations(StoredId.class)).andReturn(uops);
              expect(ds.findAndModify(query, uops)).andReturn(null);
              expect(ds.save(storedId)).andReturn(null);
            })
            .run(unit -> {
              new AutoIncID(unit.get(Datastore.class), IdGen.LOCAL)
                  .prePersist(entity, unit.get(DBObject.class), unit.get(Mapper.class));
            });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void prePersit() throws Exception {
    Object entity = new Object();
    new MockUnit(Datastore.class, DBObject.class, Mapper.class, MappedClass.class, Field.class,
        GeneratedValue.class)
            .expect(unit -> {
              GeneratedValue genval = unit.get(GeneratedValue.class);

              Field idField = unit.get(Field.class);
              expect(idField.getAnnotation(GeneratedValue.class)).andReturn(genval);
            })
            .expect(unit -> {
              Field idField = unit.get(Field.class);
              idField.setAccessible(true);
              idField.set(entity, 1L);

              MappedClass mclass = unit.get(MappedClass.class);
              expect(mclass.getIdField()).andReturn(idField);
              Class clazz = MonDoc.class;
              expect(mclass.getClazz()).andReturn(clazz);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getMappedClass(entity)).andReturn(mclass);

              Query<StoredId> query = unit.mock(Query.class);

              UpdateOperations<StoredId> uops = unit.mock(UpdateOperations.class);
              expect(uops.inc("value")).andReturn(uops);

              StoredId storedId = new StoredId();

              Datastore ds = unit.get(Datastore.class);
              expect(ds.find(StoredId.class, "_id", "Global")).andReturn(query);
              expect(ds.createUpdateOperations(StoredId.class)).andReturn(uops);
              expect(ds.findAndModify(query, uops)).andReturn(storedId);
            })
            .run(unit -> {
              new AutoIncID(unit.get(Datastore.class), IdGen.GLOBAL)
                  .prePersist(entity, unit.get(DBObject.class), unit.get(Mapper.class));
            });
  }

  @Test
  public void prePersitIgnored() throws Exception {
    Object entity = new Object();
    new MockUnit(Datastore.class, DBObject.class, Mapper.class, MappedClass.class, Field.class,
        GeneratedValue.class)
            .expect(unit -> {
              Field idField = unit.get(Field.class);
              expect(idField.getAnnotation(GeneratedValue.class)).andReturn(null);
            })
            .expect(unit -> {
              Field idField = unit.get(Field.class);

              MappedClass mclass = unit.get(MappedClass.class);
              expect(mclass.getIdField()).andReturn(idField);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getMappedClass(entity)).andReturn(mclass);
            })
            .run(unit -> {
              new AutoIncID(unit.get(Datastore.class), IdGen.GLOBAL)
                  .prePersist(entity, unit.get(DBObject.class), unit.get(Mapper.class));
            });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test(expected = IllegalStateException.class)
  public void prePersitErr() throws Exception {
    Object entity = new Object();
    new MockUnit(Datastore.class, DBObject.class, Mapper.class, MappedClass.class, Field.class,
        GeneratedValue.class)
            .expect(unit -> {
              GeneratedValue genval = unit.get(GeneratedValue.class);

              Field idField = unit.get(Field.class);
              expect(idField.getAnnotation(GeneratedValue.class)).andReturn(genval);
            })
            .expect(unit -> {
              Field idField = unit.get(Field.class);
              idField.setAccessible(true);
              idField.set(entity, 1L);
              expectLastCall().andThrow(new IllegalAccessException("intentional error"));

              MappedClass mclass = unit.get(MappedClass.class);
              expect(mclass.getIdField()).andReturn(idField);
              Class clazz = MonDoc.class;
              expect(mclass.getClazz()).andReturn(clazz);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getMappedClass(entity)).andReturn(mclass);

              Query<StoredId> query = unit.mock(Query.class);

              UpdateOperations<StoredId> uops = unit.mock(UpdateOperations.class);
              expect(uops.inc("value")).andReturn(uops);

              StoredId storedId = new StoredId();

              Datastore ds = unit.get(Datastore.class);
              expect(ds.find(StoredId.class, "_id", "Global")).andReturn(query);
              expect(ds.createUpdateOperations(StoredId.class)).andReturn(uops);
              expect(ds.findAndModify(query, uops)).andReturn(storedId);
            })
            .run(unit -> {
              new AutoIncID(unit.get(Datastore.class), IdGen.GLOBAL)
                  .prePersist(entity, unit.get(DBObject.class), unit.get(Mapper.class));
            });
  }

}