@Override @Test public void decodeToMono() { Flux<DataBuffer> input = Flux.concat( dataBuffer(this.fooBytes), dataBuffer(this.barBytes)); ByteBuffer expected = ByteBuffer.allocate(this.fooBytes.length + this.barBytes.length); expected.put(this.fooBytes).put(this.barBytes).flip(); testDecodeToMonoAll(input, ByteBuffer.class, step -> step .consumeNextWith(expectByteBuffer(expected)) .verifyComplete()); }
@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)); }
private void verifyWrittenData(Flux<DataBuffer> writeResult) throws IOException { StepVerifier.create(writeResult) .consumeNextWith(stringConsumer("foo")) .consumeNextWith(stringConsumer("bar")) .consumeNextWith(stringConsumer("baz")) .consumeNextWith(stringConsumer("qux")) .expectComplete() .verify(Duration.ofSeconds(3)); String result = String.join("", Files.readAllLines(tempFile)); assertEquals("foobarbazqux", result); }
@Override public void decode() { Flux<DataBuffer> input = Flux.just( this.bufferFactory.wrap(this.fooBytes), this.bufferFactory.wrap(this.barBytes)); testDecodeAll(input, DataBuffer.class, step -> step .consumeNextWith(expectDataBuffer(this.fooBytes)) .consumeNextWith(expectDataBuffer(this.barBytes)) .verifyComplete()); }
@Override public void encode() { Flux<Resource> input = Flux.just(new ByteArrayResource(this.bytes)); testEncodeAll(input, Resource.class, step -> step .consumeNextWith(expectBytes(this.bytes)) .verifyComplete()); }
@Test public void encodeWithType() { Flux<ParentClass> input = Flux.just(new Foo(), new Bar()); testEncode(input, ParentClass.class, step -> step .consumeNextWith(expectString("[{\"type\":\"foo\"},{\"type\":\"bar\"}]") .andThen(DataBufferUtils::release)) .verifyComplete()); }
@Override public void encode() throws Exception { Flux<Object> input = Flux.just(new Pojo("foo", "bar"), new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar")); testEncodeAll(input, ResolvableType.forClass(Pojo.class), step -> step .consumeNextWith(expectString("{\"foo\":\"foo\",\"bar\":\"bar\"}\n")) .consumeNextWith(expectString("{\"foo\":\"foofoo\",\"bar\":\"barbar\"}\n")) .consumeNextWith(expectString("{\"foo\":\"foofoofoo\",\"bar\":\"barbarbar\"}\n")) .verifyComplete(), APPLICATION_STREAM_JSON, null); }
@Test public void readByteArrayResourcePositionAndTakeUntil() throws Exception { Resource resource = new ByteArrayResource("foobarbazqux" .getBytes()); Flux<DataBuffer> flux = DataBufferUtils.read(resource, 3, this.bufferFactory, 3); flux = DataBufferUtils.takeUntilByteCount(flux, 5); StepVerifier.create(flux) .consumeNextWith(stringConsumer("bar")) .consumeNextWith(stringConsumer("ba")) .expectComplete() .verify(Duration.ofSeconds(5)); }
@Override @Test public void decode() { Flux<DataBuffer> input = Flux.concat( dataBuffer(this.fooBytes), dataBuffer(this.barBytes)); testDecodeAll(input, byte[].class, step -> step .consumeNextWith(expectBytes(this.fooBytes)) .consumeNextWith(expectBytes(this.barBytes)) .verifyComplete()); }
@Override @Test public void encode() { List<Pojo> list = Arrays.asList( new Pojo("foo", "bar"), new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar")); Flux<Pojo> input = Flux.fromIterable(list); testEncode(input, Pojo.class, step -> step .consumeNextWith(expect(list, List.class))); }
@Test public void transformNoLinks() { MockServerWebExchange exchange = MockServerWebExchange.from(get("/static/foo.css")); Resource expected = getResource("foo.css"); StepVerifier.create(this.transformerChain.transform(exchange, expected)) .consumeNextWith(resource -> assertSame(expected, resource)) .expectComplete().verify(); }
@Test public void readAsynchronousFileChannelCancel() throws Exception { URI uri = this.resource.getURI(); Flux<DataBuffer> flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), this.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("foo")) .thenCancel() .verify(); }
@Test public void readAsynchronousFileChannelPosition() throws Exception { URI uri = this.resource.getURI(); Flux<DataBuffer> flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), 9, this.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("qux")) .expectComplete() .verify(Duration.ofSeconds(5)); }
@Test public void requestPart() { Mono<ClientResponse> result = webClient .post() .uri("/requestPart") .syncBody(generateBody()) .exchange(); StepVerifier .create(result) .consumeNextWith(response -> assertEquals(HttpStatus.OK, response.statusCode())) .verifyComplete(); }
@Override @Test public void encode() { Mono<Pojo> input = Mono.just(new Pojo("foofoo", "barbar")); testEncode(input, Pojo.class, step -> step .consumeNextWith( expectXml("<?xml version='1.0' encoding='UTF-8' standalone='yes'?>" + "<pojo><bar>barbar</bar><foo>foofoo</foo></pojo>")) .verifyComplete()); }
@Override public void encode() { Flux<byte[]> input = Flux.just(this.fooBytes, this.barBytes); testEncodeAll(input, byte[].class, step -> step .consumeNextWith(expectBytes(this.fooBytes)) .consumeNextWith(expectBytes(this.barBytes)) .verifyComplete()); } }
@Override @Test public void decode() { Flux<DataBuffer> input = Flux.concat( dataBuffer(this.fooBytes), dataBuffer(this.barBytes)); testDecodeAll(input, ByteBuffer.class, step -> step .consumeNextWith(expectByteBuffer(ByteBuffer.wrap(this.fooBytes))) .consumeNextWith(expectByteBuffer(ByteBuffer.wrap(this.barBytes))) .verifyComplete()); }
private void assertResponseBody(MockServerWebExchange exchange, String responseBody) { StepVerifier.create(exchange.getResponse().getBody()) .consumeNextWith(buf -> assertEquals(responseBody, DataBufferTestUtils.dumpString(buf, StandardCharsets.UTF_8))) .expectComplete() .verify(); }
private void assertResponseBody(MockServerWebExchange exchange, String responseBody) { StepVerifier.create(exchange.getResponse().getBody()) .consumeNextWith(buf -> assertEquals(responseBody, DataBufferTestUtils.dumpString(buf, UTF_8))) .expectComplete() .verify(); }
private void assertResponseBody(MockServerWebExchange exchange, String responseBody) { StepVerifier.create(exchange.getResponse().getBody()) .consumeNextWith(buf -> assertEquals(responseBody, DataBufferTestUtils.dumpString(buf, StandardCharsets.UTF_8))) .expectComplete() .verify(); }