source: branches/OKBJavaConnector/AdministrationService/test/com/heuristiclab/services/administration/AdministrationServiceTest.java @ 6062

package com.heuristiclab.services.administration;

import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.X509TrustManager;
import javax.net.ssl.TrustManager;
import java.util.Map;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 *
 * @author MartinH
 */
public class AdministrationServiceTest {

    static {
        // Create a trust manager that does not validate certificate chains
        TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {

        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return new java.security.cert.X509Certificate[]{};
        }

        public void checkClientTrusted(
                java.security.cert.X509Certificate[] certs, String authType) {
        }

        public void checkServerTrusted(
                java.security.cert.X509Certificate[] certs, String authType) {
        }
    }};

        SSLContext sc;
        try {
            sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (KeyManagementException e) {
            throw new RuntimeException(e);
        }

    }

    public AdministrationServiceTest() {
    }
    AdministrationService srv = null;
    IAdministrationService port = null;

    /**
     * @throws java.lang.Exception
     */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    /**
     * @throws java.lang.Exception
     */
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    /**
     * @throws java.lang.Exception
     */
    @Before
    public void setUp() throws Exception {
        this.srv = new AdministrationService();
        this.port = srv.getAdministrationService(); // .getWSHttpBindingIAdministrationService1();

        /*Map<String, Object> requestContext = ((BindingProvider) port).getRequestContext();
        requestContext.put(BindingProvider.USERNAME_PROPERTY, "okbtester");
        requestContext.put(BindingProvider.PASSWORD_PROPERTY, "okbtester");*/
    }

    /**
     * @throws java.lang.Exception
     */
    @After
    public void tearDown() throws Exception {
    }

    // TODO: fix -->Problem deleting existing Algorithm
    @Test
    public void AddAlgorithmTest() throws Exception {

        ObjectFactory fac = new ObjectFactory();
        Long retval = 0L;

        // delete existing Algo and Class first
        if (port.getAlgorithmClass(1000L) != null) {
            port.deleteAlgorithmClass(1000L);
        }
        if (port.getAlgorithm(1000L) != null) {
            port.deleteAlgorithm(1000L);
        }

        // add AlgorithmClassId first
        AddAlgorithmClassTest();
        Algorithm a = fac.createAlgorithm();

        a.setAlgorithmClassId(1000L);
        a.setDescription(fac.createNamedOKBItemDescription("a new Algo"));
        a.setId(1000L);
        a.setName(fac.createNamedOKBItemName("Algorithm Name 6"));
        a.setPlatformId(1L);
        try {
            retval = port.addAlgorithm(a);
        } catch (Exception e) {
            e.printStackTrace();
            // throw new OKBWebServiceFailedException(e.getMessage());
        }
        assertTrue("Algortihm wasn't added", retval > 0);
    }

    @Test
    public void AddAlgorithmClassTest() throws Exception {

        ObjectFactory fac = new ObjectFactory();
        Long retval = 0L;

        // delete existing Algo first (if exists)
        if (port.getAlgorithmClass(1000L) != null) {
            port.deleteAlgorithmClass(1000L);
        }

        AlgorithmClass a = fac.createAlgorithmClass();
        a.setId(1000L);
        a.setName(fac.createNamedOKBItemName("a new AlgoClass"));

        try {
            retval = port.addAlgorithmClass(a);
        } catch (Exception e) {
            e.printStackTrace();
            // throw new OKBWebServiceFailedException(e.getMessage());
        }
        assertTrue("AlgortihmClass wasn't added", retval > 0);
    }

    @Test
    public void GetAlgorithmsTest() {

        ArrayOfAlgorithm algos = port.getAlgorithms();

        for (Algorithm algo : algos.getAlgorithm()) {
            System.out.println("algo ClassId:=" + algo.getAlgorithmClassId());
            System.out.println("algo Id:=" + algo.getId());
            System.out.println("algo PlattformId:=" + algo.getPlatformId());
            System.out.println("algo Class:=" + algo.getClass());
            System.out.println("algo Description:="
                    + algo.getDescription().getValue());
            System.out.println("algo Name:=" + algo.getName().getValue());
        }
        assertTrue("No Algorithms found!", algos.getAlgorithm().size() > 0);
    }
}