Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: TaggingRequestFilterFunction implements ExchangeFilterFunction { @Override public Mono<ClientResponse> filter(ClientRequest clientRequest, ExchangeFunction nextFilter) { HttpHeaders headers = clientRequest.headers(); setHeader(headers, TAG_HEADER_NAME, headerValue); if (orgHeaderValue != null && spaceHeaderValue != null) { setHeader(headers, TAG_HEADER_ORG_NAME, orgHeaderValue); setHeader(headers, TAG_HEADER_SPACE_NAME, spaceHeaderValue); } return nextFilter.exchange(clientRequest); } TaggingRequestFilterFunction(String deployServiceVersion); TaggingRequestFilterFunction(String deployServiceVersion, String org, String space); @Override Mono<ClientResponse> filter(ClientRequest clientRequest, ExchangeFunction nextFilter); static final String TAG_HEADER_SPACE_NAME; static final String TAG_HEADER_ORG_NAME; static final String TAG_HEADER_NAME; }### Answer: @Test void testInjectOnlyDeployServiceVersion() throws IOException { TaggingRequestFilterFunction testedFilterFunction = new TaggingRequestFilterFunction(TEST_VERSION_VALUE); testedFilterFunction.filter(clientRequest, nextFilter); assertEquals("MTA deploy-service v1.58.0", actualHeaders.getFirst(TaggingRequestFilterFunction.TAG_HEADER_NAME)); assertFalse(actualHeaders.containsKey(TaggingRequestFilterFunction.TAG_HEADER_ORG_NAME)); assertFalse(actualHeaders.containsKey(TaggingRequestFilterFunction.TAG_HEADER_SPACE_NAME)); } @Test void testInjectOrgAndSpaceValues() throws IOException { TaggingRequestFilterFunction testedFilterFunction = new TaggingRequestFilterFunction(TEST_VERSION_VALUE, TEST_ORG_VALUE, TEST_SPACE_VALUE); testedFilterFunction.filter(clientRequest, nextFilter); assertEquals("MTA deploy-service v1.58.0", actualHeaders.getFirst(TaggingRequestFilterFunction.TAG_HEADER_NAME)); assertEquals(TEST_ORG_VALUE, actualHeaders.getFirst(TaggingRequestFilterFunction.TAG_HEADER_ORG_NAME)); assertEquals(TEST_SPACE_VALUE, actualHeaders.getFirst(TaggingRequestFilterFunction.TAG_HEADER_SPACE_NAME)); }
### Question: Environment { public Map<String, String> getAllVariables() { return environmentVariablesAccessor.getAllVariables(); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetAllVariables() { Map<String, String> variables = new HashMap<>(); variables.put("foo", "bar"); variables.put("baz", "qux"); Mockito.when(environmentVariablesAccessor.getAllVariables()) .thenReturn(variables); assertEquals(variables, environment.getAllVariables()); }
### Question: Environment { public String getString(String name) { return getString(name, null); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetString() { Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn("cd"); assertEquals("cd", environment.getString("ab")); } @Test void testGetStringWhenVariableIsMissing() { assertNull(environment.getString("ab")); } @Test void testGetStringWithDefault() { assertEquals("cd", environment.getString("ab", "cd")); }
### Question: JdbcUtil { public static void commit(Connection connection) throws SQLException { if (!connection.getAutoCommit()) { connection.commit(); } } private JdbcUtil(); static void closeQuietly(ResultSet resultSet); static void closeQuietly(Statement statement); static void closeQuietly(Connection connection); static void logSQLException(SQLException exception); static void commit(Connection connection); static void rollback(Connection connection); }### Answer: @Test void commit() throws SQLException { Connection connection = Mockito.mock(Connection.class); Mockito.when(connection.getAutoCommit()) .thenReturn(false); JdbcUtil.commit(connection); Mockito.verify(connection) .commit(); } @Test void commitWithAutoCommit() throws SQLException { Connection connection = Mockito.mock(Connection.class); Mockito.when(connection.getAutoCommit()) .thenReturn(true); JdbcUtil.commit(connection); Mockito.verify(connection, Mockito.never()) .commit(); }
### Question: Environment { public Long getLong(String name) { return getLong(name, null); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetLong() { Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn("12"); assertEquals(12, (long) environment.getLong("ab")); } @Test void testGetLongWhenVariableIsMissing() { assertNull(environment.getLong("ab")); } @Test void testGetLongWithDefault() { assertEquals(12, (long) environment.getLong("ab", 12L)); }
### Question: Environment { public Integer getInteger(String name) { return getInteger(name, null); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetInteger() { Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn("12"); assertEquals(12, (long) environment.getInteger("ab")); } @Test void testGetIntegerWhenVariableIsMissing() { assertNull(environment.getInteger("ab")); } @Test void testGetIntegerWithDefault() { assertEquals(12, (int) environment.getInteger("ab", 12)); }
### Question: Environment { public Boolean getBoolean(String name) { return getBoolean(name, null); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetBoolean() { Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn("false"); assertEquals(false, environment.getBoolean("ab")); } @Test void testGetBooleanWhenVariableIsMissing() { assertNull(environment.getBoolean("ab")); } @Test void testGetBooleanWithDefault() { assertEquals(false, environment.getBoolean("ab", false)); }
### Question: Environment { public Integer getPositiveInteger(String name, Integer defaultValue) { Integer value = getInteger(name, defaultValue); if (value == null \|\| value <= 0) { value = Integer.MAX_VALUE; } return value; } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetPositiveIntegerWithNull() { assertEquals(Integer.MAX_VALUE, (int) environment.getPositiveInteger("ab", null)); }
### Question: Environment { public Integer getNegativeInteger(String name, Integer defaultValue) { Integer value = getInteger(name, defaultValue); if (value == null \|\| value >= 0) { value = Integer.MIN_VALUE; } return value; } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testGetNegativeIntegerWithNull() { assertEquals(Integer.MIN_VALUE, (int) environment.getNegativeInteger("ab", null)); }
### Question: Environment { public <T> T getVariable(String name, Function<String, T> mappingFunction) { return getVariable(name, mappingFunction, null); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void tetGetVariable() { UUID expectedUuid = UUID.fromString("c9fbfbfd-8d54-4cba-958f-25a3f7a14ca7"); Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn(expectedUuid.toString()); assertEquals(expectedUuid, environment.getVariable("ab", UUID::fromString)); }
### Question: Environment { public boolean hasVariable(String name) { return !StringUtils.isEmpty(getString(name)); } Environment(); Environment(EnvironmentVariablesAccessor environmentVariablesAccessor); Map<String, String> getAllVariables(); Long getLong(String name); String getString(String name); Integer getInteger(String name); Boolean getBoolean(String name); Long getLong(String name, Long defaultValue); String getString(String name, String defaultValue); Integer getInteger(String name, Integer defaultValue); Boolean getBoolean(String name, Boolean defaultValue); Integer getPositiveInteger(String name, Integer defaultValue); Integer getNegativeInteger(String name, Integer defaultValue); T getVariable(String name, Function<String, T> mappingFunction); T getVariable(String name, Function<String, T> mappingFunction, T defaultValue); boolean hasVariable(String name); }### Answer: @Test void testHasVariable() { Mockito.when(environmentVariablesAccessor.getVariable("ab")) .thenReturn("0"); assertTrue(environment.hasVariable("ab")); } @Test void testHasVariableWhenVariableIsMissing() { assertFalse(environment.hasVariable("ab")); }
### Question: ProcessLoggerProvider { public ProcessLogger getLogger(DelegateExecution execution) { return getLogger(execution, DEFAULT_LOG_NAME); } ProcessLogger getLogger(DelegateExecution execution); ProcessLogger getLogger(DelegateExecution execution, String logName); ProcessLogger getLogger(DelegateExecution execution, String logName, PatternLayout layout); List<ProcessLogger> getExistingLoggers(String processId, String activityId); void remove(ProcessLogger processLogger); }### Answer: @Test void testGetLogger() { prepareContext(); processLogger = processLoggerProvider.getLogger(execution); assertEquals(CORRELATION_ID, processLogger.getProcessId()); assertEquals(TASK_ID, processLogger.getActivityId()); assertEquals(SPACE_ID, processLogger.spaceId); } @Test void testGetNullProcessLogger() { processLogger = processLoggerProvider.getLogger(execution); assertTrue(processLogger instanceof NullProcessLogger, MessageFormat.format("Expected NullProcessLogger but was {0}", processLogger.getClass() .getSimpleName())); }
### Question: SafeExecutor { public <E extends Exception> void execute(FailableRunnable<E> runnable) { try { runnable.run(); } catch (Exception e) { exceptionHandler.accept(e); } } SafeExecutor(); SafeExecutor(Consumer<Exception> exceptionHandler); void execute(FailableRunnable<E> runnable); }### Answer: @Test void testWithoutExceptions() { SafeExecutor safeExecutor = new SafeExecutor(exceptionHandler); safeExecutor.execute(() -> { }); Mockito.verifyNoInteractions(exceptionHandler); } @Test void testWithException() { SafeExecutor safeExecutor = new SafeExecutor(exceptionHandler); Exception e = new Exception(); safeExecutor.execute(() -> { throw e; }); Mockito.verify(exceptionHandler) .accept(e); } @Test void testWithDefaultExceptionHandler() { SafeExecutor safeExecutor = new SafeExecutor(); Exception e = new Exception(); Assertions.assertDoesNotThrow(() -> safeExecutor.execute(() -> { throw e; })); }
### Question: UriUtil { public static CloudRoute findRoute(List<CloudRoute> routes, String uri) { return routes.stream() .filter(route -> routeMatchesUri(route, uri)) .findAny() .orElseThrow(() -> new NotFoundException(Messages.ROUTE_NOT_FOUND, uri)); } private UriUtil(); static String stripScheme(String uri); static CloudRoute findRoute(List<CloudRoute> routes, String uri); static boolean routeMatchesUri(CloudRoute route, String uri); static final String DEFAULT_SCHEME_SEPARATOR; static final char DEFAULT_PATH_SEPARATOR; static final char DEFAULT_HOST_DOMAIN_SEPARATOR; static final int STANDARD_HTTP_PORT; static final int STANDARD_HTTPS_PORT; static final String HTTP_PROTOCOL; static final String HTTPS_PROTOCOL; }### Answer: @Test void testFindRouteWithHostBasedUriWithPort() { List<CloudRoute> routes = List.of(route); Assertions.assertThrows(NotFoundException.class, () -> UriUtil.findRoute(routes, HOST_BASED_URI_WITH_PORT)); } @Test void testFindRouteWithHostBasedUriWithoutPort() { List<CloudRoute> routes = List.of(route); CloudRoute actualResult = UriUtil.findRoute(routes, HOST_BASED_URI_WITHOUT_PORT); Assertions.assertEquals(route, actualResult); } @Test void testFindRouteWithPortBasedUri() { List<CloudRoute> routes = List.of(route); Assertions.assertThrows(NotFoundException.class, () -> UriUtil.findRoute(routes, PORT_BASED_URI)); }
### Question: UriUtil { public static boolean routeMatchesUri(CloudRoute route, String uri) { ApplicationURI appUriFromRoute = new ApplicationURI(route); ApplicationURI appUriFromString = new ApplicationURI(uri); return appUriFromRoute.equals(appUriFromString); } private UriUtil(); static String stripScheme(String uri); static CloudRoute findRoute(List<CloudRoute> routes, String uri); static boolean routeMatchesUri(CloudRoute route, String uri); static final String DEFAULT_SCHEME_SEPARATOR; static final char DEFAULT_PATH_SEPARATOR; static final char DEFAULT_HOST_DOMAIN_SEPARATOR; static final int STANDARD_HTTP_PORT; static final int STANDARD_HTTPS_PORT; static final String HTTP_PROTOCOL; static final String HTTPS_PROTOCOL; }### Answer: @Test void testRouteMatchesWithHostBasedUriWithPort() { boolean actualResult = UriUtil.routeMatchesUri(route, HOST_BASED_URI_WITH_PORT); Assertions.assertFalse(actualResult); } @Test void testRouteMatchesWithHostBasedUriWithoutPort() { boolean actualResult = UriUtil.routeMatchesUri(route, HOST_BASED_URI_WITHOUT_PORT); Assertions.assertTrue(actualResult); } @Test void testRouteMatchesWithPortBasedUri() { boolean actualResult = UriUtil.routeMatchesUri(route, PORT_BASED_URI); Assertions.assertFalse(actualResult); }
### Question: UriUtil { public static String stripScheme(String uri) { int protocolIndex = uri.indexOf(DEFAULT_SCHEME_SEPARATOR); if (protocolIndex == -1) { return uri; } return uri.substring(protocolIndex + DEFAULT_SCHEME_SEPARATOR.length()); } private UriUtil(); static String stripScheme(String uri); static CloudRoute findRoute(List<CloudRoute> routes, String uri); static boolean routeMatchesUri(CloudRoute route, String uri); static final String DEFAULT_SCHEME_SEPARATOR; static final char DEFAULT_PATH_SEPARATOR; static final char DEFAULT_HOST_DOMAIN_SEPARATOR; static final int STANDARD_HTTP_PORT; static final int STANDARD_HTTPS_PORT; static final String HTTP_PROTOCOL; static final String HTTPS_PROTOCOL; }### Answer: @Test void testStripSchemeWithScheme() { String actual = UriUtil.stripScheme(PORT_BASED_URI); Assertions.assertEquals(PORT_BASED_URI_WITHOUT_SCHEME, actual); } @Test void testStripSchemeWithoutScheme() { String actual = UriUtil.stripScheme(PORT_BASED_URI_WITHOUT_SCHEME); Assertions.assertEquals(PORT_BASED_URI_WITHOUT_SCHEME, actual); }
### Question: NameUtil { public static String computeValidContainerName(String organization, String space, String serviceName) { String properOrganization = organization.toUpperCase(Locale.US) .replaceAll(NameRequirements.CONTAINER_NAME_ILLEGAL_CHARACTERS, "_"); String properSpace = space.toUpperCase(Locale.US) .replaceAll(NameRequirements.CONTAINER_NAME_ILLEGAL_CHARACTERS, "_"); String properServiceName = serviceName.toUpperCase(Locale.US) .replaceAll(NameRequirements.CONTAINER_NAME_ILLEGAL_CHARACTERS, "_"); return getNameWithProperLength(String.format("%s_%s_%s", properOrganization, properSpace, properServiceName), NameRequirements.CONTAINER_NAME_MAX_LENGTH).toUpperCase(Locale.US); } private NameUtil(); static String computeValidApplicationName(String applicationName, String namespace, boolean applyNamespace); static String computeValidServiceName(String serviceName, String namespace, boolean applyNamespace); static String computeValidContainerName(String organization, String space, String serviceName); static String computeValidXsAppName(String serviceName); static String getNameWithProperLength(String name, int maxLength); static String getNamespacePrefix(String namespace); static UUID getUUID(String name); static String getIndexedName(String resourceName, int index, int entriesCnt, String delimiter); static String getApplicationName(Module module); static String getServiceName(Resource resource); }### Answer: @Test void testCreateValidContainerName() { String containerName = NameUtil.computeValidContainerName("initial", "initial", "com.sap.cloud.lm.sl.xs2.a.very.very.long.service.name.with.illegal.container.name.characters"); assertEquals("INITIAL_INITIAL_COM_SAP_CLOUD_LM_SL_XS2_A_VERY_VERY_LONG3AC0B612", containerName); assertTrue(containerName.matches(NameRequirements.CONTAINER_NAME_PATTERN)); }
### Question: SecurityUtil { public static UserInfo getTokenUserInfo(OAuth2AccessToken token) { TokenProperties tokenProperties = TokenProperties.fromToken(token); return new UserInfo(tokenProperties.getUserId(), tokenProperties.getUserName(), token); } private SecurityUtil(); static OAuth2Authentication createAuthentication(String clientId, Set<String> scope, UserInfo userInfo); static UserInfo getTokenUserInfo(OAuth2AccessToken token); static final String CLIENT_ID; static final String CLIENT_SECRET; }### Answer: @Test void testGetTokenUserInfo() { DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(TOKEN); Map<String, Object> additionalInformation = asMap(USER_ID, USER_NAME); token.setAdditionalInformation(additionalInformation); UserInfo userInfo = SecurityUtil.getTokenUserInfo(token); assertEquals(USER_ID, userInfo.getId()); assertEquals(USER_NAME, userInfo.getName()); assertEquals(TOKEN, userInfo.getToken() .getValue()); }
### Question: ApplicationURI { public Map<String, Object> getURIParts() { Map<String, Object> uriParts = new HashMap<>(); uriParts.put(SupportedParameters.HOST, getHost()); uriParts.put(SupportedParameters.DOMAIN, getDomain()); uriParts.put(SupportedParameters.ROUTE_PATH, getPath()); return Collections.unmodifiableMap(uriParts); } ApplicationURI(String initial); ApplicationURI(CloudRoute route); static String getDomainFromURI(String uri); Map<String, Object> getURIParts(); Object getURIPart(String partName); void setURIPart(String partName, String part); @Override String toString(); String getHost(); void setHost(String host); String getDomain(); void setDomain(String domain); String getPath(); void setPath(String path); @Override int hashCode(); @Override boolean equals(Object object); }### Answer: @Test void testGetURIParts() { ApplicationURI applicationURI = new ApplicationURI(createCloudRoute(CUSTOM + "host", createCloudDomain(CUSTOM + "domain"), null)); Map<String, Object> expectedParts = new HashMap<>(); expectedParts.put(SupportedParameters.HOST, CUSTOM + "host"); expectedParts.put(SupportedParameters.DOMAIN, CUSTOM + "domain"); expectedParts.put(SupportedParameters.ROUTE_PATH, ""); Assertions.assertEquals(expectedParts, applicationURI.getURIParts()); }
### Question: ApplicationURI { public Object getURIPart(String partName) { switch (partName) { case SupportedParameters.HOST: return getHost(); case SupportedParameters.DOMAIN: return getDomain(); case SupportedParameters.ROUTE_PATH: return getPath(); default: return null; } } ApplicationURI(String initial); ApplicationURI(CloudRoute route); static String getDomainFromURI(String uri); Map<String, Object> getURIParts(); Object getURIPart(String partName); void setURIPart(String partName, String part); @Override String toString(); String getHost(); void setHost(String host); String getDomain(); void setDomain(String domain); String getPath(); void setPath(String path); @Override int hashCode(); @Override boolean equals(Object object); }### Answer: @Test void testGetURIPart() { ApplicationURI applicationURI = new ApplicationURI(createCloudRoute(CUSTOM + "host", createCloudDomain(CUSTOM + "domain"), "/" + CUSTOM + "path")); Assertions.assertEquals(CUSTOM + "host", applicationURI.getURIPart(SupportedParameters.HOST)); Assertions.assertEquals(CUSTOM + "domain", applicationURI.getURIPart(SupportedParameters.DOMAIN)); Assertions.assertEquals("/" + CUSTOM + "path", applicationURI.getURIPart(SupportedParameters.ROUTE_PATH)); Assertions.assertNull(applicationURI.getURIPart("invalid-parameter")); }
### Question: ApplicationURI { @Override public String toString() { StringBuilder url = new StringBuilder(); if (StringUtils.isNotEmpty(getHost())) { url.append(getHost()) .append(UriUtil.DEFAULT_HOST_DOMAIN_SEPARATOR); } url.append(getDomain()); if (StringUtils.isNotEmpty(getPath())) { url.append(getPath()); } return url.toString(); } ApplicationURI(String initial); ApplicationURI(CloudRoute route); static String getDomainFromURI(String uri); Map<String, Object> getURIParts(); Object getURIPart(String partName); void setURIPart(String partName, String part); @Override String toString(); String getHost(); void setHost(String host); String getDomain(); void setDomain(String domain); String getPath(); void setPath(String path); @Override int hashCode(); @Override boolean equals(Object object); }### Answer: @Test void testToStringWithValidHostAndPath() { ApplicationURI applicationURI = new ApplicationURI(createCloudRoute(CUSTOM + "host", createCloudDomain(CUSTOM + "domain"), "/" + CUSTOM + "path")); String expectedApplicationURI = CUSTOM + "host." + CUSTOM + "domain/" + CUSTOM + "path"; Assertions.assertEquals(expectedApplicationURI, applicationURI.toString()); } @Test void testToStringWithValidHostAndWithoutPath() { ApplicationURI applicationURI = new ApplicationURI(createCloudRoute(CUSTOM + "host", createCloudDomain(CUSTOM + "domain"), null)); Assertions.assertEquals(CUSTOM + "host." + CUSTOM + "domain", applicationURI.toString()); } @Test void testToStringWithoutHostAndWithoutPath() { ApplicationURI applicationURI = new ApplicationURI(createCloudRoute("", createCloudDomain(CUSTOM + "domain"), null)); Assertions.assertEquals(CUSTOM + "domain", applicationURI.toString()); }
### Question: ApplicationURI { public static String getDomainFromURI(String uri) { ApplicationURI parsedURI = new ApplicationURI(uri); return parsedURI.getDomain(); } ApplicationURI(String initial); ApplicationURI(CloudRoute route); static String getDomainFromURI(String uri); Map<String, Object> getURIParts(); Object getURIPart(String partName); void setURIPart(String partName, String part); @Override String toString(); String getHost(); void setHost(String host); String getDomain(); void setDomain(String domain); String getPath(); void setPath(String path); @Override int hashCode(); @Override boolean equals(Object object); }### Answer: @Test void testGetDomainFromURI() { Assertions.assertEquals(CUSTOM + "domain", ApplicationURI.getDomainFromURI("https: }
### Question: ConfigurationEntryService extends PersistenceService<ConfigurationEntry, ConfigurationEntryDto, Long> { public ConfigurationEntryQuery createQuery() { return new ConfigurationEntryQueryImpl(createEntityManager(), entryMapper); } ConfigurationEntryService(EntityManagerFactory entityManagerFactory, ConfigurationEntryMapper entryMapper); ConfigurationEntryQuery createQuery(); }### Answer: @Test void testAdd() { configurationEntryService.add(CONFIGURATION_ENTRY_1); assertEquals(1, configurationEntryService.createQuery() .list() .size()); assertEquals(CONFIGURATION_ENTRY_1.getId(), configurationEntryService.createQuery() .id(CONFIGURATION_ENTRY_1.getId()) .singleResult() .getId()); } @Test void testAddWithNonEmptyDatabase() { addConfigurationEntries(List.of(CONFIGURATION_ENTRY_1, CONFIGURATION_ENTRY_2)); assertConfigurationEntryExists(CONFIGURATION_ENTRY_1.getId()); assertConfigurationEntryExists(CONFIGURATION_ENTRY_2.getId()); assertEquals(2, configurationEntryService.createQuery() .list() .size()); } @Test void testQueryByVersion() { addConfigurationEntries(List.of(CONFIGURATION_ENTRY_1, CONFIGURATION_ENTRY_2)); String version = ">3.0.0"; assertEquals(1, configurationEntryService.createQuery() .version(version) .list() .size()); } @Test void testQueryByProviderNamespace() { addConfigurationEntries(ALL_ENTRIES); ConfigurationEntryQuery allEntries = configurationEntryService.createQuery() .providerNamespace(null, false); assertEquals(3, allEntries.list() .size()); ConfigurationEntryQuery allEntriesNoNamespace = configurationEntryService.createQuery() .providerNamespace(null, true); assertEquals(2, allEntriesNoNamespace.list() .size()); ConfigurationEntryQuery allEntriesNoNamespaceUsingKeyword = configurationEntryService.createQuery() .providerNamespace("default", false); assertEquals(2, allEntriesNoNamespaceUsingKeyword.list() .size()); ConfigurationEntryQuery specificEntryByNamespace = configurationEntryService.createQuery() .providerNamespace("namespace", false); assertEquals(1, specificEntryByNamespace.list() .size()); }
### Question: SpecialResourceTypesRequiredParametersUtil { public static void checkRequiredParameters(String serviceName, ResourceType resourceType, Map<String, Object> parameters) { Set<String> requiredParameters = resourceType.getRequiredParameters(); for (String parameter : requiredParameters) { if (!parameters.containsKey(parameter)) { throw new ContentException(Messages.SERVICE_MISSING_REQUIRED_PARAMETER, serviceName, parameter); } } } private SpecialResourceTypesRequiredParametersUtil(); static void checkRequiredParameters(String serviceName, ResourceType resourceType, Map<String, Object> parameters); }### Answer: @Test void checkRequiredParametersForManagedServiceWithNoParameters() { Map<String, Object> dummyParameters = new HashMap<>(); ResourceType resourceType = ResourceType.MANAGED_SERVICE; Assertions.assertThrows(ContentException.class, () -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); } @Test void checkRequiredParametersForManagedServiceWithMissingParameter() { Map<String, Object> dummyParameters = new HashMap<>(); dummyParameters.put("service", new Object()); ResourceType resourceType = ResourceType.MANAGED_SERVICE; Assertions.assertThrows(ContentException.class, () -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); } @Test void checkRequiredParametersForManagedServiceWithRequiredParameter() { Map<String, Object> dummyParameters = new HashMap<>(); dummyParameters.put("service", new Object()); dummyParameters.put("service-plan", new Object()); ResourceType resourceType = ResourceType.MANAGED_SERVICE; Assertions.assertDoesNotThrow(() -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); } @Test void checkRequiredParametersForUserProvidedServiceWithNoParameters() { Map<String, Object> dummyParameters = new HashMap<>(); ResourceType resourceType = ResourceType.USER_PROVIDED_SERVICE; Assertions.assertDoesNotThrow(() -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); } @Test void checkRequiredParametersForUserProvidedServiceWithRequiredParameter() { Map<String, Object> dummyParameters = new HashMap<>(); dummyParameters.put("config", new Object()); ResourceType resourceType = ResourceType.USER_PROVIDED_SERVICE; Assertions.assertDoesNotThrow(() -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); } @Test void checkRequiredParametersForExistingServiceWithNoParameters() { Map<String, Object> dummyParameters = new HashMap<>(); ResourceType resourceType = ResourceType.EXISTING_SERVICE; Assertions.assertDoesNotThrow(() -> SpecialResourceTypesRequiredParametersUtil.checkRequiredParameters(testServiceName, resourceType, dummyParameters)); }
### Question: ProgressMessageService extends PersistenceService<ProgressMessage, ProgressMessageDto, Long> { public ProgressMessageQuery createQuery() { return new ProgressMessageQueryImpl(createEntityManager(), progressMessageMapper); } @Inject ProgressMessageService(EntityManagerFactory entityManagerFactory); ProgressMessageQuery createQuery(); }### Answer: @Test void testAdd() { progressMessageService.add(PROGRESS_MESSAGE_1); assertEquals(1, progressMessageService.createQuery() .list() .size()); assertEquals(PROGRESS_MESSAGE_1.getId(), progressMessageService.createQuery() .id(PROGRESS_MESSAGE_1.getId()) .singleResult() .getId()); } @Test void testAddWithNonEmptyDatabase() { addProgressMessages(List.of(PROGRESS_MESSAGE_1, PROGRESS_MESSAGE_2)); assertProgressMessageExists(PROGRESS_MESSAGE_1.getId()); assertProgressMessageExists(PROGRESS_MESSAGE_2.getId()); assertEquals(2, progressMessageService.createQuery() .list() .size()); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public void addFile(FileEntry fileEntry, File file) throws FileStorageException { String entryName = fileEntry.getId(); long fileSize = fileEntry.getSize() .longValue(); Blob blob = blobStore.blobBuilder(entryName) .payload(file) .contentDisposition(fileEntry.getName()) .contentType(MediaType.OCTET_STREAM.toString()) .userMetadata(createFileEntryMetadata(fileEntry)) .build(); try { putBlobWithRetries(blob, 3); LOGGER.debug(MessageFormat.format(Messages.STORED_FILE_0_WITH_SIZE_1_SUCCESSFULLY_2, fileEntry.getId(), fileSize)); } catch (ContainerNotFoundException e) { throw new FileStorageException(MessageFormat.format(Messages.FILE_UPLOAD_FAILED, fileEntry.getName(), fileEntry.getNamespace())); } } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void addFileTest() throws Exception { FileEntry fileEntry = addFile(TEST_FILE_LOCATION); assertFileExists(true, fileEntry); }
### Question: RestartOnEnvChangeValidator implements ParameterValidator { @Override public String getParameterName() { return SupportedParameters.RESTART_ON_ENV_CHANGE; } @Override boolean isValid(Object restartParameters, final Map<String, Object> context); @Override Class<?> getContainerType(); @Override String getParameterName(); }### Answer: @Test void testGetParameterName() { assertEquals("restart-on-env-change", validator.getParameterName()); }
### Question: RestartOnEnvChangeValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return Module.class; } @Override boolean isValid(Object restartParameters, final Map<String, Object> context); @Override Class<?> getContainerType(); @Override String getParameterName(); }### Answer: @Test void testGetContainerType() { assertTrue(validator.getContainerType() .isAssignableFrom(Module.class)); }
### Question: HostValidator extends RoutePartValidator { @Override public String getParameterName() { return SupportedParameters.HOST; } @Override String getParameterName(); }### Answer: @Test void testGetParameterName() { assertEquals("host", validator.getParameterName()); }
### Question: TasksValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return Module.class; } @SuppressWarnings("unchecked") @Override boolean isValid(Object tasks, final Map<String, Object> context); @Override Class<?> getContainerType(); @Override String getParameterName(); static final String TASK_NAME_KEY; static final String TASK_COMMAND_KEY; static final String TASK_MEMORY_KEY; static final String TASK_DISK_QUOTA_KEY; }### Answer: @Test void testGetContainerType() { assertTrue(new TasksValidator().getContainerType() .isAssignableFrom(Module.class)); }
### Question: RouteValidator implements ParameterValidator { @Override public boolean canCorrect() { return validators.stream() .map(ParameterValidator::canCorrect) .reduce(false, Boolean::logicalOr); } RouteValidator(); @Override String attemptToCorrect(Object route, final Map<String, Object> context); @Override boolean isValid(Object route, final Map<String, Object> context); @Override String getParameterName(); @Override Class<?> getContainerType(); @Override boolean canCorrect(); }### Answer: @Test void testCanCorrect() { assertTrue(validator.canCorrect()); }
### Question: RouteValidator implements ParameterValidator { @Override public String getParameterName() { return SupportedParameters.ROUTE; } RouteValidator(); @Override String attemptToCorrect(Object route, final Map<String, Object> context); @Override boolean isValid(Object route, final Map<String, Object> context); @Override String getParameterName(); @Override Class<?> getContainerType(); @Override boolean canCorrect(); }### Answer: @Test void testGetParameterName() { assertEquals("route", validator.getParameterName()); }
### Question: RouteValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return Module.class; } RouteValidator(); @Override String attemptToCorrect(Object route, final Map<String, Object> context); @Override boolean isValid(Object route, final Map<String, Object> context); @Override String getParameterName(); @Override Class<?> getContainerType(); @Override boolean canCorrect(); }### Answer: @Test void testGetContainerType() { assertTrue(validator.getContainerType() .isAssignableFrom(Module.class)); }
### Question: DomainValidator extends RoutePartValidator { @Override public String getParameterName() { return SupportedParameters.DOMAIN; } @Override String getParameterName(); }### Answer: @Test void testGetParameterName() { assertEquals("domain", validator.getParameterName()); }
### Question: VisibilityValidator implements ParameterValidator { @Override public String getParameterName() { return SupportedParameters.VISIBILITY; } @Override boolean isValid(Object visibleTargets, final Map<String, Object> context); @Override Class<?> getContainerType(); @Override String getParameterName(); }### Answer: @Test void testGetParameterName() { assertEquals("visibility", validator.getParameterName()); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries) { Set<String> existingFiles = blobStore.list(container) .stream() .map(StorageMetadata::getName) .collect(Collectors.toSet()); return fileEntries.stream() .filter(fileEntry -> { String id = fileEntry.getId(); return !existingFiles.contains(id); }) .collect(Collectors.toList()); } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void getFileEntriesWithoutContent() throws Exception { List<FileEntry> fileEntries = new ArrayList<>(); FileEntry existingFile = addFile(TEST_FILE_LOCATION); fileEntries.add(existingFile); FileEntry existingFile2 = addFile(SECOND_FILE_TEST_LOCATION); fileEntries.add(existingFile2); FileEntry nonExistingFile = createFileEntry(); fileEntries.add(nonExistingFile); List<FileEntry> withoutContent = fileStorage.getFileEntriesWithoutContent(fileEntries); assertEquals(1, withoutContent.size()); assertEquals(nonExistingFile.getId(), withoutContent.get(0) .getId()); }
### Question: VisibilityValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return ProvidedDependency.class; } @Override boolean isValid(Object visibleTargets, final Map<String, Object> context); @Override Class<?> getContainerType(); @Override String getParameterName(); }### Answer: @Test void testGetContainerType() { assertTrue(validator.getContainerType() .isAssignableFrom(ProvidedDependency.class)); }
### Question: DescriptorParametersCompatabilityValidator extends CompatabilityParametersValidator<DeploymentDescriptor> { @Override public DeploymentDescriptor validate() { DeploymentDescriptor castedDescriptor = this.descriptor; validate(castedDescriptor); return castedDescriptor; } DescriptorParametersCompatabilityValidator(DeploymentDescriptor descriptor, UserMessageLogger userMessageLogger); @Override DeploymentDescriptor validate(); }### Answer: @Test void testDescriptorValidator() { Module module = buildModule(); DeploymentDescriptor descriptor = buildDeploymentDescriptor(module); prepareModuleParametersCompatabilityValidator(module); DescriptorParametersCompatabilityValidator descriptorValidator = new DescriptorParametersCompatabilityValidator(descriptor, userMessageLogger) { @Override protected ModuleParametersCompatabilityValidator getModuleParametersCompatabilityValidator(Module module) { return moduleParametersCompatabilityValidator; } }; DeploymentDescriptor validatedDescriptor = descriptorValidator.validate(); assertModules(module, validatedDescriptor.getModules()); }
### Question: ApplicationNameValidator implements ParameterValidator { @Override public Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters) { if (!(applicationName instanceof String)) { throw new ContentException(Messages.COULD_NOT_CREATE_VALID_APPLICATION_NAME_FROM_0, applicationName); } boolean applyNamespaceLocal = MapUtil.parseBooleanFlag(relatedParameters, SupportedParameters.APPLY_NAMESPACE, true); boolean applyNamespace = applyNamespaceGlobal && applyNamespaceLocal; return NameUtil.computeValidApplicationName((String) applicationName, namespace, applyNamespace); } ApplicationNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object applicationName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testCorrectionWithNoNamespaces() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(null, false); String result = (String) applicationNameValidator.attemptToCorrect(APPLICATION_NAME, CONTEXT_DO_NOT_APPLY_NAMESPACE); assertEquals(APPLICATION_NAME, result); } @Test void testCorrectionWithNamespaces() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, true); String result = (String) applicationNameValidator.attemptToCorrect(APPLICATION_NAME, CONTEXT_APPLY_NAMESPACE); assertEquals(String.format("%s" + Constants.NAMESPACE_SEPARATOR + "%s", NAMESPACE, APPLICATION_NAME), result); } @Test void testCorrectionWithExplicitApplyNamespaceFalse() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, true); String result = (String) applicationNameValidator.attemptToCorrect(APPLICATION_NAME, CONTEXT_DO_NOT_APPLY_NAMESPACE); assertEquals(APPLICATION_NAME, result); } @Test void testCorrectionWithInvalidApplicationName() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, false); assertThrows(ContentException.class, () -> applicationNameValidator.attemptToCorrect(Collections.emptyList(), CONTEXT_DO_NOT_APPLY_NAMESPACE)); }
### Question: ApplicationNameValidator implements ParameterValidator { @Override public boolean isValid(Object applicationName, final Map<String, Object> context) { return false; } ApplicationNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object applicationName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testValidation() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, false); assertFalse(applicationNameValidator.isValid(APPLICATION_NAME, CONTEXT_DO_NOT_APPLY_NAMESPACE)); }
### Question: ApplicationNameValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return Module.class; } ApplicationNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object applicationName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testGetContainerType() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, false); assertEquals(Module.class, applicationNameValidator.getContainerType()); }
### Question: ApplicationNameValidator implements ParameterValidator { @Override public String getParameterName() { return SupportedParameters.APP_NAME; } ApplicationNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object applicationName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testGetParameterName() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, false); assertEquals(SupportedParameters.APP_NAME, applicationNameValidator.getParameterName()); }
### Question: ApplicationNameValidator implements ParameterValidator { @Override public boolean canCorrect() { return true; } ApplicationNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object applicationName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object applicationName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testCanCorrect() { ApplicationNameValidator applicationNameValidator = new ApplicationNameValidator(NAMESPACE, false); assertTrue(applicationNameValidator.canCorrect()); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public void deleteFile(String id, String space) { blobStore.removeBlob(container, id); } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void deleteFile() throws Exception { FileEntry fileThatWillBeDeleted = addFile(TEST_FILE_LOCATION); FileEntry fileThatStays = addFile(SECOND_FILE_TEST_LOCATION); fileStorage.deleteFile(fileThatWillBeDeleted.getId(), fileThatWillBeDeleted.getSpace()); assertFileExists(false, fileThatWillBeDeleted); assertFileExists(true, fileThatStays); }
### Question: ServiceNameValidator implements ParameterValidator { @Override public Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters) { if (!(serviceName instanceof String)) { throw new ContentException(Messages.COULD_NOT_CREATE_VALID_SERVICE_NAME_FROM_0, serviceName); } boolean applyNamespaceLocal = MapUtil.parseBooleanFlag(relatedParameters, SupportedParameters.APPLY_NAMESPACE, true); boolean applyNamespace = applyNamespaceGlobal && applyNamespaceLocal; return NameUtil.computeValidServiceName((String) serviceName, namespace, applyNamespace); } ServiceNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object serviceName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testCorrectionWithNoNamespaces() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(null, false); String result = (String) serviceNameValidator.attemptToCorrect(SERVICE_NAME, CONTEXT_DO_NOT_APPLY_NAMESPACE); assertEquals(SERVICE_NAME, result); } @Test void testCorrectionWithNamespaces() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, true); String result = (String) serviceNameValidator.attemptToCorrect(SERVICE_NAME, CONTEXT_APPLY_NAMESPACE); assertEquals(String.format("%s" + Constants.NAMESPACE_SEPARATOR + "%s", NAMESPACE, SERVICE_NAME), result); } @Test void testCorrectionWithInvalidServiceName() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, false); assertThrows(ContentException.class, () -> serviceNameValidator.attemptToCorrect(Collections.emptyList(), CONTEXT_DO_NOT_APPLY_NAMESPACE)); }
### Question: ServiceNameValidator implements ParameterValidator { @Override public boolean isValid(Object serviceName, final Map<String, Object> context) { return false; } ServiceNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object serviceName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testValidation() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, false); assertFalse(serviceNameValidator.isValid(SERVICE_NAME, null)); }
### Question: ServiceNameValidator implements ParameterValidator { @Override public Class<?> getContainerType() { return Resource.class; } ServiceNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object serviceName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testGetContainerType() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, false); assertEquals(Resource.class, serviceNameValidator.getContainerType()); }
### Question: ServiceNameValidator implements ParameterValidator { @Override public String getParameterName() { return SupportedParameters.SERVICE_NAME; } ServiceNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object serviceName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testGetParameterName() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, false); assertEquals(SupportedParameters.SERVICE_NAME, serviceNameValidator.getParameterName()); }
### Question: ServiceNameValidator implements ParameterValidator { @Override public boolean canCorrect() { return true; } ServiceNameValidator(String namespace, boolean applyNamespace); @Override Class<?> getContainerType(); @Override String getParameterName(); @Override boolean isValid(Object serviceName, final Map<String, Object> context); @Override boolean canCorrect(); @Override Object attemptToCorrect(Object serviceName, final Map<String, Object> relatedParameters); @Override Set<String> getRelatedParameterNames(); }### Answer: @Test void testCanCorrect() { ServiceNameValidator serviceNameValidator = new ServiceNameValidator(NAMESPACE, false); assertTrue(serviceNameValidator.canCorrect()); }
### Question: CachedObject { public synchronized T get(Supplier<T> refreshFunction) { long currentTime = currentTimeSupplier.getAsLong(); long millisecondsSinceLastRefresh = currentTime - lastRefreshTime; long secondsSinceLastRefresh = TimeUnit.MILLISECONDS.toSeconds(millisecondsSinceLastRefresh); if (object == null \|\| secondsSinceLastRefresh > expirationTimeInSeconds) { this.object = refreshFunction.get(); this.lastRefreshTime = currentTimeSupplier.getAsLong(); } return object; } CachedObject(long expirationTimeInSeconds); CachedObject(long expirationTimeInSeconds, LongSupplier currentTimeSupplier); synchronized T get(Supplier<T> refreshFunction); synchronized T forceRefresh(Supplier<T> refreshFunction); }### Answer: @SuppressWarnings("unchecked") @Test void testGet() { LongSupplier currentTimeSupplier = Mockito.mock(LongSupplier.class); Mockito.when(currentTimeSupplier.getAsLong()) .thenReturn(0L, toMillis(5), toMillis(15), toMillis(25), toMillis(30)); Supplier<String> refreshFunction = Mockito.mock(Supplier.class); Mockito.when(refreshFunction.get()) .thenReturn("a", "b"); CachedObject<String> cachedName = new CachedObject<>(10, currentTimeSupplier); assertEquals("a", cachedName.get(refreshFunction)); assertEquals("a", cachedName.get(refreshFunction)); assertEquals("b", cachedName.get(refreshFunction)); assertEquals("b", cachedName.get(refreshFunction)); assertEquals("b", cachedName.get(refreshFunction)); }
### Question: CachedObject { public synchronized T forceRefresh(Supplier<T> refreshFunction) { object = refreshFunction.get(); lastRefreshTime = currentTimeSupplier.getAsLong(); return object; } CachedObject(long expirationTimeInSeconds); CachedObject(long expirationTimeInSeconds, LongSupplier currentTimeSupplier); synchronized T get(Supplier<T> refreshFunction); synchronized T forceRefresh(Supplier<T> refreshFunction); }### Answer: @SuppressWarnings("unchecked") @Test void testForceRefresh() { LongSupplier currentTimeSupplier = Mockito.mock(LongSupplier.class); Mockito.when(currentTimeSupplier.getAsLong()) .thenReturn(0L, toMillis(5), toMillis(10), toMillis(15), toMillis(25)); Supplier<String> refreshFunction = Mockito.mock(Supplier.class); Mockito.when(refreshFunction.get()) .thenReturn("a", "b", "c"); CachedObject<String> cachedName = new CachedObject<>(20, currentTimeSupplier); assertEquals("a", cachedName.get(refreshFunction)); assertEquals("a", cachedName.get(refreshFunction)); assertEquals("b", cachedName.forceRefresh(refreshFunction)); assertEquals("b", cachedName.get(refreshFunction)); }
### Question: HealthRetriever { public Health getHealth() { HealthCheckConfiguration healthCheckConfiguration = configuration.getHealthCheckConfiguration(); ZonedDateTime currentTime = currentTimeSupplier.get(); ZonedDateTime xSecondsAgo = currentTime.minusSeconds(healthCheckConfiguration.getTimeRangeInSeconds()); List<Operation> healthCheckOperations = getHealthCheckOperations(healthCheckConfiguration, xSecondsAgo); return Health.fromOperations(healthCheckOperations); } @Inject HealthRetriever(OperationService operationService, ApplicationConfiguration configuration); protected HealthRetriever(OperationService operationService, ApplicationConfiguration configuration, Supplier<ZonedDateTime> currentTimeSupplier); Health getHealth(); }### Answer: @Test void testGetHealth() { prepareConfiguration(ImmutableHealthCheckConfiguration.builder() .mtaId(MTA_ID) .spaceId(SPACE_ID) .userName(USER_NAME) .timeRangeInSeconds(TIME_RANGE_IN_SECONDS) .build()); Health health = healthRetriever.getHealth(); assertTrue(health.isHealthy()); assertEquals(1, health.getHealthCheckOperations() .size()); HealthCheckOperation healthCheckOperation = health.getHealthCheckOperations() .get(0); validateHealthCheckOperationParameters(healthCheckOperation); Mockito.verify(operationQuery, times(1)) .user(USER_NAME); validateMandatoryParametersAreSet(); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public void deleteFilesBySpace(String space) { removeBlobsByFilter(blob -> filterBySpace(blob, space)); } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void deleteFilesBySpace() throws Exception { FileEntry firstFile = addFile(TEST_FILE_LOCATION); FileEntry secondFile = addFile(SECOND_FILE_TEST_LOCATION); FileEntry fileInOtherSpace = addFile(TEST_FILE_LOCATION, "otherspace", namespace); fileStorage.deleteFilesBySpace(spaceId); assertFileExists(false, firstFile); assertFileExists(false, secondFile); assertFileExists(true, fileInOtherSpace); }
### Question: DataTerminationService { public void deleteOrphanUserData() { assertGlobalAuditorCredentialsExist(); List<String> deleteSpaceEventsToBeDeleted = getDeleteSpaceEvents(); for (String spaceId : deleteSpaceEventsToBeDeleted) { deleteConfigurationSubscriptionOrphanData(spaceId); deleteConfigurationEntryOrphanData(spaceId); deleteUserOperationsOrphanData(spaceId); deleteSpaceLeftovers(spaceId); } } void deleteOrphanUserData(); }### Answer: @Test void testMissingAuditorCredentials() { Exception exception = assertThrows(IllegalStateException.class, () -> dataTerminationService.deleteOrphanUserData()); assertEquals(Messages.MISSING_GLOBAL_AUDITOR_CREDENTIALS, exception.getMessage()); } @Test void testFailToDeleteSpace() throws FileStorageException { prepareGlobalAuditorCredentials(); prepareCfOptimizedEventsGetter(generateDeletedSpaces(1)); when(configurationEntryService.createQuery()).thenReturn(configurationEntryQuery); when(configurationSubscriptionService.createQuery()).thenReturn(configurationSubscriptionQuery); when(operationService.createQuery()).thenReturn(operationQuery); when(fileService.deleteBySpace(anyString())).thenThrow(new FileStorageException("")); Exception exception = assertThrows(SLException.class, () -> dataTerminationService.deleteOrphanUserData()); assertEquals(Messages.COULD_NOT_DELETE_SPACE_LEFTOVERS, exception.getMessage()); }
### Question: CredentialsGenerator { public String next(int length) { StringBuilder credential = new StringBuilder(length); for (int i = 0; i < length; i++) { int randomIndex = randomGenerator.nextInt(LEGAL_CHARACTERS.length); credential.append(LEGAL_CHARACTERS[randomIndex]); } return credential.toString(); } CredentialsGenerator(); protected CredentialsGenerator(SecureRandom randomGenerator); String next(int length); }### Answer: @Test void testGenerate() throws NoSuchAlgorithmException, NoSuchProviderException { SecureRandom randomGenerator = SecureRandom.getInstance("SHA1PRNG", "SUN"); randomGenerator.setSeed(69); CredentialsGenerator credentialsGenerator = new CredentialsGenerator(randomGenerator); assertEquals("r&k37&tl2D[MK7C", credentialsGenerator.next(16)); assertEquals("ddQz99LI1CB49(*", credentialsGenerator.next(16)); assertEquals("4y(m4ZMfpcY8#g7ur74K@@vXmAAJ4s2(", credentialsGenerator.next(32)); }
### Question: MtaConfigurationPurger { public void purge(String org, String space) { CloudTarget targetSpace = new CloudTarget(org, space); String targetId = new ClientHelper(client).computeSpaceId(org, space); List<CloudApplication> existingApps = getExistingApps(); purgeConfigurationSubscriptions(targetId, existingApps); purgeConfigurationEntries(targetSpace, existingApps); } MtaConfigurationPurger(CloudControllerClient client, ConfigurationEntryService configurationEntryService, ConfigurationSubscriptionService configurationSubscriptionService, MtaMetadataParser mtaMetadataParser); void purge(String org, String space); }### Answer: @Test void testPurge() { MtaConfigurationPurger purger = new MtaConfigurationPurger(client, configurationEntryService, configurationSubscriptionService, new MtaMetadataParser(new MtaMetadataValidator())); purger.purge("org", "space"); verifyConfigurationEntriesDeleted(); verifyConfigurationEntriesNotDeleted(); Mockito.verify(auditLoggingFacade) .logConfigDelete(ENTRY_TO_DELETE); Mockito.verify(auditLoggingFacade) .logConfigDelete(SUBSCRIPTION_TO_DELETE); }
### Question: DescriptorParserFacadeFactory { public DescriptorParserFacade getInstance() { LoaderOptions loaderOptions = new LoaderOptions(); loaderOptions.setMaxAliasesForCollections(applicationConfiguration.getSnakeyamlMaxAliasesForCollections()); YamlParser yamlParser = new YamlParser(loaderOptions); return new DescriptorParserFacade(yamlParser); } @Inject DescriptorParserFacadeFactory(ApplicationConfiguration applicationConfiguration); DescriptorParserFacade getInstance(); }### Answer: @Test void testGetInstance() { final int maxAliases = 5; ApplicationConfiguration applicationConfiguration = Mockito.mock(ApplicationConfiguration.class); Mockito.when(applicationConfiguration.getSnakeyamlMaxAliasesForCollections()) .thenReturn(maxAliases); DescriptorParserFacadeFactory descriptorParserFacadeFactory = new DescriptorParserFacadeFactory(applicationConfiguration); DescriptorParserFacade instance = descriptorParserFacadeFactory.getInstance(); InputStream mtadYaml = getClass().getResourceAsStream("billion-laughs.mtad.yaml"); Assertions.assertThrows(ParsingException.class, () -> instance.parseDeploymentDescriptor(mtadYaml)); }
### Question: ClientHelper { public void deleteRoute(String uri) { ApplicationURI route = new ApplicationURI(uri); client.deleteRoute(route.getHost(), route.getDomain(), route.getPath()); } ClientHelper(CloudControllerClient client); void deleteRoute(String uri); String computeSpaceId(String orgName, String spaceName); CloudTarget computeTarget(String spaceId); }### Answer: @Test void testDeleteRoute() { String uri = "https: clientHelper.deleteRoute(uri); ApplicationURI route = new ApplicationURI(uri); Mockito.verify(client) .deleteRoute(route.getHost(), route.getDomain(), route.getPath()); }
### Question: ClientHelper { public String computeSpaceId(String orgName, String spaceName) { CloudSpace space = client.getSpace(orgName, spaceName, false); if (space != null) { return space.getMetadata() .getGuid() .toString(); } return null; } ClientHelper(CloudControllerClient client); void deleteRoute(String uri); String computeSpaceId(String orgName, String spaceName); CloudTarget computeTarget(String spaceId); }### Answer: @Test void testComputeSpaceId() { Mockito.when(client.getSpace(ORG_NAME, SPACE_NAME, false)) .thenReturn(createCloudSpace(GUID, SPACE_NAME, ORG_NAME)); String spaceId = clientHelper.computeSpaceId(ORG_NAME, SPACE_NAME); Assertions.assertEquals(GUID.toString(), spaceId); } @Test void testComputeSpaceIdIfSpaceIsNull() { Assertions.assertNull(clientHelper.computeSpaceId(ORG_NAME, SPACE_NAME)); }
### Question: ClientHelper { public CloudTarget computeTarget(String spaceId) { CloudSpace space = attemptToFindSpace(spaceId); if (space != null) { return new CloudTarget(space.getOrganization() .getName(), space.getName()); } return null; } ClientHelper(CloudControllerClient client); void deleteRoute(String uri); String computeSpaceId(String orgName, String spaceName); CloudTarget computeTarget(String spaceId); }### Answer: @Test void testComputeTarget() { Mockito.when(client.getSpace(Matchers.any(UUID.class))) .thenReturn(createCloudSpace(GUID, SPACE_NAME, ORG_NAME)); CloudTarget target = clientHelper.computeTarget(SPACE_ID); Assertions.assertEquals(ORG_NAME, target.getOrganizationName()); Assertions.assertEquals(SPACE_NAME, target.getSpaceName()); } @Test void testComputeTargetCloudOperationExceptionForbiddenThrown() { Mockito.when(client.getSpace(Matchers.any(UUID.class))) .thenThrow(new CloudOperationException(HttpStatus.FORBIDDEN)); Assertions.assertNull(clientHelper.computeTarget(SPACE_ID)); } @Test void testComputeTargetCloudOperationExceptionNotFoundThrown() { Mockito.when(client.getSpace(Matchers.any(UUID.class))) .thenThrow(new CloudOperationException(HttpStatus.NOT_FOUND)); Assertions.assertNull(clientHelper.computeTarget(SPACE_ID)); } @Test void testComputeTargetCloudOperationExceptionBadRequestThrown() { Mockito.when(client.getSpace(Matchers.any(UUID.class))) .thenThrow(new CloudOperationException(HttpStatus.BAD_REQUEST)); CloudOperationException cloudOperationException = Assertions.assertThrows(CloudOperationException.class, () -> clientHelper.computeTarget(SPACE_ID)); Assertions.assertEquals(HttpStatus.BAD_REQUEST, cloudOperationException.getStatusCode()); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public void deleteFilesBySpaceAndNamespace(String space, String namespace) { removeBlobsByFilter(blob -> filterBySpaceAndNamespace(blob, space, namespace)); } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void deleteFilesBySpaceAndNamespace() throws Exception { FileEntry firstFile = addFile(TEST_FILE_LOCATION); FileEntry secondFile = addFile(SECOND_FILE_TEST_LOCATION); FileEntry fileInOtherSpace = addFile(TEST_FILE_LOCATION, "otherspace", namespace); FileEntry fileInOtherNamespace = addFile(TEST_FILE_LOCATION, spaceId, "othernamespace"); fileStorage.deleteFilesBySpaceAndNamespace(spaceId, namespace); assertFileExists(true, fileInOtherNamespace); assertFileExists(true, fileInOtherSpace); assertFileExists(false, firstFile); assertFileExists(false, secondFile); }
### Question: SystemParameters { public void injectInto(DeploymentDescriptor descriptor) { for (Module module : descriptor.getModules()) { Map<String, Object> moduleSystemParameters = getModuleParameters(module); module.setParameters(MapUtil.merge(moduleSystemParameters, module.getParameters())); } for (Resource resource : descriptor.getResources()) { Map<String, Object> resourceSystemParameters = getResourceParameters(resource); resource.setParameters(MapUtil.merge(resourceSystemParameters, resource.getParameters())); } Map<String, Object> generalSystemParameters = getGeneralParameters(); descriptor.setParameters(MapUtil.merge(generalSystemParameters, descriptor.getParameters())); } SystemParameters(Builder builder); void injectInto(DeploymentDescriptor descriptor); static final int GENERATED_CREDENTIALS_LENGTH; static final String IDLE_HOST_SUFFIX; static final String ROUTE_PATH_PLACEHOLDER; static final String DEFAULT_HOST_BASED_IDLE_URI; static final String DEFAULT_HOST_BASED_URI; static final String DEFAULT_IDLE_URL; static final String DEFAULT_URL; }### Answer: @Test void testDescriptorOverridesDefaults() throws Exception { SystemParameters testedClass = createSystemParameters(false); List<String> descriptorParameterFields = List.of(SupportedParameters.ORGANIZATION_NAME, SupportedParameters.SPACE_NAME, SupportedParameters.USER, SupportedParameters.DEFAULT_DOMAIN, SupportedParameters.CONTROLLER_URL, SupportedParameters.AUTHORIZATION_URL, SupportedParameters.DEPLOY_SERVICE_URL); DeploymentDescriptor descriptor = DeploymentDescriptor.createV3() .setParameters(createParametersMap(descriptorParameterFields)); testedClass.injectInto(descriptor); assertCustomValueMap(descriptorParameterFields, descriptor.getParameters()); } @Test void testModuleParametersOverrideSystemParameters() throws Exception { SystemParameters testedClass = createSystemParameters(false); List<String> fields = List.of(SupportedParameters.PROTOCOL, SupportedParameters.TIMESTAMP, SupportedParameters.INSTANCES, SupportedParameters.APP_NAME, SupportedParameters.IDLE_DOMAIN, SupportedParameters.DOMAIN); Module moduleWithParameters = Module.createV3() .setName("first") .setParameters(createParametersMap(fields)); DeploymentDescriptor descriptor = DeploymentDescriptor.createV3() .setModules(List.of(moduleWithParameters)); testedClass.injectInto(descriptor); assertCustomValueMap(fields, descriptor.getModules() .get(0) .getParameters()); } @Test void testResourceParameters() throws Exception { SystemParameters testedClass = createSystemParameters(false); Resource resourceOne = Resource.createV3() .setName("first"); Resource resourceTwo = Resource.createV3() .setName("second"); DeploymentDescriptor descriptor = DeploymentDescriptor.createV3() .setResources(List.of(resourceOne, resourceTwo)); testedClass.injectInto(descriptor); for (Resource resource : descriptor.getResources()) { verifyResourceParameters(resource.getName(), resource.getParameters()); } } @Test void testResourceParametersOverrideSystemParameters() throws Exception { SystemParameters testedClass = createSystemParameters(false); List<String> fields = List.of(SupportedParameters.SERVICE_NAME, SupportedParameters.DEFAULT_CONTAINER_NAME, SupportedParameters.DEFAULT_XS_APP_NAME); Resource resourceWithParameters = Resource.createV3() .setName("first") .setParameters(createParametersMap(fields)); DeploymentDescriptor descriptor = DeploymentDescriptor.createV3() .setResources(List.of(resourceWithParameters)); testedClass.injectInto(descriptor); assertCustomValueMap(fields, descriptor.getResources() .get(0) .getParameters()); }
### Question: DockerInfoParser implements ParametersParser<DockerInfo> { @Override public DockerInfo parse(List<Map<String, Object>> parametersList) { Map<String, String> dockerParams = getDockerParams(parametersList); return getDockerInfo(dockerParams); } @Override DockerInfo parse(List<Map<String, Object>> parametersList); }### Answer: @Test void testWithValidImageWithoutUserCredentials() { List<Map<String, Object>> parameters = new ArrayList<>(); Map<String, Object> moduleParameters = new HashMap<>(); Map<String, String> dockerParameters = new HashMap<>(); String sampleImage = "cloudfoundry/test-app"; dockerParameters.put("image", sampleImage); moduleParameters.put("docker", dockerParameters); parameters.add(moduleParameters); DockerInfo actualDockerInfo = dockerInfoParser.parse(parameters); DockerInfo expectedDockerInfo = ImmutableDockerInfo.builder() .image(sampleImage) .build(); assertEquals(expectedDockerInfo, actualDockerInfo); } @Test void testWithValidImageAndCredentials() { List<Map<String, Object>> parameters = new ArrayList<>(); Map<String, Object> moduleParameters = new HashMap<>(); Map<String, String> dockerParameters = new HashMap<>(); String sampleImage = "cloudfoundry/test-app"; String username = "someUsername"; String password = "somePassword"; dockerParameters.put("image", sampleImage); dockerParameters.put("username", username); dockerParameters.put("password", password); moduleParameters.put("docker", dockerParameters); parameters.add(moduleParameters); DockerInfo actualDockerInfo = dockerInfoParser.parse(parameters); DockerInfo expectedDockerInfo = creteDockerInfo(sampleImage, username, password); assertEquals(expectedDockerInfo, actualDockerInfo); } @Test void testWithoutArguments() { List<Map<String, Object>> parameters = new ArrayList<>(); Map<String, Object> moduleParameters = new HashMap<>(); Map<String, String> dockerParameters = new HashMap<>(); moduleParameters.put("docker", dockerParameters); parameters.add(moduleParameters); DockerInfo actualDockerInfo = dockerInfoParser.parse(parameters); assertNull(actualDockerInfo); } @Test void testWithoutDocker() { List<Map<String, Object>> parameters = Collections.emptyList(); DockerInfo dockerInfo = dockerInfoParser.parse(parameters); assertNull(dockerInfo); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public int deleteFilesModifiedBefore(Date modificationTime) { return removeBlobsByFilter(blob -> filterByModificationTime(blob, modificationTime)); } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void deleteFilesModifiedBefore() throws Exception { long currentMillis = System.currentTimeMillis(); final long oldFilesTtl = 1000 * 60 * 10; final long pastMoment = currentMillis - 1000 * 60 * 15; FileEntry fileEntryToRemain1 = addFile(TEST_FILE_LOCATION); FileEntry fileEntryToRemain2 = addFile(SECOND_FILE_TEST_LOCATION); FileEntry fileEntryToDelete1 = addFile(TEST_FILE_LOCATION, spaceId, namespace, new Date(pastMoment)); FileEntry fileEntryToDelete2 = addFile(SECOND_FILE_TEST_LOCATION, spaceId, null, new Date(pastMoment)); String blobWithNoMetadataId = addBlobWithNoMetadata(); int deletedFiles = fileStorage.deleteFilesModifiedBefore(new Date(currentMillis - oldFilesTtl)); assertEquals(3, deletedFiles); assertFileExists(true, fileEntryToRemain1); assertFileExists(true, fileEntryToRemain2); assertFileExists(false, fileEntryToDelete1); assertFileExists(false, fileEntryToDelete2); assertNull(blobStoreContext.getBlobStore() .getBlob(CONTAINER, blobWithNoMetadataId)); }
### Question: MemoryParametersParser implements ParametersParser<Integer> { @Override public Integer parse(List<Map<String, Object>> parametersList) { return parseMemory((String) PropertiesUtil.getPropertyValue(parametersList, parameterName, defaultMemory)); } MemoryParametersParser(String parameterName, String defaultMemory); @Override Integer parse(List<Map<String, Object>> parametersList); static Integer parseMemory(String value); }### Answer: @Test void testInvalidMemoryParsing() { List<Map<String, Object>> parametersList = List.of(Map.of(SupportedParameters.MEMORY, "test-mb")); assertThrows(ContentException.class, () -> parser.parse(parametersList)); } @Test void testDefaultMemoryParsing() { Integer memory = parser.parse(Collections.emptyList()); assertEquals(DEFAULT_MEMORY, memory); }
### Question: AuditLogManager { AuditLogManager(DataSource dataSource, UserInfoProvider userInfoProvider) { securityLogger = setUpLogger(dataSource, userInfoProvider, "SECURITY"); configLogger = setUpLogger(dataSource, userInfoProvider, "CONFIG"); actionLogger = setUpLogger(dataSource, userInfoProvider, "ACTION"); } AuditLogManager(DataSource dataSource, UserInfoProvider userInfoProvider); }### Answer: @Test void testAuditLogManager() { List<Logger> loggers = loadAuditLoggers(); logMessage(loggers); assertNull(auditLogManager.getException()); }
### Question: FlowableJobExecutorInformation { public int getCurrentJobExecutorQueueSize() { if (lastUpdateTime == null \|\| isPastCacheTimeout()) { updateCurrentJobExecutorQueueSize(); } return currentJobExecutorQueueSize; } @Inject FlowableJobExecutorInformation(DefaultAsyncJobExecutor jobExecutor); int getCurrentJobExecutorQueueSize(); }### Answer: @Test void testGetCurrentJobExecutorQueueSize() { prepareJobExecutor(JOBS_IN_QUEUE); int currentJobExecutorQueueSize = flowableJobExecutorInformation.getCurrentJobExecutorQueueSize(); assertEquals(JOBS_IN_QUEUE, currentJobExecutorQueueSize); } @Test void testGetCurrentJobExecutorQueueSizeFromCache() { prepareJobExecutor(JOBS_IN_QUEUE); flowableJobExecutorInformation.getCurrentJobExecutorQueueSize(); prepareJobExecutor(UPDATED_JOBS_IN_QUEUE); int currentJobExecutorQueueSize = flowableJobExecutorInformation.getCurrentJobExecutorQueueSize(); assertEquals(JOBS_IN_QUEUE, currentJobExecutorQueueSize); } @Test void testGetCurrentJobExecutorQueueSizeExpiredCache() { flowableJobExecutorInformation = new FlowableJobExecutorInformation(asyncExecutor) { @Override protected void updateTime() { lastUpdateTime = Instant.now() .minusSeconds(120); } }; prepareJobExecutor(JOBS_IN_QUEUE); flowableJobExecutorInformation.getCurrentJobExecutorQueueSize(); prepareJobExecutor(UPDATED_JOBS_IN_QUEUE); int currentJobExecutorQueueSize = flowableJobExecutorInformation.getCurrentJobExecutorQueueSize(); assertEquals(UPDATED_JOBS_IN_QUEUE, currentJobExecutorQueueSize); }
### Question: PurgeApiAuthorizationFilter extends SpaceNameBasedAuthorizationFilter { @Override public String getUriRegex() { return "/rest/configuration-entries/purge"; } @Inject PurgeApiAuthorizationFilter(AuthorizationChecker authorizationChecker); @Override String getUriRegex(); }### Answer: @Test void testUriRegexMatches() { assertTrue("/rest/configuration-entries/purge".matches(purgeApiAuthorizationFilter.getUriRegex())); }
### Question: PurgeApiAuthorizationFilter extends SpaceNameBasedAuthorizationFilter { @Override protected CloudTarget extractTarget(HttpServletRequest request) { String organizationName = request.getParameter(ConfigurationEntriesResource.REQUEST_PARAM_ORGANIZATION); String spaceName = request.getParameter(ConfigurationEntriesResource.REQUEST_PARAM_SPACE); if (StringUtils.isAnyEmpty(organizationName, spaceName)) { throw new SLException(Messages.ORG_AND_SPACE_MUST_BE_SPECIFIED); } return new CloudTarget(organizationName, spaceName); } @Inject PurgeApiAuthorizationFilter(AuthorizationChecker authorizationChecker); @Override String getUriRegex(); }### Answer: @Test void testExtractTarget() { Mockito.when(request.getParameter(ConfigurationEntriesResource.REQUEST_PARAM_ORGANIZATION)) .thenReturn(ORGANIZATION_NAME); Mockito.when(request.getParameter(ConfigurationEntriesResource.REQUEST_PARAM_SPACE)) .thenReturn(SPACE_NAME); assertEquals(new CloudTarget(ORGANIZATION_NAME, SPACE_NAME), purgeApiAuthorizationFilter.extractTarget(request)); } @Test void testExtractTargetWithMissingParameters() { assertThrows(SLException.class, () -> purgeApiAuthorizationFilter.extractTarget(request)); }
### Question: SpaceNameBasedAuthorizationFilter implements UriAuthorizationFilter { @Override public final boolean ensureUserIsAuthorized(HttpServletRequest request, HttpServletResponse response) throws IOException { CloudTarget target = extractAndLogTarget(request); try { authorizationChecker.ensureUserIsAuthorized(request, SecurityContextUtil.getUserInfo(), target, null); return true; } catch (ResponseStatusException e) { logUnauthorizedRequest(request, e); response.sendError(HttpStatus.UNAUTHORIZED.value(), MessageFormat.format(Messages.NOT_AUTHORIZED_TO_OPERATE_IN_ORGANIZATION_0_AND_SPACE_1, target.getOrganizationName(), target.getSpaceName())); return false; } } SpaceNameBasedAuthorizationFilter(AuthorizationChecker authorizationChecker); @Override final boolean ensureUserIsAuthorized(HttpServletRequest request, HttpServletResponse response); }### Answer: @Test void testWithSuccessfulAuthorization() throws IOException { dummyUriAuthorizationFilter.ensureUserIsAuthorized(request, response); Mockito.verify(authorizationChecker) .ensureUserIsAuthorized(Mockito.eq(request), Mockito.any(), Mockito.eq(new CloudTarget(ORGANIZATION_NAME, SPACE_NAME)), Mockito.any()); } @Test void testWithException() throws IOException { Mockito.doThrow(new ResponseStatusException(HttpStatus.FORBIDDEN)) .when(authorizationChecker) .ensureUserIsAuthorized(Mockito.eq(request), Mockito.any(), Mockito.eq(new CloudTarget(ORGANIZATION_NAME, SPACE_NAME)), Mockito.any()); dummyUriAuthorizationFilter.ensureUserIsAuthorized(request, response); Mockito.verify(response) .sendError(Mockito.eq(HttpStatus.UNAUTHORIZED.value()), Mockito.any()); }
### Question: ObjectStoreFileStorage implements FileStorage { @Override public <T> T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor) throws FileStorageException { FileEntry fileEntry = createFileEntry(space, id); try { Blob blob = getBlobWithRetries(fileEntry, 3); if (blob == null) { throw new FileStorageException(MessageFormat.format(Messages.FILE_WITH_ID_AND_SPACE_DOES_NOT_EXIST, fileEntry.getId(), fileEntry.getSpace())); } Payload payload = blob.getPayload(); return processContent(fileContentProcessor, payload); } catch (Exception e) { throw new FileStorageException(e); } } ObjectStoreFileStorage(BlobStore blobStore, String container); @Override void addFile(FileEntry fileEntry, File file); @Override List<FileEntry> getFileEntriesWithoutContent(List<FileEntry> fileEntries); @Override void deleteFile(String id, String space); @Override void deleteFilesBySpace(String space); @Override void deleteFilesBySpaceAndNamespace(String space, String namespace); @Override int deleteFilesModifiedBefore(Date modificationTime); @Override T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); }### Answer: @Test void processFileContent() throws Exception { FileEntry fileEntry = addFile(TEST_FILE_LOCATION); String testFileDigest = DigestHelper.computeFileChecksum(Paths.get(TEST_FILE_LOCATION), DIGEST_METHOD) .toLowerCase(); validateFileContent(fileEntry, testFileDigest); }
### Question: CustomTokenServices implements ResourceServerTokenServices { @Override public OAuth2Authentication loadAuthentication(String tokenString) { OAuth2AccessToken token = readAccessToken(tokenString); if (token == null) { logToAuditLogAndThrow("Invalid access token"); } if (token.isExpired() && token.getRefreshToken() == null) { tokenStore.removeAccessToken(token); logToAuditLogAndThrow(MessageFormat.format("The access token has expired on {0}", token.getExpiration())); } OAuth2Authentication auth = tokenStore.readAuthentication(token); if (auth == null) { TokenProperties tokenProperties = TokenProperties.fromToken(token); auth = SecurityUtil.createAuthentication(tokenProperties.getClientId(), token.getScope(), SecurityUtil.getTokenUserInfo(token)); try { LOGGER.info(MessageFormat.format(Messages.STORING_TOKEN_FOR_USER_0_WITH_EXPIRATION_TIME_1, tokenProperties.getUserName(), token.getExpiresIn())); tokenStore.storeAccessToken(token, auth); } catch (DataIntegrityViolationException e) { LOGGER.debug(Messages.ERROR_STORING_TOKEN_DUE_TO_INTEGRITY_VIOLATION, e); } } return auth; } @Inject CustomTokenServices(TokenStore tokenStore, ApplicationConfiguration configuration, TokenParserChain tokenParserChain); @Override OAuth2Authentication loadAuthentication(String tokenString); @Override OAuth2AccessToken readAccessToken(String tokenString); }### Answer: @Test void testGetTokenFromCache() { OAuth2AccessToken token = buildValidToken(); OAuth2Authentication auth = buildAuthentication(token); prepareTokenParserChain(token); prepareTokenStore(token, auth); OAuth2Authentication loadedAuthentication = customTokenServices.loadAuthentication(DUMMY_TOKEN_STRING); assertEquals(auth.getAuthorities(), loadedAuthentication.getAuthorities()); assertEquals(auth.getCredentials(), loadedAuthentication.getCredentials()); assertEquals(auth.getOAuth2Request(), loadedAuthentication.getOAuth2Request()); } @Test void testHandleExceptionForInvalidToken() { assertThrows(InvalidTokenException.class, () -> customTokenServices.loadAuthentication(DUMMY_TOKEN_STRING)); } @Test void testWithExpiredToken() { OAuth2AccessToken token = buildInvalidToken(); prepareTokenParserChain(token); assertThrows(InvalidTokenException.class, () -> customTokenServices.loadAuthentication(DUMMY_TOKEN_STRING)); verify(tokenStore).removeAccessToken(eq(token)); } @Test void testPersistTokenInCache() { OAuth2AccessToken token = buildValidToken(); prepareTokenParserChain(token); OAuth2Authentication auth = customTokenServices.loadAuthentication(DUMMY_TOKEN_STRING); assertNotNull(auth.getAuthorities()); assertNotNull(auth.getCredentials()); assertNotNull(auth.getOAuth2Request()); verify(tokenStore).storeAccessToken(token, auth); }
### Question: SpaceGuidBasedAuthorizationFilter implements UriAuthorizationFilter { @Override public final boolean ensureUserIsAuthorized(HttpServletRequest request, HttpServletResponse response) throws IOException { String spaceGuid = extractAndLogSpaceGuid(request); try { authorizationChecker.ensureUserIsAuthorized(request, SecurityContextUtil.getUserInfo(), spaceGuid, null); return true; } catch (ResponseStatusException e) { logUnauthorizedRequest(request, e); response.sendError(e.getStatus() .value(), MessageFormat.format(Messages.NOT_AUTHORIZED_TO_OPERATE_IN_SPACE_WITH_GUID_0, spaceGuid)); return false; } } SpaceGuidBasedAuthorizationFilter(AuthorizationChecker authorizationChecker); @Override final boolean ensureUserIsAuthorized(HttpServletRequest request, HttpServletResponse response); }### Answer: @Test void testWithSuccessfulAuthorization() throws IOException { dummyUriAuthorizationFilter.ensureUserIsAuthorized(request, response); Mockito.verify(authorizationChecker) .ensureUserIsAuthorized(Mockito.eq(request), Mockito.any(), Mockito.eq(SPACE_GUID), Mockito.any()); } @Test void testWithException() throws IOException { Mockito.doThrow(new ResponseStatusException(HttpStatus.FORBIDDEN)) .when(authorizationChecker) .ensureUserIsAuthorized(Mockito.eq(request), Mockito.any(), Mockito.eq(SPACE_GUID), Mockito.any()); dummyUriAuthorizationFilter.ensureUserIsAuthorized(request, response); Mockito.verify(response) .sendError(Mockito.eq(HttpStatus.FORBIDDEN.value()), Mockito.any()); }
### Question: OperationService extends PersistenceService<Operation, OperationDto, String> { public OperationQuery createQuery() { return new OperationQueryImpl(createEntityManager(), operationMapper); } @Inject OperationService(EntityManagerFactory entityManagerFactory); OperationQuery createQuery(); }### Answer: @Test void testAdd() { operationService.add(OPERATION_1); assertEquals(Collections.singletonList(OPERATION_1), operationService.createQuery() .list()); assertEquals(OPERATION_1, operationService.createQuery() .processId(OPERATION_1.getProcessId()) .singleResult()); } @Test void testAddWithNonEmptyDatabase() { addOperations(List.of(OPERATION_1, OPERATION_2)); assertOperationExists(OPERATION_1.getProcessId()); assertOperationExists(OPERATION_2.getProcessId()); assertEquals(List.of(OPERATION_1, OPERATION_2), operationService.createQuery() .list()); }
### Question: AdminApiAuthorizationFilter extends SpaceGuidBasedAuthorizationFilter { @Override protected String extractSpaceGuid(HttpServletRequest request) { String spaceGuid = applicationConfiguration.getSpaceGuid(); if (StringUtils.isEmpty(spaceGuid)) { throw new SLException("Could not retrieve the MTA deployer's space GUID."); } return spaceGuid; } @Inject AdminApiAuthorizationFilter(ApplicationConfiguration applicationConfiguration, AuthorizationChecker authorizationChecker); @Override String getUriRegex(); }### Answer: @Test void testExtractSpaceGuid() { Mockito.when(applicationConfiguration.getSpaceGuid()) .thenReturn(SPACE_GUID); assertEquals(SPACE_GUID, adminApiAuthorizationFilter.extractSpaceGuid(request)); } @Test void testExtractSpaceGuidWithEmptyString() { Mockito.when(applicationConfiguration.getSpaceGuid()) .thenReturn(""); assertThrows(SLException.class, () -> adminApiAuthorizationFilter.extractSpaceGuid(request)); }
### Question: CompositeUriAuthorizationFilter extends AuthorizationFilter { @Override protected boolean ensureUserIsAuthorized(HttpServletRequest request, HttpServletResponse response) throws IOException { try { String uri = ServletUtil.decodeUri(request); String normalizedUri = ServletUtil.removeInvalidForwardSlashes(uri); LOGGER.trace("Looking for a matching authorization filter for request to \"{}\"...", uri); LOGGER.trace("Registered authorization filters: {}", uriAuthorizationFilters); for (UriAuthorizationFilter uriAuthorizationFilter : uriAuthorizationFilters) { if (normalizedUri.matches(uriAuthorizationFilter.getUriRegex())) { return ensureUserIsAuthorized(uriAuthorizationFilter, request, response); } } LOGGER.trace("No matching authorization filter for request to \"{}\".", uri); return true; } catch (Exception e) { ResponseEntity<String> responseEntity = exceptionMapper.handleException(e); ServletUtil.send(response, responseEntity.getStatusCodeValue(), responseEntity.getBody()); return false; } } @Inject CompositeUriAuthorizationFilter(List<UriAuthorizationFilter> uriAuthorizationFilters, CFExceptionMapper exceptionMapper); }### Answer: @Test void testUriMatching() throws IOException { Mockito.when(request.getRequestURI()) .thenReturn(FOO_REQUEST_URI); assertTrue(compositeUriAuthorizationFilter.ensureUserIsAuthorized(request, response)); Mockito.verify(fooUriAuthorizationFilter) .ensureUserIsAuthorized(request, response); Mockito.verify(barUriAuthorizationFilter, Mockito.never()) .ensureUserIsAuthorized(request, response); } @Test void testUriMatchingWithoutAnyMatchingFilters() throws IOException { Mockito.when(request.getRequestURI()) .thenReturn(BAZ_REQUEST_URI); assertTrue(compositeUriAuthorizationFilter.ensureUserIsAuthorized(request, response)); Mockito.verify(fooUriAuthorizationFilter, Mockito.never()) .ensureUserIsAuthorized(request, response); Mockito.verify(barUriAuthorizationFilter, Mockito.never()) .ensureUserIsAuthorized(request, response); } @Test void testUriWhichContainsLotsOfForwardSlashes() throws IOException { Mockito.when(request.getRequestURI()) .thenReturn(BAR_REQUEST_WITH_SLASHES_URI); assertFalse(compositeUriAuthorizationFilter.ensureUserIsAuthorized(request, response)); Mockito.verify(fooUriAuthorizationFilter, Mockito.never()) .ensureUserIsAuthorized(request, response); Mockito.verify(barUriAuthorizationFilter) .ensureUserIsAuthorized(request, response); } @Test void testWithAuthorizationException() throws IOException { Mockito.when(request.getRequestURI()) .thenReturn(FOO_REQUEST_URI); Mockito.when(fooUriAuthorizationFilter.ensureUserIsAuthorized(request, response)) .thenThrow(new SLException("...")); PrintWriter writer = Mockito.mock(PrintWriter.class); Mockito.when(response.getWriter()) .thenReturn(writer); assertFalse(compositeUriAuthorizationFilter.ensureUserIsAuthorized(request, response)); Mockito.verify(response) .setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value()); Mockito.verify(writer) .print("..."); Mockito.verify(writer) .flush(); } @Test void testWithUnauthorizedUser() throws IOException { Mockito.when(request.getRequestURI()) .thenReturn(BAR_REQUEST_URI); assertFalse(compositeUriAuthorizationFilter.ensureUserIsAuthorized(request, response)); Mockito.verify(barUriAuthorizationFilter) .ensureUserIsAuthorized(request, response); }
### Question: MtasApiAuthorizationFilter extends SpaceGuidBasedAuthorizationFilter { @Override protected String extractSpaceGuid(HttpServletRequest request) { String uri = ServletUtil.decodeUri(request); return extractSpaceGuid(ServletUtil.removeInvalidForwardSlashes(uri)); } @Inject MtasApiAuthorizationFilter(AuthorizationChecker authorizationChecker); @Override String getUriRegex(); }### Answer: @Test void testExtractSpaceGuid() { Mockito.when(request.getRequestURI()) .thenReturn(String.format("/api/v1/spaces/%s/mtas", SPACE_GUID)); assertEquals(SPACE_GUID, mtasApiAuthorizationFilter.extractSpaceGuid(request)); } @Test void testExtractSpaceGuidWithDoubleForwardSlashes() { Mockito.when(request.getRequestURI()) .thenReturn(String.format("/api assertEquals(SPACE_GUID, mtasApiAuthorizationFilter.extractSpaceGuid(request)); } @Test void testExtractSpaceGuidWithNonMatchingUri() { Mockito.when(request.getRequestURI()) .thenReturn("/public/ping"); assertThrows(SLException.class, () -> mtasApiAuthorizationFilter.extractSpaceGuid(request)); }
### Question: MtasApiServiceImpl implements MtasApiService { @Override public ResponseEntity<List<Mta>> getMtas(String spaceGuid) { List<DeployedMta> deployedMtas = deployedMtaDetector.detectDeployedMtasWithoutNamespace(getCloudFoundryClient(spaceGuid)); List<Mta> mtas = getMtas(deployedMtas); return ResponseEntity.ok() .body(mtas); } @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid); @Override ResponseEntity<Mta> getMta(String spaceGuid, String mtaId); @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid, String namespace, String name); }### Answer: @Test void testGetMtas() { Mockito.when(deployedMtaDetector.detectDeployedMtasWithoutNamespace(Mockito.any())) .thenReturn(getDeployedMtas(mtas)); ResponseEntity<List<Mta>> response = testedClass.getMtas(SPACE_GUID); assertEquals(HttpStatus.OK, response.getStatusCode()); List<Mta> responseMtas = response.getBody(); assertEquals(mtas, responseMtas); }
### Question: MtasApiServiceImpl implements MtasApiService { protected ResponseEntity<List<Mta>> getAllMtas(String spaceGuid) { List<DeployedMta> deployedMtas = deployedMtaDetector.detectDeployedMtas(getCloudFoundryClient(spaceGuid)); return ResponseEntity.ok() .body(getMtas(deployedMtas)); } @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid); @Override ResponseEntity<Mta> getMta(String spaceGuid, String mtaId); @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid, String namespace, String name); }### Answer: @Test void testGetAllMtas() { Mockito.when(deployedMtaDetector.detectDeployedMtas(Mockito.any())) .thenReturn(getDeployedMtas(mtas)); ResponseEntity<List<Mta>> response = testedClass.getMtas(SPACE_GUID, null, null); assertEquals(HttpStatus.OK, response.getStatusCode()); List<Mta> responseMtas = response.getBody(); assertEquals(mtas, responseMtas); }
### Question: MtasApiServiceImpl implements MtasApiService { protected ResponseEntity<List<Mta>> getMtasByName(String spaceGuid, String name) { List<DeployedMta> deployedMtas = deployedMtaDetector.detectDeployedMtasByName(name, getCloudFoundryClient(spaceGuid)); if (deployedMtas.isEmpty()) { throw new NotFoundException(Messages.MTAS_NOT_FOUND_BY_NAME, name); } return ResponseEntity.ok() .body(getMtas(deployedMtas)); } @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid); @Override ResponseEntity<Mta> getMta(String spaceGuid, String mtaId); @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid, String namespace, String name); }### Answer: @Test void testGetMtasByName() { Mta mtaToGet = mtas.get(1); Mockito.when(deployedMtaDetector.detectDeployedMtasByName(mtaToGet.getMetadata() .getId(), client)) .thenReturn(List.of(getDeployedMta(mtaToGet))); ResponseEntity<List<Mta>> response = testedClass.getMtas(SPACE_GUID, null, mtaToGet.getMetadata() .getId()); assertEquals(HttpStatus.OK, response.getStatusCode()); List<Mta> responseMtas = response.getBody(); assertEquals(List.of(mtaToGet), responseMtas); }
### Question: MtasApiServiceImpl implements MtasApiService { protected ResponseEntity<List<Mta>> getMtasByNamespace(String spaceGuid, String namespace) { List<DeployedMta> deployedMtas = deployedMtaDetector.detectDeployedMtasByNamespace(namespace, getCloudFoundryClient(spaceGuid)); if (deployedMtas.isEmpty()) { throw new NotFoundException(Messages.MTAS_NOT_FOUND_BY_NAMESPACE, namespace); } return ResponseEntity.ok() .body(getMtas(deployedMtas)); } @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid); @Override ResponseEntity<Mta> getMta(String spaceGuid, String mtaId); @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid, String namespace, String name); }### Answer: @Test void testGetMtasByNamespace() { Mta mtaToGet = mtas.get(0); Mockito.when(deployedMtaDetector.detectDeployedMtasByNamespace(mtaToGet.getMetadata() .getNamespace(), client)) .thenReturn(List.of(getDeployedMta(mtaToGet))); ResponseEntity<List<Mta>> response = testedClass.getMtas(SPACE_GUID, mtaToGet.getMetadata() .getNamespace(), null); assertEquals(HttpStatus.OK, response.getStatusCode()); List<Mta> responseMtas = response.getBody(); assertEquals(List.of(mtaToGet), responseMtas); }
### Question: MtasApiServiceImpl implements MtasApiService { @Override public ResponseEntity<Mta> getMta(String spaceGuid, String mtaId) { List<DeployedMta> mtas = deployedMtaDetector.detectDeployedMtasByName(mtaId, getCloudFoundryClient(spaceGuid)); if (mtas.isEmpty()) { throw new NotFoundException(Messages.MTA_NOT_FOUND, mtaId); } if (mtas.size() != 1) { throw new ConflictException(Messages.MTA_SEARCH_NOT_UNIQUE_BY_NAME, mtaId); } return ResponseEntity.ok() .body(getMta(mtas.get(0))); } @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid); @Override ResponseEntity<Mta> getMta(String spaceGuid, String mtaId); @Override ResponseEntity<List<Mta>> getMtas(String spaceGuid, String namespace, String name); }### Answer: @Test void testGetMta() { Mta mtaToGet = mtas.get(1); Mockito.when(deployedMtaDetector.detectDeployedMtasByName(mtaToGet.getMetadata() .getId(), client)) .thenReturn(List.of(getDeployedMta(mtaToGet))); ResponseEntity<Mta> response = testedClass.getMta(SPACE_GUID, mtaToGet.getMetadata() .getId()); assertEquals(HttpStatus.OK, response.getStatusCode()); Mta responseMta = response.getBody(); assertEquals(mtaToGet, responseMta); } @Test void testGetMtaNotFound() { Assertions.assertThrows(NotFoundException.class, () -> testedClass.getMta(SPACE_GUID, "not_a_real_mta")); } @Test void testGetMtaNotUniqueByName() { Mockito.when(deployedMtaDetector.detectDeployedMtasByName("name_thats_not_unique", client)) .thenReturn(getDeployedMtas(mtas)); Assertions.assertThrows(ConflictException.class, () -> testedClass.getMta(SPACE_GUID, "name_thats_not_unique")); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last) { List<Operation.State> states = getStates(stateStrings); List<Operation> operations = filterByQueryParameters(last, states, spaceGuid, mtaId); return ResponseEntity.ok() .body(operations); } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testGetOperations() { ResponseEntity<List<Operation>> response = testedClass.getOperations(SPACE_GUID, null, List.of(Operation.State.FINISHED.toString(), Operation.State.ABORTED.toString()), 1); List<Operation> operations = response.getBody(); assertEquals(2, operations.size()); assertEquals(Operation.State.FINISHED, operations.get(0) .getState()); assertEquals(Operation.State.ABORTED, operations.get(1) .getState()); } @Test void testGetOperationsNotFound() { ResponseEntity<List<Operation>> response = testedClass.getOperations(SPACE_GUID, MTA_ID, Collections.singletonList(Operation.State.ACTION_REQUIRED.toString()), 1); List<Operation> operations = response.getBody(); assertTrue(operations.isEmpty()); }
### Question: ConfigurationSubscriptionService extends PersistenceService<ConfigurationSubscription, ConfigurationSubscriptionDto, Long> { public ConfigurationSubscriptionQuery createQuery() { return new ConfigurationSubscriptionQueryImpl(createEntityManager(), subscriptionMapper); } ConfigurationSubscriptionService(EntityManagerFactory entityManagerFactory, ConfigurationSubscriptionMapper subscriptionMapper); ConfigurationSubscriptionQuery createQuery(); }### Answer: @Test void testAdd() { configurationSubscriptionService.add(CONFIGURATION_SUBSCRIPTION_1); assertEquals(1, configurationSubscriptionService.createQuery() .list() .size()); assertEquals(CONFIGURATION_SUBSCRIPTION_1.getId(), configurationSubscriptionService.createQuery() .id(CONFIGURATION_SUBSCRIPTION_1.getId()) .singleResult() .getId()); } @Test void testAddWithNonEmptyDatabase() { addConfigurationSubscriptions(List.of(CONFIGURATION_SUBSCRIPTION_1, CONFIGURATION_SUBSCRIPTION_2)); assertConfigurationSubscriptionExists(CONFIGURATION_SUBSCRIPTION_1.getId()); assertConfigurationSubscriptionExists(CONFIGURATION_SUBSCRIPTION_2.getId()); assertEquals(2, configurationSubscriptionService.createQuery() .list() .size()); } @Test void testQueryByFilterMatching() { addConfigurationSubscriptions(List.of(CONFIGURATION_SUBSCRIPTION_1, CONFIGURATION_SUBSCRIPTION_2)); int foundSubscriptions = configurationSubscriptionService.createQuery() .onSelectMatching(Collections.singletonList(new ConfigurationEntry(null, null, Version.parseVersion("3.1"), "default", null, null, null, null, null))) .list() .size(); assertEquals(1, foundSubscriptions); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed) { Operation operation = getOperation(operationId); if (!operation.getSpaceId() .equals(spaceGuid)) { LOGGER.info(MessageFormat.format(org.cloudfoundry.multiapps.controller.core.Messages.OPERATION_SPACE_MISMATCH, operationId, operation.getSpaceId(), spaceGuid)); throw new NotFoundException(org.cloudfoundry.multiapps.controller.persistence.Messages.OPERATION_NOT_FOUND, operationId); } if ("messages".equals(embed)) { operation = ImmutableOperation.copyOf(operation) .withMessages(getOperationMessages(operation)); if (operation.getState() == Operation.State.ERROR && !hasErrorMessage(operation)) { LOGGER.error("MTA operation \"{}\" is in error state, but has no error messages.", operation.getProcessId()); } } return ResponseEntity.ok() .body(operation); } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testGetOperation() { String processId = FINISHED_PROCESS; ResponseEntity<Operation> response = testedClass.getOperation(SPACE_GUID, processId, null); Operation operation = response.getBody(); assertEquals(processId, operation.getProcessId()); assertEquals(Operation.State.FINISHED, operation.getState()); } @Test void testGetOperationMissing() { Assertions.assertThrows(NotFoundException.class, () -> testedClass.getOperation(SPACE_GUID, "notPresent", null)); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId) { Operation operation = getOperation(operationId); List<String> availableOperations = getAvailableActions(operation); if (!availableOperations.contains(actionId)) { throw new IllegalArgumentException(MessageFormat.format(Messages.ACTION_0_CANNOT_BE_EXECUTED_OVER_OPERATION_1_IN_STATE_2, actionId, operationId, operation.getState())); } ProcessAction action = processActionRegistry.getAction(Action.fromString(actionId)); action.execute(getAuthenticatedUser(request), operationId); AuditLoggingProvider.getFacade() .logAboutToStart(MessageFormat.format("{0} over operation with id {1}", action, operation.getProcessId())); return ResponseEntity.accepted() .header("Location", getLocationHeader(operationId, spaceGuid)) .build(); } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testExecuteOperationAction() { String processId = RUNNING_PROCESS; testedClass.executeOperationAction(mockHttpServletRequest(EXAMPLE_USER), SPACE_GUID, processId, Action.ABORT.getActionId()); Mockito.verify(processAction) .execute(Mockito.eq(EXAMPLE_USER), Mockito.eq(processId)); } @Test void testExecuteOperationActionMissingProcess() { Assertions.assertThrows(NotFoundException.class, () -> testedClass.executeOperationAction(mockHttpServletRequest(EXAMPLE_USER), SPACE_GUID, "notavalidpprocess", Action.ABORT.getActionId())); } @Test void testExecuteOperationActionInvalidAction() { assertThrows(IllegalArgumentException.class, () -> testedClass.executeOperationAction(mockHttpServletRequest(EXAMPLE_USER), SPACE_GUID, RUNNING_PROCESS, Action.START.getActionId())); } @Test void testExecuteOperationActionUnauthorized() { Assertions.assertThrows(ResponseStatusException.class, () -> testedClass.executeOperationAction(mockHttpServletRequest(null), SPACE_GUID, RUNNING_PROCESS, Action.ABORT.getActionId())); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation) { String user = getAuthenticatedUser(request); String processDefinitionKey = operationsHelper.getProcessDefinitionKey(operation); Set<ParameterMetadata> predefinedParameters = operationMetadataMapper.getOperationMetadata(operation.getProcessType()) .getParameters(); operation = addServiceParameters(operation, spaceGuid, user); operation = addParameterValues(operation, predefinedParameters); ensureRequiredParametersSet(operation, predefinedParameters); ProcessInstance processInstance = flowableFacade.startProcess(processDefinitionKey, operation.getParameters()); AuditLoggingProvider.getFacade() .logConfigCreate(operation); return ResponseEntity.accepted() .header("Location", getLocationHeader(processInstance.getProcessInstanceId(), spaceGuid)) .build(); } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testStartOperation() { Map<String, Object> parameters = Map.of(Variables.MTA_ID.getName(), "test"); Operation operation = createOperation(null, null, parameters); Mockito.when(operationsHelper.getProcessDefinitionKey(operation)) .thenReturn("deploy"); testedClass.startOperation(mockHttpServletRequest(EXAMPLE_USER), SPACE_GUID, operation); Mockito.verify(flowableFacade) .startProcess(Mockito.any(), Mockito.anyMap()); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId) { try { getOperation(operationId); List<String> logIds = logsService.getLogNames(spaceGuid, operationId); List<Log> logs = logIds.stream() .map(id -> ImmutableLog.builder() .id(id) .build()) .collect(Collectors.toList()); return ResponseEntity.ok() .body(logs); } catch (FileStorageException e) { throw new ContentException(e, e.getMessage()); } } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testGetOperationLogs() throws Exception { String processId = FINISHED_PROCESS; testedClass.getOperationLogs(SPACE_GUID, processId); Mockito.verify(logsService) .getLogNames(Mockito.eq(SPACE_GUID), Mockito.eq(processId)); } @Test void testGetOperationLogsNotFoundOperation() { assertThrows(NotFoundException.class, () -> testedClass.getOperationLogs(SPACE_GUID, "notarealop")); } @Test void testGetOperationLogsServiceException() throws Exception { String processId = FINISHED_PROCESS; Mockito.when(logsService.getLogNames(Mockito.eq(SPACE_GUID), Mockito.eq(processId))) .thenThrow(new FileStorageException("something went wrong")); Assertions.assertThrows(ContentException.class, () -> testedClass.getOperationLogs(SPACE_GUID, processId)); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId) { try { String content = logsService.getLogContent(spaceGuid, operationId, logId); return ResponseEntity.ok() .body(content); } catch (FileStorageException e) { throw new ContentException(e, e.getMessage()); } } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testGetOperationLogContent() throws Exception { String processId = FINISHED_PROCESS; String logName = "OPERATION.log"; String expectedLogContent = "somelogcontentstring\n1234"; Mockito.when(logsService.getLogContent(Mockito.eq(SPACE_GUID), Mockito.eq(processId), Mockito.eq(logName))) .thenReturn(expectedLogContent); ResponseEntity<String> response = testedClass.getOperationLogContent(SPACE_GUID, processId, logName); String logContent = response.getBody(); assertEquals(expectedLogContent, logContent); } @Test void testGetOperationLogContentNotFound() throws Exception { String processId = FINISHED_PROCESS; String logName = "OPERATION.log"; Mockito.when(logsService.getLogContent(Mockito.eq(SPACE_GUID), Mockito.eq(processId), Mockito.eq(logName))) .thenThrow(new NoResultException("log file not found")); Assertions.assertThrows(NoResultException.class, () -> testedClass.getOperationLogContent(SPACE_GUID, processId, logName)); }
### Question: OperationsApiServiceImpl implements OperationsApiService { @Override public ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId) { Operation operation = getOperation(operationId); return ResponseEntity.ok() .body(getAvailableActions(operation)); } @Override ResponseEntity<List<Operation>> getOperations(String spaceGuid, String mtaId, List<String> stateStrings, Integer last); @Override ResponseEntity<Void> executeOperationAction(HttpServletRequest request, String spaceGuid, String operationId, String actionId); @Override ResponseEntity<List<Log>> getOperationLogs(String spaceGuid, String operationId); @Override ResponseEntity<String> getOperationLogContent(String spaceGuid, String operationId, String logId); @Override ResponseEntity<Operation> startOperation(HttpServletRequest request, String spaceGuid, Operation operation); @Override ResponseEntity<Operation> getOperation(String spaceGuid, String operationId, String embed); @Override ResponseEntity<List<String>> getOperationActions(String spaceGuid, String operationId); }### Answer: @Test void testGetOperationActionsForRunning() { ResponseEntity<List<String>> response = testedClass.getOperationActions(SPACE_GUID, RUNNING_PROCESS); List<String> actions = response.getBody(); assertEquals(Collections.singletonList(Action.ABORT.getActionId()), actions); } @Test void testGetOperationActionsForFinished() { ResponseEntity<List<String>> response = testedClass.getOperationActions(SPACE_GUID, FINISHED_PROCESS); List<String> actions = response.getBody(); assertEquals(Collections.emptyList(), actions); } @Test void testGetOperationActionsForAborted() { ResponseEntity<List<String>> response = testedClass.getOperationActions(SPACE_GUID, ABORTED_PROCESS); List<String> actions = response.getBody(); assertEquals(Collections.emptyList(), actions); } @Test void testGetOperationActionsForError() { ResponseEntity<List<String>> response = testedClass.getOperationActions(SPACE_GUID, ERROR_PROCESS); List<String> actions = response.getBody(); assertEquals(List.of(Action.ABORT.getActionId(), Action.RETRY.getActionId()), actions); } @Test void testGetOperationActionsOperationNotFound() { Assertions.assertThrows(NotFoundException.class, () -> testedClass.getOperationActions(SPACE_GUID, "notarealprocess")); } @Test void testGetOperationActionsNotFound() { ResponseEntity<List<String>> response = testedClass.getOperationActions(SPACE_GUID, RUNNING_PROCESS); List<String> actions = response.getBody(); assertEquals(Collections.singletonList(Action.ABORT.getActionId()), actions); }
### Question: FilesApiServiceImpl implements FilesApiService { @Override public ResponseEntity<List<FileMetadata>> getFiles(String spaceGuid, String namespace) { try { List<FileEntry> entries = fileService.listFiles(spaceGuid, namespace); List<FileMetadata> files = entries.stream() .map(this::parseFileEntry) .collect(Collectors.toList()); return ResponseEntity.ok() .body(files); } catch (FileStorageException e) { throw new SLException(e, Messages.COULD_NOT_GET_FILES_0, e.getMessage()); } } @Override ResponseEntity<List<FileMetadata>> getFiles(String spaceGuid, String namespace); @Override ResponseEntity<FileMetadata> uploadFile(HttpServletRequest request, String spaceGuid, String namespace); }### Answer: @Test void testGetMtaFiles() throws Exception { FileEntry entryOne = createFileEntry("test.mtar"); FileEntry entryTwo = createFileEntry("extension.mtaet"); Mockito.when(fileService.listFiles(Mockito.eq(SPACE_GUID), Mockito.eq(NAMESPACE_GUID))) .thenReturn(List.of(entryOne, entryTwo)); ResponseEntity<List<FileMetadata>> response = testedClass.getFiles(SPACE_GUID, NAMESPACE_GUID); assertEquals(HttpStatus.OK, response.getStatusCode()); List<FileMetadata> files = response.getBody(); assertEquals(2, files.size()); assertMetadataMatches(entryOne, files.get(0)); assertMetadataMatches(entryTwo, files.get(1)); } @Test void testGetMtaFilesError() throws Exception { Mockito.when(fileService.listFiles(Mockito.eq(SPACE_GUID), Mockito.eq(null))) .thenThrow(new FileStorageException("error")); Assertions.assertThrows(SLException.class, () -> testedClass.getFiles(SPACE_GUID, null)); }
### Question: FilesApiServiceImpl implements FilesApiService { @Override public ResponseEntity<FileMetadata> uploadFile(HttpServletRequest request, String spaceGuid, String namespace) { try { StopWatch stopWatch = StopWatch.createStarted(); LOGGER.trace("Received upload request on URI: {}", ServletUtil.decodeUri(request)); FileEntry fileEntry = uploadFiles(request, spaceGuid, namespace).get(0); FileMetadata file = parseFileEntry(fileEntry); AuditLoggingProvider.getFacade() .logConfigCreate(file); stopWatch.stop(); LOGGER.trace("Uploaded file \"{}\" with name {}, size {} and digest {} (algorithm {}) for {} ms.", file.getId(), file.getName(), file.getSize(), file.getDigest(), file.getDigestAlgorithm(), stopWatch.getTime()); return ResponseEntity.status(HttpStatus.CREATED) .body(file); } catch (FileUploadException \| IOException \| FileStorageException e) { throw new SLException(e, Messages.COULD_NOT_UPLOAD_FILE_0, e.getMessage()); } } @Override ResponseEntity<List<FileMetadata>> getFiles(String spaceGuid, String namespace); @Override ResponseEntity<FileMetadata> uploadFile(HttpServletRequest request, String spaceGuid, String namespace); }### Answer: @Test void testUploadMtaFile() throws Exception { String fileName = "test.mtar"; FileEntry fileEntry = createFileEntry(fileName); Mockito.when(servletFileUpload.getItemIterator(Mockito.eq(request))) .thenReturn(fileItemIterator); Mockito.when(fileItemIterator.hasNext()) .thenReturn(true, true, false); Mockito.when(fileItemIterator.next()) .thenReturn(fileItemStream); Mockito.when(fileItemStream.isFormField()) .thenReturn(false, true); Mockito.when(fileItemStream.openStream()) .thenReturn(Mockito.mock(InputStream.class)); Mockito.when(fileItemStream.getName()) .thenReturn(fileName); Mockito.when(fileService.addFile(Mockito.eq(SPACE_GUID), Mockito.eq(NAMESPACE_GUID), Mockito.eq(fileName), Mockito.any(InputStream.class))) .thenReturn(fileEntry); ResponseEntity<FileMetadata> response = testedClass.uploadFile(request, SPACE_GUID, NAMESPACE_GUID); Mockito.verify(servletFileUpload) .setSizeMax(Mockito.eq(new Configuration().getMaxUploadSize())); Mockito.verify(fileItemIterator, Mockito.times(3)) .hasNext(); Mockito.verify(fileItemStream) .openStream(); Mockito.verify(fileService) .addFile(Mockito.eq(SPACE_GUID), Mockito.eq(NAMESPACE_GUID), Mockito.eq(fileName), Mockito.any(InputStream.class)); FileMetadata fileMetadata = response.getBody(); assertMetadataMatches(fileEntry, fileMetadata); } @Test void testUploadMtaFileErrorSizeExceeded() throws Exception { Mockito.when(servletFileUpload.getItemIterator(Mockito.eq(request))) .thenThrow(new SizeLimitExceededException("size limit exceeded", MAX_PERMITTED_SIZE + 1024, MAX_PERMITTED_SIZE)); Assertions.assertThrows(SLException.class, () -> testedClass.uploadFile(request, SPACE_GUID, null)); }
### Question: DatabaseSequenceMigrationExecutor extends DatabaseMigrationExecutor { private long getLastSequenceValue(String sequenceName) throws SQLException { return getSourceDatabaseQueryClient().getLastSequenceValue(sequenceName); } @Override void executeMigrationInternal(String sequenceName); }### Answer: @Test void testExecuteMigrationInternalWhenLastSequenceValueIsZero() throws SQLException { Mockito.when(mockSourceDatabaseQueryClient.getLastSequenceValue(TEST_SEQUENCE_NAME)) .thenReturn(0L); Assertions.assertThrows(IllegalStateException.class, () -> databaseSequenceMigrationExecutor.executeMigration(TEST_SEQUENCE_NAME)); } @Test void testExecuteMigrationInternalWhenLastSequenceValueIsNegative() throws SQLException { Mockito.when(mockSourceDatabaseQueryClient.getLastSequenceValue(TEST_SEQUENCE_NAME)) .thenReturn(-1L); Assertions.assertThrows(IllegalStateException.class, () -> databaseSequenceMigrationExecutor.executeMigration(TEST_SEQUENCE_NAME)); } @Test void testExecuteMigrationInternalWhenLastSequenceValueIsPositive() throws SQLException { Mockito.when(mockSourceDatabaseQueryClient.getLastSequenceValue(TEST_SEQUENCE_NAME)) .thenReturn(1L); databaseSequenceMigrationExecutor.executeMigration(TEST_SEQUENCE_NAME); Mockito.verify(mockTargetDatabaseQueryClient) .updateSequence(TEST_SEQUENCE_NAME, 1L); }
### Question: DatabaseTypeSetterFactory { public DatabaseTypeSetter get(String databaseType) { List<DatabaseTypeSetter> matchingTypeSetters = registeredTypeSetters.stream() .filter(typeSetter -> containsIgnoreCase(databaseType, typeSetter)) .collect(Collectors.toList()); if (matchingTypeSetters.isEmpty()) { throw new IllegalStateException(MessageFormat.format("No database type setter is defined for type \"{0}\"", databaseType)); } if (matchingTypeSetters.size() > 1) { throw new IllegalStateException(MessageFormat.format("More than one database type setters are defined for type \"{0}\"", databaseType)); } return matchingTypeSetters.get(0); } DatabaseTypeSetterFactory(); DatabaseTypeSetterFactory(List<DatabaseTypeSetter> registeredTypeSetters); DatabaseTypeSetter get(String databaseType); }### Answer: @Test void testGetWithNullStringParameter() { DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(); Assertions.assertThrows(IllegalStateException.class, () -> databaseTypeSetterFactory.get(null)); } @Test void testGetWithEmptyStringParameter() { DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(); Assertions.assertThrows(IllegalStateException.class, () -> databaseTypeSetterFactory.get("")); } @Test void testGetWithCustomRegisteredTypeSettersAndSingleMatch() { List<DatabaseTypeSetter> registeredDatabaseTypeSetters = List.of(new BooleanDatabaseTypeSetter()); DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(registeredDatabaseTypeSetters); DatabaseTypeSetter resultDatabaseTypeSetter = databaseTypeSetterFactory.get(BOOL_TYPE); Assertions.assertEquals(registeredDatabaseTypeSetters.get(0), resultDatabaseTypeSetter); } @Test void testGetWithCustomRegisteredTypeSettersWhenNoMatchingTypeSetter() { List<DatabaseTypeSetter> registeredDatabaseTypeSetters = Collections.emptyList(); DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(registeredDatabaseTypeSetters); Assertions.assertThrows(IllegalStateException.class, () -> databaseTypeSetterFactory.get(BOOL_TYPE)); } @Test void testGetWithCustomRegisteredTypeSettersWhenMultipleMatchingTypeSetters() { List<DatabaseTypeSetter> registeredDatabaseTypeSetters = List.of(new BooleanDatabaseTypeSetter(), new BooleanDatabaseTypeSetter()); DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(registeredDatabaseTypeSetters); Assertions.assertThrows(IllegalStateException.class, () -> databaseTypeSetterFactory.get(BOOL_TYPE)); } @Test void testGetWithDefaultRegisteredTypeSettersWhenMatchingDefaultTypeSetters() { DatabaseTypeSetterFactory databaseTypeSetterFactory = new DatabaseTypeSetterFactory(); DatabaseTypeSetter resultDatabaseTypeSetter = databaseTypeSetterFactory.get(BOOL_TYPE); Assertions.assertTrue(resultDatabaseTypeSetter.getSupportedTypes() .contains(BOOL_TYPE)); resultDatabaseTypeSetter = databaseTypeSetterFactory.get(LONG_TYPE); Assertions.assertTrue(resultDatabaseTypeSetter.getSupportedTypes() .contains(LONG_TYPE)); resultDatabaseTypeSetter = databaseTypeSetterFactory.get(STRING_TYPE); Assertions.assertTrue(resultDatabaseTypeSetter.getSupportedTypes() .contains(STRING_TYPE)); }
### Question: FileService { public void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer) throws FileStorageException { processFileContent(space, id, inputStream -> { fileContentConsumer.consume(inputStream); return null; }); } FileService(DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); FileService(String tableName, DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); protected FileService(DataSourceWithDialect dataSourceWithDialect, SqlFileQueryProvider sqlFileQueryProvider, FileStorage fileStorage); FileEntry addFile(String space, String namespace, String name, InputStream inputStream); FileEntry addFile(String space, String namespace, String name, File existingFile); List<FileEntry> listFiles(String space, String namespace); FileEntry getFile(String space, String id); void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer); T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); int deleteBySpaceAndNamespace(String space, String namespace); int deleteBySpace(String space); int deleteModifiedBefore(Date modificationTime); boolean deleteFile(String space, String id); int deleteFilesEntriesWithoutContent(); }### Answer: @Test void consumeFileContentTest() throws Exception { fileService.consumeFileContent(SPACE_1, "1111-2222-3333-4444", Mockito.mock(FileContentConsumer.class)); Mockito.verify(fileStorage) .processFileContent(Mockito.eq(SPACE_1), Mockito.eq("1111-2222-3333-4444"), Mockito.any()); }
### Question: DatabaseTableInsertQueryGenerator { public String generate(DatabaseTableData tableMetadata) { StringBuilder result = new StringBuilder(); return result.append("INSERT INTO ") .append(tableMetadata.getTableName()) .append(OPEN_BRACKET) .append(generateInsertStatementTableColums(tableMetadata.getTableColumnsMetadata())) .append(CLOSING_BRACKET) .append(" VALUES ") .append(OPEN_BRACKET) .append(generateInsertStatementParameters(tableMetadata.getTableColumnsMetadata() .size())) .append(CLOSING_BRACKET) .toString(); } String generate(DatabaseTableData tableMetadata); }### Answer: @Test void testGenerateWithTestDatabaseMetadataWhenSingleColumn() { DatabaseTableColumnMetadata databaseTableColumnMetadata = buildDatabaseTableColumnMetadata(TEST_COLUMN_NAME, TEST_COLUMN_TYPE); DatabaseTableData databaseTableMetadata = buildDatabaseTableData(List.of(databaseTableColumnMetadata), TEST_TABLE_NAME); String expectedQuery = "INSERT INTO testTableName(testColumnName) VALUES (?)"; String resultQuery = databaseTableInsertQueryGenerator.generate(databaseTableMetadata); Assertions.assertEquals(expectedQuery, resultQuery); } @Test void testGenerateWithTestDatabaseMetadataWhenMultipleColumns() { List<DatabaseTableColumnMetadata> multipleDatabaseTableColumnMetadata = List.of(buildDatabaseTableColumnMetadata(TEST_COLUMN_NAME, TEST_COLUMN_TYPE), buildDatabaseTableColumnMetadata(TEST_COLUMN_NAME_2, TEST_COLUMN_TYPE)); DatabaseTableData databaseTableMetadata = buildDatabaseTableData(multipleDatabaseTableColumnMetadata, TEST_TABLE_NAME); String resultQuery = databaseTableInsertQueryGenerator.generate(databaseTableMetadata); String expectedQuery = "INSERT INTO testTableName(testColumnName, testColumnName2) VALUES (?, ?)"; Assertions.assertEquals(expectedQuery, resultQuery); }
### Question: FileService { public int deleteBySpaceAndNamespace(String space, String namespace) throws FileStorageException { fileStorage.deleteFilesBySpaceAndNamespace(space, namespace); return deleteFileAttributesBySpaceAndNamespace(space, namespace); } FileService(DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); FileService(String tableName, DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); protected FileService(DataSourceWithDialect dataSourceWithDialect, SqlFileQueryProvider sqlFileQueryProvider, FileStorage fileStorage); FileEntry addFile(String space, String namespace, String name, InputStream inputStream); FileEntry addFile(String space, String namespace, String name, File existingFile); List<FileEntry> listFiles(String space, String namespace); FileEntry getFile(String space, String id); void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer); T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); int deleteBySpaceAndNamespace(String space, String namespace); int deleteBySpace(String space); int deleteModifiedBefore(Date modificationTime); boolean deleteFile(String space, String id); int deleteFilesEntriesWithoutContent(); }### Answer: @Test void deleteBySpaceAndNamespaceTest() throws Exception { super.deleteBySpaceAndNamespaceTest(); Mockito.verify(fileStorage) .deleteFilesBySpaceAndNamespace(Mockito.eq(SPACE_1), Mockito.eq(NAMESPACE_1)); }
### Question: FileService { public int deleteBySpace(String space) throws FileStorageException { fileStorage.deleteFilesBySpace(space); return deleteFileAttributesBySpace(space); } FileService(DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); FileService(String tableName, DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); protected FileService(DataSourceWithDialect dataSourceWithDialect, SqlFileQueryProvider sqlFileQueryProvider, FileStorage fileStorage); FileEntry addFile(String space, String namespace, String name, InputStream inputStream); FileEntry addFile(String space, String namespace, String name, File existingFile); List<FileEntry> listFiles(String space, String namespace); FileEntry getFile(String space, String id); void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer); T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); int deleteBySpaceAndNamespace(String space, String namespace); int deleteBySpace(String space); int deleteModifiedBefore(Date modificationTime); boolean deleteFile(String space, String id); int deleteFilesEntriesWithoutContent(); }### Answer: @Test void deleteBySpaceTest() throws Exception { super.deleteBySpaceTest(); Mockito.verify(fileStorage) .deleteFilesBySpace(Mockito.eq(SPACE_1)); }
### Question: FileService { public boolean deleteFile(String space, String id) throws FileStorageException { fileStorage.deleteFile(id, space); return deleteFileAttribute(space, id); } FileService(DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); FileService(String tableName, DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); protected FileService(DataSourceWithDialect dataSourceWithDialect, SqlFileQueryProvider sqlFileQueryProvider, FileStorage fileStorage); FileEntry addFile(String space, String namespace, String name, InputStream inputStream); FileEntry addFile(String space, String namespace, String name, File existingFile); List<FileEntry> listFiles(String space, String namespace); FileEntry getFile(String space, String id); void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer); T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); int deleteBySpaceAndNamespace(String space, String namespace); int deleteBySpace(String space); int deleteModifiedBefore(Date modificationTime); boolean deleteFile(String space, String id); int deleteFilesEntriesWithoutContent(); }### Answer: @Test void deleteFileTest() throws Exception { FileEntry fileEntry = addTestFile(SPACE_1, NAMESPACE_1); boolean deleteFile = fileService.deleteFile(SPACE_2, fileEntry.getId()); assertFalse(deleteFile); Mockito.verify(fileStorage) .deleteFile(Mockito.eq(fileEntry.getId()), Mockito.eq(SPACE_2)); deleteFile = fileService.deleteFile(SPACE_1, fileEntry.getId()); assertTrue(deleteFile); Mockito.verify(fileStorage) .deleteFile(Mockito.eq(fileEntry.getId()), Mockito.eq(SPACE_1)); }
### Question: FileService { public int deleteFilesEntriesWithoutContent() throws FileStorageException { try { List<FileEntry> entries = getSqlQueryExecutor().execute(getSqlFileQueryProvider().getListAllFilesQuery()); List<FileEntry> missing = fileStorage.getFileEntriesWithoutContent(entries); return deleteFileEntries(missing); } catch (SQLException e) { throw new FileStorageException(Messages.ERROR_GETTING_ALL_FILES, e); } } FileService(DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); FileService(String tableName, DataSourceWithDialect dataSourceWithDialect, FileStorage fileStorage); protected FileService(DataSourceWithDialect dataSourceWithDialect, SqlFileQueryProvider sqlFileQueryProvider, FileStorage fileStorage); FileEntry addFile(String space, String namespace, String name, InputStream inputStream); FileEntry addFile(String space, String namespace, String name, File existingFile); List<FileEntry> listFiles(String space, String namespace); FileEntry getFile(String space, String id); void consumeFileContent(String space, String id, FileContentConsumer fileContentConsumer); T processFileContent(String space, String id, FileContentProcessor<T> fileContentProcessor); int deleteBySpaceAndNamespace(String space, String namespace); int deleteBySpace(String space); int deleteModifiedBefore(Date modificationTime); boolean deleteFile(String space, String id); int deleteFilesEntriesWithoutContent(); }### Answer: @Test void deleteFilesEntriesWithoutContentTest() throws Exception { FileEntry noContent = addTestFile(SPACE_1, NAMESPACE_1); FileEntry noContent2 = addTestFile(SPACE_2, NAMESPACE_1); addTestFile(SPACE_1, NAMESPACE_2); addTestFile(SPACE_2, NAMESPACE_2); Mockito.when(fileStorage.getFileEntriesWithoutContent(Mockito.anyList())) .thenReturn(List.of(noContent, noContent2)); int deleteWithoutContent = fileService.deleteFilesEntriesWithoutContent(); assertEquals(2, deleteWithoutContent); assertNull(fileService.getFile(SPACE_1, noContent.getId())); assertNull(fileService.getFile(SPACE_2, noContent2.getId())); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.