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

Introduction

Here is the source code for org.wisdom.framework.vertx.VertxBaseTest.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 com.google.common.collect.ImmutableList;
import io.vertx.core.Vertx;
import org.apache.http.HttpResponse;
import org.junit.After;
import org.wisdom.api.concurrent.ExecutionContextService;
import org.wisdom.api.concurrent.ManagedExecutorService;
import org.wisdom.api.content.ContentEngine;
import org.wisdom.api.content.ContentSerializer;
import org.wisdom.api.http.Renderable;
import org.wisdom.executors.ManagedExecutorServiceImpl;
import org.wisdom.executors.context.HttpExecutionContextService;
import org.wisdom.framework.vertx.ssl.SSLServerContext;
import org.wisdom.test.parents.FakeConfiguration;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * Utility methods used in test.
 */
public class VertxBaseTest {

    public static final int NUMBER_OF_CLIENTS;

    public static final Random RANDOM;

    static {
        NUMBER_OF_CLIENTS = Integer.getInteger("vertx.test.clients", 10);
        RANDOM = new Random();
    }

    protected ManagedExecutorService executor = new ManagedExecutorServiceImpl("test",
            new FakeConfiguration(Collections.<String, Object>emptyMap()),
            ImmutableList.<ExecutionContextService>of(new HttpExecutionContextService()));

    Vertx vertx = Vertx.vertx();

    ExecutorService clients = Executors.newFixedThreadPool(NUMBER_OF_CLIENTS);

    List<Integer> success = new ArrayList<>();
    List<Integer> failure = new ArrayList<>();

    public static void waitForStart(WisdomVertxServer server) throws InterruptedException, IOException {
        int attempt = 0;
        while (server.httpPort() == 0 && attempt < 10) {
            Thread.sleep(1000);
            attempt++;
        }
        if (server.httpPort() == 0) {
            throw new IllegalStateException("Server not started after " + attempt + " attempts");
        }

        // No one is publishing /ping, so we are expected to get a 404.
        // Before we was trying on / but test are expecting parameters.
        URL url = new URL("http://localhost:" + server.httpPort() + "/ping");
        attempt = 0;
        int code = 0;
        while (code == 0 && attempt < 10) {
            try {
                Thread.sleep(1000);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                code = connection.getResponseCode();
                if (code != 0) {
                    System.out.println("Server started (code: " + code + ")");
                }
            } catch (IOException e) {
                // Next try...
            }
            attempt++;
        }

        if (code == 0) {
            throw new IllegalStateException("Server not ready after " + attempt + " attempts");
        }
    }

    public static void waitForHttpsStart(WisdomVertxServer server) throws InterruptedException {
        int attempt = 0;
        while (server.httpsPort() == 0 && attempt < 10) {
            Thread.sleep(1000);
            attempt++;
        }
    }

    public static boolean isOk(HttpResponse response) {
        return response != null && response.getStatusLine().getStatusCode() == 200;
    }

    public static boolean isOk(int status) {
        return status == 200;
    }

    public static boolean containsExactly(byte[] content, byte[] expected) {
        if (content.length != expected.length) {
            return false;
        }
        for (int i = 0; i < content.length; i++) {
            if (content[i] != expected[i]) {
                return false;
            }
        }
        return true;
    }

    @After
    public void stopping() {
        if (vertx != null) {
            vertx.close();
        }

        failure.clear();
        success.clear();

        executor.shutdownNow();

        // Reset SSL Context
        SSLServerContext.reset();
    }

    public synchronized void success(int id) {
        success.add(id);
    }

    public synchronized void fail(int id) {
        failure.add(id);
    }

    static ContentEngine getMockContentEngine() {
        ContentSerializer serializer = new ContentSerializer() {
            @Override
            public String getContentType() {
                return null;
            }

            @Override
            public void serialize(Renderable<?> renderable) {
                if (renderable.content() instanceof Exception) {
                    renderable.setSerializedForm(((Exception) renderable.content()).getMessage());
                }
            }
        };
        ContentEngine contentEngine = mock(ContentEngine.class);
        when(contentEngine.getContentSerializerForContentType(anyString())).thenReturn(serializer);
        return contentEngine;
    }
}