source: protocol/src/test/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsProtocolTest.java@ 10

package geniusweb.protocol.tournament.allpermutations;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;

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

import geniusweb.events.ProtocolEvent;
import geniusweb.issuevalue.Bid;
import geniusweb.protocol.CurrentNegoState;
import geniusweb.protocol.NegoState;
import geniusweb.protocol.SessionResult;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.SessionProtocol;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.SessionState;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProtocolRef;
import tudelft.utilities.listener.Listener;
import tudelft.utilities.logging.ReportToLogger;

public class AllPermutationsProtocolTest {

        private final AllPermutationsState state = mock(AllPermutationsState.class),
                        newstate = mock(AllPermutationsState.class);
        private final ReportToLogger log = new ReportToLogger("test");
        private final AllPermutationsProtocol app = new AllPermutationsProtocol(
                        state, log);
        private final ProtocolToPartyConnFactory factory = mock(
                        ProtocolToPartyConnFactory.class);
        private final SessionSettings settings = mock(SessionSettings.class);
        private final SessionState finalsessionstate = mock(SessionState.class);
        private Bid agreement = mock(Bid.class);
        private final long NOW = 1000;

        @Before
        public void before() {
                when(state.getSize()).thenReturn(BigInteger.ZERO);
                when(finalsessionstate.isFinal(anyLong())).thenReturn(true);
                when(finalsessionstate.getSettings()).thenReturn(settings);
                when(finalsessionstate.getAgreement()).thenReturn(agreement);
                when(state.with(any())).thenReturn(newstate);
        }

        @Test
        public void smokeTest() {
        }

        @Test
        public void startTestNoSessions() {
                AllPermutationsProtocol app = new AllPermutationsProtocol(state, log);
                app.start(factory);

        }

        @Test
        public void getDescrTest() {
                assertNotNull(app.getDescription());
        }

        @Test
        public void getStateTest() {
                assertEquals(state, app.getState());
        }

        @Test
        public void getRefTest() {
                assertEquals("APP", app.getRef().getURI().toString());
        }

        @Test
        public void runOneSessionTest() throws InterruptedException {
                MockSessionProtocol sessionprotocol = startSession();
                sessionprotocol.getListener();
        }

        @Test
        public void runOneSessionAndUnhandledEvent() throws InterruptedException {
                MockSessionProtocol sessionprotocol = startSession();
                sessionprotocol.getListener().notifyChange(mock(ProtocolEvent.class));
                verify(state, times(0)).with(any());
        }

        /**
         * Check that a started session correctly handles a session event.
         */
        @Test
        public void CurrentNegoStateEventTest() throws InterruptedException {
                MockSessionProtocol sessionprotocol = startSession();

                CurrentNegoState evt = mock(CurrentNegoState.class);
                when(evt.getState()).thenReturn(finalsessionstate);
                sessionprotocol.getListener().notifyChange(evt);

                ArgumentCaptor<SessionResult> argument = ArgumentCaptor
                                .forClass(SessionResult.class);
                verify(state, times(1)).with(argument.capture());
                assertEquals(agreement, argument.getValue().getAgreement());
                assertNull(argument.getValue().getError());
        }

        private MockSessionProtocol startSession() throws InterruptedException {
                SessionSettings setting = mock(SessionSettings.class);
                MockSessionProtocol sessionprotocol = new MockSessionProtocol();
                when(setting.getProtocol(log)).thenReturn(sessionprotocol);
                when(state.getNextSettings()).thenReturn(setting);

                app.start(factory);
                Thread.sleep(500); // allow app to start session
                // this call should return fine, and have listener registered to our
                // protocol. app now waits for a notification
                return sessionprotocol;
        }

}

/**
 * 
 * The protocol needs to record the listners, we need a listener to trigger
 * further protocol actions. Mockito can't handle this, we mneed our own mock...
 *
 */
class MockSessionProtocol implements SessionProtocol {
        private final List<Listener<ProtocolEvent>> listeners = new LinkedList<>();

        @Override
        public void start(ProtocolToPartyConnFactory connectionfactory) {

        }

        @Override
        public String getDescription() {
                return null;
        }

        @Override
        public NegoState getState() {
                return null;
        }

        @Override
        public ProtocolRef getRef() {
                return null;
        }

        @Override
        public void addParticipant(PartyWithProfile party) {
        }

        @Override
        public void addListener(Listener<ProtocolEvent> l) {
                listeners.add(l);
        }

        @Override
        public void removeListener(Listener<ProtocolEvent> l) {
        }

        public Listener<ProtocolEvent> getListener() {
                if (listeners.size() != 1) {
                        throw new IllegalStateException("Not having exactly 1 listener");
                }
                return listeners.get(0);
        }

}