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

@Test
public void givenServiceInstanceExists_whenGetServiceInstance_thenExistingServiceInstanceIsRetrieved() {
    // given service instance exists
    MailServiceInstance serviceInstance = new MailServiceInstance(MAIL_SERVICE_INSTANCE_ID, MAIL_SERVICE_DEFINITION_ID,
        MAIL_SERVICE_PLAN_ID, MAIL_DASHBOARD_URL);
    when(mailService.getServiceInstance(MAIL_SERVICE_INSTANCE_ID)).thenReturn(Mono.just(serviceInstance));

    // when get service instance
    GetServiceInstanceRequest request = GetServiceInstanceRequest.builder()
        .serviceInstanceId(MAIL_SERVICE_INSTANCE_ID)
        .build();

    // then the existing service instance is retrieved
    StepVerifier.create(mailServiceInstanceService.getServiceInstance(request))
        .consumeNextWith(response -> {
            assertEquals(MAIL_SERVICE_DEFINITION_ID, response.getServiceDefinitionId());
            assertEquals(MAIL_SERVICE_PLAN_ID, response.getPlanId());
            assertEquals(MAIL_DASHBOARD_URL, response.getDashboardUrl());
        })
        .verifyComplete();
}
 

@Test
public void getServiceInstanceWhenInstanceExists() {
	ServiceInstance serviceInstance = new ServiceInstance(SERVICE_INSTANCE_ID, "service-definition-id",
			"plan-id", new HashMap<>());

	when(repository.findById(SERVICE_INSTANCE_ID))
			.thenReturn(Mono.just(serviceInstance));

	GetServiceInstanceRequest request = GetServiceInstanceRequest.builder()
			.serviceInstanceId(SERVICE_INSTANCE_ID)
			.build();

	StepVerifier.create(service.getServiceInstance(request))
			.consumeNextWith(response -> {
				assertThat(response.getServiceDefinitionId()).isEqualTo(serviceInstance.getServiceDefinitionId());
				assertThat(response.getPlanId()).isEqualTo(serviceInstance.getPlanId());
				assertThat(response.getParameters()).isEqualTo(serviceInstance.getParameters());
			})
			.verifyComplete();

	verify(repository).findById(SERVICE_INSTANCE_ID);
	verifyNoMoreInteractions(repository);
}
 

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

@Test
void getServiceInstanceParametersAreMappedToRequest() {
	GetServiceInstanceRequest expectedRequest = GetServiceInstanceRequest.builder()
			.serviceInstanceId("service-instance-id")
			.platformInstanceId("platform-instance-id")
			.apiInfoLocation("api-info-location")
			.originatingIdentity(identityContext)
			.requestIdentity("request-id")
			.build();

	ServiceInstanceController controller = createControllerUnderTest(expectedRequest);

	controller.getServiceInstance(pathVariables, "service-instance-id",
			"api-info-location", encodeOriginatingIdentity(identityContext), "request-id")
			.block();
}
 

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

@Test
public void givenServiceInstanceDoesNotExist_whenGetServiceInstance_thenException() {
    // given service instance does not exist
    when(mailService.getServiceInstance(MAIL_SERVICE_INSTANCE_ID)).thenReturn(Mono.empty());

    // when get service instance
    GetServiceInstanceRequest request = GetServiceInstanceRequest.builder()
        .serviceInstanceId(MAIL_SERVICE_INSTANCE_ID)
        .build();

    // then ServiceInstanceDoesNotExistException is thrown
    StepVerifier.create(mailServiceInstanceService.getServiceInstance(request))
        .expectErrorMatches(ex -> ex instanceof ServiceInstanceDoesNotExistException)
        .verify();
}
 

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

/**
 * 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) {
	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);
}
 

@Test
public void getServiceInstanceWhenInstanceDoesNotExists() {
	when(repository.findById(SERVICE_INSTANCE_ID))
			.thenReturn(Mono.empty());

	GetServiceInstanceRequest request = GetServiceInstanceRequest.builder()
			.serviceInstanceId(SERVICE_INSTANCE_ID)
			.build();

	StepVerifier.create(service.getServiceInstance(request))
			.expectErrorMatches(e -> e instanceof ServiceInstanceDoesNotExistException)
			.verify();
}
 

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

protected GetServiceInstanceRequest verifyGetServiceInstance() {
	ArgumentCaptor<GetServiceInstanceRequest> argumentCaptor = ArgumentCaptor
			.forClass(GetServiceInstanceRequest.class);
	Mockito.verify(serviceInstanceService).getServiceInstance(argumentCaptor.capture());
	return argumentCaptor.getValue();
}
 

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

protected void setupServiceInstanceService(ServiceBrokerOperationInProgressException exception) {
	given(serviceInstanceService.getServiceInstance(any(GetServiceInstanceRequest.class)))
			.willReturn(Mono.error(exception));
}
 

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."));
}