LocatorSoapServiceTest.java

/*
 * #%L
 * Locator Service :: SOAP
 * %%
 * Copyright (C) 2011 - 2012 Talend Inc.
 * %%
 * 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.talend.esb.locator.service;

import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

import javax.xml.namespace.QName;
import javax.xml.transform.dom.DOMResult;
import javax.xml.ws.wsaddressing.W3CEndpointReference;
import javax.xml.ws.wsaddressing.W3CEndpointReferenceBuilder;

import org.easymock.EasyMock;
import org.easymock.EasyMockSupport;
import org.easymock.IArgumentMatcher;
import org.junit.Before;
import org.junit.Test;
import org.talend.schemas.esb.locator._2011._11.EntryType;
import org.talend.schemas.esb.locator._2011._11.LookupEndpointResponse;
import org.talend.schemas.esb.locator._2011._11.LookupEndpointsResponse;
import org.talend.schemas.esb.locator._2011._11.LookupRequestType;
import org.talend.schemas.esb.locator._2011._11.SLPropertiesType;
import org.talend.schemas.esb.locator._2011._11.BindingType;
import org.talend.schemas.esb.locator._2011._11.TransportType;
import org.talend.services.esb.locator.v1.InterruptedExceptionFault;
import org.talend.services.esb.locator.v1.ServiceLocatorFault;
import org.talend.esb.servicelocator.client.Endpoint;
import org.talend.esb.servicelocator.client.EndpointNotFoundException;
import org.talend.esb.servicelocator.client.SLEndpoint;
import org.talend.esb.servicelocator.client.SLPropertiesImpl;
import org.talend.esb.servicelocator.client.ServiceLocator;
import org.talend.esb.servicelocator.client.ServiceLocatorException;
import org.talend.esb.servicelocator.client.WrongArgumentException;
import org.talend.esb.servicelocator.client.internal.EndpointTransformerImpl;
import org.w3c.dom.Document;

public class LocatorSoapServiceTest extends EasyMockSupport {

    private ServiceLocator sl;
    private static QName SERVICE_NAME;
    private QName NOT_EXIST_SERVICE_NAME;
    private final String PROPERTY_KEY = "Key1";
    private final String PROPERTY_VALUE1 = "Value1";
    private final String PROPERTY_VALUE2 = "Value2";
    private final static String ENDPOINTURL = "http://Service";;
    private final static String QNAME_PREFIX1 = "http://services.talend.org/TestService";
    private final static String QNAME_LOCALPART1 = "TestServiceProvider";
    private final static String QNAME_PREFIX2 = "http://services.talend.org/NoNameService";
    private final static String QNAME_LOCALPART2 = "NoNameServiceProvider";
    private List<String> names;
    private LocatorSoapServiceImpl lps;
    private SLEndpoint endpoint;

    @Before
    public void setup() {

        sl = createMock(ServiceLocator.class);
        SERVICE_NAME = new QName(QNAME_PREFIX1, QNAME_LOCALPART1);
        NOT_EXIST_SERVICE_NAME = new QName(QNAME_PREFIX2, QNAME_LOCALPART2);
        names = new ArrayList<String>();
        lps = new LocatorSoapServiceImpl();
        lps.setLocatorClient(sl);
        lps.setLocatorEndpoints("localhost:2181");
        lps.setConnectionTimeout(5000);
        lps.setSessionTimeout(5000);
        endpoint = createMock(SLEndpoint.class);
    }

    @Test
    public void disconnectLocator() throws InterruptedException,
            ServiceLocatorException {
        sl.disconnect();
        EasyMock.expectLastCall();
        replayAll();
        lps.disconnectLocator();
    }

    @Test
    public void registerEndpoint() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {
        sl.register(endpoint(), EasyMock.eq(true));
        EasyMock.expectLastCall();
        LocatorSoapServiceImpl lps = new LocatorSoapServiceImpl();
        lps.setLocatorClient(sl);
        lps.registerEndpoint(SERVICE_NAME, ENDPOINTURL, null, null, null);
    }

    @Test(expected = ServiceLocatorFault.class)
    public void registerEndpointExpectedLocatorException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.register(endpoint(), EasyMock.eq(true));
        EasyMock.expectLastCall().andStubThrow(
                new ServiceLocatorException("test"));

        replayAll();
        lps.registerEndpoint(SERVICE_NAME, ENDPOINTURL, null, null, null);
    }

    @Test(expected = InterruptedExceptionFault.class)
    public void registerEndpointExpectedInterruptedException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.register(endpoint(), EasyMock.eq(true));
        EasyMock.expectLastCall()
                .andStubThrow(new InterruptedException("test"));

        replayAll();
        lps.registerEndpoint(SERVICE_NAME, ENDPOINTURL, null, null, null);
    }

    @Test
    public void registerEndpointWithBindingAndTransport()
            throws InterruptedExceptionFault, ServiceLocatorFault,
            ServiceLocatorException, InterruptedException {
        sl.register(endpoint(), EasyMock.eq(true));
        EasyMock.expectLastCall();

        replayAll();
        LocatorSoapServiceImpl lps = new LocatorSoapServiceImpl();
        lps.setLocatorClient(sl);
        lps.registerEndpoint(SERVICE_NAME, ENDPOINTURL, BindingType.SOAP_12,
                TransportType.HTTPS, null);
    }

    @Test
    public void registerEndpointWithOptionalParameter()
            throws InterruptedExceptionFault, ServiceLocatorFault {
        LocatorSoapServiceImpl lps = new LocatorSoapServiceImpl();
        lps.setLocatorClient(sl);

        SLPropertiesType value = new SLPropertiesType();
        EntryType e = new EntryType();

        e.setKey(PROPERTY_KEY);
        e.getValue().add(PROPERTY_VALUE1);
        e.getValue().add(PROPERTY_VALUE2);
        value.getEntry().add(e);

        lps.registerEndpoint(SERVICE_NAME, ENDPOINTURL, null, null, value);
    }
    
    @Test
    public void updateEndpointExpiringTime() throws Exception {
        final int ttl = 95;
        
        sl.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
        replay(sl);
        
        lps.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
        
        verify(sl);
    }
    
    @Test
    public void updateEndpointExpiringTimeMissingEndpoint() throws Exception {
        final int ttl = 95;
        
        sl.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
        expectLastCall().andThrow(new EndpointNotFoundException());
        replay(sl);
        
        try {
            lps.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
            fail();
        } catch (ServiceLocatorFault e) {
            // pass
        }
        
        verify(sl);
    }
    
    @Test
    public void updateEndpointExpiringTimeWrongTime() throws Exception {
        final int ttl = 95;
        
        sl.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
        expectLastCall().andThrow(new WrongArgumentException());
        replay(sl);
        
        try {
            lps.updateTimetolive(SERVICE_NAME, ENDPOINTURL, ttl);
            fail();
        } catch (ServiceLocatorFault e) {
            // pass
        }
        
        verify(sl);
    }

    @Test
    public void unregisterEndpoint() throws InterruptedExceptionFault,
            ServiceLocatorFault {
        LocatorSoapServiceImpl lps = new LocatorSoapServiceImpl();
        lps.setLocatorClient(sl);
        lps.unregisterEndpoint(SERVICE_NAME, ENDPOINTURL);
    }

    @Test(expected = ServiceLocatorFault.class)
    public void unregisterEndpointExpectedLocatorException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.unregister(SERVICE_NAME, ENDPOINTURL);
        EasyMock.expectLastCall().andStubThrow(
                new ServiceLocatorException("test"));
        replayAll();
        lps.unregisterEndpoint(SERVICE_NAME, ENDPOINTURL);
    }

    @Test(expected = InterruptedExceptionFault.class)
    public void unregisterEndpointExpectedInterruptedException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.unregister(SERVICE_NAME, ENDPOINTURL);
        EasyMock.expectLastCall()
                .andStubThrow(new InterruptedException("test"));
        replayAll();
        lps.unregisterEndpoint(SERVICE_NAME, ENDPOINTURL);
    }

    @Test
    public void lookUpEndpoint() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {
        names.clear();
        names.add(ENDPOINTURL);
        expect(sl.lookup(SERVICE_NAME)).andStubReturn(names);
        expect(sl.getEndpoint(SERVICE_NAME, ENDPOINTURL)).andStubReturn(
                endpoint);
        expect(endpoint.getProperties()).andStubReturn(
                SLPropertiesImpl.EMPTY_PROPERTIES);
        replayAll();

        W3CEndpointReference endpointRef, expectedRef;
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(SERVICE_NAME);
        builder.address(ENDPOINTURL);
        expectedRef = builder.build();

        endpointRef = lps.lookupEndpoint(SERVICE_NAME, null);

        assertTrue(endpointRef.toString().equals(expectedRef.toString()));

    }

    @Test
    public void lookUpEndpointWithReturnProps() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {
        names.clear();
        names.add(ENDPOINTURL);

        SLPropertiesImpl slPropertiesImpl = new SLPropertiesImpl();
        List<String> list = new ArrayList<String>();
        slPropertiesImpl.addProperty("test", list);

        expect(sl.lookup(SERVICE_NAME)).andStubReturn(names);
        expect(sl.getEndpoint(SERVICE_NAME, ENDPOINTURL)).andStubReturn(
                endpoint);
        expect(endpoint.getProperties()).andStubReturn(slPropertiesImpl);
        replayAll();

        W3CEndpointReference endpointRef, expectedRef;
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(SERVICE_NAME);
        builder.address(ENDPOINTURL);

        EndpointTransformerImpl transformer = new EndpointTransformerImpl();

        DOMResult result = new DOMResult();
        transformer.writePropertiesTo(slPropertiesImpl, result);
        Document docResult = (Document) result.getNode();

        builder.metadata(docResult.getDocumentElement());

        expectedRef = builder.build();

        endpointRef = lps.lookupEndpoint(SERVICE_NAME, null);

        assertTrue(endpointRef.toString().equals(expectedRef.toString()));

    }

    @Test
    public void lookUpEndpointWithLookupRequestType()
            throws InterruptedExceptionFault, ServiceLocatorFault,
            ServiceLocatorException, InterruptedException {
        names.clear();
        names.add(ENDPOINTURL);
        expect(sl.lookup(SERVICE_NAME)).andStubReturn(names);
        expect(sl.getEndpoint(SERVICE_NAME, ENDPOINTURL)).andStubReturn(
                endpoint);
        expect(endpoint.getProperties()).andStubReturn(
                SLPropertiesImpl.EMPTY_PROPERTIES);
        replayAll();

        W3CEndpointReference endpointRef, expectedRef;
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(SERVICE_NAME);
        builder.address(ENDPOINTURL);
        expectedRef = builder.build();

        LookupRequestType lrt = new LookupRequestType();
        lrt.setServiceName(SERVICE_NAME);
        LookupEndpointResponse ler = lps.lookupEndpoint(lrt);
        endpointRef = ler.getEndpointReference();
        assertTrue(endpointRef.toString().equals(expectedRef.toString()));

    }

    @Test(expected = ServiceLocatorFault.class)
    public void lookUpEndpointExpectedLocatorException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.lookup(SERVICE_NAME);
        EasyMock.expectLastCall().andStubThrow(
                new ServiceLocatorException("test"));
        replayAll();
        lps.lookupEndpoint(SERVICE_NAME, null);
    }

    @Test(expected = InterruptedExceptionFault.class)
    public void lookUpEndpointExpectedInterruptedException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.lookup(SERVICE_NAME);
        EasyMock.expectLastCall()
                .andStubThrow(new InterruptedException("test"));
        replayAll();
        lps.lookupEndpoint(SERVICE_NAME, null);
    }

    @Test(expected = ServiceLocatorFault.class)
    public void lookUpEndpointFault() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {

        expect(sl.lookup(NOT_EXIST_SERVICE_NAME)).andStubReturn(null);
        replayAll();

        lps.lookupEndpoint(NOT_EXIST_SERVICE_NAME, null);
    }

    @Test
    public void lookUpEndpointsWithLookupRequestType()
            throws InterruptedExceptionFault, ServiceLocatorFault,
            ServiceLocatorException, InterruptedException {

        names.clear();
        names.add(ENDPOINTURL);
        expect(sl.lookup(SERVICE_NAME)).andStubReturn(names);
        expect(sl.getEndpoint(SERVICE_NAME, ENDPOINTURL)).andStubReturn(
                endpoint);
        expect(endpoint.getProperties()).andStubReturn(
                SLPropertiesImpl.EMPTY_PROPERTIES);
        replayAll();

        W3CEndpointReference endpointRef, expectedRef;
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(SERVICE_NAME);
        builder.address(ENDPOINTURL);
        expectedRef = builder.build();

        LookupRequestType lrt = new LookupRequestType();
        lrt.setServiceName(SERVICE_NAME);
        LookupEndpointsResponse ler = lps.lookupEndpoints(lrt);
        endpointRef = ler.getEndpointReference().get(0);

        assertTrue(endpointRef.toString().equals(expectedRef.toString()));

    }

    @Test
    public void lookUpEndpoints() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {

        names.clear();
        names.add(ENDPOINTURL);
        expect(sl.lookup(SERVICE_NAME)).andStubReturn(names);
        expect(sl.getEndpoint(SERVICE_NAME, ENDPOINTURL)).andStubReturn(
                endpoint);
        expect(endpoint.getProperties()).andStubReturn(
                SLPropertiesImpl.EMPTY_PROPERTIES);
        replayAll();

        W3CEndpointReference endpointRef, expectedRef;
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(SERVICE_NAME);
        builder.address(ENDPOINTURL);
        expectedRef = builder.build();
        List<W3CEndpointReference> refs;

        refs = lps.lookupEndpoints(SERVICE_NAME, null);
        endpointRef = refs.get(0);

        assertTrue(endpointRef.toString().equals(expectedRef.toString()));

    }

    @Test(expected = ServiceLocatorFault.class)
    public void lookUpEndpointsExpectedLocatorException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.lookup(SERVICE_NAME);
        EasyMock.expectLastCall().andStubThrow(
                new ServiceLocatorException("test"));
        replayAll();
        lps.lookupEndpoints(SERVICE_NAME, null);
    }

    @Test(expected = InterruptedExceptionFault.class)
    public void lookUpEndpointsExpectedInterruptedException()
            throws ServiceLocatorException, InterruptedException,
            ServiceLocatorFault, InterruptedExceptionFault {
        sl.lookup(SERVICE_NAME);
        EasyMock.expectLastCall()
                .andStubThrow(new InterruptedException("test"));
        replayAll();
        lps.lookupEndpoints(SERVICE_NAME, null);
    }

    @Test(expected = ServiceLocatorFault.class)
    public void lookUpEndpointsFault() throws InterruptedExceptionFault,
            ServiceLocatorFault, ServiceLocatorException, InterruptedException {

        names.clear();
        names.add(ENDPOINTURL);
        expect(sl.lookup(NOT_EXIST_SERVICE_NAME)).andStubReturn(null);
        replayAll();

        lps.lookupEndpoints(NOT_EXIST_SERVICE_NAME, null);

    }

    public static Endpoint endpoint() {
        EasyMock.reportMatcher(new simpleEndpointMatcher());
        return null;
    }

    public static class simpleEndpointMatcher implements IArgumentMatcher {

        @Override
        public boolean matches(Object argument) {
            if (argument != null && argument instanceof Endpoint) {
                Endpoint result = (Endpoint) argument;
                if (!ENDPOINTURL.equals(result.getAddress()))
                    return false;
                if (!SERVICE_NAME.equals(result.getServiceName()))
                    return false;
            }
            return true;
        }

        @Override
        public void appendTo(StringBuffer buffer) {
        }
    }

}