RedisSessionStoreTest.java

package org.jooby.jedis;

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

import java.util.Collections;
import java.util.Map;

import org.jooby.Session;
import org.jooby.test.MockUnit;
import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;

public class RedisSessionStoreTest {

  @Test
  public void save() throws Exception {
    Map<String, String> attrs = ImmutableMap.of("x", "X");
    Map<String, String> attrsToSave = ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        );
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {
          Session session = unit.get(Session.class);
          expect(session.id()).andReturn("1234");
          expect(session.attributes()).andReturn(attrs);
          expect(session.createdAt()).andReturn(1L);
          expect(session.accessedAt()).andReturn(2L);
          expect(session.savedAt()).andReturn(3L);
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hmset("sessions:1234", attrsToSave)).andReturn("sessions:1234");
          expect(jedis.expire("sessions:1234", 1800)).andReturn(1L);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .save(unit.get(Session.class));
        });
  }

  @Test
  public void saveNoTimeout() throws Exception {
    Map<String, String> attrs = ImmutableMap.of("x", "X");
    Map<String, String> attrsToSave = ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        );
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {
          Session session = unit.get(Session.class);
          expect(session.id()).andReturn("1234");
          expect(session.attributes()).andReturn(attrs);
          expect(session.createdAt()).andReturn(1L);
          expect(session.accessedAt()).andReturn(2L);
          expect(session.savedAt()).andReturn(3L);
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hmset("sessions:1234", attrsToSave)).andReturn("sessions:1234");
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "0")
              .save(unit.get(Session.class));
        });
  }

  @Test
  public void create() throws Exception {
    Map<String, String> attrs = ImmutableMap.of("x", "X");
    Map<String, String> attrsToSave = ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        );
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {
          Session session = unit.get(Session.class);
          expect(session.id()).andReturn("1234");
          expect(session.attributes()).andReturn(attrs);
          expect(session.createdAt()).andReturn(1L);
          expect(session.accessedAt()).andReturn(2L);
          expect(session.savedAt()).andReturn(3L);
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hmset("sessions:1234", attrsToSave)).andReturn("sessions:1234");
          expect(jedis.expire("sessions:1234", 1800)).andReturn(1L);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .create(unit.get(Session.class));
        });
  }

  @Test
  public void saveTimeoutInSecs() throws Exception {
    Map<String, String> attrs = ImmutableMap.of("x", "X");
    Map<String, String> attrsToSave = ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        );
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {
          Session session = unit.get(Session.class);
          expect(session.id()).andReturn("1234");
          expect(session.attributes()).andReturn(attrs);
          expect(session.createdAt()).andReturn(1L);
          expect(session.accessedAt()).andReturn(2L);
          expect(session.savedAt()).andReturn(3L);
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hmset("sessions:1234", attrsToSave)).andReturn("sessions:1234");
          expect(jedis.expire("sessions:1234", 30)).andReturn(1L);

          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", 30)
              .save(unit.get(Session.class));
        });
  }

  @Test
  public void delete() throws Exception {
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {

          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.del("sessions:1234")).andReturn(1L);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .delete("1234");
        });
  }

  @Test
  public void get() throws Exception {
    Map<String, String> attrs = Maps.newHashMap(ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        ));

    new MockUnit(JedisPool.class, Session.class, Session.Builder.class)
        .expect(unit -> {
          Session.Builder sb = unit.get(Session.Builder.class);
          expect(sb.sessionId()).andReturn("1234");
          expect(sb.accessedAt(2)).andReturn(sb);
          expect(sb.createdAt(1)).andReturn(sb);
          expect(sb.savedAt(3)).andReturn(sb);
          expect(sb.set(ImmutableMap.of("x", "X"))).andReturn(sb);
          expect(sb.build()).andReturn(unit.get(Session.class));
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hgetAll("sessions:1234")).andReturn(attrs);
          expect(jedis.expire("sessions:1234", 1800)).andReturn(1L);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          assertEquals(unit.get(Session.class), new RedisSessionStore(
              unit.get(JedisPool.class), "sessions", "30m")
              .get(unit.get(Session.Builder.class)));
        });
  }

  @Test
  public void getNoTimeout() throws Exception {
    Map<String, String> attrs = Maps.newHashMap(ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        ));

    new MockUnit(JedisPool.class, Session.class, Session.Builder.class)
        .expect(unit -> {
          Session.Builder sb = unit.get(Session.Builder.class);
          expect(sb.sessionId()).andReturn("1234");
          expect(sb.accessedAt(2)).andReturn(sb);
          expect(sb.createdAt(1)).andReturn(sb);
          expect(sb.savedAt(3)).andReturn(sb);
          expect(sb.set(ImmutableMap.of("x", "X"))).andReturn(sb);
          expect(sb.build()).andReturn(unit.get(Session.class));
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hgetAll("sessions:1234")).andReturn(attrs);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          assertEquals(unit.get(Session.class), new RedisSessionStore(
              unit.get(JedisPool.class), "sessions", "0")
              .get(unit.get(Session.Builder.class)));
        });
  }

  @Test
  public void getNullExpired() throws Exception {
    Map<String, String> attrs = null;

    new MockUnit(JedisPool.class, Session.Builder.class)
        .expect(unit -> {
          Session.Builder sb = unit.get(Session.Builder.class);
          expect(sb.sessionId()).andReturn("1234");
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hgetAll("sessions:1234")).andReturn(attrs);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          assertEquals(null, new RedisSessionStore(
              unit.get(JedisPool.class), "sessions", "30m")
              .get(unit.get(Session.Builder.class)));
        });
  }

  @Test
  public void getEmptyExpired() throws Exception {
    Map<String, String> attrs = Collections.emptyMap();

    new MockUnit(JedisPool.class, Session.Builder.class)
        .expect(unit -> {
          Session.Builder sb = unit.get(Session.Builder.class);
          expect(sb.sessionId()).andReturn("1234");
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hgetAll("sessions:1234")).andReturn(attrs);
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          assertEquals(null, new RedisSessionStore(
              unit.get(JedisPool.class), "sessions", "30m")
              .get(unit.get(Session.Builder.class)));
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldCloseJedisOnGetErr() throws Exception {
    new MockUnit(JedisPool.class, Session.Builder.class)
        .expect(unit -> {
          Session.Builder sb = unit.get(Session.Builder.class);
          expect(sb.sessionId()).andReturn("1234");
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hgetAll("sessions:1234"))
              .andThrow(new IllegalStateException("intentional err"));

          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .get(unit.get(Session.Builder.class));
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldNotCloseJedisOnGetPoolErr() throws Exception {
    new MockUnit(JedisPool.class, Session.Builder.class)
        .expect(unit -> {
          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource())
              .andThrow(new IllegalStateException("intentional err"));
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .get(unit.get(Session.Builder.class));
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldCloseJedisOnSaveErr() throws Exception {
    Map<String, String> attrs = ImmutableMap.of("x", "X");
    Map<String, String> attrsToSave = ImmutableMap
        .of(
            "x", "X",
            "_accessedAt", "2",
            "_createdAt", "1",
            "_savedAt", "3"
        );
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {
          Session session = unit.get(Session.class);
          expect(session.id()).andReturn("1234");
          expect(session.attributes()).andReturn(attrs);
          expect(session.createdAt()).andReturn(1L);
          expect(session.accessedAt()).andReturn(2L);
          expect(session.savedAt()).andReturn(3L);
        })
        .expect(unit -> {
          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.hmset("sessions:1234", attrsToSave))
              .andThrow(new IllegalStateException("intentional err"));
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .save(unit.get(Session.class));
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldNotCloseJedisOnSavePoolErr() throws Exception {
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource())
              .andThrow(new IllegalStateException("intentional err"));
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .save(unit.get(Session.class));
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldCloseJedisOnDeleteErr() throws Exception {
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {

          Jedis jedis = unit.mock(Jedis.class);
          expect(jedis.del("sessions:1234"))
              .andThrow(new IllegalStateException("intentional err"));
          jedis.close();

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource()).andReturn(jedis);
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .delete("1234");
        });
  }

  @Test(expected = IllegalStateException.class)
  public void shouldNotCloseJedisOnDeletePoolErr() throws Exception {
    new MockUnit(JedisPool.class, Session.class)
        .expect(unit -> {

          JedisPool pool = unit.get(JedisPool.class);
          expect(pool.getResource())
              .andThrow(new IllegalStateException("intentional err"));
        })
        .run(unit -> {
          new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
              .delete("1234");
        });
  }

}