/*
* Copyright (C) 2003-2010 eXo Platform SAS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see<http://www.gnu.org/licenses/>.
*/
package org.exoplatform.social.core.manager;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.exoplatform.commons.utils.ListAccess;
import org.exoplatform.social.core.identity.model.Identity;
import org.exoplatform.social.core.identity.model.Profile;
import org.exoplatform.social.core.identity.provider.OrganizationIdentityProvider;
import org.exoplatform.social.core.model.AvatarAttachment;
import org.exoplatform.social.core.relationship.model.Relationship;
import org.exoplatform.social.core.relationship.model.Relationship.Type;
import org.exoplatform.social.core.test.AbstractCoreTest;
/**
* Unit Tests for {@link RelationshipManager}
*
*/
public class RelationshipManagerTest extends AbstractCoreTest {
private RelationshipManager relationshipManager;
private IdentityManager identityManager;
private Identity rootIdentity,
johnIdentity,
maryIdentity,
demoIdentity;
private List<Relationship> tearDownRelationshipList;
@Override
protected void setUp() throws Exception {
super.setUp();
tearDownRelationshipList = new ArrayList<Relationship>();
relationshipManager = (RelationshipManager) getContainer().getComponentInstanceOfType(RelationshipManager.class);
identityManager = (IdentityManager) getContainer().getComponentInstanceOfType(IdentityManager.class);
assertNotNull("relationshipManager must not be null", relationshipManager);
assertNotNull("identityManager must not be null", identityManager);
rootIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, "root");
johnIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, "john");
maryIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, "mary");
demoIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, "demo");
}
@Override
protected void tearDown() throws Exception {
for (Relationship relationship : tearDownRelationshipList) {
relationshipManager.remove(relationship);
}
identityManager.deleteIdentity(rootIdentity);
identityManager.deleteIdentity(johnIdentity);
identityManager.deleteIdentity(maryIdentity);
identityManager.deleteIdentity(demoIdentity);
super.tearDown();
}
/**
* Test {@link RelationshipManager#getAll(Identity)}
*
* @throws Exception
*/
public void testGetAll() throws Exception {
relationshipManager.invite(johnIdentity, demoIdentity);
List<Relationship> senderRelationships = relationshipManager.getAll(johnIdentity);
List<Relationship> receiverRelationships = relationshipManager.getAll(demoIdentity);
assertEquals(1, senderRelationships.size());
assertEquals(1, receiverRelationships.size());
tearDownRelationshipList.addAll(senderRelationships);
}
/**
* Test {@link RelationshipManager#getAll(Identity, List)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetAllWithListIdentities() throws Exception {
List<Identity> listIdentities = new ArrayList<Identity>();
listIdentities.add(rootIdentity);
listIdentities.add(demoIdentity);
listIdentities.add(johnIdentity);
listIdentities.add(maryIdentity);
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootRelationships = relationshipManager.getAll(rootIdentity, listIdentities);
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.size() must return: 3", 3, rootRelationships.size());
List<Relationship> maryRelationships = relationshipManager.getAll(maryIdentity, listIdentities);
assertNotNull("maryRelationships must not be null", maryRelationships);
assertEquals("maryRelationships.size() mut return: 1", 1, maryRelationships.size());
List<Relationship> johnRelationships = relationshipManager.getAll(johnIdentity, listIdentities);
assertNotNull("johnRelationships must not be null", johnRelationships);
assertEquals("johnRelationships.size() mut return: 1", 1, johnRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getAll(Identity, Type, List)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetAllWithTypeAndListIdentities() throws Exception {
List<Identity> listIdentities = new ArrayList<Identity>();
listIdentities.add(rootIdentity);
listIdentities.add(demoIdentity);
listIdentities.add(johnIdentity);
listIdentities.add(maryIdentity);
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootPendingRelationships = relationshipManager.getAll(rootIdentity, Relationship.Type.PENDING, listIdentities);
assertNotNull("rootPendingRelationships must not be null", rootPendingRelationships);
assertEquals("rootPendingRelationships.size() must return: 3", 3, rootPendingRelationships.size());
List<Relationship> maryPendingRelationships = relationshipManager.getAll(maryIdentity, Relationship.Type.PENDING, listIdentities);
assertNotNull("maryPendingRelationships must not be null", maryPendingRelationships);
assertEquals("maryPendingRelationships.size() mut return: 1", 1, maryPendingRelationships.size());
List<Relationship> johnPendingRelationships = relationshipManager.getAll(maryIdentity, Relationship.Type.PENDING, listIdentities);
assertNotNull("johnPendingRelationships must not be null", johnPendingRelationships);
assertEquals("johnPendingRelationships.size() mut return: 1", 1, johnPendingRelationships.size());
relationshipManager.confirm(demoIdentity, rootIdentity);
List<Relationship> rootConfirmedRelationships = relationshipManager.getAll(rootIdentity, Relationship.Type.CONFIRMED, listIdentities);
assertNotNull("rootConfirmedRelationships must not be null", rootConfirmedRelationships);
assertEquals("rootConfirmedRelationships.size() must return: 1", 1, rootConfirmedRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#get(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGet() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getSender() must return: " + rootIdentity, rootIdentity, rootToDemoRelationship.getSender());
assertEquals("rootToDemoRelationship.getReceiver() must return: " + demoIdentity, demoIdentity, rootToDemoRelationship.getReceiver());
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToDemoRelationship.getStatus());
relationshipManager.confirm(johnIdentity, rootIdentity);
rootToJohnRelationship = relationshipManager.get(johnIdentity, rootIdentity);
assertEquals("rootToJohnRelationship.getStatus() must return: ", Relationship.Type.CONFIRMED,
rootToJohnRelationship.getStatus());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#get(String)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetWithRelationshipId() throws Exception {
Relationship relationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
String relationshipId = relationship.getId();
relationshipManager.confirm(johnIdentity, rootIdentity);
relationship = relationshipManager.get(relationship.getId());
assertNotNull("relationship must not be null", relationship);
assertEquals("relationship.getStatus() must return: " + Relationship.Type.CONFIRMED, Relationship.Type.CONFIRMED, relationship.getStatus());
relationshipManager.delete(relationship);
relationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("relationship must be null", relationship);
relationship = relationshipManager.get(relationshipId);
assertNull("relationship must be null", relationship);
}
/**
* Test {@link RelationshipManager#update(Relationship)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testUpdate() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToDemoRelationship.getStatus());
rootToDemoRelationship.setStatus(Relationship.Type.CONFIRMED);
relationshipManager.update(rootToDemoRelationship);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.CONFIRMED,
Relationship.Type.CONFIRMED, rootToDemoRelationship.getStatus());
assertEquals("maryToRootRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, maryToRootRelationship.getStatus());
maryToRootRelationship.setStatus(Relationship.Type.IGNORED);
relationshipManager.update(maryToRootRelationship);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertEquals("maryToRootRelationship.getStatus() must return: " + Relationship.Type.IGNORED,
Relationship.Type.IGNORED, maryToRootRelationship.getStatus());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#inviteToConnect(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testInviteToConnect() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToDemoRelationship.getStatus());
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNotNull("maryToRootRelationship must not be null", maryToRootRelationship);
assertEquals("maryToRootRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, maryToRootRelationship.getStatus());
rootToJohnRelationship = relationshipManager.get(johnIdentity, rootIdentity);
assertNotNull("rootToJohnRelationship must not be null", rootToJohnRelationship);
assertEquals("rootToJohnRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToJohnRelationship.getStatus());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#inviteToConnect(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testDupdicateInviteToConnect() throws Exception {
Relationship relationship1 = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship relationship2 = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
assertEquals("relationShip1 and relationShip2 must be the same",relationship1.getId(), relationship2.getId());
tearDownRelationshipList.add(relationship1);
}
/**
* Test {@link RelationshipManager#inviteToConnect(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testDupdicateInviteToConnectWithConfirmedRelationShip() throws Exception {
Relationship relationship1 = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
assertEquals("RelationShip status must be PENDING",Relationship.Type.PENDING, relationship1.getStatus());
relationshipManager.confirm(rootIdentity, demoIdentity);
relationship1 = relationshipManager.get(rootIdentity, demoIdentity);
assertEquals("RelationShip status must be CONFIRMED",Relationship.Type.CONFIRMED, relationship1.getStatus());
Relationship relationship2 = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
assertEquals("RelationShip status must be CONFIRMED",Relationship.Type.CONFIRMED, relationship2.getStatus());
assertEquals("relationShip1 and relationShip2 must be the same",relationship1.getId(), relationship2.getId());
tearDownRelationshipList.add(relationship1);
}
/**
* Test {@link RelationshipManager#confirm(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testConfirmWithIdentity() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
rootToJohnRelationship = relationshipManager.get(rootToJohnRelationship.getId());
relationshipManager.confirm(rootIdentity, demoIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.CONFIRMED,
Relationship.Type.CONFIRMED, rootToDemoRelationship.getStatus());
relationshipManager.confirm(maryIdentity, rootIdentity);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNotNull("maryToRootRelationship must not be null", maryToRootRelationship);
assertEquals("maryToRootRelationship.getStatus() must return: " + Relationship.Type.CONFIRMED,
Relationship.Type.CONFIRMED, maryToRootRelationship.getStatus());
relationshipManager.confirm(rootIdentity, johnIdentity);
rootToJohnRelationship = relationshipManager.get(johnIdentity, rootIdentity);
assertNotNull("rootToJohnRelationship must not be null", rootToJohnRelationship);
assertEquals("rootToJohnRelationship.getStatus() must return: " + Relationship.Type.CONFIRMED,
Relationship.Type.CONFIRMED, rootToJohnRelationship.getStatus());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#deny(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testDeny() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.confirm(johnIdentity, rootIdentity);
relationshipManager.deny(johnIdentity, rootIdentity);
assertNotNull(relationshipManager.get(rootToJohnRelationship.getId()));
rootToJohnRelationship.setStatus(Relationship.Type.PENDING);
relationshipManager.update(rootToJohnRelationship);
relationshipManager.deny(demoIdentity, rootIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNull("rootToDemoRelationship must be null", rootToDemoRelationship);
relationshipManager.deny(maryIdentity, rootIdentity);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNull("maryToRootRelationship must be null", maryToRootRelationship);
relationshipManager.deny(rootIdentity, johnIdentity);
rootToJohnRelationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("rootToJohnRelationship must be null", rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#ignore(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testIgnore() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.ignore(demoIdentity, rootIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNull("rootToDemoRelationship must be null", rootToDemoRelationship);
relationshipManager.ignore(maryIdentity, rootIdentity);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNull("maryToRootRelationship must be null", maryToRootRelationship);
relationshipManager.ignore(rootIdentity, johnIdentity);
rootToJohnRelationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("rootToJohnRelationship must be null", rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getIncomingWithListAccess(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetIncomingWithListAccess() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToDemoRelationship = relationshipManager.inviteToConnect(maryIdentity, demoIdentity);
Relationship johnToDemoRelationship = relationshipManager.inviteToConnect(johnIdentity, demoIdentity);
ListAccess<Identity> demoIncoming = relationshipManager.getIncomingWithListAccess(demoIdentity);
assertNotNull("demoIncoming must not be null", demoIncoming);
assertEquals("demoIncoming.getSize() must return: 3", 3, demoIncoming.getSize());
//Test change avatar
InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
AvatarAttachment avatarAttachment = new AvatarAttachment(null, "avatar", "png", inputStream, null, System.currentTimeMillis());
assertNotNull(avatarAttachment);
Profile profile = maryIdentity.getProfile();
profile.setProperty(Profile.AVATAR, avatarAttachment);
identityManager.updateProfile(profile);
Identity[] identities = demoIncoming.load(0, 10);
demoIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, demoIdentity.getRemoteId(), true);
assertEquals(6, identities[0].getProfile().getProperties().size());
assertEquals(7, identities[1].getProfile().getProperties().size());
assertEquals(6, identities[2].getProfile().getProperties().size());
for (Identity identity : demoIncoming.load(0, 10)) {
assertNotNull("identity.getProfile() must not be null", identity.getProfile());
Identity identityLoadProfile = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, identity.getRemoteId(), true);
assertEquals("identity.getProfile().getFullName() must return: " + identityLoadProfile.getProfile().getFullName(),
identityLoadProfile.getProfile().getFullName(), identity.getProfile().getFullName());
}
ListAccess<Identity> rootIncoming = relationshipManager.getIncomingWithListAccess(rootIdentity);
assertNotNull("rootIncoming must not be null", rootIncoming);
assertEquals("rootIncoming.getSize() must return: 0", 0, rootIncoming.getSize());
ListAccess<Identity> maryIncoming = relationshipManager.getIncomingWithListAccess(maryIdentity);
assertNotNull("maryIncoming must not be null", maryIncoming);
assertEquals("maryIncoming.getSize() must return: 0", 0, maryIncoming.getSize());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToDemoRelationship);
tearDownRelationshipList.add(johnToDemoRelationship);
}
/**
* Test {@link RelationshipManager#getOutgoing(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetOutgoing() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship rootToMaryRelationship = relationshipManager.inviteToConnect(rootIdentity, maryIdentity);
Relationship maryToDemoRelationship = relationshipManager.inviteToConnect(maryIdentity, demoIdentity);
Relationship demoToJohnRelationship = relationshipManager.inviteToConnect(demoIdentity, johnIdentity);
ListAccess<Identity> rootOutgoing = relationshipManager.getOutgoing(rootIdentity);
assertNotNull("rootOutgoing must not be null", rootOutgoing);
assertEquals("rootOutgoing.getSize() must return: 2", 2, rootOutgoing.getSize());
//Test change avatar
InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
AvatarAttachment avatarAttachment = new AvatarAttachment(null, "avatar", "png", inputStream, null, System.currentTimeMillis());
assertNotNull(avatarAttachment);
Profile profile = demoIdentity.getProfile();
profile.setProperty(Profile.AVATAR, avatarAttachment);
identityManager.updateProfile(profile);
rootOutgoing = relationshipManager.getOutgoing(rootIdentity);
Identity[] identities = rootOutgoing.load(0, 10);
demoIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, demoIdentity.getRemoteId(), true);
assertEquals(7, identities[0].getProfile().getProperties().size());
assertEquals(6, identities[1].getProfile().getProperties().size());
for (Identity identity : rootOutgoing.load(0, 10)) {
Identity identityLoadProfile = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, identity.getRemoteId(), true);
assertNotNull("identity.getProfile() must not be nul", identity.getProfile());
assertNotNull("temp must not be null", identityLoadProfile);
assertEquals("identity.getProfile().getFullName() must return: " + identityLoadProfile.getProfile().getFullName(),
identityLoadProfile.getProfile().getFullName(),
identity.getProfile().getFullName());
}
ListAccess<Identity> maryOutgoing = relationshipManager.getOutgoing(maryIdentity);
assertNotNull("maryOutgoing must not be null", maryOutgoing);
assertEquals("maryOutgoing.getSize() must return: 1", 1, maryOutgoing.getSize());
ListAccess<Identity> demoOutgoing = relationshipManager.getOutgoing(demoIdentity);
assertNotNull("demoOutgoing must not be null", demoOutgoing);
assertEquals("demoOutgoing.getSize() must return: 1", 1, demoOutgoing.getSize());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToDemoRelationship);
tearDownRelationshipList.add(demoToJohnRelationship);
tearDownRelationshipList.add(rootToMaryRelationship);
}
/**
* Test {@link RelationshipManager#getStatus(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetStatus() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToDemoRelationship.getStatus());
assertEquals("relationshipManager.getStatus(rootIdentity, demoIdentity) must return: " +
Relationship.Type.PENDING, Relationship.Type.PENDING,
relationshipManager.getStatus(rootIdentity, demoIdentity));
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNotNull("maryToRootRelationship must not be null", maryToRootRelationship);
assertEquals("maryToRootRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, maryToRootRelationship.getStatus());
assertEquals("relationshipManager.getStatus(maryIdentity, rootIdentity) must return: " +
Relationship.Type.PENDING, Relationship.Type.PENDING,
relationshipManager.getStatus(maryIdentity, rootIdentity));
rootToJohnRelationship = relationshipManager.get(johnIdentity, rootIdentity);
assertNotNull("rootToJohnRelationship must not be null", rootToJohnRelationship);
assertEquals("rootToJohnRelationship.getStatus() must return: " + Relationship.Type.PENDING,
Relationship.Type.PENDING, rootToJohnRelationship.getStatus());
assertEquals("relationshipManager.getStatus(rootIdentity, johnIdentity) must return: " +
Relationship.Type.PENDING, Relationship.Type.PENDING,
relationshipManager.getStatus(rootIdentity, johnIdentity));
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getAllWithListAccess(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetAllWithListAccess() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
ListAccess<Identity> rootRelationships = relationshipManager.getAllWithListAccess(rootIdentity);
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.getSize() must return: 3", 3, rootRelationships.getSize());
ListAccess<Identity> demoRelationships = relationshipManager.getAllWithListAccess(demoIdentity);
assertNotNull("demoRelationships must not be null", demoRelationships);
assertEquals("demoRelationships.getSize() must return: 1", 1, demoRelationships.getSize());
ListAccess<Identity> johnRelationships = relationshipManager.getAllWithListAccess(johnIdentity);
assertNotNull("johnRelationships must not be null", johnRelationships);
assertEquals("johnRelationships.getSize() must return: 1", 1, johnRelationships.getSize());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getRelationshipById(String)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetRelationshipById() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
rootToDemoRelationship = relationshipManager.getRelationshipById(rootToDemoRelationship.getId());
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getSender() must return: " + rootIdentity, rootIdentity, rootToDemoRelationship.getSender());
assertEquals("rootToDemoRelationship.getReceiver() must return: " + demoIdentity, demoIdentity, rootToDemoRelationship.getReceiver());
tearDownRelationshipList.add(rootToDemoRelationship);
}
/**
* Test {@link RelationshipManager#deny(Relationship)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testDenyWithRelationship() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.deny(rootToDemoRelationship);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNull("rootToDemoRelationship must be null", rootToDemoRelationship);
relationshipManager.deny(maryToRootRelationship);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNull("maryToRootRelationship must be null", maryToRootRelationship);
relationshipManager.deny(rootToJohnRelationship);
rootToJohnRelationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("rootToJohnRelationship must be null", rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#ignore(Relationship)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testIgnoreWithRelationship() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.ignore(rootToDemoRelationship);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertNull("rootToDemoRelationship must be null", rootToDemoRelationship);
relationshipManager.ignore(maryToRootRelationship);
maryToRootRelationship = relationshipManager.get(maryIdentity, rootIdentity);
assertNull("maryToRootRelationship must be null", maryToRootRelationship);
relationshipManager.ignore(rootToJohnRelationship);
rootToJohnRelationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("rootToJohnRelationship must be null", rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getPendingRelationships(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetPendingRelationships() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootPendingRelationships = relationshipManager.getPendingRelationships(rootIdentity);
assertNotNull("rootPendingRelationships must not be null", rootPendingRelationships);
assertEquals("rootPendingRelationships.size() must return: 2", 2, rootPendingRelationships.size());
List<Relationship> maryPendingRelationships = relationshipManager.getPendingRelationships(maryIdentity);
assertNotNull("maryPendingRelationships must not be null", maryPendingRelationships);
assertEquals("maryPendingRelationships.size() must return: 1", 1, maryPendingRelationships.size());
List<Relationship> demoPendingRelationships = relationshipManager.getPendingRelationships(demoIdentity);
assertNotNull("demoPendingRelationships must not be null", demoPendingRelationships);
assertEquals("demoPendingRelationships.size() must return: 0", 0, demoPendingRelationships.size());
List<Relationship> johnPendingRelationships = relationshipManager.getPendingRelationships(johnIdentity);
assertNotNull("johnPendingRelationships must not be null", johnPendingRelationships);
assertEquals("johnPendingRelationships.size() must return: 0", 0, johnPendingRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getPendingRelationships(Identity, boolean)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetPendingRelationshipWithSentOrReceived() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootPendingRelationships = relationshipManager.getPendingRelationships(rootIdentity, true);
assertNotNull("rootPendingRelationships must not be null", rootPendingRelationships);
assertEquals("rootPendingRelationships.size() must return: 3", 3, rootPendingRelationships.size());
List<Relationship> maryPendingRelationships = relationshipManager.getPendingRelationships(maryIdentity, true);
assertNotNull("maryPendingRelationships must not be null", maryPendingRelationships);
assertEquals("maryPendingRelationships.size() must return: 1", 1, maryPendingRelationships.size());
List<Relationship> demoPendingRelationships = relationshipManager.getPendingRelationships(demoIdentity, true);
assertNotNull("demoPendingRelationships must not be null", demoPendingRelationships);
assertEquals("demoPendingRelationships.size() must return: 1", 1, demoPendingRelationships.size());
List<Relationship> johnPendingRelationships = relationshipManager.getPendingRelationships(johnIdentity, true);
assertNotNull("johnPendingRelationships must not be null", johnPendingRelationships);
assertEquals("johnPendingRelationships.size() must return: 1", 1, johnPendingRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getPendingRelationships(Identity, List, boolean)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetPendingRealtionshipWithListIdentities() throws Exception {
List<Identity> identities = new ArrayList<Identity> ();
identities.add(rootIdentity);
identities.add(demoIdentity);
identities.add(johnIdentity);
identities.add(maryIdentity);
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootPendingRelationships = relationshipManager.getPendingRelationships(rootIdentity, identities, true);
assertNotNull("rootPendingRelationships must not be null", rootPendingRelationships);
assertEquals("rootPendingRelationships.size() must return: 3", 3, rootPendingRelationships.size());
List<Relationship> maryPendingRelationships = relationshipManager.getPendingRelationships(maryIdentity, identities, true);
assertNotNull("maryPendingRelationships must not be null", maryPendingRelationships);
assertEquals("maryPendingRelationships.size() must return: 1", 1, maryPendingRelationships.size());
List<Relationship> demoPendingRelationships = relationshipManager.getPendingRelationships(demoIdentity, identities, true);
assertNotNull("demoPendingRelationships must not be null", demoPendingRelationships);
assertEquals("demoPendingRelationships.size() must return: 1", 1, demoPendingRelationships.size());
List<Relationship> johnPendingRelationships = relationshipManager.getPendingRelationships(johnIdentity, identities, true);
assertNotNull("johnPendingRelationships must not be null", johnPendingRelationships);
assertEquals("johnPendingRelationships.size() must return: 1", 1, johnPendingRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getContacts(Identity, List)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetContactsWithListIdentities() throws Exception {
List<Identity> identities = new ArrayList<Identity> ();
identities.add(rootIdentity);
identities.add(demoIdentity);
identities.add(johnIdentity);
identities.add(maryIdentity);
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.confirm(rootIdentity, demoIdentity);
relationshipManager.confirm(maryIdentity, rootIdentity);
relationshipManager.confirm(rootIdentity, johnIdentity);
List<Relationship> rootContacts = relationshipManager.getContacts(rootIdentity, identities);
assertNotNull("rootContacts must not be null", rootContacts);
assertEquals("rootContacts.size() must return: 3", 3, rootContacts.size());
List<Relationship> demoContacts = relationshipManager.getContacts(demoIdentity, identities);
assertNotNull("demoContacts must not be null", demoContacts);
assertEquals("demoContacts.size() must return: 1", 1, demoContacts.size());
List<Relationship> maryContacts = relationshipManager.getContacts(maryIdentity, identities);
assertNotNull("maryContacts must not be null", maryContacts);
assertEquals("maryContacts.size() must return: 1", 1, maryContacts.size());
List<Relationship> johnContacts = relationshipManager.getContacts(johnIdentity, identities);
assertNotNull("johnContacts must not be null", johnContacts);
assertEquals("johnContacts.size() must return: 1", 1, johnContacts.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getContacts(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetContacts() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.confirm(rootIdentity, demoIdentity);
relationshipManager.confirm(maryIdentity, rootIdentity);
relationshipManager.confirm(rootIdentity, johnIdentity);
List<Relationship> rootContacts = relationshipManager.getContacts(rootIdentity);
assertNotNull("rootContacts must not be null", rootContacts);
assertEquals("rootContacts.size() must return: 3", 3, rootContacts.size());
List<Relationship> demoContacts = relationshipManager.getContacts(demoIdentity);
assertNotNull("demoContacts must not be null", demoContacts);
assertEquals("demoContacts.size() must return: 1", 1, demoContacts.size());
List<Relationship> maryContacts = relationshipManager.getContacts(maryIdentity);
assertNotNull("maryContacts must not be null", maryContacts);
assertEquals("maryContacts.size() must return: 1", 1, maryContacts.size());
List<Relationship> johnContacts = relationshipManager.getContacts(johnIdentity);
assertNotNull("johnContacts must not be null", johnContacts);
assertEquals("johnContacts.size() must return: 1", 1, johnContacts.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getAllRelationships(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetAllRelationships() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootRelationships = relationshipManager.getAllRelationships(rootIdentity);
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.size() must return: 3", 3, rootRelationships.size());
List<Relationship> maryRelationships = relationshipManager.getAllRelationships(maryIdentity);
assertNotNull("maryRelationships must not be null", maryRelationships);
assertEquals("maryRelationships.size() must return: 1", 1, maryRelationships.size());
List<Relationship> demoRelationships = relationshipManager.getAllRelationships(demoIdentity);
assertNotNull("demoRelationships must not be null", demoRelationships);
assertEquals("demoRelationships.size() must return: 1", 1, demoRelationships.size());
List<Relationship> johnRelationships = relationshipManager.getAllRelationships(johnIdentity);
assertNotNull("johnRelationships must not be null", johnRelationships);
assertEquals("johnRelationships.size() must return: 1", 1, johnRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getRelationshipsByIdentityId(String)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetRelationshipsByIdentityId() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Relationship> rootRelationships = relationshipManager.getRelationshipsByIdentityId(rootIdentity.getId());
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.size() must return: 3", 3, rootRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getIdentities(Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetIdentities() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.confirm(rootIdentity, demoIdentity);
relationshipManager.confirm(maryIdentity, rootIdentity);
relationshipManager.confirm(rootIdentity, johnIdentity);
List<Identity> rootConnections = relationshipManager.getIdentities(rootIdentity);
assertNotNull("rootConnections must not be null", rootConnections);
assertEquals("rootConnections.size() must return: 3", 3, rootConnections.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#create(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testCreate() throws Exception {
Relationship demoToJohnRelationship = relationshipManager.create(demoIdentity, johnIdentity);
assertNotNull("demoToJohnRelationship must not be null", demoToJohnRelationship);
assertEquals("demoToJohnRelationship.getSender() must return: " + demoIdentity, demoIdentity, demoToJohnRelationship.getSender());
assertEquals("demoToJohnRelationship.getReceiver() must return: " + johnIdentity, johnIdentity, demoToJohnRelationship.getReceiver());
assertEquals("demoToJohnRelationship.getStatus() must return: " + Relationship.Type.PENDING, Relationship.Type.PENDING, demoToJohnRelationship.getStatus());
}
/**
* Test {@link RelationshipManager#getRelationship(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetRelationship() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
rootToDemoRelationship = relationshipManager.getRelationship(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.PENDING, Relationship.Type.PENDING, rootToDemoRelationship.getStatus());
relationshipManager.confirm(rootIdentity, demoIdentity);
rootToDemoRelationship = relationshipManager.getRelationship(rootIdentity, demoIdentity);
assertNotNull("rootToDemoRelationship must not be null", rootToDemoRelationship);
assertEquals("rootToDemoRelationship.getStatus() must return: " + Relationship.Type.CONFIRMED, Relationship.Type.CONFIRMED, rootToDemoRelationship.getStatus());
tearDownRelationshipList.add(rootToDemoRelationship);
}
/**
* Test {@link RelationshipManager#findRelationships(Identity, Type)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testFindRelationships() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
Relationship maryToRootRelationship = relationshipManager.inviteToConnect(maryIdentity, rootIdentity);
Relationship rootToJohnRelationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
List<Identity> rootRelationships = relationshipManager.findRelationships(rootIdentity, Relationship.Type.PENDING);
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.size() must return: 3", 3, rootRelationships.size());
relationshipManager.confirm(rootIdentity, demoIdentity);
rootRelationships = relationshipManager.findRelationships(rootIdentity, Relationship.Type.CONFIRMED);
assertNotNull("rootRelationships must not be null", rootRelationships);
assertEquals("rootRelationships.size() must return: 1", 1, rootRelationships.size());
tearDownRelationshipList.add(rootToDemoRelationship);
tearDownRelationshipList.add(maryToRootRelationship);
tearDownRelationshipList.add(rootToJohnRelationship);
}
/**
* Test {@link RelationshipManager#getRelationshipStatus(Relationship, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetRelationshipStatus() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
assertEquals("relationshipManager.getRelationshipStatus(rootToDemoRelationship, rootIdentity) must return: "
+ Relationship.Type.PENDING, Relationship.Type.PENDING
, relationshipManager.getRelationshipStatus(rootToDemoRelationship, rootIdentity));
relationshipManager.confirm(rootIdentity, demoIdentity);
rootToDemoRelationship = relationshipManager.get(rootIdentity, demoIdentity);
assertEquals("relationshipManager.getRelationshipStatus(rootToDemoRelationship, rootIdentity) must return: "
+ Relationship.Type.PENDING, Relationship.Type.CONFIRMED
, relationshipManager.getRelationshipStatus(rootToDemoRelationship, rootIdentity));
tearDownRelationshipList.add(rootToDemoRelationship);
}
/**
* Test {@link RelationshipManager#getConnectionStatus(Identity, Identity)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testGetConnectionStatus() throws Exception {
Relationship rootToDemoRelationship = relationshipManager.inviteToConnect(rootIdentity, demoIdentity);
assertEquals("relationshipManager.getConnectionStatus(rootIdentity, demoIdentity) must return: " +
Relationship.Type.PENDING, Relationship.Type.PENDING,
relationshipManager.getConnectionStatus(rootIdentity, demoIdentity));
relationshipManager.confirm(rootIdentity, demoIdentity);
assertEquals("relationshipManager.getConnectionStatus(rootIdentity, demoIdentity) must return: " +
Relationship.Type.CONFIRMED, Relationship.Type.CONFIRMED,
relationshipManager.getConnectionStatus(rootIdentity, demoIdentity));
tearDownRelationshipList.add(rootToDemoRelationship);
}
/**
* Test {@link RelationshipManager#invite(Identity, Identity) and RelationshipManager#get(String)}
*
* @throws Exception
*/
public void testIntiveAndGetByRelationshipId() throws Exception {
Relationship invitedRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship foundRelationship = relationshipManager.get(invitedRelationship.getId());
assertNotNull("foundRelationship must not be null", foundRelationship);
assertNotNull("foundRelationship.getId() must not be null", foundRelationship.getId());
assertEquals(foundRelationship.getId(), invitedRelationship.getId());
tearDownRelationshipList.add(invitedRelationship);
}
/**
* Test {@link RelationshipManager#getPending(Identity)}
*
* @throws Exception
*/
public void testGetPendingWithIdentity() throws Exception {
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
List<Relationship> foundListRelationships = relationshipManager.getPending(johnIdentity);
assertNotNull("foundListRelationships must not be null", foundListRelationships);
assertEquals(3, foundListRelationships.size());
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
}
/**
* Test {@link RelationshipManager#getPending(Identity) and RelationshipManager#getIncoming(Identity)}
*
* @throws Exception
*/
public void testGetPendingAndIncoming() throws Exception {
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
List<Relationship> listPendingRelationship = relationshipManager.getPending(johnIdentity);
assertNotNull("listRelationshipConfirm must not be null", listPendingRelationship);
assertEquals(3, listPendingRelationship.size());
List<Relationship> listMaryRequireValidationRelationship = relationshipManager.getIncoming(maryIdentity);
assertEquals(1, listMaryRequireValidationRelationship.size());
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
}
/**
* Test {@link RelationshipManager#getPending(Identity) and RelationshipManager#getIncoming(Identity, List)}
*
* @throws Exception
*/
public void testGetPendingAndIncomingWithListIdentities() throws Exception {
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
Relationship maryDemoRelationship = relationshipManager.invite(maryIdentity, demoIdentity);
List<Identity> listIdentities = new ArrayList<Identity>();
listIdentities.add(demoIdentity);
listIdentities.add(maryIdentity);
listIdentities.add(johnIdentity);
listIdentities.add(rootIdentity);
List<Relationship> listRelationshipConfirm = relationshipManager.getPending(johnIdentity, listIdentities);
assertEquals(3, listRelationshipConfirm.size());
List<Relationship> listRelationshipNotConfirm = relationshipManager.getIncoming(demoIdentity, listIdentities);
assertEquals(2, listRelationshipNotConfirm.size());
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
tearDownRelationshipList.add(maryDemoRelationship);
}
/**
* Test {@link RelationshipManager#getConfirmed(Identity)}
*
* @throws Exception
*/
public void testGetConfirmedWithIdentity() throws Exception {
List<Relationship> johnContacts = relationshipManager.getConfirmed(johnIdentity);
assertNotNull("johnContacts must not be null", johnContacts);
assertEquals("johnContacts.size() must be 0", 0, johnContacts.size());
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
relationshipManager.confirm(johnDemoRelationship);
relationshipManager.confirm(johnMaryRelationship);
relationshipManager.confirm(johnRootRelationship);
List<Relationship> contactsList = relationshipManager.getConfirmed(johnIdentity);
assertEquals(3, contactsList.size());
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
}
/**
* Test {@link RelationshipManager#getConfirmed(Identity, List)}
*
* @throws Exception
*/
public void testGetConfirmedWithIdentityAndListIdentity() throws Exception {
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
relationshipManager.confirm(johnDemoRelationship);
relationshipManager.confirm(johnMaryRelationship);
relationshipManager.confirm(johnRootRelationship);
List<Identity> listIdentities = new ArrayList<Identity>();
listIdentities.add(demoIdentity);
listIdentities.add(maryIdentity);
listIdentities.add(johnIdentity);
listIdentities.add(rootIdentity);
List<Relationship> contactsList = relationshipManager.getConfirmed(johnIdentity, listIdentities);
assertEquals(3, contactsList.size());
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
}
/**
* Test {@link RelationshipManager#save(Relationship)}
*
* @throws Exception
*/
public void testSave() throws Exception {
Relationship testRelationship = new Relationship(johnIdentity, demoIdentity, Type.PENDING);
relationshipManager.save(testRelationship);
assertNotNull("testRelationship.getId() must not be null", testRelationship.getId());
tearDownRelationshipList.add(testRelationship);
}
/**
*
* @throws Exception
*/
/*
public void testGetManyRelationshipsByIdentityId() throws Exception {
String providerId = OrganizationIdentityProvider.NAME;
Identity sender = identityManager.getOrCreateIdentity(providerId,"john");
identityManager.saveIdentity(sender);
assertNotNull(sender.getId());
Identity receiver = identityManager.getOrCreateIdentity(providerId,"mary");
assertNotNull(receiver.getId());
relationshipManager.invite(sender, receiver);
List<Relationship> senderRelationships = relationshipManager.getAllRelationships(sender);
List<Relationship> receiverRelationships = relationshipManager.getAllRelationships(receiver);
assertEquals(total, senderRelationships.size());
assertEquals(total, receiverRelationships.size());
}
*/
/**
* Test {@link RelationshipManager#invite(Identity, Identity)}
*
* @throws Exception
*/
public void testInviteRelationship() throws Exception {
Relationship relationship = relationshipManager.invite(johnIdentity, maryIdentity);
assertNotNull(relationship.getId());
assertEquals(Relationship.Type.PENDING, relationship.getStatus());
List<Relationship> senderRelationships = relationshipManager.getAll(johnIdentity);
List<Relationship> receiverRelationships = relationshipManager.getAll(maryIdentity);
assertEquals(1, senderRelationships.size());
assertEquals(1, receiverRelationships.size());
tearDownRelationshipList.addAll(senderRelationships);
}
/**
* Test {@link RelationshipManager#confirm(Relationship)}
*
* @throws Exception
*/
public void testConfirm() throws Exception {
Relationship relationship = relationshipManager.invite(johnIdentity, demoIdentity);
relationshipManager.confirm(relationship);
relationship = relationshipManager.get(johnIdentity, demoIdentity);
assertNotNull(relationship.getId());
assertEquals(Relationship.Type.CONFIRMED, relationship.getStatus());
List<Relationship> senderRelationships = relationshipManager.getAll(johnIdentity);
List<Relationship> receiverRelationships = relationshipManager.getAll(demoIdentity);
assertEquals(1, senderRelationships.size());
assertEquals(1, receiverRelationships.size());
tearDownRelationshipList.addAll(senderRelationships);
}
/**
* Test {@link RelationshipManager#delete(Relationship)}
*
* @throws Exception
* @since 1.2.0-Beta3
*/
public void testDelete() throws Exception {
Relationship relationship = relationshipManager.inviteToConnect(rootIdentity, johnIdentity);
relationshipManager.confirm(johnIdentity, rootIdentity);
relationshipManager.delete(relationship);
relationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("relationship must be null", relationship);
}
/**
* Test {@link RelationshipManager#remove(Relationship)}
*
* @throws Exception
*/
public void testRemove() throws Exception {
Relationship relationship = relationshipManager.invite(rootIdentity, johnIdentity);
relationshipManager.confirm(relationship);
relationshipManager.remove(relationship);
relationship = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("relationship must be null", relationship);
}
// TODO: Skip this, will be implement later
// /**
// *
// * @throws Exception
// */
// public void testIgnore() throws Exception {
//
// Relationship relationship = relationshipManager.invite(johnIdentity, rootIdentity);
// relationshipManager.ignore(relationship);
// assertNotNull(relationship.getId());
// assertEquals(Relationship.Type.IGNORED, relationship.getStatus());
//
// List<Relationship> senderRelationships = relationshipManager.getAll(johnIdentity);
// List<Relationship> receiverRelationships = relationshipManager.getAll(rootIdentity);
//
// assertEquals(1, senderRelationships.size());
// assertEquals(1, receiverRelationships.size());
//
// tearDownRelationshipList.addAll(senderRelationships);
// }
/**
* Test {@link RelationshipManager#getPending(Identity)}
*
* @throws Exception
*/
public void testGetPending() throws Exception {
Relationship rootDemo = relationshipManager.invite(rootIdentity, demoIdentity);
assertNotNull("rootDemo.getId() must not be null", rootDemo.getId());
Relationship rootJohn = relationshipManager.invite(rootIdentity, johnIdentity);
assertNotNull("rootJohn.getId() must not be null", rootJohn.getId());
Relationship rootMary = relationshipManager.invite(rootIdentity, maryIdentity);
assertNotNull("rootMary.getId() must not be null", rootMary.getId());
Relationship demoMary = relationshipManager.invite(demoIdentity, maryIdentity);
assertNotNull("demoMary.getId() must not be null", demoMary.getId());
Relationship demoJohn = relationshipManager.invite(demoIdentity, johnIdentity);
assertNotNull("demoJohn.getId() must not be null", demoJohn.getId());
Relationship johnDemo = relationshipManager.invite(johnIdentity, demoIdentity);
assertNotNull("johnDemo.getId() must not be null", johnDemo.getId());
List<Relationship> rootRelationships = relationshipManager.getPending(rootIdentity);
List<Relationship> demoRelationships = relationshipManager.getPending(demoIdentity);
List<Relationship> johnRelationships = relationshipManager.getPending(johnIdentity);
assertEquals(3, rootRelationships.size());
assertEquals(2, demoRelationships.size());
assertEquals(0, johnRelationships.size());
tearDownRelationshipList.add(rootDemo);
tearDownRelationshipList.add(rootJohn);
tearDownRelationshipList.add(rootMary);
tearDownRelationshipList.add(demoMary);
tearDownRelationshipList.add(demoJohn);
}
/**
* Test relationship with caching.
*
* @throws Exception
*/
public void testSavedCached() throws Exception {
Relationship rootDemo = relationshipManager.get(rootIdentity, demoIdentity);
assertNull("rootDemo must be null", rootDemo);
Relationship rootDemo2 = relationshipManager.get(demoIdentity, rootIdentity);
assertNull("rootDemo must be null", rootDemo2);
Relationship.Type rootDemoStatus = relationshipManager.getStatus(demoIdentity, rootIdentity);
assertNull("rootDemoStatus must be null",rootDemoStatus);
rootDemo = relationshipManager.invite(rootIdentity, demoIdentity);
assertNotNull("rootDemo.getId() must not be null", rootDemo.getId());
assertEquals(rootDemo.getStatus(), Relationship.Type.PENDING);
tearDownRelationshipList.add(rootDemo);
Relationship rootMary = relationshipManager.get(rootIdentity, maryIdentity);
Relationship.Type rootMaryStatus = relationshipManager.getStatus(maryIdentity, rootIdentity);
assertNull("rootMary must be null", rootMary);
assertNull("rootMaryStatus must be null", rootMaryStatus);
rootMary = relationshipManager.invite(rootIdentity, maryIdentity);
assertNotNull("rootMary.getId() must not be null", rootMary.getId());
assertEquals(Relationship.Type.PENDING, rootMary.getStatus());
tearDownRelationshipList.add(rootMary);
Relationship rootJohn = relationshipManager.get(rootIdentity, johnIdentity);
assertNull("rootJohn must be null", rootJohn);
assertNull("rootMaryStatus must be null", rootMaryStatus);
rootJohn = relationshipManager.invite(rootIdentity, johnIdentity);
assertNotNull("rootJohn.getId() must not be null", rootJohn.getId());
assertEquals(Relationship.Type.PENDING, rootJohn.getStatus());
tearDownRelationshipList.add(rootJohn);
Relationship demoMary = relationshipManager.get(demoIdentity, maryIdentity);
Relationship.Type demoMaryStatus = relationshipManager.getStatus(maryIdentity, demoIdentity);
assertNull("demoMary must be null", demoMary);
assertNull("demoMaryStatus must be null", demoMaryStatus);
demoMary = relationshipManager.invite(demoIdentity, maryIdentity);
assertNotNull("demoMary.getId() must not be null", demoMary.getId());
assertEquals(Relationship.Type.PENDING, demoMary.getStatus());
tearDownRelationshipList.add(demoMary);
}
/**
* Tests getting connections of one identity with list access.
*
* @throws Exception
*/
public void testGetConnections() throws Exception {
Relationship johnDemoRelationship = relationshipManager.invite(johnIdentity, demoIdentity);
Relationship johnMaryRelationship = relationshipManager.invite(johnIdentity, maryIdentity);
Relationship johnRootRelationship = relationshipManager.invite(johnIdentity, rootIdentity);
relationshipManager.confirm(johnDemoRelationship);
relationshipManager.confirm(johnMaryRelationship);
relationshipManager.confirm(johnRootRelationship);
ListAccess<Identity> contactsList = relationshipManager.getConnections(johnIdentity);
assertEquals(3, contactsList.getSize());
//Test change avatar
InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
AvatarAttachment avatarAttachment = new AvatarAttachment(null, "avatar", "png", inputStream, null, System.currentTimeMillis());
assertNotNull(avatarAttachment);
Profile profile = demoIdentity.getProfile();
profile.setProperty(Profile.AVATAR, avatarAttachment);
identityManager.updateProfile(profile);
Identity[] identities = contactsList.load(0, 10);
demoIdentity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, demoIdentity.getRemoteId(), true);
assertEquals(7, identities[0].getProfile().getProperties().size());
assertEquals(6, identities[1].getProfile().getProperties().size());
assertEquals(6, identities[2].getProfile().getProperties().size());
for (Identity identity : contactsList.load(0, 10)) {
assertNotNull("identity.getProfile() must not be null", identity.getProfile());
Identity identityLoadProfile = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, identity.getRemoteId(), true);
assertEquals("identity.getProfile().getFullName() must return: " + identityLoadProfile.getProfile().getFullName(), identityLoadProfile.getProfile().getFullName(), identity.getProfile().getFullName());
}
tearDownRelationshipList.add(johnDemoRelationship);
tearDownRelationshipList.add(johnMaryRelationship);
tearDownRelationshipList.add(johnRootRelationship);
}
}