source: protocol/src/test/java/geniusweb/protocol/session/learn/LearnTest.java@ 52

package geniusweb.protocol.session.learn;

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.isA;
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.net.URISyntaxException;
import java.util.Arrays;
import java.util.List;

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

import geniusweb.actions.EndNegotiation;
import geniusweb.actions.LearningDone;
import geniusweb.actions.PartyId;
import geniusweb.deadline.Deadline;
import geniusweb.deadline.DeadlineTime;
import geniusweb.inform.Finished;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.TeamInfo;
import geniusweb.references.Parameters;
import geniusweb.references.PartyRef;
import geniusweb.references.PartyWithParameters;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProfileRef;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.repository.NoResourcesNowException;

public class LearnTest {

        private final Reporter reporter = mock(Reporter.class);
        private Parameters params = new Parameters();
        private Deadline deadline = new DeadlineTime(1800);
        private PartyId party1id = new PartyId("party1");;
        private PartyId party2id = new PartyId("party2");;
        private final ProtocolToPartyConn conn1 = mock(ProtocolToPartyConn.class),
                        conn2 = mock(ProtocolToPartyConn.class);

        @Before
        public void before() {
                params = params.with("persistentstate",
                                "6bb5f909-0079-43ac-a8ac-a31794391074");
                params = params.with("negotiationdata",
                                Arrays.asList("12b5f909-0079-43ac-a8ac-a31794391012"));

        }

        @SuppressWarnings("unused")
        @Test
        public void smokeTest() {
                new Learn(mock(LearnState.class), mock(Reporter.class));
        }

        @Test
        public void getDescrTest() {
                Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));

                assertNotNull(l.getDescription());
        }

        @Test
        public void getStateTest() {
                LearnState state = mock(LearnState.class);
                Learn l = new Learn(state, mock(Reporter.class));
                assertEquals(state, l.getState());
        }

        @Test
        public void getRefTest() {
                Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));
                assertEquals("Learn", l.getRef().getURI().getPath().toString());
        }

        @Test
        public void finalStateNotificationTest() {
                // check that listeners get notified when session ends.

        }

        @Test
        public void testStartStopBasic() throws IOException,
                        NoResourcesNowException, InterruptedException, URISyntaxException {
                Learn learn = createBasicLearn();
                ProtocolToPartyConnFactory factory = createFactory();
                learn.start(factory);
                assertFalse(learn.getState().isFinal(System.currentTimeMillis()));
                Thread.sleep(2000);
                assertTrue(learn.getState().isFinal(System.currentTimeMillis()));
        }

        @Test
        public void testStartStopLearn() throws IOException,
                        NoResourcesNowException, InterruptedException, URISyntaxException {
                Learn learn = createBasicLearn();
                ProtocolToPartyConnFactory factory = createFactory();
                learn.start(factory);
                assertFalse(learn.getState().isFinal(System.currentTimeMillis()));

                // Instead of mocking connectin we call actionRequest directly
                learn.actionRequest(conn1, new LearningDone(party1id));
                assertFalse(learn.getState().isFinal(System.currentTimeMillis()));
                learn.actionRequest(conn2, new LearningDone(party2id));
                assertTrue(learn.getState().isFinal(System.currentTimeMillis()));
        }

        @Test(expected = IllegalStateException.class)
        public void testAddParty() {
                Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));
                l.addParticipant(mock(PartyWithProfile.class));
        }

        @Test
        public void isFinishSentNormally()
                        throws URISyntaxException, IOException, NoResourcesNowException {
                Learn learn = createBasicLearn();
                ProtocolToPartyConnFactory factory = createFactory();
                learn.start(factory);
                learn.actionRequest(conn1, new LearningDone(party1id));
                learn.actionRequest(conn2, new LearningDone(party2id));
                verify(conn1, times(1)).send(isA(Finished.class));
                verify(conn2, times(1)).send(isA(Finished.class));
        }

        @Test
        public void isFinishSentInError()
                        throws URISyntaxException, IOException, NoResourcesNowException {
                Learn learn = createBasicLearn();
                ProtocolToPartyConnFactory factory = createFactory();
                learn.start(factory);
                learn.actionRequest(conn1, new EndNegotiation(party1id));
                verify(conn1, times(1)).send(isA(Finished.class));
                verify(conn2, times(1)).send(isA(Finished.class));
        }

        private Learn createBasicLearn() throws URISyntaxException {
                TeamInfo team1 = createTeam(1);
                TeamInfo team2 = createTeam(2);
                LearnSettings settings = new LearnSettings(Arrays.asList(team1, team2),
                                deadline);
                return (Learn) settings.getProtocol(reporter);

        }

        private TeamInfo createTeam(int nr) throws URISyntaxException {
                PartyRef party1ref = new PartyRef("party" + nr);
                PartyWithParameters party1 = new PartyWithParameters(party1ref, params);
                ProfileRef profile1 = new ProfileRef("prof" + nr);
                PartyWithProfile partywithp1 = new PartyWithProfile(party1, profile1);
                List<PartyWithProfile> team1pp = Arrays.asList(partywithp1);
                TeamInfo team = new TeamInfo(team1pp);
                return team;
        }

        private ProtocolToPartyConnFactory createFactory()
                        throws IOException, NoResourcesNowException {
                when(conn1.getParty()).thenReturn(party1id);
                when(conn2.getParty()).thenReturn(party2id);

                ProtocolToPartyConnFactory factory = mock(
                                ProtocolToPartyConnFactory.class);
                // connections = mock(List.class);
                List<ProtocolToPartyConn> connections = Arrays.asList(conn1, conn2);
                when(factory.connect(any(List.class))).thenReturn(connections);
                return factory;
        }

}