import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * App can render front page.
 * @throws Exception If some problem inside
 */
@Test
public void rendersHomePage() throws Exception {
    final Take take = new TkApp(new FakeBase());
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(
            new RsPrint(
                take.act(
                    new RqWithHeader(
                        new RqFake("GET", "/"),
                        // @checkstyle MultipleStringLiteralsCheck (1 line)
                        "Accept",
                        "text/xml"
                    )
                )
            ).printBody()
        ),
        XhtmlMatchers.hasXPaths(
            "/page/@date",
            "/page/@sla",
            "/page/millis",
            "/page/links/link[@rel='self']"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * App can render front page.
 * @throws Exception If some problem inside
 */
@Test
public void rendersHomePage() throws Exception {
    final Take take = new TkApp(new FkBase());
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(
            new RsPrint(
                take.act(
                    new RqWithHeader(
                        new RqFake("GET", "/"),
                        // @checkstyle MultipleStringLiteralsCheck (1 line)
                        "Accept",
                        "text/xml"
                    )
                )
            ).printBody()
        ),
        XhtmlMatchers.hasXPaths(
            "/page/@date",
            "/page/@sla",
            "/page/millis",
            "/page/links/link[@rel='takes:logout']"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkHome can render home page.
 * @throws Exception If some problem inside
 */
@Test
public void rendersHomePage() throws Exception {
    final Take take = new TkIndex(new FkBase());
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(
            new RsPrint(
                take.act(
                    new RqWithHeader(
                        new RqFake("GET", "/"),
                        "Accept",
                        "text/xml"
                    )
                )
            ).printBody()
        ),
        XhtmlMatchers.hasXPaths(
            "/page/millis",
            "/page/links/link[@rel='takes:github']",
            "/page/total"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkEvents can render list of events.
 * @throws Exception If some problem inside
 */
@Test
public void rendersListOfEvents() throws Exception {
    final Take take = new TkAppAuth(new TkEvents(new FkBase()));
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(
            new RsPrint(
                take.act(
                    new RqWithHeader(
                        new RqFake("GET", "/"),
                        "Accept",
                        "text/xml"
                    )
                )
            ).printBody()
        ),
        XhtmlMatchers.hasXPaths(
            "/page/millis",
            "/page/events/event",
            "/page/events/@total"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkContentType can match by Content-Type header with different types.
 * @throws IOException If some problem inside
 */
@Test
public void matchesDifferentTypes() throws IOException {
    MatcherAssert.assertThat(
        new FkContentType(
            "application/json charset=utf-8",
            FkContentTypeTest.emptyResponse()
        ).route(
            new RqWithHeader(
                new RqFake(),
                FkContentTypeTest.CONTENT_TYPE,
                "images/*"
            )
        ).has(),
        Matchers.is(false)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkContentType can match by Content-Type header with identical types.
 * @throws IOException If some problem inside
 */
@Test
public void matchesIdenticalTypes() throws IOException {
    MatcherAssert.assertThat(
        new FkContentType(
            FkContentTypeTest.CTYPE,
            FkContentTypeTest.emptyResponse()
        ).route(
            new RqWithHeader(
                new RqFake(),
                FkContentTypeTest.CONTENT_TYPE,
                FkContentTypeTest.CTYPE
            )
        ).has(),
        Matchers.is(true)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkContentType can match by Content-Type header with different encodings.
 * @throws IOException If some problem inside
 */
@Test
public void matchesDifferentEncodingsTypes() throws IOException {
    MatcherAssert.assertThat(
        new FkContentType(
            FkContentTypeTest.CTYPE,
            FkContentTypeTest.emptyResponse()
        ).route(
            new RqWithHeader(
                new RqFake(),
                FkContentTypeTest.CONTENT_TYPE,
                "text/html charset=utf8"
            )
        ).has(),
        Matchers.is(false)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkEncoding can match by Accept-Encoding header.
 * @throws IOException If some problem inside
 */
@Test
public void matchesByAcceptEncodingHeader() throws IOException {
    final String header = "Accept-Encoding";
    MatcherAssert.assertThat(
        new FkEncoding("gzip", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), header, "gzip,deflate")
        ).has(),
        Matchers.is(true)
    );
    MatcherAssert.assertThat(
        new FkEncoding("", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), header, "xz,gzip,exi")
        ).has(),
        Matchers.is(true)
    );
    MatcherAssert.assertThat(
        new FkEncoding("deflate", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), header, "gzip,exi")
        ).has(),
        Matchers.is(false)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkTypes can match by Accept header.
 * @throws IOException If some problem inside
 */
@Test
public void matchesByAcceptHeader() throws IOException {
    final String accept = "Accept";
    MatcherAssert.assertThat(
        new FkTypes("text/xml", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), accept, "*/* ")
        ).has(),
        Matchers.is(true)
    );
    MatcherAssert.assertThat(
        new FkTypes("application/json", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), accept, "image/*")
        ).has(),
        Matchers.is(false)
    );
    MatcherAssert.assertThat(
        new FkTypes("*/*", new RsEmpty()).route(
            new RqWithHeader(new RqFake(), accept, "text/html")
        ).has(),
        Matchers.is(true)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkAuthenticated can match by user status.
 * @throws IOException If some problem inside
 */
@Test
public void matchesIfAuthenticatedUser() throws IOException {
    MatcherAssert.assertThat(
        new FkAuthenticated(new TkEmpty()).route(
            new RqFake("GET", "/hel?a=1")
        ).has(),
        Matchers.is(false)
    );
    MatcherAssert.assertThat(
        new FkAuthenticated(new TkEmpty()).route(
            new RqWithHeader(
                new RqFake("PUT", "/hello"),
                TkAuth.class.getSimpleName(),
                new String(
                    new CcPlain().encode(new Identity.Simple("urn:test:1"))
                )
            )
        ).has(),
        Matchers.is(true)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * FkHitRefresh can refresh on demand.
 * @throws Exception If some problem inside
 */
@Test
public void refreshesOnDemand() throws Exception {
    final Request req = new RqWithHeader(
        new RqFake(), "X-Takes-HitRefresh: yes"
    );
    final AtomicBoolean done = new AtomicBoolean(false);
    final Fork fork = new FkHitRefresh(
        this.temp.getRoot(),
        new Runnable() {
            @Override
            public void run() {
                done.set(true);
            }
        },
        new TkEmpty()
    );
    TimeUnit.SECONDS.sleep(2L);
    FileUtils.touch(this.temp.newFile("hey.txt"));
    MatcherAssert.assertThat(
        fork.route(req).has(),
        Matchers.is(true)
    );
    MatcherAssert.assertThat(done.get(), Matchers.is(true));
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * 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")
        )
    );
    MatcherAssert.assertThat(
        new RsPrint(
            take.act(
                new RqWithHeader(
                    new RqFake(),
                    PsBasicTest.header("mike", "secret11")
                )
            )
        ).print(),
        Matchers.containsString("HTTP/1.1 200 OK")
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkSecure can pass on registered user.
 * @throws IOException If some problem inside
 */
@Test
public void passesOnRegisteredUser() throws IOException {
    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)
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * XeIdentity can create a correct link.
 * @throws IOException If some problem inside
 */
@Test
public void generatesIdentityInXml() throws IOException {
    MatcherAssert.assertThat(
        IOUtils.toString(
            new RsXembly(
                new XeAppend(
                    "root",
                    new XeIdentity(
                        new RqWithHeader(
                            new RqFake(),
                            TkAuth.class.getSimpleName(),
                            "urn:test:1;name=Jeff"
                        )
                    )
                )
            ).body(),
            StandardCharsets.UTF_8
        ),
        XhtmlMatchers.hasXPaths(
            "/root/identity[urn='urn:test:1']",
            "/root/identity[name='Jeff']"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkAuth can login a user via cookie.
 * @throws IOException If some problem inside
 */
@Test
public void logsInUserViaCookie() throws IOException {
    final Pass pass = new PsChain(
        new PsCookie(new CcPlain()),
        new PsLogout()
    );
    MatcherAssert.assertThat(
        new RsPrint(
            new TkAuth(new TkText(), pass).act(
                new RqWithHeader(
                    new RqFake(),
                    String.format(
                        "Cookie:  %s=%s",
                        PsCookie.class.getSimpleName(),
                        "urn%3Atest%3A0"
                    )
                )
            )
        ).print(),
        Matchers.allOf(
            Matchers.startsWith("HTTP/1.1 200 "),
            Matchers.containsString("Set-Cookie: PsCookie=urn%3Atest%3A0")
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkAuth can logout a user.
 * @throws IOException If some problem inside
 */
@Test
public void logsUserOut() throws IOException {
    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()
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkAuth can logout a user when a login cookie is present.
 * @throws IOException If some problem inside
 */
@Test
public void logsUserOutWithCookiePresent() throws IOException {
    final Pass pass = new PsChain(
        new PsLogout(),
        new PsCookie(new CcPlain())
    );
    MatcherAssert.assertThat(
        new RsPrint(
            new TkAuth(new TkText(), pass).act(
                new RqWithHeader(
                    new RqFake(),
                    String.format(
                        "Cookie: %s=%s",
                        PsCookie.class.getSimpleName(),
                        "urn%3Atest%3A5"
                    )
                )
            )
        ).print(),
        Matchers.containsString("Set-Cookie: PsCookie=")
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkReturn can redirect to return location
 * and remove a return cookie.
 * @throws IOException If some problem inside
 */
@Test
public void redirectsAndRemovesCookie() throws IOException {
    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=;"
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * TkFlash can remove a flash cookie.
 * @throws IOException If some problem inside
 */
@Test
public void removesFlashCookie() throws IOException {
    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"
                )
            )
        )
    );
}
 

import org.takes.rq.RqWithHeader; //导入依赖的package包/类
/**
 * Route.
 * @param regex Regular expression
 * @param take Take
 * @param req Request
 * @return Response or empty
 * @throws IOException If fails
 */
private static Opt<Response> route(final String regex, final Take take,
    final Request req) throws IOException {
    return new FkRegex(
        String.format("/d/([a-z\\-]+)%s", regex),
        new TkRegex() {
            @Override
            public Response act(final RqRegex rreq) throws IOException {
                final String name = rreq.matcher().group(1);
                return FkDeck.redirect(name, take).act(
                    new RqWithHeader(rreq, "X-Thindeck-Deck", name)
                );
            }
        }
    ).route(req);
}