org.takes.Take Java Examples

/**
 * TkFlash can remove a flash cookie.
 * @throws Exception If some problem inside
 */
@Test
public void removesFlashCookie() throws Exception {
    final Take take = new TkFlash(new TkEmpty());
    MatcherAssert.assertThat(
        take.act(
            new RqWithHeader(
                new RqFake(),
                "Cookie: RsFlash=Hello!"
            )
        ).head(),
        Matchers.hasItem(
            Matchers.allOf(
                Matchers.startsWith("Set-Cookie: RsFlash=deleted;"),
                Matchers.containsString("Path=/;"),
                Matchers.containsString(
                    "Expires=Thu, 01 Jan 1970 00:00:00 GMT"
                )
            )
        )
    );
}
 

/**
 * TkForward can catch RsForward throws by Response.
 * @throws Exception If some problem inside
 */
@Test
public void catchesExceptionThrownByResponse() throws Exception {
    final Take take =
        request -> new ResponseOf(
            () -> new RsEmpty().head(),
            () -> {
                throw new RsForward("/b");
            }
        );
    MatcherAssert.assertThat(
        new RsPrint(
            new TkForward(take).act(new RqFake())
        ),
        new StartsWith("HTTP/1.1 303")
    );
}
 

/**
 * Ctor.
 * @param take Original take
 */
public TkVerbose(final Take take) {
    super(
        new Take() {
            @Override
            public Response act(final Request request) throws Exception {
                try {
                    return take.act(request);
                } catch (final HttpException ex) {
                    throw new HttpException(
                        ex.code(),
                        String.format(
                            "%s %s",
                            new RqMethod.Base(request).method(),
                            new RqHref.Base(request).href()
                        ),
                        ex
                    );
                }
            }
        }
    );
}
 

/**
 * TkReturn can redirect to return location
 * and remove a return cookie.
 * @throws Exception If some problem inside
 */
@Test
public void redirectsAndRemovesCookie() throws Exception {
    final Take take = new TkReturn(new TkEmpty());
    final String destination = "/return/to";
    MatcherAssert.assertThat(
        take.act(
            new RqWithHeader(
                new RqFake(),
                String.format(
                    "Cookie: RsReturn=%s;",
                    URLEncoder.encode(
                        destination,
                        Charset.defaultCharset().name()
                    )
                )
            )
        ).head(),
        Matchers.contains(
            "HTTP/1.1 303 See Other",
            String.format("Location: %s", destination),
            "Set-Cookie: RsReturn=;"
        )
    );
}
 

/**
 * Ctor.
 * @param location Location to redirect to
 * @param code Redirection status code
 */
public TkSmartRedirect(final String location, final int code) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) throws IOException {
                return new RsRedirect(
                    new TkSmartRedirect.RedirectParams(
                        req, location
                    ).location(),
                    code
                );
            }
        }
    );
}
 

/**
 * PsBasic can authenticate a user.
 * @throws Exception If some problem inside
 */
@Test
public void authenticatesUser() throws Exception {
    final Take take = new TkAuth(
        new TkSecure(
            new TkText("secured")
        ),
        new PsBasic(
            "myrealm",
            new PsBasic.Default("mike secret11 urn:users:michael")
        )
    );
    new Assertion<>(
        "PsBasic should authenticate mike",
        new RsPrint(
            take.act(
                new RqWithHeader(
                    new RqFake(),
                    PsBasicTest.header("mike", "secret11")
                )
            )
        ),
        new TextHasString("HTTP/1.1 200 OK")
    ).affirm();
}
 

/**
 * App can render front page.
 * @throws Exception If some problem inside
 */
@Test
public void rendersHomePageViaHttp() throws Exception {
    final Take app = new TkApp(new FkBase());
    new FtRemote(app).exec(
        home -> {
            new JdkRequest(home)
                .fetch()
                .as(RestResponse.class)
                .assertStatus(HttpURLConnection.HTTP_OK)
                .as(XmlResponse.class)
                .assertXPath("/xhtml:html");
            new JdkRequest(home)
                .through(VerboseWire.class)
                .header("Accept", "application/xml")
                .fetch()
                .as(RestResponse.class)
                .assertStatus(HttpURLConnection.HTTP_OK)
                .as(XmlResponse.class)
                .assertXPath("/page/version");
        }
    );
}
 

/**
 * Ctor.
 * @param base Base directory
 */
public TkFiles(final File base) {
    super(
        new Take() {
            @Override
            public Response act(final Request request) throws IOException {
                final File file = new File(
                    base, new RqHref.Base(request).href().path()
                );
                if (!file.exists()) {
                    throw new HttpException(
                        HttpURLConnection.HTTP_NOT_FOUND,
                        String.format(
                            "%s not found", file.getAbsolutePath()
                        )
                    );
                }
                return new RsWithBody(Files.newInputStream(file.toPath()));
            }
        }
    );
}
 

/**
 * TkSecure can pass on registered user.
 * @throws Exception If some problem inside
 */
@Test
public void passesOnRegisteredUser() throws Exception {
    MatcherAssert.assertThat(
        new TkSecure(
            new Take() {
                @Override
                public Response act(final Request request) {
                    return new RsEmpty();
                }
            }
        ).act(
            new RqWithHeader(
                new RqFake(),
                TkAuth.class.getSimpleName(),
                new String(
                    new CcPlain().encode(new Identity.Simple("urn:test:2"))
                )
            )
        ),
        Matchers.instanceOf(RsEmpty.class)
    );
}
 

/**
 * TkIndex can render home page in HTML.
 * @throws Exception If some problem inside
 */
@Test
public void rendersHomePageInHtml() throws Exception {
    final Take take = new TkAppAuth(new TkIndex(new FkBase()));
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(
            new RsPrint(
                take.act(new RqFake("GET", "/"))
            ).printBody()
        ),
        XhtmlMatchers.hasXPaths(
            "/xhtml:html",
            "/xhtml:html/xhtml:body"
        )
    );
}
 

/**
 * TkAuth can login a user.
 * @throws Exception If some problem inside
 */
@Test
public void logsUserIn() throws Exception {
    final Pass pass = new PsFixed(new Identity.Simple("urn:test:1"));
    final Take take = Mockito.mock(Take.class);
    Mockito.doReturn(new RsText()).when(take)
        .act(Mockito.any(Request.class));
    new TkAuth(take, pass).act(new RqFake());
    final ArgumentCaptor<Request> captor =
        ArgumentCaptor.forClass(Request.class);
    Mockito.verify(take).act(captor.capture());
    MatcherAssert.assertThat(
        new RqHeaders.Base(captor.getValue()).header(
            TkAuth.class.getSimpleName()
        ),
        Matchers.hasItem("urn%3Atest%3A1")
    );
}
 

/**
 * Ctor.
 * @param take Original take
 */
public TkGzip(final Take take) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) throws Exception {
                final Response response = take.act(req);
                return new RsFork(
                    req,
                    new FkEncoding("gzip", new RsGzip(response)),
                    new FkEncoding("", response)
                );
            }
        }
    );
}
 

@Test
public void rendersOneReport(@TempDir final Path temp) throws Exception {
    final Take app = new TkApp(temp);
    new FtRemote(app).exec(
        home -> {
            new JdkRequest(home)
                .uri().path("org.jpeek")
                .path("jpeek")
                .path("index.html").back()
                .fetch()
                .as(RestResponse.class)
                .assertStatus(HttpURLConnection.HTTP_NOT_FOUND);
            new JdkRequest(String.format("%s/org.jpeek/jpeek/", home))
                .fetch()
                .as(RestResponse.class)
                .assertStatus(HttpURLConnection.HTTP_SEE_OTHER);
            new JdkRequest(String.format("%s/org.jpeek/jpeek", home))
                .fetch()
                .as(RestResponse.class)
                .assertStatus(HttpURLConnection.HTTP_SEE_OTHER);
        }
    );
}
 

/**
 * TkVerbose can extend not-found exception.
 * @throws Exception If some problem inside
 */
@Test
public void extendsNotFoundException() throws Exception {
    final Take take = new Take() {
        @Override
        public Response act(final Request request) throws IOException {
            throw new HttpException(HttpURLConnection.HTTP_NOT_FOUND);
        }
    };
    try {
        new TkVerbose(take).act(new RqFake());
    } catch (final HttpException ex) {
        MatcherAssert.assertThat(
            ex.getLocalizedMessage(),
            Matchers.endsWith("GET http://www.example.com/")
        );
    }
}
 

/**
 * TkConsumes can fail on unsupported Content-Type header.
 * @throws Exception If some problem inside
 */
@Test(expected = HttpException.class)
public void failsOnUnsupportedAcceptHeader() throws Exception {
    final Take consumes = new TkConsumes(
        new TkFixed(new RsJson(new RsEmpty())),
        TkConsumesTest.APPLICATION_JSON
    );
    consumes.act(
        new RqFake(
            Arrays.asList(
                "GET /?TkConsumes error",
                "Content-Type: application/xml"
            ),
            ""
        )
    ).head();
}
 

/**
 * Ctor.
 * @param prefix Prefix
 */
public TkClasspath(final String prefix) {
    super(
        new Take() {
            @Override
            public Response act(final Request request) throws IOException {
                final String name = String.format(
                    "%s%s", prefix, new RqHref.Base(request).href().path()
                );
                final InputStream input = this.getClass()
                    .getResourceAsStream(name);
                if (input == null) {
                    throw new HttpException(
                        HttpURLConnection.HTTP_NOT_FOUND,
                        String.format("%s not found in classpath", name)
                    );
                }
                return new RsWithBody(input);
            }
        }
    );
}
 

/**
 * TkAuth can logout a user.
 * @throws Exception If some problem inside
 */
@Test
public void logsUserOut() throws Exception {
    final Pass pass = new PsLogout();
    final Take take = Mockito.mock(Take.class);
    Mockito.doReturn(new RsText()).when(take)
        .act(Mockito.any(Request.class));
    new TkAuth(take, pass).act(
        new RqWithHeader(
            new RqFake(),
            TkAuth.class.getSimpleName(),
            "urn%3Atest%3A2"
        )
    );
    final ArgumentCaptor<Request> captor =
        ArgumentCaptor.forClass(Request.class);
    Mockito.verify(take).act(captor.capture());
    MatcherAssert.assertThat(
        new RqHeaders.Base(captor.getValue()).header(
            TkAuth.class.getSimpleName()
        ),
        Matchers.emptyIterable()
    );
}
 

/**
 * Ctor.
 * @param take The take to wrap
 * @checkstyle AnonInnerLengthCheck (100 lines)
 */
public TkJoinedCookies(final Take take) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) throws Exception {
                return TkJoinedCookies.join(take.act(req));
            }
        }
    );
}
 

/**
 * Ctor.
 * @param take Original take
 * @param fbk Fallback
 */
public TkFallback(final Take take, final Fallback fbk) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) throws Exception {
                return TkFallback.route(take, fbk, req);
            }
        }
    );
}
 

/**
 * Creates an instance of secure Front.
 *
 * @param take Take
 * @return Secure Front
 * @throws IOException If some problem inside
 */
private static FtRemote secure(final Take take) throws IOException {
    final ServerSocket skt = SSLServerSocketFactory.getDefault()
        .createServerSocket(0);
    return new FtRemote(
        new FtSecure(new BkBasic(take), skt),
        skt,
        true
    );
}
 

/**
 * TkText can print multiple times.
 * @throws Exception If some problem inside
 */
@Test
public void printsResourceMultipleTimes() throws Exception {
    final String body = "hello, dude!";
    final Take take = new TkText(body);
    MatcherAssert.assertThat(
        new RsPrint(take.act(new RqFake())),
        new TextHasString(body)
    );
    MatcherAssert.assertThat(
        new RsPrint(take.act(new RqFake())),
        new TextHasString(body)
    );
}
 

/**
 * TkProxy can correctly maps path string.
 * @throws Exception If some problem inside
 * @checkstyle AnonInnerLengthCheck (100 lines)
 */
@Test
public void correctlyMapsPathString() throws Exception {
    final Take take = new Take() {
        @Override
        public Response act(final Request req) throws IOException {
            return new RsText(new RqHref.Base(req).href().toString());
        }
    };
    new FtRemote(
        new TkFork(
            new FkMethods(this.method, take)
        )
    ).exec(
        new FtRemote.Script() {
            @Override
            public void exec(final URI home) throws Exception {
                MatcherAssert.assertThat(
                    new RsPrint(
                        new TkProxy(home).act(
                            new RqFake(
                                TkProxyTest.this.method,
                                "/a/%D0%B0/c?%D0%B0=1#%D0%B0"
                            )
                        )
                    ).printBody(),
                    Matchers.equalTo(
                        String.format(
                            "http://%s:%d/a/%%D0%%B0/c?%%D0%%B0=1",
                            home.getHost(), home.getPort()
                        )
                    )
                );
            }
        }
    );
}
 

/**
 * Checks FkContentType equals method.
 * @throws Exception If some problem inside
 */
@Test
public void mustEvaluateEqualsTest() throws Exception {
    final Take take = req -> new RsEmpty();
    final String type = "text/xml";
    new Assertion<>(
        "Must evaluate true equality",
        new FkContentType(type, take),
        new IsEqual<>(new FkContentType(type, take))
    ).affirm();
}
 

/**
 * Redirects when it's HTTP instead of HTTPS.
 * @throws Exception If fails
 */
@Test
public void redirects() throws Exception {
    final Request req = new RqFake(
        Arrays.asList(
            "GET /one/two?a=1",
            "Host: www.0crat.com",
            "X-Forwarded-Proto: http"
        ),
        ""
    );
    MatcherAssert.assertThat(
        new RsPrint(
            new TkSslOnly(
                new Take() {
                    @Override
                    public Response act(final Request request)
                        throws IOException {
                        return new RsText(
                            new RqPrint(request).print()
                        );
                    }
                }
            ).act(req)
        ),
        new TextHasString("https://www.0crat.com/one/two?a=1")
    );
}
 

/**
 * FtBasic can properly parse incoming HTTP request.
 * @throws Exception If some problem inside
 */
@Test
public void parsesIncomingHttpRequest() throws Exception {
    final Take take = new Take() {
        @Override
        public Response act(final Request request) throws IOException {
            MatcherAssert.assertThat(
                new RqPrint(request).printBody(),
                Matchers.containsString("Jeff")
            );
            return new RsText("works!");
        }
    };
    new FtRemote(take).exec(
        new FtRemote.Script() {
            @Override
            public void exec(final URI home) throws IOException {
                new JdkRequest(home)
                    .method("PUT")
                    .body().set("Jeff, how are you?").back()
                    .fetch()
                    .as(RestResponse.class)
                    .assertStatus(HttpURLConnection.HTTP_OK);
            }
        }
    );
}
 

/**
 * TkFallback can fall back.
 * @throws Exception If some problem inside
 */
@Test
public void fallsBackInsideResponse() throws Exception {
    MatcherAssert.assertThat(
        new RsPrint(
            new TkFallback(
                new Take() {
                    @Override
                    public Response act(final Request req) {
                        return new ResponseOf(
                            () -> {
                                throw new UnsupportedOperationException("");
                            },
                            () -> {
                                throw new IllegalArgumentException(
                                    "here we fail"
                                );
                            }
                        );
                    }
                },
                new FbFixed(new RsText("caught here!"))
            ).act(new RqFake())
        ).printBody(),
        Matchers.startsWith("caught")
    );
}
 

/**
 * Ctor.
 * @param body Text
 */
public TkText(final String body) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) {
                return new RsText(body);
            }
        }
    );
}
 

/**
 * Ctor.
 * @param body Body with HTML
 */
public TkText(final byte[] body) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) {
                return new RsText(body);
            }
        }
    );
}
 

/**
 * Ctor.
 * @param take Original
 * @param key Cookie name
 * @param value Cookie value
 */
public TkWithCookie(final Take take, final String key, final String value) {
    super(
        new TkWithHeaders(
            take,
            String.format("Set-Cookie: %s=%s", key, value)
    )
    );
}
 

/**
 * Ctor.
 * @param take Original take
 * @param type Content type
 */
public TkWithType(final Take take, final String type) {
    super(
        new Take() {
            @Override
            public Response act(final Request req) throws Exception {
                return new RsWithType(take.act(req), type);
            }
        }
    );
}