/** Tests whether there is a offline message received and whether is the one we have send */
public void testReceiveOfflineMessages() {
String messageText = fixture.offlineMsgCollector.getMessageText();
Message receiveMessage = fixture.offlineMsgCollector.getReceivedMessage();
assertNotNull("No Offline messages have been received", receiveMessage);
assertEquals("message body", messageText, receiveMessage.getContent());
}
/**
* When a sent message is delivered shows it in the chat conversation panel.
*
* @param evt the event containing details on the message delivery
*/
public void messageDelivered(MessageDeliveredEvent evt) {
Contact contact = evt.getDestinationContact();
MetaContact metaContact =
GuiActivator.getContactListService().findMetaContactByContact(contact);
if (logger.isTraceEnabled())
logger.trace("MESSAGE DELIVERED to contact: " + contact.getAddress());
ChatPanel chatPanel = chatWindowManager.getContactChat(metaContact, false);
if (chatPanel != null) {
Message msg = evt.getSourceMessage();
ProtocolProviderService protocolProvider = contact.getProtocolProvider();
if (logger.isTraceEnabled())
logger.trace(
"MESSAGE DELIVERED: process message to chat for contact: "
+ contact.getAddress()
+ " MESSAGE: "
+ msg.getContent());
chatPanel.addMessage(
this.mainFrame.getAccountAddress(protocolProvider),
this.mainFrame.getAccountDisplayName(protocolProvider),
evt.getTimestamp(),
Chat.OUTGOING_MESSAGE,
msg.getContent(),
msg.getContentType(),
msg.getMessageUID(),
evt.getCorrectedMessageUID());
if (evt.isSmsMessage() && !ConfigurationUtils.isSmsNotifyTextDisabled()) {
chatPanel.addMessage(
contact.getDisplayName(),
new Date(),
Chat.ACTION_MESSAGE,
GuiActivator.getResources().getI18NString("service.gui.SMS_SUCCESSFULLY_SENT"),
"text");
}
}
}
/**
* Shows a warning message to the user when message delivery has failed.
*
* @param evt the event containing details on the message delivery failure
*/
public void messageDeliveryFailed(MessageDeliveryFailedEvent evt) {
logger.error(evt.getReason());
String errorMsg = null;
Message sourceMessage = (Message) evt.getSource();
Contact sourceContact = evt.getDestinationContact();
MetaContact metaContact =
GuiActivator.getContactListService().findMetaContactByContact(sourceContact);
if (evt.getErrorCode() == MessageDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED) {
errorMsg =
GuiActivator.getResources()
.getI18NString(
"service.gui.MSG_DELIVERY_NOT_SUPPORTED",
new String[] {sourceContact.getDisplayName()});
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.NETWORK_FAILURE) {
errorMsg = GuiActivator.getResources().getI18NString("service.gui.MSG_NOT_DELIVERED");
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.PROVIDER_NOT_REGISTERED) {
errorMsg =
GuiActivator.getResources().getI18NString("service.gui.MSG_SEND_CONNECTION_PROBLEM");
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.INTERNAL_ERROR) {
errorMsg =
GuiActivator.getResources().getI18NString("service.gui.MSG_DELIVERY_INTERNAL_ERROR");
} else {
errorMsg = GuiActivator.getResources().getI18NString("service.gui.MSG_DELIVERY_ERROR");
}
String reason = evt.getReason();
if (reason != null)
errorMsg +=
" "
+ GuiActivator.getResources()
.getI18NString("service.gui.ERROR_WAS", new String[] {reason});
ChatPanel chatPanel = chatWindowManager.getContactChat(metaContact, sourceContact);
chatPanel.addMessage(
sourceContact.getAddress(),
metaContact.getDisplayName(),
new Date(),
Chat.OUTGOING_MESSAGE,
sourceMessage.getContent(),
sourceMessage.getContentType(),
sourceMessage.getMessageUID(),
evt.getCorrectedMessageUID());
chatPanel.addErrorMessage(metaContact.getDisplayName(), errorMsg);
chatWindowManager.openChat(chatPanel, false);
}
/**
* Sends the <tt>message</tt> to the destination indicated by the <tt>to</tt> contact.
*
* @param to the <tt>Contact</tt> to send <tt>message</tt> to
* @param message the <tt>Message</tt> to send.
* @throws IllegalStateException if the underlying ICQ stack is not registered and initialized.
* @throws IllegalArgumentException if <tt>to</tt> is not an instance belonging to the underlying
* implementation.
*/
public void sendInstantMessage(Contact to, Message message)
throws IllegalStateException, IllegalArgumentException {
if (!(to instanceof ContactDictImpl)) {
throw new IllegalArgumentException("The specified contact is not a Dict contact." + to);
}
// Remove all html tags from the message
message = createMessage(Html2Text.extractText(message.getContent()));
// Display the queried word
fireMessageDelivered(message, to);
this.submitDictQuery((ContactDictImpl) to, message);
}
/**
* Send an instant message from the tester agent and assert reception by the tested implementation
*/
public void thenTestSendMessage() {
String body =
"This is an IM coming from the tested implementation" + " on " + new Date().toString();
// create the message
net.java.sip.communicator.service.protocol.Message msg = opSetBasicIM.createMessage(body);
// register a listener in the op set
ImEventCollector imEvtCollector = new ImEventCollector();
opSetBasicIM.addMessageListener(imEvtCollector);
// register a listener in the tester agent
JoustSimMessageEventCollector jsEvtCollector = new JoustSimMessageEventCollector();
fixture.testerAgent.addConversationListener(fixture.ourUserID, jsEvtCollector);
Contact testerAgentContact = opSetPresence.findContactByID(fixture.testerAgent.getIcqUIN());
opSetBasicIM.sendInstantMessage(testerAgentContact, msg);
imEvtCollector.waitForEvent(10000);
jsEvtCollector.waitForEvent(10000);
fixture.testerAgent.removeConversationListener(fixture.ourUserID, jsEvtCollector);
opSetBasicIM.removeMessageListener(imEvtCollector);
// verify that the message delivered event was dispatched
assertTrue(
"No events delivered when sending a message", imEvtCollector.collectedEvents.size() > 0);
assertTrue(
"Received evt was not an instance of " + MessageDeliveredEvent.class.getName(),
imEvtCollector.collectedEvents.get(0) instanceof MessageDeliveredEvent);
MessageDeliveredEvent evt = (MessageDeliveredEvent) imEvtCollector.collectedEvents.get(0);
assertEquals(
"message destination ",
evt.getDestinationContact().getAddress(),
fixture.testerAgent.getIcqUIN());
assertSame("source message", msg, evt.getSourceMessage());
// verify that the message has successfully arived at the destination
assertTrue(
"No messages received by the tester agent", jsEvtCollector.collectedMessageInfo.size() > 0);
String receivedBody =
((MessageInfo) jsEvtCollector.collectedMessageInfo.get(0)).getMessage().getMessageBody();
assertEquals("received message body", msg.getContent(), receivedBody);
}
/**
* Create, execute and display a query to a dictionary (ContactDictImpl)
*
* @param dictContact the contact containing the database name
* @param message the message containing the word
*/
private void submitDictQuery(ContactDictImpl dictContact, Message message) {
Message msg = this.createMessage("");
String database = dictContact.getContactID();
DictConnection conn = this.parentProvider.getConnection();
boolean doMatch = false;
String word;
// Formatting the query message, if the word as one or more spaces we
// put it between quotes to prevent errors
word = message.getContent().replace("\"", "").trim();
if (word.indexOf(' ') > 0) {
word = "\"" + word + "\"";
}
// Try to get the definition of the work
try {
List<Definition> definitions = conn.define(database, word);
msg = this.createMessage(retrieveDefine(definitions, word));
} catch (DictException dx) {
if (dx.getErrorCode()
== DictReturnCode.NO_MATCH) { // No word found, we are going to try the match command
doMatch = true;
} else { // Otherwise we display the error returned by the server
msg = this.createMessage(manageException(dx, database));
}
}
if (doMatch) {
// Trying the match command
try {
List<MatchWord> matchWords = conn.match(database, word, this.accountID.getStrategy());
msg = this.createMessage(retrieveMatch(matchWords, word));
} catch (DictException dx) {
msg = this.createMessage(manageException(dx, database));
}
}
// Send message
fireMessageReceived(msg, dictContact);
}
/** Creates an Message through the advance createMessage() method and inspects its parameters. */
public void testCreateMessage2() {
String body =
"This is an IM coming from the tested implementation" + " on " + new Date().toString();
String contentType = "text/html";
String encoding = "UTF-16";
String subject = "test message";
net.java.sip.communicator.service.protocol.Message msg =
opSetBasicIM.createMessage(body.getBytes(), contentType, encoding, subject);
assertEquals("message body", body, msg.getContent());
assertTrue("message body bytes", Arrays.equals(body.getBytes(), msg.getRawData()));
assertEquals("message length", body.length(), msg.getSize());
assertEquals("message content type", contentType, msg.getContentType());
assertEquals("message encoding", encoding, msg.getEncoding());
assertNotNull("message uid", msg.getMessageUID());
// a further test on message uid.
net.java.sip.communicator.service.protocol.Message msg2 = opSetBasicIM.createMessage(body);
assertFalse("message uid", msg.getMessageUID().equals(msg2.getMessageUID()));
}
/** Creates an Message through the simple createMessage() method and inspects its parameters. */
public void testCreateMessage1() {
String body =
"This is an IM coming from the tested implementation" + " on " + new Date().toString();
net.java.sip.communicator.service.protocol.Message msg = opSetBasicIM1.createMessage(body);
assertEquals("message body", body, msg.getContent());
assertTrue("message body bytes", Arrays.equals(body.getBytes(), msg.getRawData()));
assertEquals("message length", body.length(), msg.getSize());
assertEquals(
"message content type",
OperationSetBasicInstantMessaging.DEFAULT_MIME_TYPE,
msg.getContentType());
assertEquals(
"message encoding",
OperationSetBasicInstantMessaging.DEFAULT_MIME_ENCODING,
msg.getEncoding());
assertNotNull("message uid", msg.getMessageUID());
// a further test on message uid.
net.java.sip.communicator.service.protocol.Message msg2 = opSetBasicIM1.createMessage(body);
assertFalse("message uid", msg.getMessageUID().equals(msg2.getMessageUID()));
}
/**
* Send an instant message from the tester agent and assert reception by the tested implementation
*/
public void thenTestSendMessage() {
logger.debug(
"Printing Server Stored list to see if message fails are contacts in each other lists");
ContactGroup rootGroup1 =
((OperationSetPersistentPresence) opSetPresence1).getServerStoredContactListRoot();
logger.debug("=========== Server Stored Contact List 1 =================");
logger.debug(
"rootGroup="
+ rootGroup1.getGroupName()
+ " rootGroup.childContacts="
+ rootGroup1.countContacts()
+ "rootGroup.childGroups="
+ rootGroup1.countSubgroups()
+ "Printing rootGroupContents=\n"
+ rootGroup1.toString());
ContactGroup rootGroup2 =
((OperationSetPersistentPresence) opSetPresence2).getServerStoredContactListRoot();
logger.debug("=========== Server Stored Contact List 2 =================");
logger.debug(
"rootGroup="
+ rootGroup2.getGroupName()
+ " rootGroup.childContacts="
+ rootGroup2.countContacts()
+ "rootGroup.childGroups="
+ rootGroup2.countSubgroups()
+ "Printing rootGroupContents=\n"
+ rootGroup2.toString());
String body =
"This is an IM coming from the tested implementation" + " on " + new Date().toString();
// create the message
net.java.sip.communicator.service.protocol.Message msg = opSetBasicIM1.createMessage(body);
// register a listener in the op set
ImEventCollector imEvtCollector1 = new ImEventCollector();
opSetBasicIM1.addMessageListener(imEvtCollector1);
// register a listener in the tester agent
ImEventCollector imEvtCollector2 = new ImEventCollector();
opSetBasicIM2.addMessageListener(imEvtCollector2);
Contact testerAgentContact = opSetPresence1.findContactByID(fixture.userID2);
opSetBasicIM1.sendInstantMessage(testerAgentContact, msg);
imEvtCollector1.waitForEvent(10000);
imEvtCollector2.waitForEvent(10000);
opSetBasicIM1.removeMessageListener(imEvtCollector1);
opSetBasicIM2.removeMessageListener(imEvtCollector2);
// verify that the message delivered event was dispatched
assertTrue(
"No events delivered when sending a message", imEvtCollector1.collectedEvents.size() > 0);
assertTrue(
"Received evt was not an instance of " + MessageDeliveredEvent.class.getName(),
imEvtCollector1.collectedEvents.get(0) instanceof MessageDeliveredEvent);
MessageDeliveredEvent evt = (MessageDeliveredEvent) imEvtCollector1.collectedEvents.get(0);
assertEquals("message destination ", evt.getDestinationContact().getAddress(), fixture.userID2);
assertSame("source message", msg, evt.getSourceMessage());
// verify that the message has successfully arived at the destination
assertTrue(
"No messages received by the tester agent", imEvtCollector2.collectedEvents.size() > 0);
assertFalse(
"Message was unable to deliver !",
imEvtCollector2.collectedEvents.get(0) instanceof MessageDeliveryFailedEvent);
String receivedBody =
((MessageReceivedEvent) imEvtCollector2.collectedEvents.get(0))
.getSourceMessage()
.getContent();
assertEquals("received message body", msg.getContent(), receivedBody);
}
/**
* When a message is received determines whether to open a new chat window or chat window tab, or
* to indicate that a message is received from a contact which already has an open chat. When the
* chat is found checks if in mode "Auto popup enabled" and if this is the case shows the message
* in the appropriate chat panel.
*
* @param protocolContact the source contact of the event
* @param contactResource the resource from which the contact is writing
* @param metaContact the metacontact containing <tt>protocolContact</tt>
* @param message the message to deliver
* @param eventType the event type
* @param timestamp the timestamp of the event
* @param correctedMessageUID the identifier of the corrected message
* @param isPrivateMessaging if <tt>true</tt> the message is received from private messaging
* contact.
* @param privateContactRoom the chat room associated with the private messaging contact.
*/
private void messageReceived(
final Contact protocolContact,
final ContactResource contactResource,
final MetaContact metaContact,
final Message message,
final int eventType,
final Date timestamp,
final String correctedMessageUID,
final boolean isPrivateMessaging,
final ChatRoom privateContactRoom) {
if (!SwingUtilities.isEventDispatchThread()) {
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
messageReceived(
protocolContact,
contactResource,
metaContact,
message,
eventType,
timestamp,
correctedMessageUID,
isPrivateMessaging,
privateContactRoom);
}
});
return;
}
// Obtain the corresponding chat panel.
final ChatPanel chatPanel =
chatWindowManager.getContactChat(
metaContact, protocolContact, contactResource, message.getMessageUID());
// Show an envelope on the sender contact in the contact list and
// in the systray.
if (!chatPanel.isChatFocused()) contactList.setActiveContact(metaContact, true);
// Distinguish the message type, depending on the type of event that
// we have received.
String messageType = null;
if (eventType == MessageReceivedEvent.CONVERSATION_MESSAGE_RECEIVED) {
messageType = Chat.INCOMING_MESSAGE;
} else if (eventType == MessageReceivedEvent.SYSTEM_MESSAGE_RECEIVED) {
messageType = Chat.SYSTEM_MESSAGE;
} else if (eventType == MessageReceivedEvent.SMS_MESSAGE_RECEIVED) {
messageType = Chat.SMS_MESSAGE;
}
String contactAddress =
(contactResource != null)
? protocolContact.getAddress() + " (" + contactResource.getResourceName() + ")"
: protocolContact.getAddress();
chatPanel.addMessage(
contactAddress,
protocolContact.getDisplayName(),
timestamp,
messageType,
message.getContent(),
message.getContentType(),
message.getMessageUID(),
correctedMessageUID);
String resourceName = (contactResource != null) ? contactResource.getResourceName() : null;
if (isPrivateMessaging) {
chatWindowManager.openPrivateChatForChatRoomMember(privateContactRoom, protocolContact);
} else {
chatWindowManager.openChat(chatPanel, false);
}
ChatTransport chatTransport =
chatPanel.getChatSession().findChatTransportForDescriptor(protocolContact, resourceName);
chatPanel.setSelectedChatTransport(chatTransport, true);
}