org.springframework.cloud.servicebroker.model.instance.GetServiceInstanceResponse Java Examples

@Test
void getServiceInstanceSucceeds() throws Exception {
	setupServiceInstanceService(GetServiceInstanceResponse.builder()
			.build());

	MvcResult mvcResult = mockMvc.perform(get(buildCreateUpdateUrl(PLATFORM_INSTANCE_ID, false))
			.header(API_INFO_LOCATION_HEADER, API_INFO_LOCATION)
			.header(ORIGINATING_IDENTITY_HEADER, buildOriginatingIdentityHeader())
			.contentType(MediaType.APPLICATION_JSON)
			.accept(MediaType.APPLICATION_JSON))
			.andExpect(request().asyncStarted())
			.andReturn();

	mockMvc.perform(asyncDispatch(mvcResult))
			.andExpect(status().isOk());

	GetServiceInstanceRequest actualRequest = verifyGetServiceInstance();
	assertHeaderValuesSet(actualRequest);
}
 

private void validateGetServiceInstanceWithResponseStatus(GetServiceInstanceResponse response,
		HttpStatus expectedStatus) {
	Mono<GetServiceInstanceResponse> responseMono;
	if (response == null) {
		responseMono = Mono.empty();
	}
	else {
		responseMono = Mono.just(response);
	}
	given(serviceInstanceService.getServiceInstance(any(GetServiceInstanceRequest.class)))
			.willReturn(responseMono);

	ResponseEntity<GetServiceInstanceResponse> responseEntity = controller
			.getServiceInstance(pathVariables, null, null, null, null)
			.block();

	assertThat(responseEntity).isNotNull();
	assertThat(responseEntity.getStatusCode()).isEqualTo(expectedStatus);
	assertThat(responseEntity.getBody()).isEqualTo(response);
}
 

/**
 * REST controller for getting a service instance
 *
 * @param pathVariables the path variables
 * @param serviceInstanceId the service instance ID
 * @param apiInfoLocation location of the API info endpoint of the platform instance
 * @param originatingIdentityString identity of the user that initiated the request from the platform
 * @param requestIdentity identity of the request sent from the platform
 * @return the response
 */
@GetMapping({PLATFORM_PATH_MAPPING, PATH_MAPPING})
public Mono<ResponseEntity<GetServiceInstanceResponse>> getServiceInstance(
		@PathVariable Map<String, String> pathVariables,
		@PathVariable(ServiceBrokerRequest.INSTANCE_ID_PATH_VARIABLE) String serviceInstanceId,
		@RequestHeader(value = ServiceBrokerRequest.API_INFO_LOCATION_HEADER, required = false) String apiInfoLocation,
		@RequestHeader(value = ServiceBrokerRequest.ORIGINATING_IDENTITY_HEADER, required = false) String originatingIdentityString,
		@RequestHeader(value = ServiceBrokerRequest.REQUEST_IDENTITY_HEADER, required = false) String requestIdentity) {
	return Mono.just(GetServiceInstanceRequest.builder()
			.serviceInstanceId(serviceInstanceId)
			.platformInstanceId(pathVariables.get(ServiceBrokerRequest.PLATFORM_INSTANCE_ID_VARIABLE))
			.apiInfoLocation(apiInfoLocation)
			.originatingIdentity(parseOriginatingIdentity(originatingIdentityString))
			.requestIdentity(requestIdentity)
			.build())
			.flatMap(request -> service.getServiceInstance(request)
					.doOnRequest(v -> {
						LOG.info("Getting service instance");
						LOG.debug(DEBUG_REQUEST, request);
					})
					.doOnSuccess(response -> {
						LOG.info("Getting service instance succeeded");
						LOG.debug(DEBUG_RESPONSE, serviceInstanceId, response);
					})
					.doOnError(e -> LOG.error("Error getting service instance. error=" + e.getMessage(), e)))
			.map(response -> new ResponseEntity<>(response, HttpStatus.OK))
			.switchIfEmpty(Mono.just(new ResponseEntity<>(HttpStatus.OK)))
			.onErrorResume(e -> {
				if (e instanceof ServiceInstanceDoesNotExistException) {
					return Mono.just(new ResponseEntity<>(HttpStatus.NOT_FOUND));
				}
				else {
					return Mono.error(e);
				}
			});
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
    return Mono.just(request.getServiceInstanceId())
        .flatMap(instanceId -> mailService.getServiceInstance(instanceId)
            .switchIfEmpty(Mono.error(new ServiceInstanceDoesNotExistException(instanceId)))
            .flatMap(serviceInstance -> Mono.just(GetServiceInstanceResponse.builder()
                .serviceDefinitionId(serviceInstance.getServiceDefinitionId())
                .planId(serviceInstance.getPlanId())
                .dashboardUrl(serviceInstance.getDashboardUrl())
                .build())));
}
 

@Test
void getServiceInstanceWithMissingInstanceGivesExpectedStatus() {
	given(serviceInstanceService.getServiceInstance(any(GetServiceInstanceRequest.class)))
			.willReturn(Mono.error(new ServiceInstanceDoesNotExistException("instance does not exist")));

	ResponseEntity<GetServiceInstanceResponse> responseEntity = controller
			.getServiceInstance(pathVariables, null, "service-definition-id", null, null)
			.block();

	assertThat(responseEntity).isNotNull();
	assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}
 

@Test
void getServiceInstanceWithResponseGivesExpectedStatus() {
	validateGetServiceInstanceWithResponseStatus(GetServiceInstanceResponse.builder()
			.serviceDefinitionId("service-definition-id")
			.planId("plan-id")
			.build(), HttpStatus.OK);
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	String serviceInstanceId = request.getServiceInstanceId();

	//
	// retrieve the details of the specified service instance
	//

	String dashboardUrl = ""; /* retrieve dashboard URL */

	return Mono.just(GetServiceInstanceResponse.builder()
			.dashboardUrl(dashboardUrl)
			.build());
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	if (IN_PROGRESS_SERVICE_INSTANCE_ID.equals(request.getServiceInstanceId())) {
		return Mono.error(new ServiceBrokerOperationInProgressException("task_10"));
	}
	return Mono.just(GetServiceInstanceResponse.builder()
			.build());
}
 

@Test
void getServiceInstanceSucceeds() throws Exception {
	setupServiceInstanceService(GetServiceInstanceResponse.builder()
			.build());

	client.get().uri(buildCreateUpdateUrl(PLATFORM_INSTANCE_ID, false))
			.header(API_INFO_LOCATION_HEADER, API_INFO_LOCATION)
			.header(ORIGINATING_IDENTITY_HEADER, buildOriginatingIdentityHeader())
			.accept(MediaType.APPLICATION_JSON)
			.exchange()
			.expectStatus().isOk();

	GetServiceInstanceRequest actualRequest = verifyGetServiceInstance();
	assertHeaderValuesSet(actualRequest);
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	return Mono.just(request.getServiceInstanceId())
			.flatMap(instanceId -> instanceRepository.findById(instanceId)
					.switchIfEmpty(Mono.error(new ServiceInstanceDoesNotExistException(instanceId)))
					.flatMap(serviceInstance -> Mono.just(GetServiceInstanceResponse.builder()
							.serviceDefinitionId(serviceInstance.getServiceDefinitionId())
							.planId(serviceInstance.getPlanId())
							.parameters(serviceInstance.getParameters())
							.build())));
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	return Mono.empty();
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	//TODO add functionality
	return Mono.empty();
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	return service.getServiceInstance(request);
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	assertThat(request).isEqualTo(expectedRequest);
	return Mono.empty();
}
 

protected void setupServiceInstanceService(GetServiceInstanceResponse response) {
	given(serviceInstanceService.getServiceInstance(any(GetServiceInstanceRequest.class)))
			.willReturn(Mono.just(response));
}
 

@Override
public Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	return Mono.empty();
}
 

/**
 * Get the details of a service instance.
 *
 * @param request containing the details of the request
 * @return a {@link GetServiceInstanceResponse} on successful processing of the request
 * @throws ServiceInstanceDoesNotExistException if a service instance with the given ID is not known to the
 * 		broker
 * @throws ServiceBrokerOperationInProgressException if a service instance provisioning is still in progress
 * @throws ServiceBrokerConcurrencyException if a service instance is being updated and therefore cannot be
 * 		fetched
 */
default Mono<GetServiceInstanceResponse> getServiceInstance(GetServiceInstanceRequest request) {
	return Mono.error(new UnsupportedOperationException(
			"This service broker does not support retrieving service instances. " +
					"The service broker should set 'instances_retrievable:false' in the service catalog, " +
					"or provide an implementation of the fetch instance API."));
}