@Test
  public void testDeleteRole() {
    // Setup role
    Role role = new Role();
    role.setName("TestRole");

    // Save role, verify has ID value after save
    assertNull(role.getId()); // Null before save
    roleRepository.save(role);
    assertNotNull(role.getId()); // Not null after save

    // Fetch from database
    Role fetchedRole = roleRepository.findOne(role.getId());

    // Should not be null
    assertNotNull(fetchedRole);

    // Delete role from database
    roleRepository.delete(fetchedRole.getId());

    // Fetch from database (should not exist anymore)
    fetchedRole = roleRepository.findOne(role.getId());

    // Should be null
    assertNull(fetchedRole);
  }
 @Cacheable(value = FIND_ALL)
 public Map<Long, Role> findAll() {
   ImmutableMap.Builder<Long, Role> builder = ImmutableMap.builder();
   for (Role role : roleRepository.findAll()) {
     builder.put(role.getId(), role);
   }
   return builder.build();
 }
  @Test
  public void deleteParentCheck() {
    Set<Role> roles =
        Sets.newHashSet(
            roleRepository.save(
                Sets.newHashSet(
                    Role.builder().name("admin").build(),
                    Role.builder().name("verified").build(),
                    Role.builder().name("registered").build())));

    User parent =
        userRepository.save(
            User.builder()
                .accessToken("testAccessToken")
                .email("*****@*****.**")
                .name("testUser")
                .password("testPassword")
                .resetToken("testResetToken")
                .roles(roles)
                .build());

    Check parentCheck =
        checkRepository.save(
            Check.builder()
                .probe("testProbe")
                .interval(1)
                .name("testCheck")
                .state(State.ELECTED)
                .status(Status.UP)
                .user(parent)
                .url("http://www.test.com")
                .build());

    resultRepository.save(
        Result.builder()
            .probe("testProbe")
            .changed(true)
            .confirmation(true)
            .check(parentCheck)
            .responseTime(15)
            .status(Status.UP)
            .statusCode(200)
            .build());

    checkRepository.delete(parentCheck);
    List<Result> results = resultRepository.findByCheckId(parentCheck.getId(), null).getContent();
    Assert.assertTrue(results.isEmpty());
    userRepository.delete(parent);
  }
  @Test
  public void testSaveRole() {
    // Setup role
    Role role = new Role();
    role.setName("TestRole");

    // Save role, verify has ID value after save
    assertNull(role.getId()); // Null before save
    roleRepository.save(role);
    assertNotNull(role.getId()); // Not null after save

    // Fetch from database
    Role fetchedRole = roleRepository.findOne(role.getId());

    // Should not be null
    assertNotNull(fetchedRole);

    // Should equals
    assertEquals(role.getId(), fetchedRole.getId());
    assertEquals(role.getName(), fetchedRole.getName());

    // Update description and save
    fetchedRole.setName("NewRoleName");
    roleRepository.save(fetchedRole);

    // Get from database, should be updated
    Role fetchedUpdatedRole = roleRepository.findOne(fetchedRole.getId());
    assertEquals(fetchedRole.getName(), fetchedUpdatedRole.getName());

    // Verify count of roles in database
    long roleCount = roleRepository.count();
    assertEquals(roleCount, origRoleRepositorySize + 1); // One role has been added to the database

    // Get all roles, list should only have one more then initial value
    Iterable<Role> roles = roleRepository.findAll();

    int count = 0;

    for (Role p : roles) {
      count++;
    }

    // There are originally 'origRoleRepositorySize' roles declared in the database (+1 has been
    // added in this test)
    assertEquals(count, origRoleRepositorySize + 1);
  }
 @Before
 public void setup() {
   origRoleRepositorySize = (int) roleRepository.count();
 }
  @Test
  public void findByPrevious() {
    Set<Role> roles =
        Sets.newHashSet(
            roleRepository.save(
                Sets.newHashSet(
                    Role.builder().name("admin").build(),
                    Role.builder().name("verified").build(),
                    Role.builder().name("registered").build())));

    User parent =
        userRepository.save(
            User.builder()
                .accessToken("testAccessToken")
                .email("*****@*****.**")
                .name("testUser")
                .password("testPassword")
                .resetToken("testResetToken")
                .roles(roles)
                .build());

    Check parentCheck =
        checkRepository.save(
            Check.builder()
                .probe("testProbe")
                .interval(1)
                .name("testCheck")
                .state(State.ELECTED)
                .status(Status.UP)
                .user(parent)
                .url("http://www.test.com")
                .build());

    Result previousResult =
        resultRepository.save(
            Result.builder()
                .probe("testProbe")
                .changed(true)
                .confirmation(true)
                .check(parentCheck)
                .responseTime(15)
                .status(Status.UP)
                .statusCode(200)
                .build());

    Result result =
        resultRepository.save(
            Result.builder()
                .probe("testProbe")
                .changed(true)
                .confirmation(true)
                .check(parentCheck)
                .previous(previousResult)
                .responseTime(15)
                .status(Status.UP)
                .statusCode(200)
                .build());

    Result foundResult = resultRepository.findByPrevious(previousResult.getId()).get(0);
    Assert.assertEquals(result.getId(), foundResult.getId());
    userRepository.delete(parent);
  }
  /** Stores to persistence layer initial data. */
  @PostConstruct
  public void init() {
    if (roleRepository.findByName("ROLE_ADMIN") == null) {
      Role roleUser = new Role();
      roleUser.setName("ROLE_USER");
      roleRepository.save(roleUser);

      Role roleAdmin = new Role();
      roleAdmin.setName("ROLE_ADMIN");
      roleRepository.save(roleAdmin);

      User user = new User();
      user.setEnabled(true);
      user.setEmail("admin@admin");

      BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
      user.setPassword(encoder.encode("admin"));
      List<Role> roles = new ArrayList<>();
      roles.add(roleAdmin);
      roles.add(roleUser);
      user.setRoles(roles);
      userRepository.save(user);

      // Create account for wallet
      Account walletAccount = new Account();
      walletAccount.setName(context.getMessage("Name.default.account", null, Locale.ENGLISH));
      walletAccount.setUser(user);
      walletAccount.setAmount(new BigDecimal(0));
      walletAccount.setCurrency(Currency.getInstance("UAH"));
      accountRepository.save(walletAccount);

      Account bankAccount = new Account();
      bankAccount.setName("Bank");
      bankAccount.setUser(user);
      bankAccount.setAmount(new BigDecimal(500));
      bankAccount.setCurrency(Currency.getInstance("UAH"));
      accountRepository.save(bankAccount);

      // Create categories for expenses
      for (int i = 1; i < 6; i++) {
        Category category = new Category();
        category.setName(
            context.getMessage("Name" + i + ".default.category", null, Locale.ENGLISH));
        category.setType(Operation.EXPENSE);
        category.setUser(user);
        categoryRepository.save(category);
      }

      // Create categories for incomes
      for (int i = 6; i < 8; i++) {
        Category category = new Category();
        category.setName(
            context.getMessage("Name" + i + ".default.category", null, Locale.ENGLISH));
        category.setType(Operation.INCOME);
        category.setUser(user);
        categoryRepository.save(category);
      }

      Transaction transaction1 = new Transaction();
      transaction1.setDate(new Date());
      transaction1.setAccount(walletAccount);
      transaction1.setAmount(new BigDecimal(50));
      transaction1.setCurrency(Currency.getInstance("UAH"));
      transaction1.setCategory(categoryRepository.findOne(3));
      transaction1.setType(Operation.EXPENSE);
      transaction1.setComment("McDonalds");
      transaction1.setUser(user);
      transactionRepository.save(transaction1);

      Transaction transaction2 = new Transaction();
      Calendar calendar = new GregorianCalendar();
      calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1);
      transaction2.setDate(calendar.getTime());
      transaction2.setAccount(bankAccount);
      transaction2.setAmount(new BigDecimal(45));
      transaction2.setCurrency(Currency.getInstance("UAH"));
      transaction2.setCategory(categoryRepository.findOne(7));
      transaction2.setType(Operation.INCOME);
      transaction2.setComment("Festo");
      transaction2.setUser(user);
      transactionRepository.save(transaction2);

      List<Transaction> transactions = new ArrayList<>();
      transactions.add(transaction1);
      user.setTransactions(transactions);
    }
  }