org.wisdom.framework.vertx.ResponseEncodingTest.java Source code

Java tutorial

Introduction

Here is the source code for org.wisdom.framework.vertx.ResponseEncodingTest.java

Source

/*
 * #%L
 * Wisdom-Framework
 * %%
 * Copyright (C) 2013 - 2014 Wisdom Framework
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
package org.wisdom.framework.vertx;

import org.apache.commons.io.IOUtils;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.junit.After;
import org.junit.Test;
import org.wisdom.api.Controller;
import org.wisdom.api.DefaultController;
import org.wisdom.api.configuration.ApplicationConfiguration;
import org.wisdom.api.cookies.Cookie;
import org.wisdom.api.cookies.SessionCookie;
import org.wisdom.api.crypto.Crypto;
import org.wisdom.api.exceptions.ExceptionMapper;
import org.wisdom.api.http.HeaderNames;
import org.wisdom.api.http.HttpMethod;
import org.wisdom.api.http.Request;
import org.wisdom.api.http.Result;
import org.wisdom.api.router.Route;
import org.wisdom.api.router.RouteBuilder;
import org.wisdom.api.router.Router;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.*;

/**
 * Check the wisdom server behavior about response encoding.
 * This class is listening for http requests on random port.
 */
public class ResponseEncodingTest extends VertxBaseTest {

    private WisdomVertxServer server;
    protected static final String LOREM = "Lorem ipsum dolor sit amet, consectetur adipisicing elit,"
            + " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim"
            + " veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo"
            + " consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolor"
            + "e eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in"
            + " culpa qui officia deserunt mollit anim id est laborum.";

    @After
    public void tearDown() {
        if (server != null) {
            server.stop();
            server = null;
        }
    }

    private String generate(int length) {
        StringBuilder builder = new StringBuilder();
        while (builder.length() < length) {
            builder.append(LOREM);
        }
        return builder.toString();
    }

    @Test
    public void testEncodingOfResponse() throws InterruptedException, IOException {
        Router router = prepareServer();

        byte[] content = generate(1000).getBytes();

        // Prepare the router with a controller
        Controller controller = new DefaultController() {
            @SuppressWarnings("unused")
            public Result index() {
                return ok(content, false);
            }
        };
        final Route route1 = new RouteBuilder().route(HttpMethod.GET).on("/").to(controller, "index");
        configureRouter(router, route1);

        server.start();
        waitForStart(server);

        // Now start bunch of clients
        int num = NUMBER_OF_CLIENTS;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(num);

        int port = server.httpPort();

        for (int i = 0; i < num; ++i) {// create and start threads
            executor.submit(new Client(startSignal, doneSignal, port, i, content, "gzip"));
        }

        startSignal.countDown(); // let all threads proceed
        assertThat(doneSignal.await(60, TimeUnit.SECONDS)).isTrue(); // wait for all to finish

        assertThat(failure).isEmpty();
        assertThat(success).hasSize(num);
    }

    @Test
    public void testThatSmallResponsesAreNotEncoded() throws InterruptedException, IOException {
        Router router = prepareServer();

        byte[] content = generate(100).getBytes();

        // Prepare the router with a controller
        Controller controller = new DefaultController() {
            @SuppressWarnings("unused")
            public Result index() {
                return ok(content, false);
            }
        };
        final Route route1 = new RouteBuilder().route(HttpMethod.GET).on("/").to(controller, "index");
        configureRouter(router, route1);

        server.start();
        waitForStart(server);

        // Now start bunch of clients
        int num = NUMBER_OF_CLIENTS;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(num);

        int port = server.httpPort();

        for (int i = 0; i < num; ++i) {// create and start threads
            executor.submit(new Client(startSignal, doneSignal, port, i, content, null));
        }

        startSignal.countDown(); // let all threads proceed
        assertThat(doneSignal.await(60, TimeUnit.SECONDS)).isTrue(); // wait for all to finish

        assertThat(failure).isEmpty();
        assertThat(success).hasSize(num);
    }

    @Test
    public void testThatLargeResponsesAreNotEncoded() throws InterruptedException, IOException {
        Router router = prepareServer();

        byte[] content = generate(2000).getBytes();

        // Prepare the router with a controller
        Controller controller = new DefaultController() {
            @SuppressWarnings("unused")
            public Result index() {
                return ok(content, false);
            }
        };
        final Route route1 = new RouteBuilder().route(HttpMethod.GET).on("/").to(controller, "index");
        configureRouter(router, route1);

        server.start();
        waitForStart(server);

        // Now start bunch of clients
        int num = NUMBER_OF_CLIENTS;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(num);

        int port = server.httpPort();

        for (int i = 0; i < num; ++i) {// create and start threads
            executor.submit(new Client(startSignal, doneSignal, port, i, content, null));
        }

        startSignal.countDown(); // let all threads proceed
        assertThat(doneSignal.await(60, TimeUnit.SECONDS)).isTrue(); // wait for all to finish

        assertThat(failure).isEmpty();
        assertThat(success).hasSize(num);
    }

    private void configureRouter(Router router, Route root) {
        doAnswer(invocationOnMock -> {
            String path = (String) invocationOnMock.getArguments()[1];
            if (path.equals("/")) {
                return root;
            }
            return null;
        }).when(router).getRouteFor(anyString(), anyString(), any(Request.class));
    }

    private Router prepareServer() {
        ApplicationConfiguration configuration = mock(ApplicationConfiguration.class);
        when(configuration.getBooleanWithDefault("vertx.compression", true)).thenReturn(true);
        when(configuration.getIntegerWithDefault(eq("vertx.http.port"), anyInt())).thenReturn(0);
        when(configuration.getIntegerWithDefault(eq("vertx.https.port"), anyInt())).thenReturn(-1);
        when(configuration.getIntegerWithDefault("request.body.max.size", 100 * 1024)).thenReturn(100 * 1024);
        when(configuration.getIntegerWithDefault("vertx.acceptBacklog", -1)).thenReturn(-1);
        when(configuration.getIntegerWithDefault("vertx.receiveBufferSize", -1)).thenReturn(-1);
        when(configuration.getIntegerWithDefault("vertx.sendBufferSize", -1)).thenReturn(-1);
        when(configuration.getWithDefault(Cookie.APPLICATION_COOKIE_PREFIX, "wisdom")).thenReturn("wisdom");
        when(configuration.getIntegerWithDefault(SessionCookie.SESSION_EXPIRE_TIME_SECOND, 3600) * 1000)
                .thenReturn(1000);
        when(configuration.getBooleanWithDefault(SessionCookie.SESSION_SEND_ONLY_IF_CHANGED, true))
                .thenReturn(true);
        when(configuration.getBooleanWithDefault(SessionCookie.SESSION_OVER_HTTPS_ONLY, false)).thenReturn(false);
        when(configuration.getBooleanWithDefault(SessionCookie.SESSION_HTTP_ONLY, true)).thenReturn(true);
        when(configuration.getBytes(ApplicationConfiguration.ENCODING_MIN_SIZE,
                ApplicationConfiguration.DEFAULT_ENCODING_MIN_SIZE)).thenReturn(800L);
        when(configuration.getBytes(ApplicationConfiguration.ENCODING_MAX_SIZE,
                ApplicationConfiguration.DEFAULT_ENCODING_MAX_SIZE)).thenReturn(1500L);

        when(configuration.getStringArray("wisdom.websocket.subprotocols")).thenReturn(new String[0]);
        when(configuration.getStringArray("vertx.websocket-subprotocols")).thenReturn(new String[0]);

        Crypto crypto = mock(Crypto.class);
        when(crypto.sign(anyString())).thenReturn("aaaaaa");

        Router router = mock(Router.class);

        // Configure the server.
        server = new WisdomVertxServer();
        server.configuration = configuration;
        server.accessor = new ServiceAccessor(crypto, configuration, router, getMockContentEngine(), executor, null,
                Collections.<ExceptionMapper>emptyList());
        server.vertx = vertx;
        return router;
    }

    private class Client implements Runnable {
        private final CountDownLatch startSignal;
        private final CountDownLatch doneSignal;
        private final int port;
        private final int id;
        private byte[] content;
        private String encoding;

        Client(CountDownLatch startSignal, CountDownLatch doneSignal, int port, int id, byte[] content,
                String expectedEncoding) {
            this.startSignal = startSignal;
            this.doneSignal = doneSignal;
            this.port = port;
            this.id = id;
            this.content = content;
            this.encoding = expectedEncoding;
        }

        public void run() {
            try {
                startSignal.await();
                doWork();
            } catch (Throwable ex) {
                ex.printStackTrace();
                fail(id);
            }
            doneSignal.countDown();
        }

        void doWork() throws IOException {
            CloseableHttpClient httpclient = null;
            CloseableHttpResponse response = null;
            try {
                httpclient = HttpClientBuilder.create().disableContentCompression().build();
                HttpClientContext context = HttpClientContext.create();

                final String uri = "http://localhost:" + port + "/?id=" + id;
                HttpGet req1 = new HttpGet(uri);
                req1.setHeader(HeaderNames.ACCEPT_ENCODING, "gzip, deflate, sdch");

                response = httpclient.execute(req1, context);
                byte[] content = EntityUtils.toByteArray(response.getEntity());

                assertThat(response.getStatusLine().getStatusCode()).isEqualTo(200);
                System.out.println(Arrays.toString(response.getAllHeaders()));
                if (encoding == null) {
                    assertThat(response.getFirstHeader(HeaderNames.CONTENT_ENCODING)).isNull();
                    assertThat(content.length).isEqualTo(this.content.length);
                } else {
                    assertThat(response.getFirstHeader(HeaderNames.CONTENT_ENCODING).getValue())
                            .isEqualTo(encoding);
                    assertThat(content.length).isLessThan(this.content.length);
                }

                success(id);

            } finally {
                IOUtils.closeQuietly(httpclient);
                IOUtils.closeQuietly(response);
            }
        }
    }
}