source: protocol/src/test/java/geniusweb/protocol/session/mopac2/MOPAC2Test.java@ 52

package geniusweb.protocol.session.mopac2;

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.mopac2.phase.OfferPhase;
import geniusweb.protocol.session.mopac2.phase.Phase;
import geniusweb.protocol.session.mopac2.phase.VotingPhase;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.repository.NoResourcesNowException;

public class MOPAC2Test {

        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.
        // notice, 3 parties, this differs from MopacSettingsTest output.
        private final String setstr = "{\"MOPAC2Settings\":{\"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\":{\"LargestAgreementWithValue\":{}}}}";

        // {"MOPAC2Settings":{"participants":[{"TeamInfo":{"parties":[{"party":{"partyref":"http://party1","parameters":{}},"profile":"http://profile1"}]}},{"TeamInfo":{"parties":[{"party":{"partyref":"http://party2","parameters":{}},"profile":"http://profile2"}]}}],"deadline":{"deadlinetime":{"durationms":100}},"votingevaluator":{"LargestAgreementWithValue":{}}}}

        private MOPAC2Settings settings;
        private Reporter logger = mock(Reporter.class);
        private MOPAC2 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, MOPAC2Settings.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() {
                MOPAC2State state = mopac.getState();
                assertEquals(settings, state.getSettings());
                assertTrue(state.getActions().isEmpty());
        }

        @Test
        public void testProtocol() {
                assertEquals("MOPAC2", 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
                MOPAC2State offerstate = mock(MOPAC2State.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);
                MOPAC2State finalofferstate = mock(MOPAC2State.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();
                MOPAC2State votingstate = mock(MOPAC2State.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 MOPAC2(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());
        }

}