How to use

Repository

in

com.castlemock.repository

/**
 * Retrieves a list of all the instances of the specific type
 * @return A list that contains all the instances of the type that is managed by the operation
 */
public List<D> findAll() {
  return repository.findAll();
}

/**
 * The method provides the functionality to find a specific instance that matches the provided id
 * @param id The id that an instance has to match in order to be retrieved
 * @return Returns an instance that matches the provided id
 */
protected D find(I id) {
  Preconditions.checkNotNull(id, "The provided id cannot be null");
  return repository.findOne(id);
}

/**
 * Delete an instance that match the provided id
 * @param id The instance that matches the provided id will be deleted in the database
 */
protected D delete(final I id) {
  Preconditions.checkNotNull(id, "The provided id cannot be null");
  return repository.delete(id);
}

@Test(expected = IllegalArgumentException.class)
public void testProcessDeleteLastAdmin(){
  User user = new User();
  user.setRole(Role.ADMIN);
  List<User> users = new ArrayList<>();
  users.add(user);
  Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(user);
  Mockito.when(repository.findAll()).thenReturn(users);
  final DeleteUserInput input = new DeleteUserInput(new String());
  final ServiceTask<DeleteUserInput> serviceTask = new ServiceTask<DeleteUserInput>();
  serviceTask.setInput(input);
  final ServiceResult<DeleteUserOutput> serviceResult = service.process(serviceTask);
  serviceResult.getOutput();
  Mockito.verify(repository, Mockito.times(1)).delete(Mockito.anyString());
}

updatedUser.setEmail("email@email.com");
Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(user);
Mockito.when(repository.findAll()).thenReturn(users);
Mockito.when(repository.save(Mockito.any(User.class))).thenReturn(user);
final UpdateCurrentUserInput input = new UpdateCurrentUserInput(updatedUser);
final ServiceTask<UpdateCurrentUserInput> serviceTask = new ServiceTask<UpdateCurrentUserInput>();
Assert.assertEquals(updatedUser.getStatus(), returnedUser.getStatus());
Assert.assertEquals(updatedUser.getUsername(), returnedUser.getUsername());
Mockito.verify(repository, Mockito.times(1)).save(Mockito.any(User.class));

@Test
public void testProcess(){
  User user = new User();
  user.setRole(Role.MODIFIER);
  Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(user);
  final DeleteUserInput input = new DeleteUserInput(new String());
  final ServiceTask<DeleteUserInput> serviceTask = new ServiceTask<DeleteUserInput>();
  serviceTask.setInput(input);
  final ServiceResult<DeleteUserOutput> serviceResult = service.process(serviceTask);
  serviceResult.getOutput();
  Mockito.verify(repository, Mockito.times(1)).delete(Mockito.anyString());
}

updatedConfigurationGroup.getConfigurations().add(updatedConfiguration);
Mockito.when(repository.findAll()).thenReturn(sourceConfigurationGroups);
Mockito.when(repository.save(Mockito.any(ConfigurationGroup.class))).thenReturn(updatedConfigurationGroup);
Assert.assertEquals(returnedConfiguration.getKey(), updatedConfiguration.getKey());
Assert.assertEquals(returnedConfiguration.getValue(), updatedConfiguration.getValue());
Mockito.verify(repository, Mockito.times(1)).save(Mockito.any(ConfigurationGroup.class));
Mockito.verify(repository, Mockito.times(1)).findAll();

updatedUser.setEmail("email@email.com");
Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(user);
Mockito.when(repository.save(Mockito.any(User.class))).thenReturn(user);
final UpdateUserInput input = new UpdateUserInput(new String(), updatedUser);
final ServiceTask<UpdateUserInput> serviceTask = new ServiceTask<UpdateUserInput>();
Assert.assertEquals(updatedUser.getStatus(), returnedUser.getStatus());
Assert.assertEquals(updatedUser.getUsername(), returnedUser.getUsername());
Mockito.verify(repository, Mockito.times(1)).save(Mockito.any(User.class));

/**
 * The save method provides functionality to save the provided instance to the database
 * @param dto The instance that will be saved
 * @return Return the same instance that has been saved in the database
 */
protected D save(D dto) {
  Preconditions.checkNotNull(dto, "Unable to save due to invalid " + dto.getClass().getName() + " instance. Instance cannot be null");
  return repository.save(dto);
}

/**
 * Count all the stored entities for the repository
 * @return The count of entities
 */
protected Integer count(){
  return repository.count();
}

/**
 * The method provides the functionality to retrieve all the repositories and initialize them
 * @see Repository
 */
protected void initializeRepository(){
  final Map<String, Object> repositories = applicationContext.getBeansWithAnnotation(org.springframework.stereotype.Repository.class);
  for(Map.Entry<String, Object> entry : repositories.entrySet()){
    final Object value = entry.getValue();
    if(value instanceof Repository){
      final Repository repository = (Repository) value;
      repository.initialize();
    }
  }
}

createdUser.setEmail("email@email.com");
Mockito.when(repository.save(Mockito.any(User.class))).thenReturn(createdUser);
final CreateUserInput input = new CreateUserInput(user);
final ServiceTask<CreateUserInput> serviceTask = new ServiceTask<CreateUserInput>();
Assert.assertEquals(user.getStatus(), returnedUser.getStatus());
Assert.assertEquals(user.getUsername(), returnedUser.getUsername());
Mockito.verify(repository, Mockito.times(1)).save(Mockito.any(User.class));

  @Test
  public void testProcess(){
    final List<SoapEvent> soapEvents = new ArrayList<SoapEvent>();
    for(int index = 0; index < 3; index++){
      final SoapEvent soapEvent = SoapEventGenerator.generateSoapEvent();
      soapEvents.add(soapEvent);
    }

    Mockito.when(repository.findAll()).thenReturn(soapEvents);

    final ReadAllSoapEventInput input = ReadAllSoapEventInput.builder().build();
    final ServiceTask<ReadAllSoapEventInput> serviceTask = new ServiceTask<ReadAllSoapEventInput>(input);
    final ServiceResult<ReadAllSoapEventOutput> serviceResult = service.process(serviceTask);
    final ReadAllSoapEventOutput output = serviceResult.getOutput();

    Assert.assertEquals(soapEvents.size(), output.getSoapEvents().size());

    for(int index = 0; index < 3; index++){
      final SoapEvent soapEvent = soapEvents.get(index);
      final SoapEvent returnedSoapEvent = output.getSoapEvents().get(index);

      Assert.assertEquals(soapEvent.getId(), returnedSoapEvent.getId());
      Assert.assertEquals(soapEvent.getOperationId(), returnedSoapEvent.getOperationId());
      Assert.assertEquals(soapEvent.getPortId(), returnedSoapEvent.getPortId());
      Assert.assertEquals(soapEvent.getProjectId(), returnedSoapEvent.getProjectId());
    }
  }
}

  @Test
  public void testProcess(){
    final SoapEvent soapEvent = SoapEventGenerator.generateSoapEvent();
    Mockito.when(repository.findOne(soapEvent.getId())).thenReturn(soapEvent);

    final ReadSoapEventInput input = ReadSoapEventInput.builder()
        .soapEventId(soapEvent.getId())
        .build();
    final ServiceTask<ReadSoapEventInput> serviceTask = new ServiceTask<ReadSoapEventInput>(input);
    final ServiceResult<ReadSoapEventOutput> serviceResult = service.process(serviceTask);
    final ReadSoapEventOutput output = serviceResult.getOutput();
    final SoapEvent returnedSoapEvent = output.getSoapEvent();

    Assert.assertEquals(soapEvent.getId(), returnedSoapEvent.getId());
    Assert.assertEquals(soapEvent.getOperationId(), returnedSoapEvent.getOperationId());
    Assert.assertEquals(soapEvent.getPortId(), returnedSoapEvent.getPortId());
    Assert.assertEquals(soapEvent.getProjectId(), returnedSoapEvent.getProjectId());
  }
}

  @Test
  public void testProcess(){
    final List<RestEvent> restEvents = new ArrayList<RestEvent>();
    for(int index = 0; index < 3; index++){
      final RestEvent restEvent = RestEventGenerator.generateRestEvent();
      restEvents.add(restEvent);
    }

    Mockito.when(repository.findAll()).thenReturn(restEvents);

    final ReadAllRestEventInput input = ReadAllRestEventInput.builder().build();
    final ServiceTask<ReadAllRestEventInput> serviceTask = new ServiceTask<ReadAllRestEventInput>(input);
    final ServiceResult<ReadAllRestEventOutput> serviceResult = service.process(serviceTask);
    final ReadAllRestEventOutput output = serviceResult.getOutput();

    Assert.assertEquals(restEvents.size(), output.getRestEvents().size());

    for(int index = 0; index < 3; index++){
      final RestEvent restEvent = restEvents.get(index);
      final RestEvent returnedRestEvent = output.getRestEvents().get(index);

      Assert.assertEquals(restEvent.getId(), returnedRestEvent.getId());
      Assert.assertEquals(restEvent.getResourceId(), returnedRestEvent.getResourceId());
      Assert.assertEquals(restEvent.getMethodId(), returnedRestEvent.getMethodId());
      Assert.assertEquals(restEvent.getProjectId(), returnedRestEvent.getProjectId());
      Assert.assertEquals(restEvent.getApplicationId(), returnedRestEvent.getApplicationId());
    }
  }
}

@Test
public void testProcess(){
  User user = new User();
  user.setId("UserId");
  user.setUsername("Username");
  user.setStatus(Status.ACTIVE);
  user.setRole(Role.ADMIN);
  user.setEmail("email@email.com");
  Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(user);
  final ReadUserInput input = new ReadUserInput("UserId");
  final ServiceTask<ReadUserInput> serviceTask = new ServiceTask<ReadUserInput>();
  serviceTask.setInput(input);
  final ServiceResult<ReadUserOutput> serviceResult = service.process(serviceTask);
  final ReadUserOutput output = serviceResult.getOutput();
  final User returnedUser = output.getUser();
  Assert.assertNotNull(returnedUser);
  Assert.assertEquals(user.getId(), returnedUser.getId());
  Assert.assertEquals(user.getEmail(), returnedUser.getEmail());
  Assert.assertEquals(user.getRole(), returnedUser.getRole());
  Assert.assertEquals(user.getStatus(), returnedUser.getStatus());
  Assert.assertEquals(user.getUsername(), returnedUser.getUsername());
}

@Test
public void testProcess(){
  List<ConfigurationGroup> configurationGroups = new ArrayList<ConfigurationGroup>();
  ConfigurationGroup configurationGroup = new ConfigurationGroup();
  configurationGroup.setId(new String());
  configurationGroup.setName("Configuration group");
  configurationGroup.setConfigurations(new ArrayList<Configuration>());
  Configuration configuration = new Configuration();
  configuration.setKey("Key");
  configuration.setValue("Value");
  configuration.setType(ConfigurationType.BOOLEAN);
  configurationGroup.getConfigurations().add(configuration);
  configurationGroups.add(configurationGroup);
  Mockito.when(repository.findAll()).thenReturn(configurationGroups);
  final ReadAllConfigurationGroupsInput input = new ReadAllConfigurationGroupsInput();
  final ServiceTask<ReadAllConfigurationGroupsInput> serviceTask = new ServiceTask<ReadAllConfigurationGroupsInput>();
  serviceTask.setInput(input);
  final ServiceResult<ReadAllConfigurationGroupsOutput> serviceResult = service.process(serviceTask);
  final ReadAllConfigurationGroupsOutput output = serviceResult.getOutput();
  final List<ConfigurationGroup> returnedConfigurationGroups = output.getConfigurationGroups();
  Assert.assertEquals(returnedConfigurationGroups.size(), configurationGroups.size());
  final ConfigurationGroup returnedConfigurationGroup = returnedConfigurationGroups.get(0);
  Assert.assertEquals(returnedConfigurationGroup.getId(), configurationGroup.getId());
  Assert.assertEquals(returnedConfigurationGroup.getName(), configurationGroup.getName());
  Assert.assertEquals(returnedConfigurationGroup.getConfigurations().size(), configurationGroup.getConfigurations().size());
  final Configuration returnedConfiguration = returnedConfigurationGroup.getConfigurations().get(0);
  Assert.assertEquals(returnedConfiguration.getType(), configuration.getType());
  Assert.assertEquals(returnedConfiguration.getKey(), configuration.getKey());
  Assert.assertEquals(returnedConfiguration.getValue(), configuration.getValue());
}

  @Test
  public void testProcess(){
    final RestEvent restEvent = RestEventGenerator.generateRestEvent();
    Mockito.when(repository.findOne(restEvent.getId())).thenReturn(restEvent);

    final ReadRestEventInput input = ReadRestEventInput.builder()
        .restEventId(restEvent.getId())
        .build();
    final ServiceTask<ReadRestEventInput> serviceTask = new ServiceTask<ReadRestEventInput>(input);
    final ServiceResult<ReadRestEventOutput> serviceResult = service.process(serviceTask);
    final ReadRestEventOutput output = serviceResult.getOutput();
    final RestEvent returnedRestEvent = output.getRestEvent();

    Assert.assertEquals(restEvent.getId(), returnedRestEvent.getId());
    Assert.assertEquals(restEvent.getResourceId(), returnedRestEvent.getResourceId());
    Assert.assertEquals(restEvent.getMethodId(), returnedRestEvent.getMethodId());
    Assert.assertEquals(restEvent.getProjectId(), returnedRestEvent.getProjectId());
    Assert.assertEquals(restEvent.getApplicationId(), returnedRestEvent.getApplicationId());
  }
}

@Test
public void testProcess(){
  List<User> users = new ArrayList<User>();
  User user = new User();
  user.setId(new String());
  user.setUsername("Username");
  user.setStatus(Status.ACTIVE);
  user.setRole(Role.ADMIN);
  user.setEmail("email@email.com");
  users.add(user);
  Mockito.when(repository.findAll()).thenReturn(users);
  final ReadUsersByRoleInput input = new ReadUsersByRoleInput(Role.ADMIN);
  final ServiceTask<ReadUsersByRoleInput> serviceTask = new ServiceTask<ReadUsersByRoleInput>();
  serviceTask.setInput(input);
  final ServiceResult<ReadUsersByRoleOutput> serviceResult = service.process(serviceTask);
  final ReadUsersByRoleOutput output = serviceResult.getOutput();
  final List<User> returnedUsers = output.getUsers();
  Assert.assertNotNull(returnedUsers);
  Assert.assertEquals(users.size(), returnedUsers.size());
  final User returnedUser = returnedUsers.get(0);
  Assert.assertEquals(user.getId(), returnedUser.getId());
  Assert.assertEquals(user.getEmail(), returnedUser.getEmail());
  Assert.assertEquals(user.getRole(), returnedUser.getRole());
  Assert.assertEquals(user.getStatus(), returnedUser.getStatus());
  Assert.assertEquals(user.getUsername(), returnedUser.getUsername());
}

@Test
public void testProcess(){
  List<User> users = new ArrayList<User>();
  User user = new User();
  user.setId(new String());
  user.setUsername("Username");
  user.setStatus(Status.ACTIVE);
  user.setRole(Role.ADMIN);
  user.setEmail("email@email.com");
  users.add(user);
  Mockito.when(repository.findAll()).thenReturn(users);
  final ReadAllUsersInput input = new ReadAllUsersInput();
  final ServiceTask<ReadAllUsersInput> serviceTask = new ServiceTask<ReadAllUsersInput>();
  serviceTask.setInput(input);
  final ServiceResult<ReadAllUsersOutput> serviceResult = service.process(serviceTask);
  final ReadAllUsersOutput output = serviceResult.getOutput();
  final List<User> returnedUsers = output.getUsers();
  Assert.assertEquals(returnedUsers.size(), users.size());
  final User returnedUser = returnedUsers.get(0);
  Assert.assertEquals(user.getId(), returnedUser.getId());
  Assert.assertEquals(user.getEmail(), returnedUser.getEmail());
  Assert.assertEquals(user.getRole(), returnedUser.getRole());
  Assert.assertEquals(user.getStatus(), returnedUser.getStatus());
  Assert.assertEquals(user.getUsername(), returnedUser.getUsername());
}