path: root/test/net/java/sip/communicator/slick/contactlist/MclSlickFixture.java

/*
 * Jitsi, the OpenSource Java VoIP and Instant Messaging client.
 *
 * Copyright @ 2015 Atlassian Pty Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.java.sip.communicator.slick.contactlist;

import java.util.*;

import net.java.sip.communicator.impl.protocol.mock.*;
import net.java.sip.communicator.service.contactlist.*;
import net.java.sip.communicator.service.protocol.*;

import org.osgi.framework.*;

/**
 * Fields, commonly used by the MetaContactListSlick.
 *
 * @author Emil Ivov
 */
public class MclSlickFixture
    extends junit.framework.TestCase
{
    /**
     * The bundle context that we received when the slick was activated.
     */
    public static BundleContext bundleContext = null;

    /**
     * A reference to the meta contact list service currently available on the
     * OSGI bus.
     */
    public MetaContactListService metaClService = null;

    /**
     * The provider that we use to make a dummy server-stored contactlist
     * used for testing. The mockProvider is instantiated and registered
     * by the metacontactlist slick activator.
     */
    public static MockProvider mockProvider = null;

    /**
     * The persistent presence operation set of the default mock provider.
     */
    public static MockPersistentPresenceOperationSet mockPresOpSet = null;

    /**
     * A reference to the registration of the first mock provider.
     */
    public static ServiceRegistration mockPrServiceRegistration = null;

    /** The provider we will be using to replace mockProvider*/
    public static MockProvider replacementMockPr = null;


    //Mock Provider 1
    /**
     * A second mock provider that we will be using when testing support for
     * multiple protocol providers
     */
    public static MockProvider mockP1 = new MockProvider("mockP1");

    /** A test group for mockP1*/
    public static MockContactGroup mockP1Grp1
                                = new MockContactGroup("MockP1.Grp1", mockP1);

    /** A test sub group for mockP1*/
    public static MockContactGroup subMockP1Grp = new MockContactGroup(
        "Mock1.SubProtoGroup", mockP1);

    /** A test contact for mockP1*/
    public static MockContact emilP1 = new MockContact("emil@MockP1", mockP1);

    /** A test contact for mockP1*/
    public static MockContact subEmilP1
        = new MockContact("subemil@MockP1", mockP1);

    /** The meta contact group encapsulator of mockP1Grp1*/
    public static MetaContactGroup metaP1Grp1 = null;

    /** The presence operation set for the mockP1 provider */
    public static MockPersistentPresenceOperationSet mockPresOpSetP1 = null;

    /** A reference to the service registration of mock p1 */
    public static ServiceRegistration mockP1ServiceRegistration = null;

    /** The provider we will be using to replace mockP1*/
    public static MockProvider replacementMockP1 = null;

    //Mock Provider 2
    /**
     * Yet another mock provider that we will be using when testing support for
     * multiple providers.
     */
    public static MockProvider mockP2 = new MockProvider("mockP2");

    /** A test group for mockP2*/
    public static MockContactGroup mockP2Grp1
        = new MockContactGroup("MockP2.Grp1", mockP2);

    /** A test contact for mockP2*/
    public static MockContact emilP2 = new MockContact("emil@MockP2", mockP2);

    /** The meta encapsulator of the mockP2Grp1 group*/
    public static MetaContactGroup metaP2Grp1 = null;

    /** The presence operation set of the mockP2 provider.*/
    public static MockPersistentPresenceOperationSet mockPresOpSetP2 = null;

    /** A reference to the service registration of the mockP2 provider. */
    public static ServiceRegistration mockP2ServiceRegistration = null;

    /** The provider we will be using to replace mockP2*/
    public static MockProvider replacementMockP2 = null;

    /**
     * Initialize the contacts of the two test providers so that they could
     * be directly comparable to what has been parsed from the file.
     */
    static
    {
        //init mock provider 1
        subMockP1Grp.addContact(subEmilP1);
        mockP1Grp1.addContact(emilP1);
        mockP1Grp1.addSubgroup(subMockP1Grp);

        mockPresOpSetP1 =
            (MockPersistentPresenceOperationSet) mockP1
                .getOperationSet(OperationSetPresence.class);
        mockPresOpSetP1.addMockGroup(mockP1Grp1);

        //init mock provider 2
        mockP2Grp1.addContact(emilP2);

        mockPresOpSetP2 =
            (MockPersistentPresenceOperationSet) mockP2
                .getOperationSet(OperationSetPresence.class);
        mockPresOpSetP2.addMockGroup(mockP2Grp1);
    }

    public MclSlickFixture(Object obj)
    {
    }

    /**
     * Find a reference of the meta contact list service and set the
     * corresponding field.
     */
    @Override
    public void setUp()
    {
        //find a reference to the meta contaact list service.
        ServiceReference ref = bundleContext.getServiceReference(
            MetaContactListService.class.getName());
        metaClService
            = (MetaContactListService)bundleContext.getService(ref);

    }

    /**
     *
     */
    @Override
    public void tearDown()
    {
    }

    /**
     * Makes sure that the specified actualGroup contains the same contacts
     * and subgroups as the expectedGroup. (Method operates recursively).
     *
     * @param expectedGroup a MockContactGroup instance used as a reference.
     * @param actualGroup the MetaContactGroup retrieved from the metacontact
     * list.
     * @param ignoreEmptyMetaGroups determines whether empty meta groups should
     * be considered a problem.
     */
    static void assertGroupEquals(  MockContactGroup expectedGroup,
                                    MetaContactGroup actualGroup,
                                    boolean ignoreEmptyMetaGroups)
    {
        assertNotNull("Group " + expectedGroup.getGroupName() + " was "
                      + "returned by the MetaContactListService implementation "
                      + "but was not in the expected contact list."
                      , actualGroup);

        assertEquals("Group " + expectedGroup.getGroupName()
                     + ",  number of member contacts: "
                     , expectedGroup.countContacts()
                     , actualGroup.countChildContacts());

        if( !ignoreEmptyMetaGroups)
        {
            assertEquals("Group " + expectedGroup.getGroupName()
                         + ", numbber of subgroups: "
                         , expectedGroup.countSubgroups()
                         , actualGroup.countSubgroups());
        }
        else
        {
            int emptyMetaGroups = 0;
            for(int i = 0; i < actualGroup.countSubgroups(); i++)
            {
                if(actualGroup.getMetaContactSubgroup(i).countContactGroups() == 0)
                    emptyMetaGroups ++;
            }

            assertEquals("Group " + expectedGroup.getGroupName()
                         + ", numbber of subgroups: "
                         , expectedGroup.countSubgroups()
                         , actualGroup.countSubgroups() - emptyMetaGroups);

        }

        //go over the subgroups and check that they've been all added to the
        //meta contact list.
        Iterator<ContactGroup> expectedSubgroups = expectedGroup.subgroups();
        while (expectedSubgroups.hasNext() )
        {
            MockContactGroup expectedSubGroup
                = (MockContactGroup)expectedSubgroups.next();

            MetaContactGroup actualSubGroup
                = actualGroup
                    .getMetaContactSubgroup(expectedSubGroup.getGroupName());

            assertGroupEquals(
                expectedSubGroup, actualSubGroup, ignoreEmptyMetaGroups);
        }

        Iterator<MetaContact> actualContactsIter
            = actualGroup.getChildContacts();

        //check whether every contact in the meta list exists in the source
        //mock provider contact list.
        while (actualContactsIter.hasNext())
        {
            MetaContact actualMetaContact = actualContactsIter.next();

            assertEquals("Number of protocol specific contacts in a MetaContact"
                          , 1, actualMetaContact.getContactCount());

            assertTrue(
                "No contacts were encapsulated by MetaContact: "
                + actualMetaContact
                , actualMetaContact.getContacts().hasNext());

            Contact actualProtoContact
                = actualMetaContact.getContacts().next();

            assertNotNull("getContactForProvider returned null for MockProvider"
                          , actualProtoContact);

            Contact expectedProtoContact
                = expectedGroup.getContact(actualProtoContact.getAddress());

            assertNotNull("Contact " + actualMetaContact.getDisplayName()
                          + " was returned by "
                          + "the MetaContactListService implementation but was "
                          + "not in the expected contact list."
                          , expectedProtoContact);
        }
    }
}