TestStatementAwareListener.java

/*
 * *************************************************************************************
 *  Copyright (C) 2008 EsperTech, Inc. All rights reserved.                            *
 *  http://esper.codehaus.org                                                          *
 *  http://www.espertech.com                                                           *
 *  ---------------------------------------------------------------------------------- *
 *  The software in this package is published under the terms of the GPL license       *
 *  a copy of which has been included with this distribution in the license.txt file.  *
 * *************************************************************************************
 */

package com.espertech.esper.regression.client;

import com.espertech.esper.client.scopetest.EPAssertionUtil;
import com.espertech.esper.client.scopetest.SupportUpdateListener;
import junit.framework.TestCase;
import com.espertech.esper.client.*;
import com.espertech.esper.client.EventBean;
import com.espertech.esper.support.bean.SupportBean;
import com.espertech.esper.support.client.SupportConfigFactory;
import com.espertech.esper.support.util.SupportStmtAwareUpdateListener;

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

public class TestStatementAwareListener extends TestCase
{
    private EPServiceProvider epService;
    private SupportStmtAwareUpdateListener listener;

    public void setUp()
    {
        Configuration configuration = SupportConfigFactory.getConfiguration();
        configuration.addEventType("Bean", SupportBean.class.getName());
        epService = EPServiceProviderManager.getDefaultProvider(configuration);
        epService.initialize();

        listener = new SupportStmtAwareUpdateListener();
    }

    public void tearDown() {
        listener = null;
    }

    public void testStmtAware()
    {
        String stmtText = "select * from Bean";
        EPStatement statement = epService.getEPAdministrator().createEPL(stmtText);
        statement.addListener(listener);

        epService.getEPRuntime().sendEvent(new SupportBean());
        assertTrue(listener.isInvoked());
        assertEquals(1, listener.getStatementList().size());
        assertEquals(statement, listener.getStatementList().get(0));
        assertEquals(1, listener.getSvcProviderList().size());
        assertEquals(epService, listener.getSvcProviderList().get(0));
    }

    public void testInvalid()
    {
        String stmtText = "select * from Bean";
        EPStatement statement = epService.getEPAdministrator().createEPL(stmtText);
        StatementAwareUpdateListener listener = null;
        try
        {
            statement.addListener(listener);
            fail();
        }
        catch (IllegalArgumentException ex)
        {
            // expected
        }
    }

    public void testBothListeners()
    {
        String stmtText = "select * from Bean";
        EPStatement statement = epService.getEPAdministrator().createEPL(stmtText);

        SupportStmtAwareUpdateListener awareListeners[] = new SupportStmtAwareUpdateListener[3];
        SupportUpdateListener updateListeners[] = new SupportUpdateListener[awareListeners.length];
        for (int i = 0; i < awareListeners.length; i++)
        {
            awareListeners[i] = new SupportStmtAwareUpdateListener();
            statement.addListener(awareListeners[i]);
            updateListeners[i] = new SupportUpdateListener();
            statement.addListener(updateListeners[i]);
        }        

        Object theEvent = new SupportBean();
        epService.getEPRuntime().sendEvent(theEvent);
        for (int i = 0; i < awareListeners.length; i++)
        {
            assertSame(theEvent, updateListeners[i].assertOneGetNewAndReset().getUnderlying());
            assertSame(theEvent, awareListeners[i].assertOneGetNewAndReset().getUnderlying());
        }

        statement.removeListener(awareListeners[1]);
        theEvent = new SupportBean();
        epService.getEPRuntime().sendEvent(theEvent);
        for (int i = 0; i < awareListeners.length; i++)
        {
            if(i == 1)
            {
                assertSame(theEvent, updateListeners[i].assertOneGetNewAndReset().getUnderlying());
                assertFalse(awareListeners[i].isInvoked());
            }
            else
            {
                assertSame(theEvent, updateListeners[i].assertOneGetNewAndReset().getUnderlying());
                assertSame(theEvent, awareListeners[i].assertOneGetNewAndReset().getUnderlying());
            }
        }

        statement.removeListener(updateListeners[1]);
        theEvent = new SupportBean();
        epService.getEPRuntime().sendEvent(theEvent);
        for (int i = 0; i < awareListeners.length; i++)
        {
            if(i == 1)
            {
                assertFalse(updateListeners[i].isInvoked());
                assertFalse(awareListeners[i].isInvoked());
            }
            else
            {
                assertSame(theEvent, updateListeners[i].assertOneGetNewAndReset().getUnderlying());
                assertSame(theEvent, awareListeners[i].assertOneGetNewAndReset().getUnderlying());
            }
        }

        statement.addListener(updateListeners[1]);
        statement.addListener(awareListeners[1]);
        theEvent = new SupportBean();
        epService.getEPRuntime().sendEvent(theEvent);
        for (int i = 0; i < awareListeners.length; i++)
        {
            assertSame(theEvent, updateListeners[i].assertOneGetNewAndReset().getUnderlying());
            assertSame(theEvent, awareListeners[i].assertOneGetNewAndReset().getUnderlying());
        }

        statement.removeAllListeners();
        for (int i = 0; i < awareListeners.length; i++)
        {
            assertFalse(updateListeners[i].isInvoked());
            assertFalse(awareListeners[i].isInvoked());
        }
    }
    
    public void testUseOnMultipleStmts()
    {
        EPStatement statementOne = epService.getEPAdministrator().createEPL("select * from Bean(theString='A' or theString='C')");
        EPStatement statementTwo = epService.getEPAdministrator().createEPL("select * from Bean(theString='B' or theString='C')");

        SupportStmtAwareUpdateListener awareListener = new SupportStmtAwareUpdateListener();
        statementOne.addListener(awareListener);
        statementTwo.addListener(awareListener);

        epService.getEPRuntime().sendEvent(new SupportBean("B", 1));
        assertEquals("B", awareListener.assertOneGetNewAndReset().get("theString"));

        epService.getEPRuntime().sendEvent(new SupportBean("A", 1));
        assertEquals("A", awareListener.assertOneGetNewAndReset().get("theString"));

        epService.getEPRuntime().sendEvent(new SupportBean("C", 1));
        assertEquals(2, awareListener.getNewDataList().size());
        assertEquals("C", awareListener.getNewDataList().get(0)[0].get("theString"));
        assertEquals("C", awareListener.getNewDataList().get(1)[0].get("theString"));
        EPStatement stmts[] = awareListener.getStatementList().toArray(new EPStatement[0]);
        EPAssertionUtil.assertEqualsAnyOrder(stmts, new Object[]{statementOne, statementTwo});
    }

    public void testOrderOfInvocation()
    {
        String stmtText = "select * from Bean";
        EPStatement statement = epService.getEPAdministrator().createEPL(stmtText);

        MyStmtAwareUpdateListener awareListeners[] = new MyStmtAwareUpdateListener[2];
        MyUpdateListener updateListeners[] = new MyUpdateListener[awareListeners.length];
        List<Object> invoked = new ArrayList<Object>();
        for (int i = 0; i < awareListeners.length; i++)
        {
            awareListeners[i] = new MyStmtAwareUpdateListener(invoked);
            updateListeners[i] = new MyUpdateListener(invoked);
        }

        statement.addListener(awareListeners[0]);
        statement.addListener(updateListeners[1]);
        statement.addListener(updateListeners[0]);
        statement.addListener(awareListeners[1]);

        epService.getEPRuntime().sendEvent(new SupportBean());

        assertEquals(updateListeners[1], invoked.get(0));
        assertEquals(updateListeners[0], invoked.get(1));
        assertEquals(awareListeners[0], invoked.get(2));
        assertEquals(awareListeners[1], invoked.get(3));

        try
        {
            Iterator<UpdateListener> itOne = statement.getUpdateListeners();
            itOne.next();
            itOne.remove();
            fail();
        }
        catch (UnsupportedOperationException ex)
        {
            // expected
        }

        try
        {
            Iterator<StatementAwareUpdateListener> itOne = statement.getStatementAwareListeners();
            itOne.next();
            itOne.remove();
            fail();
        }
        catch (UnsupportedOperationException ex)
        {
            // expected
        }

        Iterator<UpdateListener> itOne = statement.getUpdateListeners();
        assertEquals(updateListeners[1], itOne.next());
        assertEquals(updateListeners[0], itOne.next());
        assertFalse(itOne.hasNext());

        Iterator<StatementAwareUpdateListener> itTwo = statement.getStatementAwareListeners();
        assertEquals(awareListeners[0], itTwo.next());
        assertEquals(awareListeners[1], itTwo.next());
        assertFalse(itTwo.hasNext());

        statement.removeAllListeners();
        assertFalse(statement.getStatementAwareListeners().hasNext());
        assertFalse(statement.getUpdateListeners().hasNext());

    }

    public class MyUpdateListener implements UpdateListener
    {
        private List<Object> invoked;

        public MyUpdateListener(List<Object> invoked)
        {
            this.invoked = invoked;
        }

        public void update(EventBean[] newEvents, EventBean[] oldEvents)
        {
            invoked.add(this);
        }
    }

    public class MyStmtAwareUpdateListener implements StatementAwareUpdateListener
    {
        private List<Object> invoked;

        public MyStmtAwareUpdateListener(List<Object> invoked)
        {
            this.invoked = invoked;
        }

        public void update(EventBean[] newEvents, EventBean[] oldEvents, EPStatement statement, EPServiceProvider epServiceProvider)
        {
            invoked.add(this);
        }
    }
}