@Test
  public void get() {
    String key = getKey(getUser("imaPigg"));

    assertThat(usersTemplate.get(key)).isEqualTo(users.get(key));
    assertNullEquals(users.get("mrT"), usersTemplate.get("mrT"));
  }
  @Test
  public void putIfAbsent() {
    User stewieGriffon = newUser("stewieGriffon");

    assertThat(users.containsValue(stewieGriffon)).isFalse();
    assertThat(usersTemplate.putIfAbsent(getKey(stewieGriffon), stewieGriffon)).isNull();
    assertThat(users.containsValue(stewieGriffon)).isTrue();
    assertThat(usersTemplate.putIfAbsent(getKey(stewieGriffon), newUser("megGriffon")))
        .isEqualTo(stewieGriffon);
    assertThat(users.get(getKey(stewieGriffon))).isEqualTo(stewieGriffon);
  }
  @Test
  public void remove() {
    User mandyHandy = users.get(getKey(getUser("mandyHandy")));

    assertThat(mandyHandy).isNotNull();
    assertThat(usersTemplate.remove(getKey(mandyHandy))).isEqualTo(mandyHandy);
    assertThat(users.containsKey(getKey(mandyHandy))).isFalse();
    assertThat(users.containsValue(mandyHandy)).isFalse();
    assertThat(users.containsKey("loisGriffon")).isFalse();
    assertThat(usersTemplate.remove("loisGriffon")).isNull();
    assertThat(users.containsKey("loisGriffon")).isFalse();
  }
  @Test
  public void replaceOldValueWithNewValue() {
    User jackHandy = getUser("jackHandy");
    User imaPigg = getUser("imaPigg");

    assertThat(users.containsValue(jackHandy)).isTrue();
    assertThat(usersTemplate.replace(getKey(jackHandy), null, imaPigg)).isFalse();
    assertThat(users.containsValue(jackHandy)).isTrue();
    assertThat(users.get(getKey(jackHandy))).isEqualTo(jackHandy);
    assertThat(usersTemplate.replace(getKey(jackHandy), jackHandy, imaPigg)).isTrue();
    assertThat(users.containsValue(jackHandy)).isFalse();
    assertThat(users.get(getKey(jackHandy))).isEqualTo(imaPigg);
  }
  @Test
  public void replace() {
    User randyHandy = users.get(getKey(getUser("randyHandy")));
    User lukeFluke = newUser("lukeFluke");
    User chrisGriffon = newUser("chrisGriffon");

    assertThat(randyHandy).isNotNull();
    assertThat(usersTemplate.replace(getKey(randyHandy), lukeFluke)).isEqualTo(randyHandy);
    assertThat(users.get(getKey(randyHandy))).isEqualTo(lukeFluke);
    assertThat(users.containsValue(randyHandy)).isFalse();
    assertThat(users.containsValue(chrisGriffon)).isFalse();
    assertThat(usersTemplate.replace(getKey(chrisGriffon), chrisGriffon)).isNull();
    assertThat(users.containsValue(chrisGriffon)).isFalse();
  }
  @Test
  public void put() {
    User peterGriffon = newUser("peterGriffon");

    assertThat(usersTemplate.put(getKey(peterGriffon), peterGriffon)).isNull();
    assertThat(users.get(getKey(peterGriffon))).isEqualTo(peterGriffon);
  }
  @Test
  public void findUniqueReturnsResult() {
    User jonDoe =
        usersTemplate.findUnique("SELECT u FROM /Users u WHERE u.username = $1", "jonDoe");

    assertThat(jonDoe).isNotNull();
    assertThat(jonDoe).isEqualTo(getUser("jonDoe"));
  }
  @Test
  public void getAllReturnsResults() {
    Map<String, User> users =
        usersTemplate.getAll(Arrays.asList(getKey(getUser("jonDoe")), getKey(getUser("pieDoe"))));

    assertThat(users).isNotNull();
    assertThat(users).isEqualTo(getUsersAsMap(getUser("jonDoe"), getUser("pieDoe")));
  }
  @Test
  public void getAllReturnsNoResults() {
    List<String> keys = Arrays.asList("keyOne", "keyTwo", "keyThree");
    Map<String, User> users = usersTemplate.getAll(keys);

    assertThat(users).isNotNull();
    assertThat(users).isEqualTo(this.users.getAll(keys));
  }
  @Test
  public void create() {
    User bartSimpson = newUser("bartSimpson");

    usersTemplate.create(getKey(bartSimpson), bartSimpson);

    assertThat(users.containsKey(getKey(bartSimpson))).isTrue();
    assertThat(users.containsValueForKey(getKey(bartSimpson))).isTrue();
    assertThat(users.containsValue(bartSimpson)).isTrue();
    assertThat(users.get(getKey(bartSimpson))).isEqualTo(bartSimpson);
  }
  @Test
  public void query() {
    SelectResults<User> queryResults = usersTemplate.query("username LIKE '%Doe'");

    assertThat(queryResults).isNotNull();

    List<User> usersFound = queryResults.asList();

    assertThat(usersFound).isNotNull();
    assertThat(usersFound.size()).isEqualTo(4);
    assertThat(usersFound.containsAll(getUsers("jonDoe", "janeDoe", "pieDoe", "cookieDoe")))
        .isTrue();
  }
  @Test
  public void find() {
    SelectResults<User> findResults =
        usersTemplate.find(
            "SELECT u FROM /Users u WHERE u.username LIKE $1 AND u.active = $2", "%Doe", true);

    assertThat(findResults).isNotNull();

    List<User> usersFound = findResults.asList();

    assertThat(usersFound).isNotNull();
    assertThat(usersFound.size()).isEqualTo(2);
    assertThat(usersFound.containsAll(getUsers("jonDoe", "cookieDoe"))).isTrue();
  }
  @Test
  public void putAll() {
    User batMan = newUser("batMan");
    User spiderMan = newUser("spiderMan");
    User superMan = newUser("superMan");

    Map<String, User> userMap = getUsersAsMap(batMan, spiderMan, superMan);

    assertThat(users.keySet().containsAll(userMap.keySet())).isFalse();
    assertThat(users.values().containsAll(userMap.values())).isFalse();

    usersTemplate.putAll(userMap);

    assertThat(users.keySet().containsAll(userMap.keySet())).isTrue();
    assertThat(users.values().containsAll(userMap.values())).isTrue();
  }
 @Test
 public void containsValue() {
   assertThat(usersTemplate.containsValue(getUser("pieDoe"))).isTrue();
   assertThat(usersTemplate.containsValue(newUser("pieDough"))).isFalse();
 }
 @Test
 public void containsKeyOnServer() {
   assumeThat(CacheUtils.isClient(gemfireCache), is(true));
   assertThat(usersTemplate.containsKeyOnServer(getKey(getUser("jackHandy")))).isTrue();
   assertThat(usersTemplate.containsKeyOnServer("maxPayne")).isFalse();
 }
 @Test(expected = InvalidDataAccessApiUsageException.class)
 public void findUniqueReturnsNoResult() {
   usersTemplate.findUnique("SELECT u FROM /Users u WHERE u.username = $1", "benDover");
 }
 @Test
 public void containsValueForKey() {
   assertThat(usersTemplate.containsValueForKey(getKey(getUser("cookieDoe")))).isTrue();
   assertThat(usersTemplate.containsValueForKey("chocolateChipCookieDoe")).isFalse();
 }
 @Test(expected = InvalidDataAccessApiUsageException.class)
 public void findUnqiueReturnsTooManyResults() {
   usersTemplate.findUnique("SELECT u FROM /Users u WHERE u.username LIKE $1", "%Doe");
 }
 @Test
 public void containsKey() {
   assertThat(usersTemplate.containsKey(getKey(getUser("jonDoe")))).isTrue();
   assertThat(usersTemplate.containsKey("dukeNukem")).isFalse();
 }