gibberish slck (Issue #241) and a better meta contact list ordering policy (Issue #316)

tests for OperationSetBasicInstantMessagingGibberishImpl

1 files changed, 479 insertions, 0 deletions

diff --git a/test/net/java/sip/communicator/slick/protocol/gibberish/TestOperationSetBasicInstantMessaging.java b/test/net/java/sip/communicator/slick/protocol/gibberish/TestOperationSetBasicInstantMessaging.java
new file mode 100644
index 0000000..5323000
--- /dev/null
+++ b/test/net/java/sip/communicator/slick/protocol/gibberish/TestOperationSetBasicInstantMessaging.java
@@ -0,0 +1,479 @@
+/*
+ * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
+ *
+ * Distributable under LGPL license.
+ * See terms of license at gnu.org.
+ */
+package net.java.sip.communicator.slick.protocol.gibberish;
+
+import java.net.*;
+import java.util.*;
+
+import junit.framework.*;
+import net.java.sip.communicator.service.protocol.*;
+import net.java.sip.communicator.service.protocol.Message;
+import net.java.sip.communicator.service.protocol.event.*;
+import net.java.sip.communicator.util.*;
+
+/**
+ * Performs testing of the basic instant messaging operation set. Tests include
+ * going over basic functionality such as sending a message from the tested
+ * implementation and asserting reception by the tester agent and vice versa.
+ *
+ * @author Emil Ivov
+ */
+public class TestOperationSetBasicInstantMessaging
+    extends TestCase
+{
+    private static final Logger logger =
+        Logger.getLogger(TestOperationSetBasicInstantMessaging.class);
+
+    private GibberishSlickFixture fixture = new GibberishSlickFixture();
+
+    private OperationSetBasicInstantMessaging opSetBasicIM1 = null;
+    private OperationSetBasicInstantMessaging opSetBasicIM2 = null;
+
+    private OperationSetPresence opSetPresence1 = null;
+    private OperationSetPresence opSetPresence2 = null;
+
+    public TestOperationSetBasicInstantMessaging(String name)
+    {
+        super(name);
+    }
+
+    /**
+     * Get a reference to the basic IM operation set.
+     * @throws Exception if this is not a good day.
+     */
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        fixture.setUp();
+
+        Map supportedOperationSets1 =
+            fixture.provider1.getSupportedOperationSets();
+
+        if ( supportedOperationSets1 == null
+            || supportedOperationSets1.size() < 1)
+            throw new NullPointerException(
+                "No OperationSet implementations are supported by "
+                +"this implementation. ");
+
+        //get the operation set presence here.
+        opSetBasicIM1 =
+            (OperationSetBasicInstantMessaging)supportedOperationSets1.get(
+                OperationSetBasicInstantMessaging.class.getName());
+
+        if (opSetBasicIM1 == null)
+        {
+            throw new NullPointerException(
+                "No implementation for basic IM was found");
+        }
+
+        //we also need the presence op set in order to retrieve contacts.
+        opSetPresence1 =
+            (OperationSetPresence)supportedOperationSets1.get(
+                OperationSetPresence.class.getName());
+
+        //if the op set is null show that we're not happy.
+        if (opSetPresence1 == null)
+        {
+            throw new NullPointerException(
+                "An implementation of the service must provide an "
+                + "implementation of at least one of the PresenceOperationSets");
+        }
+
+        Map supportedOperationSets2 =
+            fixture.provider2.getSupportedOperationSets();
+
+        if ( supportedOperationSets2 == null
+            || supportedOperationSets2.size() < 1)
+            throw new NullPointerException(
+                "No OperationSet implementations are supported by "
+                +"this implementation. ");
+
+        //get the operation set presence here.
+        opSetBasicIM2 =
+            (OperationSetBasicInstantMessaging)supportedOperationSets2.get(
+                OperationSetBasicInstantMessaging.class.getName());
+
+        if (opSetBasicIM2 == null)
+        {
+            throw new NullPointerException(
+                "No implementation for basic IM was found");
+        }
+
+        opSetPresence2 =
+            (OperationSetPresence) supportedOperationSets2.get(
+                OperationSetPresence.class.getName());
+
+        //if the op set is null show that we're not happy.
+        if (opSetPresence2 == null)
+        {
+            throw new NullPointerException(
+                "An implementation of the service must provide an "
+                + "implementation of at least one of the PresenceOperationSets");
+        }
+
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+
+        fixture.tearDown();
+    }
+
+    /**
+     * Creates a test suite containing tests of this class in a specific order.
+     * We'll first execute tests beginning with the "test" prefix and then go to
+     * ordered tests.We first execture tests for receiving messagese, so that
+     * a volatile contact is created for the sender. we'll then be able to
+     * retrieve this volatile contact and send them a message on our turn.
+     * We need to do things this way as the contact corresponding to the tester
+     * agent has been removed in the previous test and we no longer have it
+     * in our contact list.
+     *
+     * @return Test a testsuite containing all tests to execute.
+     */
+    public static Test suite()
+    {
+        TestSuite suite = new TestSuite();
+
+        suite.addTest(new TestOperationSetBasicInstantMessaging(
+                                "prepareContactList"));
+
+        suite.addTestSuite(TestOperationSetBasicInstantMessaging.class);
+
+        //the following 2 need to be run in the specified order.
+        suite.addTest(new TestOperationSetBasicInstantMessaging(
+                                "firstTestReceiveMessage"));
+        suite.addTest(new TestOperationSetBasicInstantMessaging(
+                                "thenTestSendMessage"));
+
+        return suite;
+    }
+
+    /**
+     * Create the list to be sure that contacts exchanging messages
+     * exists in each other lists
+     * @throws Exception
+     */
+    public void prepareContactList()
+        throws Exception
+    {
+        fixture.clearProvidersLists();
+
+        Object o = new Object();
+        synchronized(o)
+        {
+            o.wait(2000);
+        }
+
+        try
+        {
+            opSetPresence1.subscribe(fixture.userID2);
+        }
+        catch (OperationFailedException ex)
+        {
+            // the contact already exist its OK
+        }
+
+        try
+        {
+            opSetPresence2.subscribe(fixture.userID1);
+        }
+        catch (OperationFailedException ex1)
+        {
+            // the contact already exist its OK
+        }
+
+        synchronized(o)
+        {
+            o.wait(2000);
+        }
+    }
+
+    /**
+     * Send an instant message from the tested operation set and assert
+     * reception by the tester agent.
+     */
+    public void firstTestReceiveMessage()
+    {
+        String body = "This is an IM coming from the tester agent"
+            + " on " + new Date().toString();
+
+        ImEventCollector evtCollector = new ImEventCollector();
+
+        //add a msg listener and register to the op set and send an instant
+        //msg from the tester agent.
+        opSetBasicIM1.addMessageListener(evtCollector);
+
+        Contact testerAgentContact
+            = opSetPresence2.findContactByID(fixture.userID1);
+
+        logger.debug("Will send message " + body + " to: " + testerAgentContact);
+
+        opSetBasicIM2.sendInstantMessage(testerAgentContact,
+                                         opSetBasicIM2.createMessage(body));
+
+        evtCollector.waitForEvent(10000);
+
+        opSetBasicIM1.removeMessageListener(evtCollector);
+
+        //assert reception of a message event
+        assertTrue( "No events delivered upon a received message"
+                    , evtCollector.collectedEvents.size() > 0);
+
+        //assert event instance of Message Received Evt
+        assertTrue( "Received evt was not an instance of "
+                    + MessageReceivedEvent.class.getName()
+                    , evtCollector.collectedEvents.get(0)
+                                instanceof MessageReceivedEvent);
+
+        //assert source contact == testAgent.uin
+        MessageReceivedEvent evt
+            = (MessageReceivedEvent)evtCollector.collectedEvents.get(0);
+        assertEquals("message sender "
+                     , evt.getSourceContact().getAddress()
+                     , fixture.userID2);
+
+        //assert messageBody == body
+        assertEquals("message body", body, evt.getSourceMessage().getContent());
+    }
+
+    /**
+     * Send an instant message from the tester agent and assert reception by
+     * the tested implementation
+     */
+    public void thenTestSendMessage()
+    {
+        logger.debug("Printing Server Stored list to see if message fails are contacts in each other lists");
+        ContactGroup rootGroup1
+            = ((OperationSetPersistentPresence)opSetPresence1).
+            getServerStoredContactListRoot();
+
+        logger.debug("=========== Server Stored Contact List 1 =================");
+
+        logger.debug("rootGroup="+rootGroup1.getGroupName()
+                     +" rootGroup.childContacts="+rootGroup1.countContacts()
+                     + "rootGroup.childGroups="+rootGroup1.countSubgroups()
+                     + "Printing rootGroupContents=\n"+rootGroup1.toString());
+
+        ContactGroup rootGroup2
+            = ((OperationSetPersistentPresence)opSetPresence2).
+            getServerStoredContactListRoot();
+
+        logger.debug("=========== Server Stored Contact List 2 =================");
+
+        logger.debug("rootGroup="+rootGroup2.getGroupName()
+                     +" rootGroup.childContacts="+rootGroup2.countContacts()
+                     + "rootGroup.childGroups="+rootGroup2.countSubgroups()
+                     + "Printing rootGroupContents=\n"+rootGroup2.toString());
+
+        String body = "This is an IM coming from the tested implementation"
+            + " on " + new Date().toString();
+
+        //create the message
+        net.java.sip.communicator.service.protocol.Message msg
+            = opSetBasicIM1.createMessage(body);
+
+        //register a listener in the op set
+        ImEventCollector imEvtCollector1 = new ImEventCollector();
+        opSetBasicIM1.addMessageListener(imEvtCollector1);
+
+        //register a listener in the tester agent
+        ImEventCollector imEvtCollector2 = new ImEventCollector();
+        opSetBasicIM2.addMessageListener(imEvtCollector2);
+
+        Contact testerAgentContact
+            = opSetPresence1.findContactByID(fixture.userID2);
+
+        opSetBasicIM1.sendInstantMessage(testerAgentContact, msg);
+
+        imEvtCollector1.waitForEvent(10000);
+        imEvtCollector2.waitForEvent(10000);
+
+        opSetBasicIM1.removeMessageListener(imEvtCollector1);
+        opSetBasicIM2.removeMessageListener(imEvtCollector2);
+
+        //verify that the message delivered event was dispatched
+        assertTrue( "No events delivered when sending a message"
+                    , imEvtCollector1.collectedEvents.size() > 0);
+
+        assertTrue( "Received evt was not an instance of "
+                    + MessageDeliveredEvent.class.getName()
+                    , imEvtCollector1.collectedEvents.get(0)
+                                instanceof MessageDeliveredEvent);
+
+        MessageDeliveredEvent evt
+            = (MessageDeliveredEvent)imEvtCollector1.collectedEvents.get(0);
+        assertEquals("message destination "
+                     , evt.getDestinationContact().getAddress()
+                     , fixture.userID2);
+
+        assertSame("source message", msg, evt.getSourceMessage());
+
+
+        //verify that the message has successfully arived at the destination
+        assertTrue( "No messages received by the tester agent"
+                    , imEvtCollector2.collectedEvents.size() > 0);
+
+        assertFalse( "Message was unable to deliver !",
+            imEvtCollector2.collectedEvents.get(0)
+            instanceof MessageDeliveryFailedEvent);
+
+        String receivedBody =
+            ((MessageReceivedEvent)imEvtCollector2.collectedEvents
+                               .get(0)).getSourceMessage().getContent();
+
+        assertEquals("received message body", msg.getContent(), receivedBody);
+    }
+
+    /**
+     * Creates an Message through the simple createMessage() method and inspects
+     * its parameters.
+     */
+    public void testCreateMessage1()
+    {
+        String body = "This is an IM coming from the tested implementation"
+            + " on " + new Date().toString();
+        net.java.sip.communicator.service.protocol.Message msg
+            = opSetBasicIM1.createMessage(body);
+
+        assertEquals("message body", body, msg.getContent());
+        assertTrue("message body bytes"
+                   , Arrays.equals(body.getBytes(), msg.getRawData()));
+        assertEquals("message length", body.length(), msg.getSize());
+        assertEquals("message content type"
+                     , OperationSetBasicInstantMessaging.DEFAULT_MIME_TYPE
+                     , msg.getContentType());
+
+        assertEquals("message encoding"
+                     , OperationSetBasicInstantMessaging.DEFAULT_MIME_ENCODING
+                     , msg.getEncoding());
+
+        assertNotNull("message uid", msg.getMessageUID());
+
+        //a further test on message uid.
+        net.java.sip.communicator.service.protocol.Message msg2
+            = opSetBasicIM1.createMessage(body);
+        assertFalse("message uid", msg.getMessageUID().equals(
+                                                        msg2.getMessageUID()));
+    }
+
+    /**
+     * Creates an Message through the advance createMessage() method and
+     * inspects its parameters.
+     */
+    public void testCreateMessage2()
+    {
+        String body = "This is an IM coming from the tested implementation"
+            + " on " + new Date().toString();
+        String contentType = "text/html";
+        String encoding = "UTF-16";
+        String subject = "test message";
+        net.java.sip.communicator.service.protocol.Message msg
+            = opSetBasicIM1.createMessage(
+                    body.getBytes(), contentType, encoding, subject);
+
+        assertEquals("message body", body, msg.getContent());
+        assertTrue("message body bytes"
+                   , Arrays.equals(body.getBytes(), msg.getRawData()));
+        assertEquals("message length", body.length(), msg.getSize());
+        assertEquals("message content type", contentType, msg.getContentType());
+        assertEquals("message encoding", encoding, msg.getEncoding());
+        assertNotNull("message uid", msg.getMessageUID());
+
+        //a further test on message uid.
+        net.java.sip.communicator.service.protocol.Message msg2
+            = opSetBasicIM1.createMessage(body);
+        assertFalse("message uid", msg.getMessageUID().equals(
+            msg2.getMessageUID()));
+    }
+
+    /**
+     * Collects instant messaging events.
+     */
+    private class ImEventCollector implements MessageListener
+    {
+        private List collectedEvents = new LinkedList();
+        /**
+         * Called when a new incoming <tt>Message</tt> has been received.
+         * @param evt the <tt>MessageReceivedEvent</tt> containing the newly
+         * received message, its sender and other details.
+         */
+        public void messageReceived(MessageReceivedEvent evt)
+        {
+            logger.debug("Received a MessageReceivedEvent: " + evt);
+
+            synchronized(this)
+            {
+                collectedEvents.add(evt);
+                notifyAll();
+            }
+        }
+
+        /**
+         * Called to indicated that delivery of a message sent earlier has failed.
+         * Reason code and phrase are contained by the <tt>MessageFailedEvent</tt>
+         * @param evt the <tt>MessageFailedEvent</tt> containing the ID of the
+         * message whose delivery has failed.
+         */
+        public void messageDeliveryFailed(MessageDeliveryFailedEvent evt)
+        {
+            logger.debug("Received a MessageDeliveryFailedEvent: " + evt);
+
+            synchronized(this)
+            {
+                collectedEvents.add(evt);
+                notifyAll();
+            }
+        }
+
+
+        /**
+         * Called when the underlying implementation has received an indication
+         * that a message, sent earlier has been successfully received by the
+         * destination.
+         * @param evt the MessageDeliveredEvent containing the id of the message
+         * that has caused the event.
+         */
+        public void messageDelivered(MessageDeliveredEvent evt)
+        {
+            logger.debug("Received a MessageDeliveredEvent: " + evt);
+
+            synchronized(this)
+            {
+                collectedEvents.add(evt);
+                notifyAll();
+            }
+        }
+
+        /**
+         * Blocks until at least one event is received or until waitFor
+         * miliseconds pass (whichever happens first).
+         *
+         * @param waitFor the number of miliseconds that we should be waiting
+         * for an event before simply bailing out.
+         */
+        public void waitForEvent(long waitFor)
+        {
+            synchronized(this)
+            {
+
+                if(collectedEvents.size() > 0)
+                    return;
+
+                try{
+                    wait(waitFor);
+                }
+                catch (InterruptedException ex)
+                {
+                    logger.debug(
+                        "Interrupted while waiting for a message evt", ex);
+                }
+            }
+        }
+    }
+}