GuiceObjectFactoryTest.java

package org.jooby.internal.mongodb;

import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.isA;
import static org.junit.Assert.assertEquals;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.inject.Inject;

import org.jooby.Registry;
import org.jooby.test.MockUnit;
import org.junit.Test;
import org.mongodb.morphia.Morphia;
import org.mongodb.morphia.ObjectFactory;
import org.mongodb.morphia.mapping.MappedField;
import org.mongodb.morphia.mapping.Mapper;
import org.mongodb.morphia.mapping.MapperOptions;

import com.mongodb.DBObject;

public class GuiceObjectFactoryTest {

  public static class Injectable {

    @Inject
    public Injectable() {
    }
  }

  MockUnit.Block boot = unit -> {
    ObjectFactory delegate = unit.get(ObjectFactory.class);

    MapperOptions options = unit.mock(MapperOptions.class);
    expect(options.getObjectFactory()).andReturn(delegate);
    options.setObjectFactory(isA(GuiceObjectFactory.class));

    Mapper mapper = unit.get(Mapper.class);
    expect(mapper.getOptions()).andReturn(options);

    Morphia morphia = unit.get(Morphia.class);
    expect(morphia.getMapper()).andReturn(mapper);
  };

  @Test
  public void createInstanceFromClazz() throws Exception {
    Injectable injectable = new Injectable();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class)
        .expect(boot)
        .expect(unit -> {
          Registry injector = unit.get(Registry.class);
          expect(injector.require(Injectable.class)).andReturn(injectable);
        })
        .run(unit -> {
          assertEquals(injectable,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createInstance(Injectable.class));

        });
  }

  @Test
  public void createInstanceFromClazzNoInjectable() throws Exception {
    GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class)
        .expect(boot)
        .expect(unit -> {
          ObjectFactory injector = unit.get(ObjectFactory.class);
          expect(injector.createInstance(GuiceObjectFactoryTest.class)).andReturn(expected);
        })
        .run(unit -> {
          assertEquals(expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createInstance(GuiceObjectFactoryTest.class));

        });
  }

  @Test
  public void createInstanceFromClazzWithDBObject() throws Exception {
    Injectable injectable = new Injectable();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class)
        .expect(boot)
        .expect(unit -> {
          Registry injector = unit.get(Registry.class);
          expect(injector.require(Injectable.class)).andReturn(injectable);
        })
        .run(unit -> {
          assertEquals(injectable,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createInstance(Injectable.class, unit.get(DBObject.class)));

        });
  }

  @Test
  public void createInstanceFromClazzWithDBObjectNoInjectable() throws Exception {
    GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class)
        .expect(boot)
        .expect(unit -> {
          ObjectFactory factory = unit.get(ObjectFactory.class);
          expect(factory.createInstance(GuiceObjectFactoryTest.class, unit.get(DBObject.class)))
              .andReturn(expected);
        })
        .run(unit -> {
          assertEquals(expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createInstance(GuiceObjectFactoryTest.class, unit.get(DBObject.class)));

        });
  }

  @Test
  public void createInstanceFully() throws Exception {
    Injectable injectable = new Injectable();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class,
        MappedField.class)
        .expect(boot)
        .expect(unit -> {
          MappedField mf = unit.get(MappedField.class);
          expect(mf.getType()).andReturn(Injectable.class);

          Registry injector = unit.get(Registry.class);
          expect(injector.require(Injectable.class)).andReturn(injectable);
        })
        .run(
            unit -> {
              assertEquals(
                  injectable,
                  new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                      .createInstance(unit.get(Mapper.class), unit.get(MappedField.class),
                          unit.get(DBObject.class)));

            });
  }

  @Test
  public void createInstanceFullyNoInjectable() throws Exception {
    GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class,
        MappedField.class)
        .expect(boot)
        .expect(unit -> {
          MappedField mf = unit.get(MappedField.class);
          expect(mf.getType()).andReturn(GuiceObjectFactoryTest.class);

          ObjectFactory factory = unit.get(ObjectFactory.class);
          expect(factory.createInstance(unit.get(Mapper.class), mf, unit.get(DBObject.class)))
              .andReturn(expected);
        })
        .run(unit -> {
          assertEquals(
              expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createInstance(unit.get(Mapper.class), unit.get(MappedField.class),
                      unit.get(DBObject.class)));

        });
  }

  @Test
  public void createMap() throws Exception {
    Map<String, Object> expected = Collections.emptyMap();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
        MappedField.class)
        .expect(boot)
        .expect(unit -> {
          ObjectFactory factory = unit.get(ObjectFactory.class);
          expect(factory.createMap(unit.get(MappedField.class))).andReturn(expected);
        })
        .run(unit -> {
          assertEquals(
              expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createMap(unit.get(MappedField.class)));

        });
  }

  @Test
  public void createSet() throws Exception {
    Set<String> expected = Collections.emptySet();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
        MappedField.class)
        .expect(boot)
        .expect(unit -> {
          ObjectFactory factory = unit.get(ObjectFactory.class);
          expect(factory.createSet(unit.get(MappedField.class))).andReturn(expected);
        })
        .run(unit -> {
          assertEquals(
              expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createSet(unit.get(MappedField.class)));

        });
  }

  @Test
  public void createList() throws Exception {
    List<String> expected = Collections.emptyList();

    new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
        MappedField.class)
        .expect(boot)
        .expect(unit -> {
          ObjectFactory factory = unit.get(ObjectFactory.class);
          expect(factory.createList(unit.get(MappedField.class))).andReturn(expected);
        })
        .run(unit -> {
          assertEquals(
              expected,
              new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                  .createList(unit.get(MappedField.class)));

        });
  }

}