package io.jooby;

import io.jooby.freemarker.FreemarkerModule;

import io.jooby.handlebars.HandlebarsModule;

import io.jooby.json.JacksonModule;

import io.jooby.junit.ServerTest;

import io.jooby.junit.ServerTestRunner;

import io.jooby.netty.Netty;

import io.jooby.utow.Utow;

import io.reactivex.Flowable;

import io.reactivex.Maybe;

import io.reactivex.Observable;

import io.reactivex.Single;

import io.reactivex.schedulers.Schedulers;

import okhttp3.FormBody;

import okhttp3.MediaType;

import okhttp3.MultipartBody;

import okhttp3.RequestBody;

import okhttp3.Response;

import okhttp3.ResponseBody;

import org.apache.commons.io.IOUtils;

import org.junit.jupiter.api.DisplayName;

import reactor.core.publisher.Flux;

import reactor.core.publisher.Mono;

import javax.annotation.Nonnull;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import java.io.StringReader;

import java.io.Writer;

import java.lang.reflect.Type;

import java.nio.channels.FileChannel;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.time.Duration;

import java.time.Instant;

import java.time.ZoneId;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Optional;

import java.util.Properties;

import java.util.Scanner;

import java.util.Set;

import java.util.UUID;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.zip.GZIPInputStream;

import static io.jooby.ExecutionMode.DEFAULT;

import static io.jooby.ExecutionMode.EVENT_LOOP;

import static io.jooby.ExecutionMode.WORKER;

import static io.jooby.MediaType.text;

import static io.jooby.MediaType.xml;

import static java.util.concurrent.CompletableFuture.supplyAsync;

import static okhttp3.RequestBody.create;

import static org.junit.jupiter.api.Assertions.assertEquals;

import static org.junit.jupiter.api.Assertions.assertNotNull;

import static org.junit.jupiter.api.Assertions.assertNull;

import static org.junit.jupiter.api.Assertions.assertTrue;

import static reactor.core.scheduler.Schedulers.elastic;

public class FeaturedTest {

private static String _19kb = readText(

userdir("src", "test", "resources", "files", "19kb.txt"));

private static String _16kb = _19kb.substring(0, ServerOptions._16KB);

private static String _8kb = _16kb.substring(0, _16kb.length() / 2);

private static MediaType json = MediaType.parse("application/json");

private static MediaType textplain = MediaType.parse("text/plain");

public static class Datafile {

public final String name;

public final FileUpload filename;

public Datafile(String name, FileUpload filename) {

this.name = name;

this.filename = filename;

}

}

public static class Datafiles {

public final String name;

public final List<FileUpload> filename;

public Datafiles(String name, List<FileUpload> filename) {

this.name = name;

this.filename = filename;

}

}

@ServerTest

public void sayHi(ServerTestRunner runner) {

runner.define(app -> {

app.get("/", ctx -> "Hello World!");

}).ready(client -> {

client.get("/", rsp -> {

assertEquals("Hello World!", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(12, rsp.body().contentLength());

});

});

}

@ServerTest(executionMode = EVENT_LOOP)

public void sayHiFromIO(ServerTestRunner runner) {

runner.define(app -> {

app.get("/", ctx -> "Hello World!");

app.dispatch(() -> {

app.get("/worker", ctx -> "Hello World!");

});

}).ready(client -> {

client.get("/", rsp -> {

assertEquals("Hello World!", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(12, rsp.body().contentLength());

});

client.get("/worker", rsp -> {

assertEquals("Hello World!", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(12, rsp.body().contentLength());

});

client.get("/favicon.ico", rsp -> {

assertEquals("", rsp.body().string());

assertEquals(404, rsp.code());

assertEquals(0, rsp.body().contentLength());

});

client.get("/notFound", rsp -> {

assertEquals("<!doctype html>\n"

+ "<html>\n"

+ "<head>\n"

+ "<meta charset=\"utf-8\">\n"

+ "<style>\n"

+ "body {font-family: \"open sans\",sans-serif; margin-left: 20px;}\n"

+ "h1 {font-weight: 300; line-height: 44px; margin: 25px 0 0 0;}\n"

+ "h2 {font-size: 16px;font-weight: 300; line-height: 44px; margin: 0;}\n"

+ "footer {font-weight: 300; line-height: 44px; margin-top: 10px;}\n"

+ "hr {background-color: #f7f7f9;}\n"

+ "div.trace {border:1px solid #e1e1e8; background-color: #f7f7f9;}\n"

+ "p {padding-left: 20px;}\n"

+ "p.tab {padding-left: 40px;}\n"

+ "</style>\n"

+ "<title>Not Found (404)</title>\n"

+ "<body>\n"

+ "<h1>Not Found</h1>\n"

+ "<hr>\n"

+ "<h2>message: /notFound</h2>\n"

+ "<h2>status code: 404</h2>\n"

+ "</body>\n"

+ "</html>", rsp.body().string());

assertEquals(404, rsp.code());

assertEquals(608, rsp.body().contentLength());

});

});

}

@ServerTest(executionMode = WORKER)

public void sayHiFromWorker(ServerTestRunner runner) {

runner.define(app -> {

app.get("/", ctx -> "Hello World!");

app.dispatch(() -> {

app.get("/worker", ctx -> "Hello World!");

});

}).ready(client -> {

client.get("/?foo=bar", rsp -> {

assertEquals("Hello World!", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(12, rsp.body().contentLength());

});

client.get("/worker", rsp -> {

assertEquals("Hello World!", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(12, rsp.body().contentLength());

});

client.get("/favicon.ico", rsp -> {

assertEquals("", rsp.body().string());

assertEquals(404, rsp.code());

assertEquals(0, rsp.body().contentLength());

});

client.get("/notFound", rsp -> {

assertEquals("<!doctype html>\n"

+ "<html>\n"

+ "<head>\n"

+ "<meta charset=\"utf-8\">\n"

+ "<style>\n"

+ "body {font-family: \"open sans\",sans-serif; margin-left: 20px;}\n"

+ "h1 {font-weight: 300; line-height: 44px; margin: 25px 0 0 0;}\n"

+ "h2 {font-size: 16px;font-weight: 300; line-height: 44px; margin: 0;}\n"

+ "footer {font-weight: 300; line-height: 44px; margin-top: 10px;}\n"

+ "hr {background-color: #f7f7f9;}\n"

+ "div.trace {border:1px solid #e1e1e8; background-color: #f7f7f9;}\n"

+ "p {padding-left: 20px;}\n"

+ "p.tab {padding-left: 40px;}\n"

+ "</style>\n"

+ "<title>Not Found (404)</title>\n"

+ "<body>\n"

+ "<h1>Not Found</h1>\n"

+ "<hr>\n"

+ "<h2>message: /notFound</h2>\n"

+ "<h2>status code: 404</h2>\n"

+ "</body>\n"

+ "</html>", rsp.body().string());

assertEquals(404, rsp.code());

assertEquals(608, rsp.body().contentLength());

});

});

}

@ServerTest

public void rawPath(ServerTestRunner runner) {

runner.define(app -> {

app.get("/{code}", ctx -> ctx.getRequestPath());

}).ready(client -> {

client.get("/foo", rsp -> {

assertEquals("/foo", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(4, rsp.body().contentLength());

});

client.get("/a+b", rsp -> {

assertEquals("/a+b", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(4, rsp.body().contentLength());

});

client.get("/%2F", rsp -> {

assertEquals("/%2F", rsp.body().string());

assertEquals(200, rsp.code());

assertEquals(4, rsp.body().contentLength());

});

});

}

@ServerTest

public void httpMethods(ServerTestRunner runner) {

runner.define(app -> {

app.get("/", ctx -> ctx.getMethod());

app.post("/", ctx -> ctx.getMethod());

app.put("/", ctx -> ctx.getMethod());

app.delete("/", ctx -> ctx.getMethod());

app.patch("/", ctx -> ctx.getMethod());

}).ready(client -> {

client.get("/", rsp -> {

assertEquals("GET", rsp.body().string());

});

client.post("/", rsp -> {

assertEquals("POST", rsp.body().string());

});

client.put("/", rsp -> {

assertEquals("PUT", rsp.body().string());

});

client.delete("/", rsp -> {

assertEquals("DELETE", rsp.body().string());

});

client.put("/", rsp -> {

assertEquals("PUT", rsp.body().string());

});

client.patch("/", rsp -> {

assertEquals("PATCH", rsp.body().string());

});

});

}

@ServerTest

public void gzip(ServerTestRunner runner) throws IOException {

String text =

"Praesent blandit, justo a luctus elementum, ante sapien pellentesque tortor, "

+ "vitae maximus nulla augue sed nulla. Phasellus quis turpis ac mi tristique aliquam. "

+ "Suspendisse tellus sem, sollicitudin ac elit id, laoreet viverra erat. Proin libero "

+ "nulla, efficitur at facilisis a, placerat in ligula. Quisque sem dolor, efficitur ac "

+ "nisl ut, porttitor iaculis leo. Nullam auctor neque augue, quis malesuada nisl rhoncus "

+ "id. Quisque ut odio erat. Mauris pellentesque suscipit libero et laoreet. Nulla ipsum "

+ "enim, sodales in risus egestas, tempus pulvinar erat. Sed elementum, leo eget vulputate "

+ "commodo, ligula eros ullamcorper risus, at feugiat neque ipsum quis lectus. Nulla sit "

+ "amet lectus lacinia, congue sapien ac, vehicula lacus. Vestibulum vitae vestibulum enim. "

+ "Proin vulputate, quam ut commodo pellentesque, enim tortor ornare neque, a aliquam massa "

+ "felis a ligula. Pellentesque lorem erat, fringilla at ipsum a, scelerisque hendrerit "

+ "lorem. Sed interdum nibh at ante consequat, vitae fermentum augue luctus.";

runner.define(app -> {

app.setServerOptions(new ServerOptions().setGzip(true));

app.get("/gzip", ctx -> text);

}).ready(client -> {

client.get("/gzip").prepare(req -> {

req.addHeader("Accept-Encoding", "gzip");

}).execute(rsp -> {

int min = 525;

int max = 532;

ResponseBody body = rsp.body();

long len = body.contentLength();

assertTrue(len == min || len == max, "Content-Length:" + len);

assertEquals("gzip", rsp.header("content-encoding"));

assertEquals(text, ungzip(body.bytes()));

});

// No ContentNegotiation-Encoding

client.get("/gzip").prepare(req -> {

// NOTE: required bc okhttp always set ContentNegotiation-Encoding to gzip

req.addHeader("Accept-Encoding", "");

}).execute(rsp -> {

ResponseBody body = rsp.body();

assertEquals(text, new String(body.bytes()));

assertEquals(1013, body.contentLength());

assertEquals(null, rsp.header("content-encoding"));

});

});

}

private String ungzip(byte[] buff) throws IOException {

GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(buff));

Scanner scanner = new Scanner(gzip);

StringBuilder str = new StringBuilder();

while (scanner.hasNext()) {

str.append(scanner.nextLine());

}

return str.toString();

}

@ServerTest

public void pathVariable(ServerTestRunner runner) {

runner.define(app -> {

app.get("/articles/{id}", ctx -> ctx.path("id").intValue());

app.get("/articles/*", ctx -> ctx.path("*").value());

app.get("/file/*path", ctx -> ctx.path("path").value());

app.get("/catchallWithVarPrefix/{id}/*path",

ctx -> ctx.path("id").value() + ":" + ctx.path("path").value());

app.get("/regex/{nid:[0-9]+}", ctx -> ctx.path("nid").intValue());

app.get("/regex/{zid:[0-9]+}/edit", ctx -> ctx.path("zid").intValue());

app.get("/file/{file}.json", ctx -> ctx.path("file").value() + ".JSON");

app.get("/file/{file}.{ext}",

ctx -> ctx.path("file").value() + "." + ctx.path("ext").value());

app.get("/profile/{pid}", ctx -> ctx.path("pid").value());

app.get("/profile/me", ctx -> "me!");

}).ready(client -> {

client.get("/articles/123", rsp -> {

assertEquals("123", rsp.body().string());

});

client.get("/articles/tail/match", rsp -> {

assertEquals("tail/match", rsp.body().string());

});

client.get("/catchallWithVarPrefix/55/js/index.js", rsp -> {

assertEquals("55:js/index.js", rsp.body().string());

});

client.get("/file/js/index.js", rsp -> {

assertEquals("js/index.js", rsp.body().string());

});

client.get("/regex/678", rsp -> {

assertEquals("678", rsp.body().string());

});

client.get("/regex/678/edit", rsp -> {

assertEquals("678", rsp.body().string());

});

client.get("/regex/678d", rsp -> {

assertEquals(404, rsp.code());

});

client.get("/file/foo.js", rsp -> {

assertEquals("foo.js", rsp.body().string());

});

client.get("/file/foo.json", rsp -> {

assertEquals("foo.JSON", rsp.body().string());

});

client.get("/profile/me", rsp -> {

assertEquals("me!", rsp.body().string());

});

client.get("/profile/edgar", rsp -> {

assertEquals("edgar", rsp.body().string());

});

});

}

@ServerTest

public void paramKeys(ServerTestRunner runner) {

runner.define(app -> {

app.get("/articles/{id}", ctx -> ctx.getRoute().getPathKeys());

app.get("/articles/*", ctx -> ctx.getRoute().getPathKeys());

app.get("/file/*path", ctx -> ctx.getRoute().getPathKeys());

app.get("/regex/{nid:[0-9]+}", ctx -> ctx.getRoute().getPathKeys());

app.get("/regex/{zid:[0-9]+}/edit", ctx -> ctx.getRoute().getPathKeys());

app.get("/file/{file}.json", ctx -> ctx.getRoute().getPathKeys());

app.get("/file/{file}.{ext}", ctx -> ctx.getRoute().getPathKeys());

app.get("/profile/{pid}", ctx -> ctx.getRoute().getPathKeys());

app.get("/profile/me", ctx -> ctx.getRoute().getPathKeys());

}).ready(client -> {

client.get("/articles/123", rsp -> {

assertEquals("[id]", rsp.body().string());

});

client.get("/articles/tail/match", rsp -> {

assertEquals("[*]", rsp.body().string());

});

client.get("/file/js/index.js", rsp -> {

assertEquals("[path]", rsp.body().string());

});

client.get("/regex/678", rsp -> {

assertEquals("[nid]", rsp.body().string());

});

client.get("/regex/678/edit", rsp -> {

assertEquals("[zid]", rsp.body().string());

});

client.get("/file/foo.js", rsp -> {

assertEquals("[file, ext]", rsp.body().string());

});

client.get("/file/foo.json", rsp -> {

assertEquals("[file]", rsp.body().string());

});

client.get("/profile/me", rsp -> {

assertEquals("[]", rsp.body().string());

});

client.get("/profile/edgar", rsp -> {

assertEquals("[pid]", rsp.body().string());

});

});

}

@ServerTest

public void pathEncoding(ServerTestRunner runner) {

runner.define(app -> {

app.get("/{value}", ctx -> ctx.getRequestPath() + "@" + ctx.path("value").value());

}).ready(client -> {

client.get("/a+b", rsp -> {

assertEquals("/a+b@a+b", rsp.body().string());

});

client.get("/a b", rsp -> {

assertEquals("/a%20b@a b", rsp.body().string());

});

client.get("/%2F%2B", rsp -> {

assertEquals("/%2F%2B@/+", rsp.body().string());

});

});

}

@ServerTest

public void queryString(ServerTestRunner runner) {

runner.define(app -> {

app.get("/", ctx -> ctx.queryString() + "@" + ctx.query("q").value(""));

app.get("/value", ctx -> ctx.query("user"));

}).ready(client -> {

client.get("/?q=a+b", rsp -> {

assertEquals("?q=a+b@a b", rsp.body().string());

});

client.get("/", rsp -> {

assertEquals("@", rsp.body().string());

});

client.get("/value?user.name=user&user.pass=pwd", rsp -> {

assertEquals("{name=user, pass=pwd}", rsp.body().string());

});

});

}

@ServerTest(executionMode = {EVENT_LOOP, WORKER})

public void form(ServerTestRunner runner) {

runner.define(app -> {

app.post("/", ctx -> ctx.form());

}).ready(client -> {

client.post("/", new FormBody.Builder()

.add("q", "a b")

.add("user.name", "user")

.build(), rsp -> {

assertEquals("{q=a b, user={name=user}}", rsp.body().string());

});

});

}

@ServerTest

public void multipart(ServerTestRunner runner) {

runner.define(app -> {

app.post("/large", ctx -> {

FileUpload f = ctx.file("f");

return new String(f.bytes(), StandardCharsets.UTF_8);

});

app.post("/f", ctx -> {

FileUpload f = ctx.file("f");

return f.getFileName() + "(type=" + f.getContentType() + ";exists=" + Files

.exists(f.path())

+ ")";

});

app.post("/files", ctx -> {

List<FileUpload> files = ctx.files("f");

return files.stream().map(f -> f.getFileName() + "=" + f.getFileSize())

.collect(Collectors.toList());

});

app.post("/datafile", ctx -> {

Datafile file = ctx.multipart(Datafile.class);

String result = file.name + "=" + Files.exists(file.filename.path());

return result;

});

app.post("/datafiles", ctx -> {

Datafiles file = ctx.multipart(Datafiles.class);

return file.name + "=" + file.filename;

});

app.post("/multipart", ctx -> {

Multipart multipart = ctx.multipart();

Map<String, List<String>> multimap = multipart.toMultimap();

Map<String, Object> rsp = new LinkedHashMap<>();

rsp.putAll(multimap);

rsp.put("f", multipart.files("f"));

return rsp;

});

}).ready(client -> {

client.post("/large", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("f", "19kb.txt", create(_19kb, MediaType.parse("text/plain")))

.build(), rsp -> {

assertEquals(_19kb, rsp.body().string());

});

client.post("/f", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("user.name", "user")

.addFormDataPart("f", "fileupload.js",

create(userdir("src", "test", "resources", "files", "fileupload.js").toFile(),

MediaType.parse("application/javascript")))

.build(), rsp -> {

assertEquals("fileupload.js(type=application/javascript;exists=true)",

rsp.body().string());

});

client.post("/files", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("user.name", "user")

.addFormDataPart("f", "f1.txt", create("text1", MediaType.parse("text/plain")))

.addFormDataPart("f", "f2.txt", create("text2", MediaType.parse("text/plain")))

.build(), rsp -> {

assertEquals("[f1.txt=5, f2.txt=5]", rsp.body().string());

});

client.post("/multipart", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("user.name", "user")

.addFormDataPart("f", "f1.txt",

create("text1", MediaType.parse("text/plain")))

.addFormDataPart("f", "f2.txt",

create("text2", MediaType.parse("text/plain")))

.build(), rsp -> {

assertEquals("{user.name=[user], f=[f1.txt, f2.txt]}", rsp.body().string());

});

client.post("/datafile", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("name", "foo_report")

.addFormDataPart("filename", "fileupload.js",

create(userdir("src", "test", "resources", "files", "fileupload.js").toFile(),

MediaType.parse("application/javascript")))

.build(), rsp -> {

assertEquals("foo_report=true", rsp.body().string());

});

client.post("/datafiles", new MultipartBody.Builder()

.setType(MultipartBody.FORM)

.addFormDataPart("name", "foo_report")

.addFormDataPart("filename", "f1.txt",

create("text1", MediaType.parse("text/plain")))

.addFormDataPart("filename", "f2.txt",

create("text2", MediaType.parse("text/plain")))

.build(), rsp -> {

assertEquals("foo_report=[f1.txt, f2.txt]", rsp.body().string());

});

});

}

/* No Jetty bc always use a worker thread */

@ServerTest(server = {Netty.class, Utow.class}, executionMode = EVENT_LOOP)

public void beforeAfter(ServerTestRunner runner) {

runner.define(app -> {

app.before(ctx -> {

StringBuilder buff = new StringBuilder();

buff.append("before1:" + ctx.isInIoThread()).append(";");

ctx.attribute("buff", buff);

});

app.after((ctx, value, failure) -> {

StringBuilder buff = (StringBuilder) value;

buff.append("after1:" + ctx.isInIoThread()).append(";");

});

app.dispatch(() -> {

app.before(ctx -> {

StringBuilder buff = ctx.attribute("buff");

buff.append("before2:" + ctx.isInIoThread()).append(";");

});

app.after((ctx, value, failure) -> {

StringBuilder buff = ctx.attribute("buff");

buff.append("after2:" + ctx.isInIoThread()).append(";");

});

app.get("/", ctx -> {

StringBuilder buff = ctx.attribute("buff");

buff.append("result:").append(ctx.isInIoThread()).append(";");

return buff;

});

});

}).ready(client -> {

client.get("/", rsp -> {

assertEquals("before1:false;before2:false;result:false;after2:false;after1:false;",

rsp.body().string());

});

});

}

@ServerTest

public void decorator(ServerTestRunner runner) {

runner.define(app -> {

app.decorator(next -> ctx -> "{" + ctx.attribute("prefix") + next.apply(ctx) + "}");

app.before(ctx -> {

ctx.attribute("prefix", "%");

});

app.decorator(next -> ctx -> "<" + ctx.attribute("prefix") + next.apply(ctx) + ">");

app.get("/decorator", ctx -> ctx.attribute("prefix") + "OK" + "%");

}).ready(client -> {

client.get("/decorator", rsp -> {

assertEquals("{%<%%OK%>}",

rsp.body().string());

});

});

}

@ServerTest

public void decoder(ServerTestRunner runner) {

runner.define(app -> {

app.install(new JacksonModule());

app.post("/map", ctx -> ctx.body(Map.class));

app.post("/toListInt", ctx -> {

List<Integer> ints = ctx.body().toList(Integer.class);

return ints;

});

app.post("/intBody", ctx -> {

return ctx.body().to(Integer.class);

});

app.post("/str", ctx -> ctx.body().value());

}).ready(client -> {

client.header("Content-Type", "application/json");

client.post("/map", create("{\"foo\": \"bar\"}", json), rsp -> {

assertEquals("{\"foo\":\"bar\"}", rsp.body().string());

});

client.header("Content-Type", "application/json");

client.post("/toListInt", create("[3, 4, 1]", json), rsp -> {

assertEquals("[3,4,1]", rsp.body().string());

});

client.post("/intBody", create("678", textplain), rsp -> {

assertEquals("678", rsp.body().string());

});

client.post("/str", create(_19kb, textplain), rsp -> {

String value = rsp.body().string();

assertEquals(_19kb, value);

});

});

}

@ServerTest

public void jsonVsRawOutput(ServerTestRunner runner) {

runner.define(app -> {

app.install(new JacksonModule());

app.path("/api/pets", () -> {

app.get("/{id}", ctx -> {

ctx.setResponseType(io.jooby.MediaType.json);

return "{\"message\": \"" + ctx.path("id") + "\"}";

});

app.get("/raw", ctx -> {

ctx.setResponseType(io.jooby.MediaType.json);

return "{\"message\": \"raw\"}".getBytes(StandardCharsets.UTF_8);

});

app.get("/", ctx -> {

return Arrays.asList(mapOf("message", "fooo"));

});

});

}).ready(client -> {

client.get("/api/pets/fooo", rsp -> {

assertEquals("application/json;charset=utf-8", rsp.header("content-type").toLowerCase());

assertEquals("{\"message\": \"fooo\"}", rsp.body().string());

});

client.get("/api/pets/raw", rsp -> {

assertEquals("application/json;charset=utf-8", rsp.header("content-type").toLowerCase());

assertEquals("{\"message\": \"raw\"}", rsp.body().string());

});

client.get("/api/pets", rsp -> {

assertEquals("application/json;charset=utf-8", rsp.header("content-type").toLowerCase());

assertEquals("[{\"message\":\"fooo\"}]", rsp.body().string());

});

});

}

@ServerTest

public void defaultAndExplicitAcceptableResponses(ServerTestRunner runner) {

class Message {

String value = "OK";

@Override public String toString() {

return value;

}

}

runner.define(app -> {

app.encoder(io.jooby.MediaType.json, (@Nonnull Context ctx, @Nonnull Object value) ->

("{" + value.toString() + "}").getBytes(StandardCharsets.UTF_8)

);

app.encoder(io.jooby.MediaType.xml, (@Nonnull Context ctx, @Nonnull Object value) ->

("<" + value.toString() + ">").getBytes(StandardCharsets.UTF_8)

);

app.get("/defaults", ctx -> {

ctx.query("type").toOptional().ifPresent(ctx::setResponseType);

return new Message();

});

app.get("/produces", ctx -> new Message())

.produces(io.jooby.MediaType.json, io.jooby.MediaType.xml);

}).ready(client -> {

client.header("Accept", "application/json");

client.get("/defaults", rsp -> {

assertEquals("{OK}", rsp.body().string());

assertEquals("text/plain", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "application/xml");

client.get("/defaults", rsp -> {

assertEquals("<OK>", rsp.body().string());

assertEquals("text/plain", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "text/plain");

client.get("/defaults", rsp -> {

assertEquals("OK", rsp.body().string());

assertEquals("text/plain", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "*/*");

client.get("/defaults", rsp -> {

assertEquals("{OK}", rsp.body().string());

assertEquals("text/plain", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "text/html");

client.get("/defaults", rsp -> {

assertEquals(406, rsp.code());

assertEquals("text/html;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "text/html");

client.get("/defaults?type=text/html", rsp -> {

assertEquals("OK", rsp.body().string());

assertEquals("text/html", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "application/json");

client.get("/produces", rsp -> {

assertEquals("{OK}", rsp.body().string());

assertEquals("application/json;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "application/xml");

client.get("/produces", rsp -> {

assertEquals("<OK>", rsp.body().string());

assertEquals("application/xml;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "*/*");

client.get("/produces", rsp -> {

assertEquals("{OK}", rsp.body().string());

assertEquals("application/json;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "text/html");

client.get("/produces", rsp -> {

assertEquals(406, rsp.code());

assertEquals("text/html;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

client.header("Accept", "text/plain");

client.get("/produces", rsp -> {

assertEquals(406, rsp.code());

assertEquals("text/plain;charset=utf-8", rsp.header("Content-Type").toLowerCase());

});

});

}

@ServerTest

public void consumes(ServerTestRunner runner) {

runner.define(app -> {

app.decoder(io.jooby.MediaType.json, new MessageDecoder() {

@Nonnull @Override public String decode(@Nonnull Context ctx, @Nonnull Type type)

throws Exception {

return "{" + ctx.body().value() + "}";

}

});

app.decoder(xml, new MessageDecoder() {

@Nonnull @Override public String decode(@Nonnull Context ctx, @Nonnull Type type)

throws Exception {

return "<" + ctx.body().value() + ">";

}

});

app.get("/defaults", ctx -> {

return ctx.body(String.class);

});

app.get("/consumes", ctx -> ctx.body(String.class))

.consumes(io.jooby.MediaType.json, io.jooby.MediaType.xml);

}).ready(client -> {

client.header("Content-Type", "application/json");

client.get("/defaults", rsp -> {

assertEquals("{}", rsp.body().string());

});

client.header("Content-Type", "application/xml");

client.get("/defaults", rsp -> {

assertEquals("<>", rsp.body().string());

});

client.header("Content-Type", "text/plain");

client.get("/defaults", rsp -> {

assertEquals("", rsp.body().string());

});

client.header("Content-Type", "application/json");

client.get("/consumes", rsp -> {

assertEquals("{}", rsp.body().string());

});

client.header("Content-Type", "application/xml");

client.get("/consumes", rsp -> {

assertEquals("<>", rsp.body().string());

});

client.header("Content-Type", "text/plain");

client.get("/consumes", rsp -> {

assertEquals(415, rsp.code());

});

});

}

@ServerTest

public void errorHandler(ServerTestRunner runner) {

runner.define(app -> {

app.install(new JacksonModule());

app.get("/", ctx -> {

if (ctx.getRequestPath().length() != 0) {

throw new IllegalArgumentException("Intentional error");

}

return "OK";

});

}).ready(client -> {

client.get("/", rsp -> {

assertEquals("text/html;charset=utf-8", rsp.body().contentType().toString().toLowerCase());

assertEquals("<!doctype html>\n"

+ "<html>\n"

+ "<head>\n"

+ "<meta charset=\"utf-8\">\n"

+ "<style>\n"

+ "body {font-family: \"open sans\",sans-serif; margin-left: 20px;}\n"

+ "h1 {font-weight: 300; line-height: 44px; margin: 25px 0 0 0;}\n"

+ "h2 {font-size: 16px;font-weight: 300; line-height: 44px; margin: 0;}\n"

+ "footer {font-weight: 300; line-height: 44px; margin-top: 10px;}\n"

+ "hr {background-color: #f7f7f9;}\n"

+ "div.trace {border:1px solid #e1e1e8; background-color: #f7f7f9;}\n"

+ "p {padding-left: 20px;}\n"

+ "p.tab {padding-left: 40px;}\n"

+ "</style>\n"

+ "<title>Bad Request (400)</title>\n"

+ "<body>\n"

+ "<h1>Bad Request</h1>\n"

+ "<hr>\n"

+ "<h2>message: Intentional error</h2>\n"

+ "<h2>status code: 400</h2>\n"

+ "</body>\n"

+ "</html>", rsp.body().string());

});

client.header("Accept", "application/json");

client.get("/", rsp -> {

assertEquals("application/json;charset=utf-8",

rsp.body().contentType().toString().toLowerCase());

assertEquals(

"{\"message\":\"Intentional error\",\"statusCode\":400,\"reason\":\"Bad Request\"}",

rsp.body().string());

});

});

}

@ServerTest

public void rx2(ServerTestRunner runner) {

runner.define(app -> {

app.get("/rx/flowable", ctx ->

Flowable.range(1, 10)

.map(i -> i + ",")

.subscribeOn(Schedulers.io())

.observeOn(Schedulers.computation())

);

app.get("/rx/observable", ctx ->

Observable.range(1, 10)

.map(i -> i + ",")

.subscribeOn(Schedulers.io())

.observeOn(Schedulers.computation())

);