/**
* Removes the group created in the server stored contact list by the create group test, makes
* sure that the corresponding event has been generated and verifies that the group is not in the
* list any more.
*/
public void postTestRemoveGroup() {
logger.trace("testing removal of server stored groups");
// first add a listener
GroupChangeCollector groupChangeCollector = new GroupChangeCollector();
opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector);
try {
// remove the group
opSetPersPresence1.removeServerStoredContactGroup(
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2));
} catch (OperationFailedException ex) {
logger.error("error removing group", ex);
}
groupChangeCollector.waitForEvent(10000);
opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector);
// check whether we got group created event
assertEquals("Collected Group Change event", 1, groupChangeCollector.collectedEvents.size());
assertEquals(
"Group name.",
testGroupName2,
((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0))
.getSourceGroup()
.getGroupName());
// check whether the group is still on the contact list
ContactGroup group =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2);
assertNull("A freshly removed group was still on the contact list.", group);
}
public AuthorizationRequest createAuthorizationRequest(Contact contact) {
logger.trace("createAuthorizationRequest " + contact);
AuthorizationRequest authReq = new AuthorizationRequest();
authReq.setReason(authorizationRequestReason);
isAuthorizationRequestSent = true;
return authReq;
}
/**
* Creates a group in the server stored contact list, makes sure that the corresponding event has
* been generated and verifies that the group is in the list.
*
* @throws java.lang.Exception
*/
public void postTestCreateGroup() throws Exception {
// first clear the list
fixture.clearProvidersLists();
Object o = new Object();
synchronized (o) {
o.wait(3000);
}
logger.trace("testing creation of server stored groups");
// first add a listener
GroupChangeCollector groupChangeCollector = new GroupChangeCollector();
opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector);
// create the group
opSetPersPresence1.createServerStoredContactGroup(
opSetPersPresence1.getServerStoredContactListRoot(), testGroupName);
groupChangeCollector.waitForEvent(10000);
opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector);
// check whether we got group created event
assertEquals("Collected Group Change events: ", 1, groupChangeCollector.collectedEvents.size());
assertEquals(
"Group name.",
testGroupName,
((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0))
.getSourceGroup()
.getGroupName());
// check whether the group is retrievable
ContactGroup group =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName);
assertNotNull("A newly created group was not in the contact list.", group);
assertEquals("New group name", testGroupName, group.getGroupName());
// when opearting with groups . the group must have entries
// so changes to take effect. Otherwise group will be lost after loggingout
try {
opSetPersPresence1.subscribe(group, fixture.userID2);
synchronized (o) {
o.wait(1500);
}
} catch (Exception ex) {
fail("error adding entry to group : " + group.getGroupName() + " " + ex.getMessage());
}
}
public void processAuthorizationResponse(
AuthorizationResponse response, Contact sourceContact) {
synchronized (this) {
isAuthorizationResponseReceived = true;
this.response = response;
authorizationResponseString = response.getReason();
logger.trace(
"processAuthorizationResponse '"
+ authorizationResponseString
+ "' "
+ response.getResponseCode()
+ " "
+ sourceContact);
notifyAll();
}
}
/**
* Renames our test group and checks whether corresponding events are triggered. Verifies whether
* the group has really changed its name and whether it is findable by its new name. Also makes
* sure that it does not exist under its previous name any more.
*/
public void postTestRenameGroup() {
logger.trace("Testing renaming groups.");
ContactGroup group =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName);
// first add a listener
GroupChangeCollector groupChangeCollector = new GroupChangeCollector();
opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector);
// change the name and wait for a confirmation event
opSetPersPresence1.renameServerStoredContactGroup(group, testGroupName2);
groupChangeCollector.waitForEvent(10000);
opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector);
// examine the event
assertEquals("Collected Group Change event", 1, groupChangeCollector.collectedEvents.size());
assertEquals(
"Group name.",
testGroupName2,
((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0))
.getSourceGroup()
.getGroupName());
// check whether the group is still on the contact list
ContactGroup oldGroup =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName);
assertNull("A group was still findable by its old name after renaming.", oldGroup);
// make sure that we could find the group by its new name.
ContactGroup newGroup =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2);
assertNotNull("Could not find a renamed group by its new name.", newGroup);
}
public AuthorizationResponse processAuthorisationRequest(
AuthorizationRequest req, Contact sourceContact) {
logger.debug("Processing in " + this);
synchronized (this) {
logger.trace("processAuthorisationRequest " + req + " " + sourceContact);
isAuthorizationRequestReceived = true;
authorizationRequestReason = req.getReason();
notifyAll();
// will wait as a normal user
Object lock = new Object();
synchronized (lock) {
try {
lock.wait(2000);
} catch (Exception ex) {
}
}
return responseToRequest;
}
}
/**
* The method would add a subscription for a contact, wait for a subscription event confirming the
* subscription, then change the status of the newly added contact (which is actually the
* IcqTesterAgent) and make sure that the corresponding notification events have been generated.
*
* @throws java.lang.Exception if an exception occurs during testing.
*/
public void postTestSubscribe() throws Exception {
logger.debug("Testing Subscription and Subscription Event Dispatch.");
// First create a subscription and verify that it really gets created.
SubscriptionEventCollector subEvtCollector = new SubscriptionEventCollector();
logger.trace("set Auth Handler");
operationSetPresence.setAuthorizationHandler(authEventCollector);
synchronized (authEventCollector) {
authEventCollector.authorizationRequestReason = "Please deny my request!";
fixture.testerAgent.getAuthCmdFactory().responseReasonStr =
"First authorization I will Deny!!!";
fixture.testerAgent.getAuthCmdFactory().ACCEPT = false;
operationSetPresence.subscribe(fixture.testerAgent.getIcqUIN());
// this one collects event that the buddy has been added
// to the list as awaiting
SubscriptionEventCollector moveEvtCollector = new SubscriptionEventCollector();
operationSetPresence.addSubscriptionListener(moveEvtCollector);
logger.debug("Waiting for authorization error and authorization response...");
authEventCollector.waitForAuthResponse(15000);
assertTrue(
"Error adding buddy not recieved or the buddy("
+ fixture.testerAgent.getIcqUIN()
+ ") doesn't require authorization",
authEventCollector.isAuthorizationRequestSent);
assertNotNull(
"Agent haven't received any reason for authorization",
fixture.testerAgent.getAuthCmdFactory().requestReasonStr);
assertEquals(
"Error sent request reason is not as the received one",
authEventCollector.authorizationRequestReason,
fixture.testerAgent.getAuthCmdFactory().requestReasonStr);
logger.debug(
"authEventCollector.isAuthorizationResponseReceived "
+ authEventCollector.isAuthorizationResponseReceived);
assertTrue("Response not received!", authEventCollector.isAuthorizationResponseReceived);
boolean isAcceptedAuthReuest =
authEventCollector.response.getResponseCode().equals(AuthorizationResponse.ACCEPT);
assertEquals(
"Response is not as the sent one",
fixture.testerAgent.getAuthCmdFactory().ACCEPT,
isAcceptedAuthReuest);
assertNotNull(
"We didn't receive any reason! ", authEventCollector.authorizationResponseString);
assertEquals(
"The sent response reason is not as the received one",
fixture.testerAgent.getAuthCmdFactory().responseReasonStr,
authEventCollector.authorizationResponseString);
// here we must wait for server to move the awaiting buddy
// to the first specified group
synchronized (moveEvtCollector) {
moveEvtCollector.waitForEvent(20000);
// don't want any more events
operationSetPresence.removeSubscriptionListener(moveEvtCollector);
}
Contact c = operationSetPresence.findContactByID(fixture.testerAgent.getIcqUIN());
logger.debug("I will remove " + c + " from group : " + c.getParentContactGroup());
UnsubscribeWait unsubscribeEvtCollector = new UnsubscribeWait();
operationSetPresence.addSubscriptionListener(unsubscribeEvtCollector);
synchronized (unsubscribeEvtCollector) {
operationSetPresence.unsubscribe(c);
logger.debug("Waiting to be removed...");
unsubscribeEvtCollector.waitForUnsubscribre(20000);
logger.debug("Received unsubscribed ok or we lost patients!");
// don't want any more events
operationSetPresence.removeSubscriptionListener(unsubscribeEvtCollector);
}
// so we haven't asserted so everithing is fine lets try to be authorized
authEventCollector.authorizationRequestReason = "Please accept my request!";
fixture.testerAgent.getAuthCmdFactory().responseReasonStr =
"Second authorization I will Accept!!!";
fixture.testerAgent.getAuthCmdFactory().ACCEPT = true;
// clear some things
authEventCollector.isAuthorizationRequestSent = false;
authEventCollector.isAuthorizationResponseReceived = false;
authEventCollector.authorizationResponseString = null;
logger.debug(
"I will add buddy does it exists ? "
+ (operationSetPresence.findContactByID(fixture.testerAgent.getIcqUIN()) != null));
// add the listener beacuse now our authorization will be accepted
// and so the buddy will be finally added to the list
operationSetPresence.addSubscriptionListener(subEvtCollector);
// subscribe again so we can trigger again the authorization procedure
operationSetPresence.subscribe(fixture.testerAgent.getIcqUIN());
logger.debug(
"Waiting ... Subscribe must fail and the authorization process "
+ "to be trigered again so waiting for auth response ...");
authEventCollector.waitForAuthResponse(15000);
assertTrue(
"Error adding buddy not recieved or the buddy("
+ fixture.testerAgent.getIcqUIN()
+ ") doesn't require authorization",
authEventCollector.isAuthorizationRequestSent);
assertNotNull(
"Agent haven't received any reason for authorization",
fixture.testerAgent.getAuthCmdFactory().requestReasonStr);
// not working for now
assertEquals(
"Error sent request reason",
authEventCollector.authorizationRequestReason,
fixture.testerAgent.getAuthCmdFactory().requestReasonStr);
// wait for authorization process to be finnished
// the modification of buddy (server will inform us
// that he removed - awaiting authorization flag)
Object obj = new Object();
synchronized (obj) {
logger.debug("wait for authorization process to be finnished");
obj.wait(10000);
logger.debug("Stop waiting!");
}
subEvtCollector.waitForEvent(10000);
// don't want any more events
operationSetPresence.removeSubscriptionListener(subEvtCollector);
}
// after adding awaitingAuthorization group here are catched 3 events
// 1 - creating unresolved contact
// 2 - move of the contact to awaitingAuthorization group
// 3 - move of the contact from awaitingAuthorization group to original group
assertTrue(
"Subscription event dispatching failed.", subEvtCollector.collectedEvents.size() > 0);
EventObject evt = null;
Iterator<EventObject> events = subEvtCollector.collectedEvents.iterator();
while (events.hasNext()) {
EventObject elem = events.next();
if (elem instanceof SubscriptionEvent) {
if (((SubscriptionEvent) elem).getEventID() == SubscriptionEvent.SUBSCRIPTION_CREATED)
evt = (SubscriptionEvent) elem;
}
}
Object source = null;
Contact srcContact = null;
ProtocolProviderService srcProvider = null;
// the event can be SubscriptionEvent and the new added one
// SubscriptionMovedEvent
if (evt instanceof SubscriptionEvent) {
SubscriptionEvent subEvt = (SubscriptionEvent) evt;
source = subEvt.getSource();
srcContact = subEvt.getSourceContact();
srcProvider = subEvt.getSourceProvider();
}
assertEquals(
"SubscriptionEvent Source:",
fixture.testerAgent.getIcqUIN(),
((Contact) source).getAddress());
assertEquals(
"SubscriptionEvent Source Contact:",
fixture.testerAgent.getIcqUIN(),
srcContact.getAddress());
assertSame("SubscriptionEvent Source Provider:", fixture.provider, srcProvider);
subEvtCollector.collectedEvents.clear();
// make the user agent tester change its states and make sure we are
// notified
logger.debug("Testing presence notifications.");
IcqStatusEnum testerAgentOldStatus = fixture.testerAgent.getPresneceStatus();
IcqStatusEnum testerAgentNewStatus = IcqStatusEnum.FREE_FOR_CHAT;
long testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_FFC;
// in case we are by any chance already in a FREE_FOR_CHAT status, we'll
// be changing to something else
if (testerAgentOldStatus.equals(testerAgentNewStatus)) {
testerAgentNewStatus = IcqStatusEnum.DO_NOT_DISTURB;
testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_DND;
}
// now do the actual status notification testing
ContactPresenceEventCollector contactPresEvtCollector =
new ContactPresenceEventCollector(fixture.testerAgent.getIcqUIN(), testerAgentNewStatus);
operationSetPresence.addContactPresenceStatusListener(contactPresEvtCollector);
synchronized (contactPresEvtCollector) {
if (!fixture.testerAgent.enterStatus(testerAgentNewStatusLong)) {
throw new RuntimeException(
"Tester UserAgent Failed to switch to the "
+ testerAgentNewStatus.getStatusName()
+ " state.");
}
// we may already have the event, but it won't hurt to check.
contactPresEvtCollector.waitForEvent(12000);
operationSetPresence.removeContactPresenceStatusListener(contactPresEvtCollector);
}
if (contactPresEvtCollector.collectedEvents.size() == 0) {
logger.info(
"PROBLEM. Authorisation process doesn't have finnished "
+ "Server doesn't report us for changing authorization flag! Will try to authorize once again");
fixture.testerAgent.sendAuthorizationReplay(
fixture.icqAccountID.getUserID(),
fixture.testerAgent.getAuthCmdFactory().responseReasonStr,
fixture.testerAgent.getAuthCmdFactory().ACCEPT);
Object obj = new Object();
synchronized (obj) {
logger.debug("wait for authorization process to be finnished for second time");
obj.wait(10000);
logger.debug("Stop waiting!");
}
testerAgentOldStatus = fixture.testerAgent.getPresneceStatus();
testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_FFC;
// in case we are by any chance already in a FREE_FOR_CHAT status, we'll
// be changing to something else
if (testerAgentOldStatus.equals(testerAgentNewStatus)) {
testerAgentNewStatus = IcqStatusEnum.OCCUPIED;
testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_OCCUPIED;
}
contactPresEvtCollector =
new ContactPresenceEventCollector(fixture.testerAgent.getIcqUIN(), testerAgentNewStatus);
operationSetPresence.addContactPresenceStatusListener(contactPresEvtCollector);
synchronized (contactPresEvtCollector) {
if (!fixture.testerAgent.enterStatus(testerAgentNewStatusLong)) {
throw new RuntimeException(
"Tester UserAgent Failed to switch to the "
+ testerAgentNewStatus.getStatusName()
+ " state.");
}
// we may already have the event, but it won't hurt to check.
contactPresEvtCollector.waitForEvent(12000);
operationSetPresence.removeContactPresenceStatusListener(contactPresEvtCollector);
}
}
assertEquals(
"Presence Notif. event dispatching failed.",
1,
contactPresEvtCollector.collectedEvents.size());
ContactPresenceStatusChangeEvent presEvt =
(ContactPresenceStatusChangeEvent) contactPresEvtCollector.collectedEvents.get(0);
assertEquals(
"Presence Notif. event Source:",
fixture.testerAgent.getIcqUIN(),
((Contact) presEvt.getSource()).getAddress());
assertEquals(
"Presence Notif. event Source Contact:",
fixture.testerAgent.getIcqUIN(),
presEvt.getSourceContact().getAddress());
assertSame(
"Presence Notif. event Source Provider:", fixture.provider, presEvt.getSourceProvider());
PresenceStatus reportedNewStatus = presEvt.getNewStatus();
PresenceStatus reportedOldStatus = presEvt.getOldStatus();
assertEquals("Reported new PresenceStatus: ", testerAgentNewStatus, reportedNewStatus);
// don't require equality between the reported old PresenceStatus and
// the actual presence status of the tester agent because a first
// notification is not supposed to have the old status as it really was.
assertNotNull("Reported old PresenceStatus: ", reportedOldStatus);
/** @todo tester agent changes status message we see the new message */
/** @todo we should see the alias of the tester agent. */
Object obj = new Object();
synchronized (obj) {
logger.debug("wait a moment. give time to server");
obj.wait(4000);
}
}
/**
* Used by methods testing state transiotions
*
* @param newStatus the IcqStatusEnum field corresponding to the status that we'd like the
* opeation set to enter.
* @throws Exception in case changing the state causes an exception
*/
public void subtestStateTransition(IcqStatusEnum newStatus) throws Exception {
logger.trace(" --=== beginning state transition test ===--");
PresenceStatus oldStatus = operationSetPresence.getPresenceStatus();
String oldStatusMessage = operationSetPresence.getCurrentStatusMessage();
String newStatusMessage = statusMessageRoot + newStatus;
logger.debug(
"old status is=" + oldStatus.getStatusName() + " new status=" + newStatus.getStatusName());
// First register a listener to make sure that all corresponding
// events have been generated.
PresenceStatusEventCollector statusEventCollector = new PresenceStatusEventCollector();
operationSetPresence.addProviderPresenceStatusListener(statusEventCollector);
// change the status
operationSetPresence.publishPresenceStatus(newStatus, newStatusMessage);
// test event notification.
statusEventCollector.waitForPresEvent(10000);
statusEventCollector.waitForStatMsgEvent(10000);
// sometimes we don't get response from the server for the
// changed status. we will query it once again.
// and wait for the response
if (statusEventCollector.collectedPresEvents.size() == 0) {
logger.trace("Will query again status as we haven't received one");
operationSetPresence.queryContactStatus(fixture.icqAccountID.getUserID());
statusEventCollector.waitForPresEvent(10000);
}
operationSetPresence.removeProviderPresenceStatusListener(statusEventCollector);
assertEquals(
"Events dispatched during an event transition.",
1,
statusEventCollector.collectedPresEvents.size());
assertEquals(
"A status changed event contained wrong old status.",
oldStatus,
((ProviderPresenceStatusChangeEvent) statusEventCollector.collectedPresEvents.get(0))
.getOldStatus());
assertEquals(
"A status changed event contained wrong new status.",
newStatus,
((ProviderPresenceStatusChangeEvent) statusEventCollector.collectedPresEvents.get(0))
.getNewStatus());
// verify that the operation set itself is aware of the status change
assertEquals(
"opSet.getPresenceStatus() did not return properly.",
newStatus,
operationSetPresence.getPresenceStatus());
IcqStatusEnum actualStatus =
fixture.testerAgent.getBuddyStatus(fixture.icqAccountID.getUserID());
assertEquals(
"The underlying implementation did not switch to the " + "requested presence status.",
newStatus,
actualStatus);
// check whether the server returned the status message that we've set.
assertEquals(
"No status message events.", 1, statusEventCollector.collectedStatMsgEvents.size());
assertEquals(
"A status message event contained wrong old value.",
oldStatusMessage,
((PropertyChangeEvent) statusEventCollector.collectedStatMsgEvents.get(0)).getOldValue());
assertEquals(
"A status message event contained wrong new value.",
newStatusMessage,
((PropertyChangeEvent) statusEventCollector.collectedStatMsgEvents.get(0)).getNewValue());
// verify that the operation set itself is aware of the new status msg.
assertEquals(
"opSet.getCurrentStatusMessage() did not return properly.",
newStatusMessage,
operationSetPresence.getCurrentStatusMessage());
logger.trace(" --=== finished test ===--");
// make it sleep a bit cause the aol server gets mad otherwise.
pauseBetweenStateChanges();
}