DatastoreTest.java

package org.jooby.cassandra;

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

import org.jooby.test.MockUnit;
import org.jooby.test.MockUnit.Block;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.ResultSetFuture;
import com.datastax.driver.core.Session;
import com.datastax.driver.core.SimpleStatement;
import com.datastax.driver.mapping.Mapper;
import com.datastax.driver.mapping.MappingManager;
import com.datastax.driver.mapping.Result;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;

@RunWith(PowerMockRunner.class)
@PrepareForTest({Datastore.class, SimpleStatement.class, Futures.class })
public class DatastoreTest {

  public static class Bean {
  }

  @Test
  public void newDatastore() throws Exception {
    new MockUnit(MappingManager.class, Mapper.class)
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class));
        });
  }

  @SuppressWarnings("rawtypes")
  @Test
  public void get() throws Exception {
    Bean bean = new Bean();
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.get("beanId")).andReturn(bean);
        })
        .run(unit -> {
          Bean result = new Datastore(unit.get(MappingManager.class))
              .get(Bean.class, "beanId");
          assertEquals(bean, result);
        });
  }

  @SuppressWarnings("rawtypes")
  @Test
  public void getAsync() throws Exception {
    ListenableFuture<Bean> bean = Futures.immediateFuture(new Bean());
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.getAsync("beanId")).andReturn(bean);
        })
        .run(unit -> {
          ListenableFuture<Bean> result = new Datastore(unit.get(MappingManager.class))
              .getAsync(Bean.class, "beanId");
          assertEquals(bean, result);
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void delete() throws Exception {
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          mapper.delete("beanId", new Mapper.Option[0]);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .delete(Bean.class, "beanId");
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void deleteAsync() throws Exception {
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.deleteAsync("beanId", new Mapper.Option[0])).andReturn(null);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .deleteAsync(Bean.class, "beanId");
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void deleteAsyncEntity() throws Exception {
    Bean bean = new Bean();
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.deleteAsync(bean, new Mapper.Option[0])).andReturn(null);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .deleteAsync(bean);
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void deleteEntity() throws Exception {
    Bean bean = new Bean();
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          mapper.delete(bean, new Mapper.Option[0]);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .delete(bean);
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void save() throws Exception {
    Bean bean = new Bean();
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          mapper.save(bean, new Mapper.Option[0]);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .save(bean);
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void saveAsync() throws Exception {
    Bean bean = new Bean();
    new MockUnit(MappingManager.class, Mapper.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.saveAsync(bean, new Mapper.Option[0])).andReturn(null);
        })
        .run(unit -> {
          new Datastore(unit.get(MappingManager.class))
              .saveAsync(bean);
        });
  }

  @SuppressWarnings({"rawtypes" })
  @Test
  public void queryString() throws Exception {
    new Bean();
    String statement = "select * from beer";
    new MockUnit(MappingManager.class, Mapper.class, Session.class, ResultSet.class, Result.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          ResultSet rs = unit.get(ResultSet.class);

          Session session = unit.get(Session.class);
          expect(session.execute(unit.capture(SimpleStatement.class))).andReturn(rs);

          MappingManager manager = unit.get(MappingManager.class);
          expect(manager.getSession()).andReturn(session);

          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.getManager()).andReturn(manager);
          expect(mapper.map(rs)).andReturn(unit.get(Result.class));
        })
        .run(unit -> {
          Result<Bean> r = new Datastore(unit.get(MappingManager.class))
              .query(Bean.class, statement);
          assertEquals(unit.get(Result.class), r);
        }, unit -> {
          SimpleStatement stt = unit.captured(SimpleStatement.class).iterator().next();
          assertEquals(statement, stt.getQueryString());
          assertEquals(0, stt.valuesCount());
        });
  }

  @SuppressWarnings({"rawtypes" })
  @Test
  public void queryStatementMap() throws Exception {
    new Bean();
    String statement = ("select * from beer");
    new MockUnit(MappingManager.class, Mapper.class, Session.class, ResultSet.class, Result.class)
        .expect(mapper(Bean.class))
        .expect(unit -> {
          ResultSet rs = unit.get(ResultSet.class);

          Session session = unit.get(Session.class);
          expect(session.execute(unit.capture(SimpleStatement.class))).andReturn(rs);

          MappingManager manager = unit.get(MappingManager.class);
          expect(manager.getSession()).andReturn(session);

          Mapper mapper = unit.get(Mapper.class);
          expect(mapper.getManager()).andReturn(manager);
          expect(mapper.map(rs)).andReturn(unit.get(Result.class));
        })
        .run(unit -> {
          Result<Bean> r = new Datastore(unit.get(MappingManager.class))
              .query(Bean.class, statement, ImmutableMap.of("foo", "bar"));
          assertEquals(unit.get(Result.class), r);
        }, unit -> {
          SimpleStatement stt = unit.captured(SimpleStatement.class).iterator().next();
          assertEquals(statement, stt.getQueryString());
          assertEquals(1, stt.valuesCount());
          assertEquals(ImmutableSet.of("foo"), stt.getValueNames());
        });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void queryAsyncStatement() throws Exception {
    String statement = ("select * from beer");
    new MockUnit(MappingManager.class, Mapper.class, Session.class, ResultSetFuture.class,
        Result.class, ListenableFuture.class, ResultSet.class)
            .expect(mapper(Bean.class))
            .expect(unit -> {
              ResultSetFuture rs = unit.get(ResultSetFuture.class);

              Session session = unit.get(Session.class);
              expect(session.executeAsync(unit.capture(SimpleStatement.class))).andReturn(rs);

              MappingManager manager = unit.get(MappingManager.class);
              expect(manager.getSession()).andReturn(session);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getManager()).andReturn(manager);
              expect(mapper.map(unit.get(ResultSet.class))).andReturn(unit.get(Result.class));

              unit.mockStatic(Futures.class);
              expect(Futures.transformAsync(eq(rs), unit.capture(AsyncFunction.class)))
                  .andReturn(unit.get(ListenableFuture.class));
              expect(Futures.immediateFuture(unit.get(Result.class)))
                  .andReturn(unit.get(ListenableFuture.class));
            })
            .run(unit -> {
              ListenableFuture<Result<Bean>> r = new Datastore(unit.get(MappingManager.class))
                  .queryAsync(Bean.class, statement);
              assertEquals(unit.get(ListenableFuture.class), r);
            }, unit -> {
              AsyncFunction fn = unit.captured(AsyncFunction.class).iterator().next();
              ListenableFuture f = fn.apply(unit.get(ResultSet.class));
              assertEquals(unit.get(ListenableFuture.class), f);
            }, unit -> {
              SimpleStatement stt = unit.captured(SimpleStatement.class).iterator().next();
              assertEquals(statement, stt.getQueryString());
              assertEquals(0, stt.valuesCount());
            });
  }

  @SuppressWarnings({"rawtypes", "unchecked" })
  @Test
  public void queryAsyncStatementMap() throws Exception {
    String statement = ("select * from beer");
    new MockUnit(MappingManager.class, Mapper.class, Session.class, ResultSetFuture.class,
        Result.class, ListenableFuture.class, ResultSet.class)
            .expect(mapper(Bean.class))
            .expect(unit -> {
              ResultSetFuture rs = unit.get(ResultSetFuture.class);

              Session session = unit.get(Session.class);
              expect(session.executeAsync(unit.capture(SimpleStatement.class))).andReturn(rs);

              MappingManager manager = unit.get(MappingManager.class);
              expect(manager.getSession()).andReturn(session);

              Mapper mapper = unit.get(Mapper.class);
              expect(mapper.getManager()).andReturn(manager);
              expect(mapper.map(unit.get(ResultSet.class))).andReturn(unit.get(Result.class));

              unit.mockStatic(Futures.class);
              expect(Futures.transformAsync(eq(rs), unit.capture(AsyncFunction.class)))
                  .andReturn(unit.get(ListenableFuture.class));
              expect(Futures.immediateFuture(unit.get(Result.class)))
                  .andReturn(unit.get(ListenableFuture.class));
            })
            .run(unit -> {
              ListenableFuture<Result<Bean>> r = new Datastore(unit.get(MappingManager.class))
                  .queryAsync(Bean.class, statement, ImmutableMap.of("foo", "bar"));
              assertEquals(unit.get(ListenableFuture.class), r);
            }, unit -> {
              AsyncFunction fn = unit.captured(AsyncFunction.class).iterator().next();
              ListenableFuture f = fn.apply(unit.get(ResultSet.class));
              assertEquals(unit.get(ListenableFuture.class), f);
            }, unit -> {
              SimpleStatement stt = unit.captured(SimpleStatement.class).iterator().next();
              assertEquals(statement, stt.getQueryString());
              assertEquals(1, stt.valuesCount());
              assertEquals(ImmutableSet.of("foo"), stt.getValueNames());
            });
  }

  @SuppressWarnings({"unchecked", "rawtypes" })
  private Block mapper(final Class type) {
    return unit -> {
      MappingManager manager = unit.get(MappingManager.class);
      expect(manager.mapper(type)).andReturn(unit.get(Mapper.class));
    };
  }
}