source: simplerunner/src/test/java/geniusweb/simplerunner/SessionRunnerTest.java@ 39

package geniusweb.simplerunner;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.logging.Level;

import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

import geniusweb.actions.PartyId;
import geniusweb.protocol.CurrentNegoState;
import geniusweb.protocol.NegoState;
import geniusweb.protocol.ProtocolException;
import geniusweb.protocol.session.SessionProtocol;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.SessionState;
import tudelft.utilities.listener.Listener;
import tudelft.utilities.logging.ReportToLogger;
import tudelft.utilities.logging.Reporter;

public class SessionRunnerTest {
        private static final ProtocolException PROTOCOL_EXC = new ProtocolException(
                        "fake protocol exception", new PartyId("test"));
        private CurrentNegoState finishedEvent;
        private final long NOW = 1000;
        private final Reporter logger = new ReportToLogger("test");

        @Before
        public void before() {
                finishedEvent = mock(CurrentNegoState.class);
                SessionState finishedstate = mock(SessionState.class);
                when(finishedstate.isFinal(anyLong())).thenReturn(true);
                when(finishedEvent.getState()).thenReturn(finishedstate);

        }

        @SuppressWarnings("unchecked")
        @Test
        public void smokeTest() {
                new NegoRunner(mock(SessionSettings.class),
                                mock(ClassPathConnectionFactory.class), logger, 5000);
        }

        @Test
        public void testRun() {
                SessionSettings settings = mock(SessionSettings.class);
                SessionProtocol protocol = mock(SessionProtocol.class);
                when(settings.getProtocol(logger)).thenReturn(protocol);
                @SuppressWarnings("unchecked")
                ClassPathConnectionFactory factory = mock(
                                ClassPathConnectionFactory.class);

                NegoRunner runner = spy(
                                new NegoRunner(settings, factory, logger, 5000));
                runner.run();

                verify(protocol, times(1)).addListener(any());
                verify(protocol, times(1)).start(factory);

                verify(runner, times(0)).stop();

        }

        @Test
        public void testStopNormally() {
                SessionSettings settings = mock(SessionSettings.class);
                SessionProtocol protocol = mock(SessionProtocol.class);
                when(settings.getProtocol(any())).thenReturn(protocol);
                SessionState state = mock(SessionState.class);
                when(protocol.getState()).thenReturn(state);
                Reporter logger = mock(Reporter.class);
                @SuppressWarnings("unchecked")
                ClassPathConnectionFactory factory = mock(
                                ClassPathConnectionFactory.class);
                NegoRunner runner = spy(
                                new NegoRunner(settings, factory, logger, 5000) {
                                        @Override
                                        protected void logFinal(Level level, NegoState state) {
                                                log.log(level, state.toString());
                                        }
                                });
                ArgumentCaptor<Listener> listener = ArgumentCaptor
                                .forClass(Listener.class);
                runner.run();

                verify(protocol, times(1)).addListener(listener.capture());

                // make the finixhed event.... too complex...
                listener.getValue().notifyChange(finishedEvent);
                verify(runner, times(1)).stop();
                verify(logger, times(0)).log(eq(Level.WARNING), any(String.class));

        }

        @Test
        public void testStopWithError() throws InterruptedException {
                Reporter logger = mock(Reporter.class);
                SessionSettings settings = mock(SessionSettings.class);
                SessionProtocol protocol = mock(SessionProtocol.class);
                when(settings.getProtocol(any())).thenReturn(protocol);
                SessionState state = mock(SessionState.class);
                when(protocol.getState()).thenReturn(state);
                @SuppressWarnings("unchecked")
                ClassPathConnectionFactory factory = mock(
                                ClassPathConnectionFactory.class);
                NegoRunner runner = spy(
                                new NegoRunner(settings, factory, logger, 5000) {
                                        @Override
                                        protected void logFinal(Level level, NegoState state) {
                                                log.log(level, state.toString());
                                        }
                                });
                ArgumentCaptor<Listener> listener = ArgumentCaptor
                                .forClass(Listener.class);
                runner.run();

                verify(protocol, times(1)).addListener(listener.capture());

                listener.getValue().notifyChange(finishedEvent);
                verify(runner, times(1)).stop();
                // check final state is logged
                String statestr = state.toString();
                verify(logger, times(1)).log(any(), eq(statestr));

        }

}