CustomServerEvaluationStrategyTest.java

/*******************************************************************************
 * Copyright (c) 2012-2017 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.plugin.docker.machine;

import org.eclipse.che.api.machine.server.model.impl.ServerConfImpl;
import org.eclipse.che.api.machine.server.model.impl.ServerImpl;
import org.eclipse.che.plugin.docker.client.json.ContainerConfig;
import org.eclipse.che.plugin.docker.client.json.ContainerInfo;
import org.eclipse.che.plugin.docker.client.json.NetworkSettings;
import org.eclipse.che.plugin.docker.client.json.PortBinding;
import org.mockito.Mock;
import org.mockito.testng.MockitoTestNGListener;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static org.mockito.Mockito.when;

/**
 * Test for {@Link CustomServerEvaluationStrategy}
 *
 * @author Florent Benoit
 */
@Listeners(MockitoTestNGListener.class)
public class CustomServerEvaluationStrategyTest {

    private static final String ALL_IP_ADDRESS = "0.0.0.0";

    private static final String WORKSPACE_ID_VALUE    = "work123";
    private static final String WORKSPACE_ID_PROPERTY = "CHE_WORKSPACE_ID=" + WORKSPACE_ID_VALUE;

    private static final String MACHINE_NAME_VALUE    = "myMachine";
    private static final String MACHINE_NAME_PROPERTY = "CHE_MACHINE_NAME=" + MACHINE_NAME_VALUE;

    @Mock
    private ContainerConfig containerConfig;

    @Mock
    private ContainerInfo containerInfo;

    @Mock
    private NetworkSettings networkSettings;


    private CustomServerEvaluationStrategy customServerEvaluationStrategy;

    private Map<String, Map<String, String>> containerExposedPorts;
    private Map<String, String>              containerLabels;
    private String[]                         envContainerConfig;
    private Map<String, List<PortBinding>>   networkExposedPorts;


    @BeforeMethod
    protected void setup() throws Exception {
        containerLabels = new HashMap<>();
        containerExposedPorts = new HashMap<>();
        networkExposedPorts = new HashMap<>();
        when(containerInfo.getConfig()).thenReturn(containerConfig);
        when(containerConfig.getLabels()).thenReturn(containerLabels);
        when(containerConfig.getExposedPorts()).thenReturn(containerExposedPorts);

        envContainerConfig = new String[]{WORKSPACE_ID_PROPERTY, MACHINE_NAME_PROPERTY};
        when(containerConfig.getEnv()).thenReturn(envContainerConfig);

        when(containerInfo.getNetworkSettings()).thenReturn(networkSettings);
        when(networkSettings.getGateway()).thenReturn("127.0.0.1");
        when(networkSettings.getPorts()).thenReturn(networkExposedPorts);

        containerLabels.put("foo1", "bar");
        containerLabels.put("foo1/dummy", "bar");
        containerLabels.put("che:server:4401/tcp:protocol", "http");
        containerLabels.put("che:server:4401/tcp:ref", "wsagent");
        containerLabels.put("che:server:22/tcp:protocol", "ssh");
        containerLabels.put("che:server:22/tcp:ref", "ssh");
        containerLabels.put("che:server:22/tcp:path", "/api");
        containerLabels.put("che:server:4411/tcp:ref", "terminal");
        containerLabels.put("che:server:4411/tcp:protocol", "http");
        containerLabels.put("che:server:8080:protocol", "http");
        containerLabels.put("che:server:8080:ref", "tomcat8");
        containerLabels.put("anotherfoo1", "bar2");
        containerLabels.put("anotherfoo1/dummy", "bar2");

        containerExposedPorts.put("22/tcp", Collections.emptyMap());
        networkExposedPorts.put("22/tcp", Collections.singletonList(new PortBinding().withHostIp(ALL_IP_ADDRESS)
                                                                                     .withHostPort("3222")));
        containerExposedPorts.put("4401/tcp", Collections.emptyMap());
        networkExposedPorts.put("4401/tcp", Collections.singletonList(new PortBinding().withHostIp(ALL_IP_ADDRESS)
                                                                                       .withHostPort("324401")));
        containerExposedPorts.put("4411/tcp", Collections.emptyMap());
        networkExposedPorts.put("4411/tcp", Collections.singletonList(new PortBinding().withHostIp(ALL_IP_ADDRESS)
                                                                                       .withHostPort("324411")));
        containerExposedPorts.put("8080/tcp", Collections.emptyMap());
        networkExposedPorts.put("8080/tcp", Collections.singletonList(new PortBinding().withHostIp(ALL_IP_ADDRESS)
                                                                                       .withHostPort("328080")));
    }


    /**
     * Check workspace Id template
     */
    @Test
    public void testWorkspaceIdRule() throws Throwable {
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("10.0.0.1", "192.168.1.1", "<workspaceId>", "http", "8080");

        Map<String, String> portMapping = this.customServerEvaluationStrategy.getExternalAddressesAndPorts(containerInfo, "localhost");

        Assert.assertTrue(portMapping.containsKey("4401/tcp"));
        Assert.assertEquals(portMapping.get("4401/tcp"), WORKSPACE_ID_VALUE);
    }


    /**
     * Check workspace Id template
     */
    @Test
    public void testMachineNameRule() throws Throwable {
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("10.0.0.1", "192.168.1.1", "<machineName>", "http", "8080");

        Map<String, String> portMapping = this.customServerEvaluationStrategy.getExternalAddressesAndPorts(containerInfo, "localhost");

        Assert.assertTrue(portMapping.containsKey("4401/tcp"));
        Assert.assertEquals(portMapping.get("4401/tcp"), MACHINE_NAME_VALUE);
    }

    /**
     * Check updates of protocols
     */
    @Test
    public void testProtocolUpdate() throws Throwable {
        HashMap<String, ServerConfImpl> serverConfs = new HashMap<>();
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("10.0.0.1", "192.168.1.1", "<workspaceId>", "https", "8080");
        Map<String, ServerImpl> portMapping = this.customServerEvaluationStrategy.getServers(containerInfo, "localhost", serverConfs);

        Assert.assertTrue(portMapping.containsKey("4401/tcp"));
        ServerImpl server = portMapping.get("4401/tcp");
        Assert.assertNotNull(server);
        Assert.assertEquals(server.getUrl(), "https://" + WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getProtocol(), "https");
        Assert.assertEquals(server.getAddress(), WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getRef(), "wsagent");
    }

    /**
     * Check defaults values
     */
    @Test
    public void testDefaults() throws Throwable {
        HashMap<String, ServerConfImpl> serverConfs = new HashMap<>();

        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("127.0.0.1", null, "<externalAddress>-<workspaceId>", "https", "8080");

        Map<String, ServerImpl> portMapping = this.customServerEvaluationStrategy.getServers(containerInfo, "localhost", serverConfs);

        Assert.assertTrue(portMapping.containsKey("4401/tcp"));
        ServerImpl server = portMapping.get("4401/tcp");
        Assert.assertNotNull(server);
        Assert.assertEquals(server.getUrl(), "https://127.0.0.1-" + WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getProtocol(), "https");
        Assert.assertEquals(server.getAddress(), "127.0.0.1-" + WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getRef(), "wsagent");
        Assert.assertEquals(server.getRef(), "wsagent");
    }

    /**
     * Check defaults values
     */
    @Test
    public void testDefaultsNoGateway() throws Throwable {
        when(networkSettings.getGateway()).thenReturn(null);
        HashMap<String, ServerConfImpl> serverConfs = new HashMap<>();
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("127.0.0.1", null, "<externalAddress>-<workspaceId>", "https", "8080");
        Map<String, ServerImpl> portMapping = this.customServerEvaluationStrategy.getServers(containerInfo, "127.0.0.1", serverConfs);
        Assert.assertTrue(portMapping.containsKey("4401/tcp"));
        ServerImpl server = portMapping.get("4401/tcp");
        Assert.assertNotNull(server);
        Assert.assertEquals(server.getUrl(), "https://127.0.0.1-" + WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getProtocol(), "https");
        Assert.assertEquals(server.getAddress(), "127.0.0.1-" + WORKSPACE_ID_VALUE);
        Assert.assertEquals(server.getRef(), "wsagent");
        Assert.assertEquals(server.getRef(), "wsagent");
    }


    /**
     * Check offline mode
     */
    @Test
    public void testOffline() throws Throwable {
        Set<String> exposedPorts = new HashSet<>();
        exposedPorts.add("22/tcp");
        exposedPorts.add("4401/tcp");
        exposedPorts.add("4411/tcp");
        exposedPorts.add("8080/tcp");
        List<String> env = Arrays.asList(WORKSPACE_ID_PROPERTY, MACHINE_NAME_PROPERTY);
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("127.0.0.1", null, "<externalAddress>-<workspaceId>", "https", "8080");
        CustomServerEvaluationStrategy.RenderingEvaluation renderingEvaluation = this.customServerEvaluationStrategy
                .getOfflineRenderingEvaluation(containerLabels, exposedPorts, env.stream().toArray(String[]::new));
        String eval = renderingEvaluation.render("<workspaceId>", "4401/tcp");
        Assert.assertEquals(eval, WORKSPACE_ID_VALUE);
    }


    /**
     * Check offline mode with external ip
     */
    @Test
    public void testOfflineExternal() throws Throwable {
        Set<String> exposedPorts = new HashSet<>();
        exposedPorts.add("22/tcp");
        exposedPorts.add("4401/tcp");
        exposedPorts.add("4411/tcp");
        exposedPorts.add("8080/tcp");
        List<String> env = Arrays.asList(WORKSPACE_ID_PROPERTY, MACHINE_NAME_PROPERTY);
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("127.0.0.1", "127.0.0.1", "<externalAddress>-<workspaceId>", "https", "8080");
        CustomServerEvaluationStrategy.RenderingEvaluation renderingEvaluation = this.customServerEvaluationStrategy
                .getOfflineRenderingEvaluation(containerLabels, exposedPorts, env.stream().toArray(String[]::new));
        String eval = renderingEvaluation.render("<workspaceId>", "4401/tcp");
        Assert.assertEquals(eval, WORKSPACE_ID_VALUE);
    }


    /**
     * Check offline mode with external ip
     */
    //@Test(expectedExceptions = UnsupportedOperationException.class, expectedExceptionsMessageRegExp = "Unable to find the IP for the address .*")
    public void testOfflineInvalidExternal() throws Throwable {
        Set<String> exposedPorts = new HashSet<>();
        exposedPorts.add("22/tcp");
        exposedPorts.add("4401/tcp");
        exposedPorts.add("4411/tcp");
        exposedPorts.add("8080/tcp");
        List<String> env = Arrays.asList(WORKSPACE_ID_PROPERTY, MACHINE_NAME_PROPERTY);
        this.customServerEvaluationStrategy =
                new CustomServerEvaluationStrategy("127.0.0.1", "300.300.300.300", "<externalAddress>-<workspaceId>", "https", "8080");
        CustomServerEvaluationStrategy.RenderingEvaluation renderingEvaluation = this.customServerEvaluationStrategy
                .getOfflineRenderingEvaluation(containerLabels, exposedPorts, env.stream().toArray(String[]::new));
        String eval = renderingEvaluation.render("<workspaceId>", "4401/tcp");
        Assert.assertEquals(eval, WORKSPACE_ID_VALUE);
    }


}