RegisterEndpointProviderTest.java

/*
 * #%L
 * Service Locator Client for CXF
 * %%
 * 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.servicelocator.client.internal;

import javax.xml.namespace.QName;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.data.Stat;
import org.easymock.Capture;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.talend.esb.servicelocator.TestContent;
import org.talend.esb.servicelocator.client.BindingType;
import org.talend.esb.servicelocator.client.Endpoint;
import org.talend.esb.servicelocator.client.SLEndpoint;
import org.talend.esb.servicelocator.client.ServiceLocatorException;
import org.talend.esb.servicelocator.client.TransportType;

import static org.apache.zookeeper.CreateMode.EPHEMERAL;
import static org.apache.zookeeper.CreateMode.PERSISTENT;
import static org.easymock.EasyMock.anyLong;
import static org.easymock.EasyMock.aryEq;
import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertTrue;
import static org.talend.esb.servicelocator.TestValues.*;
import static org.talend.esb.servicelocator.client.internal.PathValues.*;
import static org.talend.esb.servicelocator.client.internal.EndpointStubFactory.create;

public class RegisterEndpointProviderTest extends AbstractServiceLocatorImplTest {

    public static final byte[] OLD_DATA = TestContent.CONTENT_ANY_1;

    public static final byte[] NEW_DATA = TestContent.CONTENT_ANY_2;

    private EndpointTransformer trans = createMock(EndpointTransformer.class);

    private SLEndpoint slEndpointStub;
 
    @Before
    public void setUp() throws Exception {
        super.setUp();
        
        slEndpointStub = createMock(SLEndpoint.class);
        expect(slEndpointStub.getLastTimeStopped()).andStubReturn(LAST_TIME_STOPPED);
        expect(slEndpointStub.getLastTimeStarted()).andStubReturn(LAST_TIME_STARTED);
    }

    @Ignore
    @Test
    public void registerServiceExistsEndpointExistsCheckLastTimes() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);
        Capture<Long> lastTimeStartedCapture = new Capture<Long>();

        serviceExists(SERVICE_PATH_1);
        endpointExists(ENDPOINT_PATH_11);
        getData(ENDPOINT_PATH_11, OLD_DATA);
        data2Ep(SERVICE_QNAME_1, OLD_DATA);
        ep2Data(endpoint, lastTimeStartedCapture, LAST_TIME_STOPPED, NEW_DATA);
        setData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11);
        
        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);

        long beforeRegister = System.currentTimeMillis();
        slc.register(endpoint);
        long afterRegister = System.currentTimeMillis();

        verifyAll();
        long lastTimeStarted = lastTimeStartedCapture.getValue();
        assertTrue(beforeRegister <= lastTimeStarted && lastTimeStarted <= afterRegister);
    }

    @Ignore
    @Test
    public void registerEndpointStatusExists() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        serviceExists(SERVICE_PATH_1);
        endpointExists(ENDPOINT_PATH_11);
        getData(ENDPOINT_PATH_11, OLD_DATA);
        data2Ep(SERVICE_QNAME_1, OLD_DATA);
        ep2Data(endpoint, NEW_DATA);
        setData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatusFails(ENDPOINT_PATH_11);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);

        slc.register(endpoint);

        verifyAll();
    }

    @Ignore
    @Test
    public void registerServiceExistsEndpointExistsNot() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        serviceExists(SERVICE_PATH_1);
        endpointExistsNot(ENDPOINT_PATH_11);

        ep2Data(endpoint, NEW_DATA);
        createEndpointAndSetData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);
        slc.register(endpoint);

        verifyAll();
    }

    @Ignore
    @Test
    public void registerEndpointPersistently() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        serviceExists(SERVICE_PATH_1);

        endpointExistsNot(ENDPOINT_PATH_11);
        ep2Data(endpoint, NEW_DATA);
        createEndpointAndSetData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11, true);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);
        slc.register(endpoint, true);

        verifyAll();
    }

    @Ignore
    @Test
    public void registerServiceExistsNot() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        serviceExistsNot(SERVICE_PATH_1);
        createService(SERVICE_PATH_1);

        endpointExistsNot(ENDPOINT_PATH_11);
        ep2Data(endpoint, NEW_DATA);
        createEndpointAndSetData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);
        slc.register(endpoint);

        verifyAll();
    }

    @Ignore
    @Test
    public void registerServiceExistsNotWithAuthentication() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        setAuthentication(true);
        zkMock.addAuthInfo(eq("sl"), aryEq(USER_NAME_PASSWORD_BYTES));
        
        serviceExistsNot(SERVICE_PATH_1);
        createService(SERVICE_PATH_1);

        endpointExistsNot(ENDPOINT_PATH_11);
        ep2Data(endpoint, NEW_DATA);
        createEndpointAndSetData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);
//        slc.setName(USER_NAME);
//        slc.setPassword(PASSWORD);
        slc.register(endpoint);

        verifyAll();
    }

    @Ignore
    @Test
    public void registerServiceExistsNotButConcurrentlyCreated() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1);

        serviceExistsNot(SERVICE_PATH_1);
        createServiceFails(SERVICE_PATH_1);

        endpointExistsNot(ENDPOINT_PATH_11);
        ep2Data(endpoint, NEW_DATA);
        createEndpointAndSetData(ENDPOINT_PATH_11, NEW_DATA);

        createEndpointStatus(ENDPOINT_PATH_11);


        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);
        slc.register(endpoint);

        verifyAll();
    }

    @Ignore
    @Test
    public void unregister() throws Exception {
        Endpoint endpoint = create(SERVICE_QNAME_1, ENDPOINT_1, BindingType.JAXRS, TransportType.HTTP);

        Capture<Long> lastTimeStoppedCapture = new Capture<Long>();

        endpointExists(ENDPOINT_PATH_11);
        getData(ENDPOINT_PATH_11, OLD_DATA);
        data2Ep(SERVICE_QNAME_1, OLD_DATA);

        deleteEndpointStatus(ENDPOINT_PATH_11);
        ep2Data(endpoint, LAST_TIME_STARTED, lastTimeStoppedCapture, NEW_DATA);
        setData(ENDPOINT_PATH_11, NEW_DATA);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);

        long beforeUnregister = System.currentTimeMillis();
        slc.unregister(endpoint);
        long afterUnregister = System.currentTimeMillis();

        verifyAll();

        long lastTimeStopped = lastTimeStoppedCapture.getValue();
        assertTrue(beforeUnregister <= lastTimeStopped && lastTimeStopped <= afterUnregister);
    }

    @Ignore
    @Test
    public void unregisterEndpointExistsNot() throws Exception {
        endpointExistsNot(ENDPOINT_PATH_11);

        Endpoint eprProvider = create(SERVICE_QNAME_1, ENDPOINT_1);

        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);

        slc.unregister(eprProvider);

        verifyAll();
    }

    @Ignore
    @Test
    public void unregisterEndpointDeleteFails() throws Exception {
        endpointExists(ENDPOINT_PATH_11);
        getData(ENDPOINT_PATH_11, OLD_DATA);
        data2Ep(SERVICE_QNAME_1, OLD_DATA);

        delete(ENDPOINT_STATUS_PATH_11, new KeeperException.RuntimeInconsistencyException());

        Endpoint eprProvider = create(SERVICE_QNAME_1, ENDPOINT_1);
        replayAll();

        ServiceLocatorImpl slc = createServiceLocatorSuccess();
        slc.setEndpointTransformer(trans);

        try {
            slc.unregister(eprProvider);
            fail("A ServiceLocatorException should have been thrown.");
        } catch (ServiceLocatorException e) {
            ignore("Expected exception");
        }

        verifyAll();
    }

    public void ep2Data(Endpoint endpoint, Capture<Long> lastTimeStartedCapture, long lastTimeStopped, byte[] content)
    throws ServiceLocatorException {
        expect(trans.fromEndpoint(eq(endpoint), capture(lastTimeStartedCapture), eq(lastTimeStopped)))
        .andReturn(content);
    }

    public void ep2Data(Endpoint endpoint, long lastTimeStarted, Capture<Long> lastTimeStoppedCapture, byte[] content)
    throws ServiceLocatorException {
        expect(trans.fromEndpoint(eq(endpoint), eq(lastTimeStarted), capture(lastTimeStoppedCapture) ))
        .andReturn(content);
    }

    public void ep2Data(Endpoint endpoint, byte[] content)
    throws ServiceLocatorException {
        expect(trans.fromEndpoint(eq(endpoint), anyLong(), anyLong()))
        .andReturn(content);
    }

    public void data2Ep(QName serviceName, byte[] content) {
        expect(trans.toSLEndpoint(serviceName, content, false)).andReturn(slEndpointStub);        
    }

    private void serviceExists(String path) throws KeeperException, InterruptedException {
        pathExists(path);
    }

    private void serviceExistsNot(String path) throws KeeperException, InterruptedException {
        pathExistsNot(path);
    }

    private void endpointExists(String path) throws KeeperException, InterruptedException {
        expect(zkMock.exists(path, false)).andReturn(new Stat()).atLeastOnce();
    }

    private void endpointExistsNot(String path) throws KeeperException, InterruptedException {
        expect(zkMock.exists(path, false)).andReturn(null).atLeastOnce();
    }

    private void createService(String path) throws KeeperException, InterruptedException {
        createNode(path, PERSISTENT);
    }

    private void createServiceFails(String path) throws KeeperException, InterruptedException {
        createNode(path, PERSISTENT, new KeeperException.NodeExistsException());
    }

    private void createEndpointAndSetData(String path, byte[] content) throws KeeperException, InterruptedException {
        expect(zkMock.create(path, content, getACLs(), PERSISTENT)).andReturn(path);
    }

    private void createEndpointStatus(String endpointPath)
        throws KeeperException, InterruptedException {
        createEndpointStatus(endpointPath, false);
    }

    private void createEndpointStatus(String endpointPath, boolean persistent)
        throws KeeperException, InterruptedException {
        String endpointStatusPath = endpointPath + "/" + STATUS_NODE;
        CreateMode mode = persistent ? PERSISTENT : EPHEMERAL; 

        createNode(endpointStatusPath, mode);
    }

    private void deleteEndpointStatus(String endpointPath)
        throws KeeperException, InterruptedException {
        String endpointStatusPath = endpointPath + "/" + STATUS_NODE;
        delete(endpointStatusPath);
    }   

    private void createEndpointStatusFails(String endpointPath)
        throws KeeperException, InterruptedException {
        String endpointStatusPath = endpointPath + "/" + STATUS_NODE;
        createNode(endpointStatusPath, EPHEMERAL, new KeeperException.NodeExistsException());
    }
}