下面列出了怎么用io.reactivex.Maybe的API类实例代码及写法，或者点击链接到github查看源代码。
@Test
public void multiExportToRx() {
Multi<String> multi = Multi.createFrom().items("hello", "bonjour");
// tag::multi-export[]
Completable completable = multi.convert().with(MultiRxConverters.toCompletable());
Single<Optional<String>> single = multi.convert().with(MultiRxConverters.toSingle());
Single<String> single2 = multi.convert().with(MultiRxConverters
.toSingle().onEmptyThrow(() -> new Exception("D'oh!")));
Maybe<String> maybe = multi.convert().with(MultiRxConverters.toMaybe());
Observable<String> observable = multi.convert().with(MultiRxConverters.toObservable());
Flowable<String> flowable = multi.convert().with(MultiRxConverters.toFlowable());
// end::multi-export[]
completable.test().assertComplete();
single.test().assertValue(o -> o.isPresent() && o.get().equals("hello"));
single2.test().assertValue("hello");
maybe.test().assertValue("hello");
observable.test().assertValues("hello", "bonjour").assertComplete();
flowable.test().assertValues("hello", "bonjour").assertComplete();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Maybe<List<String>> month_maybe = Maybe.create(emitter -> {
try {
String[] monthArray = { "Jan", "Feb", "Mar", "Apl", "May", "Jun", "July", "Aug", "Sept", "Oct", "Nov",
"Dec" };
List<String> months = Arrays.asList(monthArray);
if (months != null && !months.isEmpty()) {
emitter.onSuccess(months);
} else {
emitter.onComplete();
}
} catch (Exception e) {
emitter.onError(e);
}
});
month_maybe.subscribe(s->System.out.println(s));
}
@Test
public void shouldAuthenticate_secondAuthProvider() {
AuthenticationProvider authenticationProvider = mock(AuthenticationProvider.class);
when(authenticationProvider.loadUserByUsername(any(io.gravitee.am.identityprovider.api.Authentication.class))).thenReturn(Maybe.error(new BadCredentialsException()));
AuthenticationProvider authenticationProvider2 = mock(AuthenticationProvider.class);
when(authenticationProvider2.loadUserByUsername(any(io.gravitee.am.identityprovider.api.Authentication.class))).thenReturn(Maybe.just(new DefaultUser("username")));
when(identityProviderManager.getIdentityProvider("idp1")).thenReturn(new IdentityProvider());
when(identityProviderManager.getIdentityProvider("idp2")).thenReturn(new IdentityProvider());
when(identityProviderManager.get("idp1")).thenReturn(authenticationProvider);
when(identityProviderManager.get("idp2")).thenReturn(authenticationProvider2);
Authentication authentication = managementAuthenticationProvider.authenticate(new UsernamePasswordAuthenticationToken("username", "password"));
Assert.assertNotNull(authentication);
verify(identityProviderManager, times(1)).get("idp1");
verify(identityProviderManager, times(1)).get("idp2");
}
@Test
public void update_clientCredentials_ok() {
when(applicationRepository.findById(any())).thenReturn(Maybe.just(new Application()));
when(applicationRepository.update(any(Application.class))).thenReturn(Single.just(new Application()));
when(domainService.findById(any())).thenReturn(Maybe.just(new Domain()));
when(eventService.create(any())).thenReturn(Single.just(new Event()));
when(scopeService.validateScope(any(),any())).thenReturn(Single.just(true));
Application toPatch = new Application();
toPatch.setDomain(DOMAIN);
ApplicationSettings settings = new ApplicationSettings();
ApplicationOAuthSettings oAuthSettings = new ApplicationOAuthSettings();
oAuthSettings.setGrantTypes(Arrays.asList("client_credentials"));
oAuthSettings.setResponseTypes(Arrays.asList());
settings.setOauth(oAuthSettings);
toPatch.setSettings(settings);
TestObserver testObserver = applicationService.update(toPatch).test();
testObserver.awaitTerminalEvent();
testObserver.assertComplete();
testObserver.assertNoErrors();
verify(applicationRepository, times(1)).findById(any());
verify(applicationRepository, times(1)).update(any(Application.class));
}
@Override
public Completable delete(ReferenceType referenceType, String referenceId, String formId, User principal) {
LOGGER.debug("Delete form {}", formId);
return formRepository.findById(referenceType, referenceId, formId)
.switchIfEmpty(Maybe.error(new FormNotFoundException(formId)))
.flatMapCompletable(page -> {
// create event for sync process
Event event = new Event(Type.FORM, new Payload(page.getId(), page.getReferenceType(), page.getReferenceId(), Action.DELETE));
return formRepository.delete(formId)
.andThen(eventService.create(event)).toCompletable()
.doOnComplete(() -> auditService.report(AuditBuilder.builder(FormTemplateAuditBuilder.class).principal(principal).type(EventType.FORM_TEMPLATE_DELETED).form(page)))
.doOnError(throwable -> auditService.report(AuditBuilder.builder(FormTemplateAuditBuilder.class).principal(principal).type(EventType.FORM_TEMPLATE_DELETED).throwable(throwable)));
})
.onErrorResumeNext(ex -> {
if (ex instanceof AbstractManagementException) {
return Completable.error(ex);
}
LOGGER.error("An error occurs while trying to delete form: {}", formId, ex);
return Completable.error(new TechnicalManagementException(
String.format("An error occurs while trying to delete form: %s", formId), ex));
});
}
@Test
public void storeImpression_noErrors_storesAppendedCampaigns() {
when(storageClient.read(any(CampaignImpressionsParser.class)))
.thenReturn(
Maybe.just(
CampaignImpressionList.newBuilder()
.addAlreadySeenCampaigns(campaignImpression)
.build()));
ArgumentCaptor<CampaignImpressionList> campaignImpressionListArgumentCaptor =
ArgumentCaptor.forClass(CampaignImpressionList.class);
impressionStorageClient.storeImpression(campaignImpression).subscribe();
verify(storageClient).write(campaignImpressionListArgumentCaptor.capture());
assertThat(campaignImpressionListArgumentCaptor.getValue().getAlreadySeenCampaignsList())
.containsExactly(campaignImpression, campaignImpression);
}
@Test
public void shouldNotUpdate_malformedIconUri() {
UpdateScope updateScope = new UpdateScope();
updateScope.setIconUri("malformedIconUri");
when(scopeRepository.findById("toUpdateId")).thenReturn(Maybe.just(new Scope()));
TestObserver testObserver = new TestObserver();
scopeService.update(DOMAIN, "toUpdateId",updateScope).subscribe(testObserver);
testObserver.assertError(MalformedIconUriException.class);
testObserver.assertNotComplete();
verify(scopeRepository, times(1)).findById("toUpdateId");
verify(scopeRepository, never()).update(any(Scope.class));
}
@Test
public void shouldPatch_mobileApplication_googleCase() {
Application client = new Application();
client.setDomain(DOMAIN);
PatchClient patchClient = new PatchClient();
patchClient.setAuthorizedGrantTypes(Optional.of(Arrays.asList("authorization_code")));
patchClient.setRedirectUris(Optional.of(Arrays.asList("com.google.app:/callback")));
when(applicationService.findById("my-client")).thenReturn(Maybe.just(client));
when(applicationService.update(any(Application.class))).thenReturn(Single.just(new Application()));
TestObserver testObserver = clientService.patch(DOMAIN, "my-client", patchClient).test();
testObserver.awaitTerminalEvent();
testObserver.assertComplete();
testObserver.assertNoErrors();
verify(applicationService, times(1)).findById(anyString());
verify(applicationService, times(1)).update(any(Application.class));
}
@Test
public void shouldCreate() {
final String domainId = "domain-1";
final Domain mockDomain = new Domain();
mockDomain.setId(domainId);
NewApplication newApplication = new NewApplication();
newApplication.setName("name");
newApplication.setType(ApplicationType.SERVICE);
Application application = new Application();
application.setId("app-id");
application.setName("name");
application.setType(ApplicationType.SERVICE);
doReturn(Maybe.just(mockDomain)).when(domainService).findById(domainId);
doReturn(Single.just(application)).when(applicationService).create(eq(domainId), any(NewApplication.class), any());
final Response response = target("domains")
.path(domainId)
.path("applications")
.request().post(Entity.json(newApplication));
assertEquals(HttpStatusCode.CREATED_201, response.getStatus());
}
@Test
public void emptyBodyWithMaybe() throws Exception {
MethodParameter param = this.testMethod.annot(requestBody()).arg(Maybe.class, String.class);
Maybe<String> maybe = resolveValueWithEmptyBody(param);
StepVerifier.create(maybe.toFlowable())
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annot(requestBody().notRequired()).arg(Maybe.class, String.class);
maybe = resolveValueWithEmptyBody(param);
StepVerifier.create(maybe.toFlowable())
.expectNextCount(0)
.expectComplete()
.verify();
}
@SuppressWarnings("unused")
void handle(
String string,
Mono<String> monoString,
HttpEntity<String> httpEntity,
HttpEntity<Mono<String>> monoBody,
HttpEntity<Flux<String>> fluxBody,
HttpEntity<Single<String>> singleBody,
HttpEntity<io.reactivex.Single<String>> rxJava2SingleBody,
HttpEntity<Maybe<String>> rxJava2MaybeBody,
HttpEntity<Observable<String>> observableBody,
HttpEntity<io.reactivex.Observable<String>> rxJava2ObservableBody,
HttpEntity<Flowable<String>> flowableBody,
HttpEntity<CompletableFuture<String>> completableFutureBody,
RequestEntity<String> requestEntity,
Mono<HttpEntity<String>> httpEntityMono) {}
@Test
public void shouldRevokeConsent() throws Exception {
when(userService.findById(anyString())).thenReturn(Maybe.just(new User()));
when(userService.revokeConsent(anyString(), anyString(), any())).thenReturn(Completable.complete());
router.route("/users/:userId/consents/:consentId")
.handler(rc -> {
JWT token = new JWT();
token.setSub("sub");
rc.put(OAuth2AuthHandler.TOKEN_CONTEXT_KEY, token);
rc.next();
})
.handler(userConsentEndpointHandler::revoke)
.failureHandler(new ErrorHandler());
testRequest(
HttpMethod.DELETE, "/users/user-id/consents/consent-id",
req -> req.putHeader(HttpHeaders.AUTHORIZATION.toString(), "Bearer token"),
204,
"No Content", null);
}
@DELETE
@ApiOperation(value = "Remove a membership",
notes = "User must have the DOMAIN_MEMBER[DELETE] permission on the specified domain " +
"or DOMAIN_MEMBER[DELETE] permission on the specified environment " +
"or DOMAIN_MEMBER[DELETE] permission on the specified organization")
@ApiResponses({
@ApiResponse(code = 204, message = "Membership successfully deleted"),
@ApiResponse(code = 500, message = "Internal server error")})
public void removeMember(
@PathParam("organizationId") String organizationId,
@PathParam("environmentId") String environmentId,
@PathParam("domain") String domain,
@PathParam("member") String membershipId,
@Suspended final AsyncResponse response) {
final io.gravitee.am.identityprovider.api.User authenticatedUser = getAuthenticatedUser();
checkAnyPermission(organizationId, environmentId, domain, Permission.DOMAIN_MEMBER, Acl.DELETE)
.andThen(domainService.findById(domain)
.switchIfEmpty(Maybe.error(new DomainNotFoundException(domain)))
.flatMapCompletable(irrelevant -> membershipService.delete(membershipId, authenticatedUser)))
.subscribe(() -> response.resume(Response.noContent().build()), response::resume);
}
@Test
public void shouldNotInvokeUserEndpoint_userNotFound() throws Exception {
JWT jwt = new JWT();
jwt.setJti("id-token");
jwt.setAud("client-id");
jwt.setSub("id-subject");
jwt.setScope("openid");
Client client = new Client();
client.setId("client-id");
client.setClientId("client-id");
router.route().order(-1).handler(createOAuth2AuthHandler(oAuth2AuthProvider(jwt, client)));
when(userService.findById(anyString())).thenReturn(Maybe.empty());
testRequest(
HttpMethod.GET, "/userinfo", req -> req.putHeader(HttpHeaders.AUTHORIZATION, "Bearer test-token"),
HttpStatusCode.UNAUTHORIZED_401, "Unauthorized", null);
}
@Test
public void snapshotWithNoSensors() {
final RecorderControllerImpl rc =
new RecorderControllerImpl(
getContext(),
getAppAccount(),
environment,
new RecorderListenerRegistry(),
null,
dataController,
scheduler,
Delay.ZERO,
new FakeUnitAppearanceProvider());
Maybe<String> snapshot =
rc.generateSnapshotText(Lists.<String>newArrayList(sensorId), sensorRegistry);
assertEquals("[No sensors observed]", snapshot.test().values().toString());
}
private static void checkReturnType(Method method1, Method method2) {
Class<?> returnType;
Type returnType1, returnType2;
if (ModuleCall.class.equals(method1.getReturnType())) { // 异步回调的方法
returnType = method2.getReturnType();
if (returnType.equals(Observable.class) || returnType.equals(Single.class) || returnType.equals(Flowable.class) || returnType.equals(Maybe.class)) {
returnType1 = method1.getGenericReturnType();
returnType2 = method2.getGenericReturnType();
if (returnType1 instanceof ParameterizedType && returnType2 instanceof ParameterizedType) { // 都带泛型
// 检查泛型的类型是否一样
if (!((ParameterizedType) returnType1).getActualTypeArguments()[0].equals(((ParameterizedType) returnType2).getActualTypeArguments()[0])) {
throw new IllegalArgumentException(method1.getName() + "方法的返回值类型的泛型的须一样");
}
} else if (!(returnType1 instanceof Class && returnType2 instanceof Class)) {
throw new IllegalArgumentException(method1.getName() + "方法的返回值类型的泛型的须一样");
}
} else {
throw new IllegalArgumentException(String.format("%s::%s的返回值类型必须是Observable,Single,Flowable,Maybe之一", method2.getDeclaringClass().getSimpleName(), method2.getName()));
}
} else {
if (!method1.getGenericReturnType().equals(method2.getGenericReturnType())) { //同步调用的返回值必须一样
throw new IllegalArgumentException(method1.getName() + "方法的返回值类型不一样");
}
}
}
@Test
public void createMultiFromRx() {
// tag::multi-create[]
Completable completable = Completable.complete();
Single<String> single = Single.just("hello");
Maybe<String> maybe = Maybe.just("hello");
Maybe<String> emptyMaybe = Maybe.empty();
Observable<String> observable = Observable.fromArray("a", "b", "c");
Flowable<String> flowable = Flowable.fromArray("a", "b", "c");
Multi<Void> multiFromCompletable = Multi.createFrom()
.converter(MultiRxConverters.fromCompletable(), completable);
Multi<String> multiFromSingle = Multi.createFrom().converter(MultiRxConverters.fromSingle(), single);
Multi<String> multiFromMaybe = Multi.createFrom().converter(MultiRxConverters.fromMaybe(), maybe);
Multi<String> multiFromEmptyMaybe = Multi.createFrom().converter(MultiRxConverters.fromMaybe(), emptyMaybe);
Multi<String> multiFromObservable = Multi.createFrom()
.converter(MultiRxConverters.fromObservable(), observable);
Multi<String> multiFromFlowable = Multi.createFrom().converter(MultiRxConverters.fromFlowable(), flowable);
Multi<String> multiFromPublisher = Multi.createFrom().publisher(flowable);
// end::multi-create[]
assertThat(multiFromCompletable.collectItems().first().await().indefinitely()).isNull();
assertThat(multiFromSingle.collectItems().first().await().indefinitely()).isEqualTo("hello");
assertThat(multiFromMaybe.collectItems().first().await().indefinitely()).isEqualTo("hello");
assertThat(multiFromEmptyMaybe.collectItems().first().await().indefinitely()).isNull();
assertThat(multiFromObservable.collectItems().asList().await().indefinitely()).containsExactly("a", "b", "c");
assertThat(multiFromFlowable.collectItems().asList().await().indefinitely()).containsExactly("a", "b", "c");
assertThat(multiFromPublisher.collectItems().asList().await().indefinitely()).containsExactly("a", "b", "c");
}
@Test
public void shouldGetClient_domainNotFound() {
final String domainId = "domain-id";
final String clientId = "client-id";
doReturn(Maybe.empty()).when(domainService).findById(domainId);
final Response response = target("domains").path(domainId).path("applications").path(clientId).request().get();
assertEquals(HttpStatusCode.NOT_FOUND_404, response.getStatus());
}
@Test
public void shouldFindByDomainAndTemplate_notExistingEmail() {
when(emailRepository.findByTemplate(ReferenceType.DOMAIN, DOMAIN, Template.LOGIN.template())).thenReturn(Maybe.empty());
TestObserver testObserver = emailTemplateService.findByDomainAndTemplate(DOMAIN, Template.LOGIN.template()).test();
testObserver.awaitTerminalEvent();
testObserver.assertNoValues();
}
@Test
public void shouldFindById_technicalException() {
when(applicationService.findById("my-client")).thenReturn(Maybe.error(TechnicalManagementException::new));
TestObserver testObserver = new TestObserver();
clientService.findById("my-client").subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void shouldNotInvokeLoginEndpoint_noClient() throws Exception {
when(clientSyncService.findByClientId("test")).thenReturn(Maybe.empty());
testRequest(
HttpMethod.GET, "/login?client_id=test",
HttpStatusCode.BAD_REQUEST_400, "Bad Request");
}
@Test
public void shouldCreateIDToken_clientOnly_clientCertificate() {
OAuth2Request oAuth2Request = new OAuth2Request();
oAuth2Request.setClientId("client-id");
oAuth2Request.setScopes(Collections.singleton("openid"));
Client client = new Client();
client.setCertificate("client-certificate");
String idTokenPayload = "payload";
io.gravitee.am.gateway.certificate.CertificateProvider clientCert = new io.gravitee.am.gateway.certificate.CertificateProvider(certificateProvider);
io.gravitee.am.gateway.certificate.CertificateProvider defaultCert = new io.gravitee.am.gateway.certificate.CertificateProvider(defaultCertificateProvider);
ExecutionContext executionContext = mock(ExecutionContext.class);
when(certificateManager.findByAlgorithm(any())).thenReturn(Maybe.empty());
when(certificateManager.get(anyString())).thenReturn(Maybe.just(clientCert));
when(certificateManager.defaultCertificateProvider()).thenReturn(defaultCert);
when(jwtService.encode(any(), any(io.gravitee.am.gateway.certificate.CertificateProvider.class))).thenReturn(Single.just(idTokenPayload));
when(executionContextFactory.create(any())).thenReturn(executionContext);
TestObserver<String> testObserver = idTokenService.create(oAuth2Request, client, null).test();
testObserver.assertComplete();
testObserver.assertNoErrors();
verify(certificateManager, times(1)).findByAlgorithm(any());
verify(certificateManager, times(1)).get(anyString());
verify(certificateManager, times(1)).defaultCertificateProvider();
verify(jwtService, times(1)).encode(any(), eq(clientCert));
}
@Test
public void testCreatingFromAMaybeWithFailure() {
MultiAssertSubscriber<Integer> subscriber = Multi.createFrom()
.converter(MultiRxConverters.fromMaybe(), Maybe.<Integer> error(new IOException("boom")))
.subscribe()
.withSubscriber(MultiAssertSubscriber.create(1));
subscriber.assertHasFailedWith(IOException.class, "boom");
}
@Before
public void setUp() throws Exception {
just = MaybeT.of(AnyM.ofNullable(Maybe.just(10)));
none = MaybeT.of(AnyM.ofNullable(null));
one = MaybeT.of(AnyM.ofNullable(Maybe.just(1)));
}
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Create a email for an application",
notes = "User must have APPLICATION_EMAIL_TEMPLATE[CREATE] permission on the specified application " +
"or APPLICATION_EMAIL_TEMPLATE[CREATE] permission on the specified domain " +
"or APPLICATION_EMAIL_TEMPLATE[CREATE] permission on the specified environment " +
"or APPLICATION_EMAIL_TEMPLATE[CREATE] permission on the specified organization")
@ApiResponses({
@ApiResponse(code = 201, message = "Email successfully created"),
@ApiResponse(code = 500, message = "Internal server error")})
public void create(
@PathParam("organizationId") String organizationId,
@PathParam("environmentId") String environmentId,
@PathParam("domain") String domain,
@PathParam("application") String application,
@ApiParam(name = "email", required = true)
@Valid @NotNull final NewEmail newEmail,
@Suspended final AsyncResponse response) {
final User authenticatedUser = getAuthenticatedUser();
checkAnyPermission(organizationId, environmentId, domain, Permission.APPLICATION_EMAIL_TEMPLATE, Acl.CREATE)
.andThen(domainService.findById(domain)
.switchIfEmpty(Maybe.error(new DomainNotFoundException(domain)))
.flatMap(irrelevant -> applicationService.findById(application))
.switchIfEmpty(Maybe.error(new ApplicationNotFoundException(application)))
.flatMapSingle(irrelevant -> emailTemplateService.create(domain, application, newEmail, authenticatedUser))
.flatMap(email -> emailManager.reloadEmail(email))
.map(email -> Response
.created(URI.create("/organizations/" + organizationId + "/environments/" + environmentId + "/domains/" + domain + "/applications/" + application + "/emails/" + email.getId()))
.entity(email)
.build()))
.subscribe(response::resume, response::resume);
}
@Test
public void shouldNotRefresh_refreshNotFound() {
String clientId = "client-id";
TokenRequest tokenRequest = new TokenRequest();
tokenRequest.setClientId(clientId);
String token = "refresh-token";
RefreshToken refreshToken = new RefreshToken();
refreshToken.setId(token);
refreshToken.setToken(token);
refreshToken.setExpireAt(new Date(System.currentTimeMillis() + 10000));
Client client = new Client();
client.setClientId(clientId);
JWT jwt = new JWT();
jwt.setJti(token);
jwt.setAud(clientId);
jwt.setExp(refreshToken.getExpireAt().getTime() / 1000l);
when(jwtService.decodeAndVerify(any(), any())).thenReturn(Single.just(jwt));
when(refreshTokenRepository.findByToken(any())).thenReturn(Maybe.empty());
TestObserver<Token> testObserver = tokenService.refresh(any(), tokenRequest, any()).test();
testObserver.assertNotComplete();
testObserver.assertError(InvalidGrantException.class);
verify(refreshTokenRepository, times(1)).findByToken(any());
verify(refreshTokenRepository, never()).delete(anyString());
verify(accessTokenRepository, never()).create(any());
}
@Override
public Single<Scope> update(String domain, String id, UpdateSystemScope updateScope) {
LOGGER.debug("Update a system scope {} for domain {}", id, domain);
return scopeRepository.findById(id)
.switchIfEmpty(Maybe.error(new ScopeNotFoundException(id)))
.flatMapSingle(scope -> {
scope.setName(updateScope.getName());
scope.setDescription(updateScope.getDescription());
scope.setUpdatedAt(new Date());
scope.setSystem(true);
scope.setClaims(updateScope.getClaims());
scope.setExpiresIn(updateScope.getExpiresIn());
scope.setDiscovery(updateScope.isDiscovery());
return scopeRepository.update(scope);
})
.flatMap(scope -> {
// create event for sync process
Event event = new Event(Type.SCOPE, new Payload(scope.getId(), ReferenceType.DOMAIN, scope.getDomain(), Action.UPDATE));
return eventService.create(event).flatMap(__ -> Single.just(scope));
})
.onErrorResumeNext(ex -> {
if (ex instanceof AbstractManagementException) {
return Single.error(ex);
}
LOGGER.error("An error occurs while trying to update a system scope", ex);
return Single.error(new TechnicalManagementException("An error occurs while trying to update a system scope", ex));
});
}
@Test
public void shouldEmitErrorWithBulkheadFullException() {
given(bulkhead.tryAcquirePermission()).willReturn(false);
Maybe.just(1)
.compose(BulkheadOperator.of(bulkhead))
.test()
.assertSubscribed()
.assertError(BulkheadFullException.class)
.assertNotComplete();
verify(bulkhead, never()).onComplete();
}
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Create a form",
notes = "User must have the DOMAIN_FORM[CREATE] permission on the specified domain " +
"or DOMAIN_FORM[CREATE] permission on the specified environment " +
"or DOMAIN_FORM[CREATE] permission on the specified organization")
@ApiResponses({
@ApiResponse(code = 201, message = "Form successfully created"),
@ApiResponse(code = 500, message = "Internal server error")})
public void create(
@PathParam("organizationId") String organizationId,
@PathParam("environmentId") String environmentId,
@PathParam("domain") String domain,
@ApiParam(name = "form", required = true)
@Valid @NotNull final NewForm newForm,
@Suspended final AsyncResponse response) {
final User authenticatedUser = getAuthenticatedUser();
checkAnyPermission(organizationId, environmentId, domain, Permission.DOMAIN_FORM, Acl.CREATE)
.andThen(domainService.findById(domain)
.switchIfEmpty(Maybe.error(new DomainNotFoundException(domain)))
.flatMapSingle(irrelevant -> formService.create(domain, newForm, authenticatedUser)
.map(form -> Response
.created(URI.create("/organizations/" + organizationId + "/environments/" + environmentId + "/domains/" + domain + "/forms/" + form.getId()))
.entity(form)
.build())))
.subscribe(response::resume, response::resume);
}
@Test
public void shouldFindById_technicalException() {
when(factorRepository.findById("my-factor")).thenReturn(Maybe.error(TechnicalException::new));
TestObserver testObserver = new TestObserver();
factorService.findById("my-factor").subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}