functionaltests.AbstractRestFuncTestCase.java Source code

Java tutorial

Introduction

Here is the source code for functionaltests.AbstractRestFuncTestCase.java

Source

/*
 * ProActive Parallel Suite(TM):
 * The Open Source library for parallel and distributed
 * Workflows & Scheduling, Orchestration, Cloud Automation
 * and Big Data Analysis on Enterprise Grids & Clouds.
 *
 * Copyright (c) 2007 - 2017 ActiveEon
 * Contact: contact@activeeon.com
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License
 * as published by the Free Software Foundation: version 3 of
 * the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * If needed, contact us to obtain a release under GPL Version 2 or 3
 * or a different license than the AGPL.
 */
package functionaltests;

import java.security.Policy;

import javax.ws.rs.core.MediaType;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.junit.AfterClass;
import org.junit.Assert;
import org.ow2.proactive.resourcemanager.core.properties.PAResourceManagerProperties;
import org.ow2.proactive.scheduler.common.Scheduler;
import org.ow2.proactive.scheduler.common.job.Job;
import org.ow2.proactive.scheduler.common.job.JobId;
import org.ow2.proactive.scheduler.common.job.JobPriority;
import org.ow2.proactive.scheduler.common.job.JobStatus;
import org.ow2.proactive.scheduler.common.job.TaskFlowJob;
import org.ow2.proactive.scheduler.common.task.ForkEnvironment;
import org.ow2.proactive.scheduler.common.task.JavaTask;
import org.ow2.proactive.scheduler.common.task.OnTaskError;

import functionaltests.jobs.NonTerminatingJob;
import functionaltests.jobs.SimpleJob;
import functionaltests.utils.RestFuncTUtils;

public abstract class AbstractRestFuncTestCase {

    static {
        configureSecurityManager();
        configureLog4j();
    }

    static Logger logger;

    private static void configureLog4j() {
        BasicConfigurator.configure();
        Logger.getRootLogger().setLevel(Level.INFO);
        logger = Logger.getLogger(AbstractRestFuncTestCase.class);
    }

    private static void configureSecurityManager() {
        if (System.getProperty("java.security.policy") == null) {
            System.setProperty("java.security.policy",
                    System.getProperty(PAResourceManagerProperties.RM_HOME.getKey())
                            + "/config/security.java.policy-server");

            Policy.getPolicy().refresh();
        }
    }

    private static final int STATUS_OK = 200;

    private volatile String session;

    protected void setSessionHeader(HttpUriRequest request) throws Exception {
        if (session == null) {
            synchronized (AbstractRestFuncTestCase.class) {
                if (session == null) {
                    session = getSession(RestFuncTHelper.getRestfulSchedulerUrl(), getLogin(), getPassword());
                }
            }

        }
        request.setHeader("sessionid", session);
    }

    protected JSONObject toJsonObject(HttpResponse response) throws Exception {
        String content = getContent(response);
        JSONParser parser = new JSONParser();
        return (JSONObject) parser.parse(content);
    }

    protected JSONArray toJsonArray(HttpResponse response) throws Exception {
        String content = getContent(response);
        JSONParser parser = new JSONParser();
        return (JSONArray) parser.parse(content);
    }

    protected Scheduler getScheduler() {
        return RestFuncTHelper.getScheduler();
    }

    protected void assertHttpStatusOK(HttpResponse response) {
        assertEquals(STATUS_OK, getStatusCode(response));
    }

    protected String assertContentNotEmpty(HttpResponse response) throws Exception {
        String content = getContent(response);
        assertNotNull(content);
        assertTrue(content.length() != 0);
        return content;
    }

    protected int getStatusCode(HttpResponse response) {
        return response.getStatusLine().getStatusCode();
    }

    protected String getContent(HttpResponse response) throws Exception {
        return EntityUtils.toString(response.getEntity());
    }

    protected HttpResponse executeUriRequest(HttpUriRequest request) throws Exception {
        return HttpClientBuilder.create().build().execute(request);
    }

    protected void assertEquals(int expected, int actual) {
        Assert.assertEquals(expected, actual);
    }

    protected void assertEquals(long expected, long actual) {
        Assert.assertEquals(expected, actual);
    }

    protected void assertEquals(Object expected, Object actual) {
        Assert.assertEquals(expected, actual);
    }

    protected void assertNotNull(Object actual) {
        Assert.assertNotNull(actual);
    }

    protected void assertTrue(boolean condition) {
        Assert.assertTrue(condition);
    }

    protected String trim(String content) {
        return content.replaceAll("^\"|\"$", "");
    }

    protected void fail(String message) {
        Assert.fail(message);
    }

    protected String getResourceUrl(String resource) {
        return RestFuncTHelper.getResourceUrl(resource);
    }

    protected String getLogin() throws Exception {
        return RestFuncTestConfig.getInstance().getLogin();
    }

    protected String getNonAdminLogin() throws Exception {
        return RestFuncTestConfig.getInstance().getNonAdminLogin();
    }

    protected String getPassword() throws Exception {
        return RestFuncTestConfig.getInstance().getPassword();
    }

    protected String getNonAdminLoginPassword() throws Exception {
        return RestFuncTestConfig.getInstance().getNonAdminLonginPassword();
    }

    protected JobId submitDefaultJob() throws Exception {
        Job job = defaultJob();
        return getScheduler().submit(job);
    }

    protected String submitFinishedJob() throws Exception {
        Scheduler scheduler = getScheduler();
        Job job = defaultJob();
        JobId jobId = scheduler.submit(job);
        waitJobState(jobId, JobStatus.FINISHED, 120000);
        return jobId.value();
    }

    public void waitJobState(JobId jobId, JobStatus expected, long timeout) throws Exception {
        waitJobState(jobId.value(), expected, timeout);
    }

    public void waitJobState(String jobId, JobStatus expected, long timeout) throws Exception {
        long stopTime = System.currentTimeMillis() + timeout;

        while (System.currentTimeMillis() < stopTime) {
            JobStatus currentStatus = getScheduler().getJobState(jobId).getStatus();
            if (currentStatus.equals(expected)) {
                return;
            } else if (!currentStatus.isJobAlive()) {
                break;
            } else {
                Thread.sleep(300);
            }
        }

        Assert.fail("Failed to wait when " + jobId + " is " + expected + ", current status is "
                + getScheduler().getJobState(jobId).getStatus());
    }

    protected String submitPendingJobId() throws Exception {
        Job job = pendingJob();
        JobId jobId = getScheduler().submit(job);
        return jobId.value();
    }

    protected Job defaultJob() throws Exception {
        return createJob(SimpleJob.class);
    }

    protected String getDefaultTaskName() {
        return getTaskName(SimpleJob.class);
    }

    protected Job pendingJob() throws Exception {
        return createJob(NonTerminatingJob.class);
    }

    protected String getTaskNameForClass(Class<?> clazz) {
        return clazz.getSimpleName() + "Task";
    }

    protected Job createJob(Class<?> clazz) throws Exception {
        TaskFlowJob job = new TaskFlowJob();
        job.setName(clazz.getSimpleName());
        job.setPriority(JobPriority.NORMAL);
        job.setOnTaskError(OnTaskError.CANCEL_JOB);
        job.setDescription("Test " + clazz.getSimpleName());
        job.setMaxNumberOfExecution(1);

        JavaTask task = new JavaTask();
        task.setName(getTaskNameForClass(clazz));
        task.setExecutableClassName(clazz.getName());
        task.setMaxNumberOfExecution(1);
        task.setOnTaskError(OnTaskError.CANCEL_JOB);

        String classpath = RestFuncTUtils.getClassPath(clazz);
        ForkEnvironment forkEnvironment = new ForkEnvironment();
        forkEnvironment.addAdditionalClasspath(classpath);
        task.setForkEnvironment(forkEnvironment);

        job.addTask(task);

        return job;
    }

    protected Job createJobManyTasks(String jobName, Class<?>... clazzes) throws Exception {
        TaskFlowJob job = new TaskFlowJob();
        job.setName(jobName);
        job.setPriority(JobPriority.NORMAL);
        job.setDescription("Test " + jobName);
        job.setMaxNumberOfExecution(1);

        for (Class<?> clazz : clazzes) {
            JavaTask task = new JavaTask();
            task.setName(clazz.getSimpleName() + "Task");
            task.setExecutableClassName(clazz.getName());
            task.setMaxNumberOfExecution(1);
            String classpath = RestFuncTUtils.getClassPath(clazz);
            ForkEnvironment forkEnvironment = new ForkEnvironment();
            forkEnvironment.addAdditionalClasspath(classpath);
            task.setForkEnvironment(forkEnvironment);
            job.addTask(task);
        }
        return job;
    }

    protected String getTaskName(Class<?> clazz) {
        return clazz.getSimpleName() + "Task";
    }

    private String getSession(String schedulerUrl, String username, String password) throws Exception {
        String resourceUrl = getResourceUrl("login");
        HttpPost httpPost = new HttpPost(resourceUrl);
        StringBuilder buffer = new StringBuilder();
        buffer.append("username=").append(username).append("&password=").append(password);
        StringEntity entity = new StringEntity(buffer.toString());
        entity.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        httpPost.setEntity(entity);
        HttpResponse response = HttpClientBuilder.create().build().execute(httpPost);
        String responseContent = EntityUtils.toString(response.getEntity());
        if (STATUS_OK != getStatusCode(response)) {
            throw new RuntimeException(String.format("Authentication error: %n%s", responseContent));
        } else {
            return responseContent;
        }
    }

    public static void init(int nbNodes) throws Exception {
        try {
            System.out.println("Starting the Scheduler & REST server");
            RestFuncTHelper.startRestfulSchedulerWebapp(nbNodes);
        } catch (Exception e) {
            e.printStackTrace();
            RestFuncTHelper.stopRestfulSchedulerWebapp();
            throw e;
        }
    }

    public static void init() throws Exception {
        init(RestFuncTHelper.DEFAULT_NUMBER_OF_NODES);
    }

    @AfterClass
    public static void afterClass() {
        RestFuncTHelper.stopRestfulSchedulerWebapp();
    }

}