source: protocol/src/test/java/geniusweb/protocol/session/mopac/MOPACTest.java@ 32

package geniusweb.protocol.session.mopac;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
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.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import org.junit.Before;
import org.junit.Test;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.actions.Action;
import geniusweb.actions.Offer;
import geniusweb.actions.PartyId;
import geniusweb.inform.Inform;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.mopac.phase.OfferPhase;
import geniusweb.protocol.session.mopac.phase.Phase;
import geniusweb.protocol.session.mopac.phase.VotingPhase;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.repository.NoResourcesNowException;

public class MOPACTest {

        private final ObjectMapper jackson = new ObjectMapper();

        private static final PartyId PARTY1ID = new PartyId("party1");
        private static final PartyId PARTY2ID = new PartyId("party2");
        private static final PartyId PARTY3ID = new PartyId("party3");

        // don't try to mock settings, all parts are needed and mocking
        // makes the test unreadable.
        private final String setstr = "{\"MOPACSettings\":{\"participants\":["
                        + "{\"TeamInfo\":{\"parties\":[{\"party\":{\"partyref\":\"http://party1\",\"parameters\":{}},\"profile\":\"http://profile1\"}]}},"
                        + "{\"TeamInfo\":{\"parties\":[{\"party\":{\"partyref\":\"http://party2\",\"parameters\":{}},\"profile\":\"http://profile2\"}]}},"
                        + "{\"TeamInfo\":{\"parties\":[{\"party\":{\"partyref\":\"http://party3\",\"parameters\":{}},\"profile\":\"http://profile3\"}]}}],"
                        + "\"deadline\":{\"deadlinetime\":{\"durationms\":100}},\"votingevaluator\":{\"LargestAgreement\":{}}}}";

        private MOPACSettings settings;
        private Reporter logger = mock(Reporter.class);
        private MOPAC mopac;

        private final ProtocolToPartyConnFactory factory = mock(
                        ProtocolToPartyConnFactory.class);
        private final ProtocolToPartyConn conn1 = mock(ProtocolToPartyConn.class),
                        conn2 = mock(ProtocolToPartyConn.class),
                        conn3 = mock(ProtocolToPartyConn.class);

        private List<ProtocolToPartyConn> connections;

        @Before
        public void before() throws JsonParseException, JsonMappingException,
                        IOException, NoResourcesNowException {
                settings = jackson.readValue(setstr, MOPACSettings.class);
                mopac = settings.getProtocol(logger);

                connections = Arrays.asList(conn1, conn2, conn3);
                when(factory.connect(any(List.class))).thenReturn(connections);

                // hack the state.with(connection) stuff simplistically

                when(conn1.getParty()).thenReturn(PARTY1ID);
                when(conn2.getParty()).thenReturn(PARTY2ID);
                when(conn3.getParty()).thenReturn(PARTY3ID);
        }

        @Test
        public void testSmoke() {
        }

        @Test
        public void testGetDescr() {
                assertNotNull(mopac.getDescription());
        }

        @Test
        public void testInitialState() {
                MOPACState state = mopac.getState();
                assertEquals(settings, state.getSettings());
                assertTrue(state.getActions().isEmpty());
        }

        @Test
        public void testProtocol() {
                assertEquals("MOPAC", mopac.getRef().getURI().getPath());
        }

        @Test
        public void testWorkingCheckDeadline()
                        throws IOException, NoResourcesNowException, InterruptedException {

                mopac.start(factory);

                assertFalse(mopac.getState().isFinal(System.currentTimeMillis()));
                // we have deadline in 100ms so check
                Thread.sleep(200);
                assertTrue(mopac.getState().isFinal(System.currentTimeMillis()));
        }

        @Test
        public void testSubscribedToConnections() {
                mopac.start(factory);
                verify(conn1, times(1)).addListener(any());
                verify(conn2, times(1)).addListener(any());
                verify(conn3, times(1)).addListener(any());
        }

        @Test
        public void testActionIsBroadcast()
                        throws IOException, NoResourcesNowException, InterruptedException {

                mopac.start(factory);
                Action offer = mock(Offer.class);
                mopac.actionRequest(conn1, offer, 1l);

                // 1 time for YourTurn, one time for ActionDone.
                // but filtering ActionDone here (instead of Action) does not work,
                // maybe bug in Mockito?
                verify(conn1, times(2)).send(any(Inform.class));
        }

        /**
         * Fatal error occurs, run should fail
         */
        @Test(expected = RuntimeException.class)
        public void testPartyFailsConnect()
                        throws IOException, NoResourcesNowException {
                ProtocolToPartyConnFactory factory1 = mock(
                                ProtocolToPartyConnFactory.class);
                // irrecoverable fail test
                when(factory1.connect(any(List.class)))
                                .thenThrow(new IOException("Failed to connect to parties"));

                mopac.start(factory1);

        }

        /**
         * Nonfatal error occurs, protocol should retry till success
         */
        @Test
        public void testPartyFailsConnect2ndtimeOK()
                        throws IOException, NoResourcesNowException {
                long now = System.currentTimeMillis();
                ProtocolToPartyConnFactory factory1 = mock(
                                ProtocolToPartyConnFactory.class);
                // recoverable fail, and then success.
                when(factory1.connect(any(List.class)))
                                .thenThrow(new NoResourcesNowException("try again later",
                                                new Date(now + 100)))
                                .thenReturn(connections);

                mopac.start(factory1);

        }

        /**
         * Test that in Offer phase, and party does action, the next phase is
         * entered.
         */
        @Test
        public void testProceedsNextPhase() {
                // the state before the last party makes the offer
                MOPACState offerstate = mock(MOPACState.class);
                when(offerstate.getSettings()).thenReturn(settings);
                OfferPhase offerphase = mock(OfferPhase.class);
                when(offerphase.isFinal(anyLong())).thenReturn(false);
                when(offerstate.getPhase()).thenReturn(offerphase);

                // the phase where all parties placed an offer
                OfferPhase finalofferphase = mock(OfferPhase.class);
                when(finalofferphase.isFinal(anyLong())).thenReturn(true);
                MOPACState finalofferstate = mock(MOPACState.class);
                when(finalofferstate.getPhase()).thenReturn(finalofferphase);
                when(finalofferstate.finishPhase()).thenReturn(finalofferstate);

                when(offerstate.with(any(PartyId.class), any(Action.class), anyLong()))
                                .thenReturn(finalofferstate);

                // the phase where all parties can start voting.
                // this is the state to be reached.
                long now = System.currentTimeMillis();
                MOPACState votingstate = mock(MOPACState.class);
                Phase votingphase = mock(VotingPhase.class);
                PartyStates votingpartystates = mock(PartyStates.class);
                when(votingphase.getDeadline()).thenReturn(now + 100);
                when(votingphase.getPartyStates()).thenReturn(votingpartystates);
                when(votingstate.getPhase()).thenReturn(votingphase);

                when(finalofferstate.nextPhase(anyLong())).thenReturn(votingstate);

                mopac = new MOPAC(offerstate, logger);
                Offer action = mock(Offer.class);
                mopac.actionRequest(conn3, action, now);

                // check that the action result in reaching the voting phase
                assertEquals(votingstate, mopac.getState());
        }

}