@Test
  public void deleteById() throws NotFoundException {
    when(redisTemplateMock.boundHashOps(CONTACT_KEY)).thenReturn(boundHashOperationsMock);
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);
    when(setOperationsMock.isMember(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY))
        .thenReturn(true);
    initGetHashOperationsForContact(CONTACT_ID);

    Contact deleted = service.deleteById(CONTACT_ID);

    verify(redisTemplateMock, times(2)).boundHashOps(CONTACT_KEY);

    verifyThatContactWasGet();
    verifyThatContactWasDeleted();

    verify(redisTemplateMock, times(2)).opsForSet();
    verify(setOperationsMock, times(1)).isMember(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY);
    verify(setOperationsMock, times(1)).remove(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY);
    verifyNoMoreInteractions(setOperationsMock);

    verifyNoMoreInteractions(boundHashOperationsMock, redisTemplateMock);
    verifyZeroInteractions(contactIdCounterMock);

    assertContact(CONTACT_ID, deleted);
  }
  @Test(expected = NotFoundException.class)
  public void deleteByIdWhenContactIsNotFound() throws NotFoundException {
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);
    when(setOperationsMock.isMember(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY))
        .thenReturn(false);

    service.deleteById(CONTACT_ID);

    verifyThatExistCheckForContactIsDone(CONTACT_KEY);
    verifyNoMoreInteractions(redisTemplateMock, setOperationsMock);

    verifyZeroInteractions(boundHashOperationsMock, contactIdCounterMock);
  }
  @Test
  public void update() throws NotFoundException {
    when(redisTemplateMock.boundHashOps(CONTACT_KEY)).thenReturn(boundHashOperationsMock);
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);
    when(setOperationsMock.isMember(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY))
        .thenReturn(true);

    Contact updated = ContactTestUtil.createModel(CONTACT_ID);
    service.update(updated);

    verify(redisTemplateMock, times(1)).boundHashOps(CONTACT_KEY);
    verifyThatContactWasPersisted(CONTACT_ID, updated);

    verifyThatExistCheckForContactIsDone(CONTACT_KEY);

    verifyNoMoreInteractions(boundHashOperationsMock, redisTemplateMock);
    verifyZeroInteractions(contactIdCounterMock, setOperationsMock);
  }
  @Test
  public void findById() throws NotFoundException {
    when(redisTemplateMock.boundHashOps(CONTACT_KEY)).thenReturn(boundHashOperationsMock);
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);
    when(setOperationsMock.isMember(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY))
        .thenReturn(true);
    initGetHashOperationsForContact(CONTACT_ID);

    Contact found = service.findById(CONTACT_ID);

    verify(redisTemplateMock, times(1)).boundHashOps(CONTACT_KEY);

    verifyThatExistCheckForContactIsDone(CONTACT_KEY);
    verifyThatContactWasGet();

    verifyNoMoreInteractions(boundHashOperationsMock, redisTemplateMock, setOperationsMock);
    verifyZeroInteractions(contactIdCounterMock);

    assertContact(CONTACT_ID, found);
  }
  @Test
  public void add() {
    when(contactIdCounterMock.incrementAndGet()).thenReturn(CONTACT_ID);
    when(redisTemplateMock.boundHashOps(CONTACT_KEY)).thenReturn(boundHashOperationsMock);
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);

    Contact added = ContactTestUtil.createModel();
    Contact actual = service.add(added);

    verify(contactIdCounterMock, times(1)).incrementAndGet();
    verifyNoMoreInteractions(contactIdCounterMock);

    verify(redisTemplateMock, times(1)).boundHashOps(CONTACT_KEY);
    verifyThatContactWasPersisted(CONTACT_ID, added);

    verify(redisTemplateMock, times(1)).opsForSet();
    verify(setOperationsMock, times(1)).add(RedisContactService.KEY_CONTACT_SET, CONTACT_KEY);
    verifyNoMoreInteractions(boundHashOperationsMock, setOperationsMock, redisTemplateMock);

    assertEquals(added, actual);
  }
  @Test
  public void findAll() {
    when(redisTemplateMock.opsForSet()).thenReturn(setOperationsMock);
    when(setOperationsMock.members(RedisContactService.KEY_CONTACT_SET))
        .thenReturn(createKeySet(CONTACT_KEY));
    when(redisTemplateMock.boundHashOps(CONTACT_KEY)).thenReturn(boundHashOperationsMock);
    initGetHashOperationsForContact(CONTACT_ID);

    List<Contact> contacts = service.findAll();

    verify(redisTemplateMock, times(1)).opsForSet();
    verify(redisTemplateMock, times(1)).boundHashOps(CONTACT_KEY);
    verify(setOperationsMock, times(1)).members(RedisContactService.KEY_CONTACT_SET);
    verifyNoMoreInteractions(setOperationsMock);

    verifyThatContactWasGet();
    verifyNoMoreInteractions(boundHashOperationsMock, redisTemplateMock);

    verifyZeroInteractions(contactIdCounterMock);

    assertEquals(1, contacts.size());
    Contact actual = contacts.get(0);
    assertContact(CONTACT_ID, actual);
  }