How to use

findAll

method

in

com.castlemock.repository.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();
}

@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());
}

  @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());
    }
  }
}

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

  @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(){
  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(){
  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());
}

Mockito.when(repository.findAll()).thenReturn(users);
Mockito.when(repository.save(Mockito.any(User.class))).thenReturn(user);
final UpdateCurrentUserInput input = new UpdateCurrentUserInput(updatedUser);

@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 ReadUserByUsernameInput input = new ReadUserByUsernameInput("Username");
  final ServiceTask<ReadUserByUsernameInput> serviceTask = new ServiceTask<ReadUserByUsernameInput>();
  serviceTask.setInput(input);
  final ServiceResult<ReadUserByUsernameOutput> serviceResult = service.process(serviceTask);
  final ReadUserByUsernameOutput 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());
}