@Test public void readByteChannelError() throws Exception { ReadableByteChannel channel = mock(ReadableByteChannel.class); when(channel.read(any())) .thenAnswer(invocation -> { ByteBuffer buffer = invocation.getArgument(0); buffer.put("foo".getBytes(StandardCharsets.UTF_8)); buffer.flip(); return 3; }) .thenThrow(new IOException()); Flux<DataBuffer> result = DataBufferUtils.readByteChannel(() -> channel, this.bufferFactory, 3); StepVerifier.create(result) .consumeNextWith(stringConsumer("foo")) .expectError(IOException.class) .verify(Duration.ofSeconds(3)); }
@Test public void takeUntilByteCountError() { Flux<DataBuffer> source = Flux.concat( Mono.defer(() -> Mono.just(stringBuffer("foo"))), Mono.error(new RuntimeException()) ); Flux<DataBuffer> result = DataBufferUtils.takeUntilByteCount(source, 5L); StepVerifier.create(result) .consumeNextWith(stringConsumer("foo")) .expectError(RuntimeException.class) .verify(Duration.ofSeconds(5)); }
@Test public void writeWritableByteChannelErrorInFlux() throws Exception { DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux<DataBuffer> flux = Flux.just(foo, bar).concatWith(Flux.error(new RuntimeException())); WritableByteChannel channel = Files.newByteChannel(tempFile, StandardOpenOption.WRITE); Flux<DataBuffer> writeResult = DataBufferUtils.write(flux, channel); StepVerifier.create(writeResult) .consumeNextWith(stringConsumer("foo")) .consumeNextWith(stringConsumer("bar")) .expectError() .verify(Duration.ofSeconds(5)); String result = String.join("", Files.readAllLines(tempFile)); assertEquals("foobar", result); channel.close(); }
@Test public void emptyBodyWithObservable() throws Exception { MethodParameter param = this.testMethod.annot(requestBody()).arg(Observable.class, String.class); Observable<String> observable = resolveValueWithEmptyBody(param); StepVerifier.create(RxReactiveStreams.toPublisher(observable)) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); param = this.testMethod.annot(requestBody().notRequired()).arg(Observable.class, String.class); observable = resolveValueWithEmptyBody(param); StepVerifier.create(RxReactiveStreams.toPublisher(observable)) .expectNextCount(0) .expectComplete() .verify(); }
@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(); }
@Test public void readError() { Flux<DataBuffer> body = Flux.just(stringBuffer("data:foo\ndata:bar\n\ndata:baz\n\n")) .concatWith(Flux.error(new RuntimeException())); MockServerHttpRequest request = MockServerHttpRequest.post("/") .body(body); Flux<String> data = messageReader.read(ResolvableType.forClass(String.class), request, Collections.emptyMap()).cast(String.class); StepVerifier.create(data) .expectNextMatches(elem -> elem.equals("foo\nbar")) .expectNextMatches(elem -> elem.equals("baz")) .expectError() .verify(); }
@Test public void emptyBodyWithSingle() throws Exception { MethodParameter param = this.testMethod.annot(requestBody()).arg(Single.class, String.class); Single<String> single = resolveValueWithEmptyBody(param); StepVerifier.create(RxReactiveStreams.toPublisher(single)) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); param = this.testMethod.annot(requestBody().notRequired()).arg(Single.class, String.class); single = resolveValueWithEmptyBody(param); StepVerifier.create(RxReactiveStreams.toPublisher(single)) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test @SuppressWarnings("unchecked") public void emptyBodyWithMono() throws Exception { MethodParameter param = this.testMethod.annot(requestBody()).arg(Mono.class, String.class); StepVerifier.create((Mono<Void>) resolveValueWithEmptyBody(param)) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); param = this.testMethod.annot(requestBody().notRequired()).arg(Mono.class, String.class); StepVerifier.create((Mono<Void>) resolveValueWithEmptyBody(param)) .expectNextCount(0) .expectComplete() .verify(); }
@Test public void decodeErrorAalto() { Flux<DataBuffer> source = Flux.concat( stringBuffer("<pojo>"), Flux.error(new RuntimeException())); Flux<XMLEvent> events = this.decoder.decode(source, null, null, Collections.emptyMap()); StepVerifier.create(events) .consumeNextWith(e -> assertTrue(e.isStartDocument())) .consumeNextWith(e -> assertStartElement(e, "pojo")) .expectError(RuntimeException.class) .verify(); }
@Test @SuppressWarnings("unchecked") public void emptyBodyWithFlux() throws Exception { MethodParameter param = this.testMethod.annot(requestBody()).arg(Flux.class, String.class); StepVerifier.create((Flux<Void>) resolveValueWithEmptyBody(param)) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); param = this.testMethod.annot(requestBody().notRequired()).arg(Flux.class, String.class); StepVerifier.create((Flux<Void>) resolveValueWithEmptyBody(param)) .expectNextCount(0) .expectComplete() .verify(); }
@Test public void resolve() throws Exception { MethodParameter param = this.testMethod.annot(requestAttribute().noName()).arg(Foo.class); Mono<Object> mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); Foo foo = new Foo(); this.exchange.getAttributes().put("foo", foo); mono = this.resolver.resolveArgument(param, new BindingContext(), this.exchange); assertSame(foo, mono.block()); }
@Test public void contentNegotiationWith406() { TestBean value = new TestBean("Joe"); MethodParameter returnType = on(Handler.class).resolveReturnType(TestBean.class); HandlerResult handlerResult = new HandlerResult(new Object(), value, returnType, this.bindingContext); MockServerWebExchange exchange = MockServerWebExchange.from(get("/account").accept(APPLICATION_JSON)); ViewResolutionResultHandler resultHandler = resultHandler(new TestViewResolver("account")); Mono<Void> mono = resultHandler.handleResult(exchange, handlerResult); StepVerifier.create(mono) .expectNextCount(0) .expectError(NotAcceptableStatusException.class) .verify(); }
@Test public void emptyBodyWithSingle() throws Exception { ResolvableType type = httpEntityType(Single.class, String.class); HttpEntity<Single<String>> entity = resolveValueWithEmptyBody(type); StepVerifier.create(RxReactiveStreams.toPublisher(entity.getBody())) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test public void missingRequestParam() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/")); MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(String[].class); Mono<Object> mono = this.resolver.resolveArgument(param, this.bindContext, exchange); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test public void notFound() throws Exception { Mono<Object> mono = resolver.resolveArgument( this.paramNamedValueStringArray, this.bindingContext, MockServerWebExchange.from(MockServerHttpRequest.get("/"))); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test public void handleMissingValue() throws Exception { BindingContext bindingContext = new BindingContext(); Mono<Object> mono = this.resolver.resolveArgument(this.paramNamedString, bindingContext, this.exchange); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerErrorException.class) .verify(); }
@Test @SuppressWarnings("unchecked") public void validateFluxTestBean() throws Exception { String body = "[{\"bar\":\"b1\",\"foo\":\"f1\"},{\"bar\":\"b2\"}]"; ResolvableType type = forClassWithGenerics(Flux.class, TestBean.class); MethodParameter param = this.testMethod.arg(type); Flux<TestBean> flux = resolveValue(param, body); StepVerifier.create(flux) .expectNext(new TestBean("f1", "b1")) .expectError(ServerWebInputException.class) .verify(); }
@Test @SuppressWarnings("unchecked") public void validateMonoTestBean() throws Exception { String body = "{\"bar\":\"b1\"}"; ResolvableType type = forClassWithGenerics(Mono.class, TestBean.class); MethodParameter param = this.testMethod.arg(type); Mono<TestBean> mono = resolveValue(param, body); StepVerifier.create(mono).expectNextCount(0).expectError(ServerWebInputException.class).verify(); }
@Test public void emptyBodyWithRxJava2Single() throws Exception { ResolvableType type = httpEntityType(io.reactivex.Single.class, String.class); HttpEntity<io.reactivex.Single<String>> entity = resolveValueWithEmptyBody(type); StepVerifier.create(entity.getBody().toFlowable()) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test public void notFound() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/")); Mono<Object> mono = resolver.resolveArgument(this.cookieParameter, this.bindingContext, exchange); StepVerifier.create(mono) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }