446 lines
16 KiB
Java
446 lines
16 KiB
Java
/**
|
|
*
|
|
* Copyright 2010 Jive Software.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.jivesoftware.smack;
|
|
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.fail;
|
|
|
|
import org.jivesoftware.smack.ChatManager.MatchMode;
|
|
import org.jivesoftware.smack.packet.Message;
|
|
import org.jivesoftware.smack.packet.Message.Type;
|
|
import org.jivesoftware.smack.packet.Packet;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
|
|
public class ChatConnectionTest {
|
|
|
|
private DummyConnection connection;
|
|
|
|
@Before
|
|
public void setUp() throws Exception {
|
|
connection = getConnection();
|
|
}
|
|
|
|
@After
|
|
public void tearDown() throws Exception {
|
|
if (connection != null)
|
|
connection.disconnect();
|
|
}
|
|
|
|
@Test
|
|
public void validateDefaultSetNormalIncluded() {
|
|
ChatManager.setDefaultIsNormalIncluded(false);
|
|
assertFalse(ChatManager.getInstanceFor(getConnection()).isNormalIncluded());
|
|
|
|
ChatManager.setDefaultIsNormalIncluded(true);
|
|
assertTrue(ChatManager.getInstanceFor(getConnection()).isNormalIncluded());
|
|
}
|
|
|
|
@Test
|
|
public void validateDefaultSetMatchMode() {
|
|
ChatManager.setDefaultMatchMode(MatchMode.NONE);
|
|
assertEquals(MatchMode.NONE, ChatManager.getInstanceFor(getConnection()).getMatchMode());
|
|
|
|
ChatManager.setDefaultMatchMode(MatchMode.BARE_JID);
|
|
assertEquals(MatchMode.BARE_JID, ChatManager.getInstanceFor(getConnection()).getMatchMode());
|
|
}
|
|
|
|
@Test
|
|
public void validateMessageTypeWithDefaults() {
|
|
DummyConnection dc = getConnection();
|
|
ChatManager cm = ChatManager.getInstanceFor(dc);
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
Message incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.chat);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNotNull(listener.getNewChat());
|
|
|
|
dc = getConnection();
|
|
cm = ChatManager.getInstanceFor(dc);
|
|
listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.normal);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNotNull(listener.getNewChat());
|
|
|
|
dc = getConnection();
|
|
cm = ChatManager.getInstanceFor(dc);
|
|
listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.groupchat);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNull(listener.getNewChat());
|
|
|
|
dc = getConnection();
|
|
cm = ChatManager.getInstanceFor(dc);
|
|
listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.headline);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNull(listener.getNewChat());
|
|
}
|
|
|
|
@Test
|
|
public void validateMessageTypeWithNoNormal() {
|
|
DummyConnection dc = getConnection();
|
|
ChatManager cm = ChatManager.getInstanceFor(dc);
|
|
cm.setNormalIncluded(false);
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
Message incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.chat);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNotNull(listener.getNewChat());
|
|
|
|
dc = getConnection();
|
|
cm = ChatManager.getInstanceFor(dc);
|
|
cm.setNormalIncluded(false);
|
|
listener = new TestChatManagerListener();
|
|
cm.addChatListener(listener);
|
|
incomingChat = createChatPacket("134", true);
|
|
incomingChat.setType(Type.normal);
|
|
processServerMessage(incomingChat, dc);
|
|
assertNull(listener.getNewChat());
|
|
}
|
|
|
|
// No thread behaviour
|
|
@Test
|
|
public void chatMatchedOnJIDWhenNoThreadBareMode() {
|
|
// MatchMode.BARE_JID is the default, so setting required.
|
|
DummyConnection con = getConnection();
|
|
TestMessageListener msgListener = new TestMessageListener();
|
|
TestChatManagerListener listener = new TestChatManagerListener(msgListener);
|
|
ChatManager cm = ChatManager.getInstanceFor(con);
|
|
cm.addChatListener(listener);
|
|
Packet incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
|
|
// Should match on chat with full jid
|
|
incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(2, msgListener.getNumMessages());
|
|
|
|
// Should match on chat with bare jid
|
|
incomingChat = createChatPacket(null, false);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(3, msgListener.getNumMessages());
|
|
}
|
|
|
|
@Test
|
|
public void chatMatchedOnJIDWhenNoThreadJidMode() {
|
|
DummyConnection con = getConnection();
|
|
TestMessageListener msgListener = new TestMessageListener();
|
|
TestChatManagerListener listener = new TestChatManagerListener(msgListener);
|
|
ChatManager cm = ChatManager.getInstanceFor(con);
|
|
cm.setMatchMode(MatchMode.SUPPLIED_JID);
|
|
cm.addChatListener(listener);
|
|
Packet incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
cm.removeChatListener(listener);
|
|
|
|
// Should match on chat with full jid
|
|
incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(2, msgListener.getNumMessages());
|
|
|
|
// Should not match on chat with bare jid
|
|
TestChatManagerListener listener2 = new TestChatManagerListener();
|
|
cm.addChatListener(listener2);
|
|
incomingChat = createChatPacket(null, false);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(2, msgListener.getNumMessages());
|
|
assertNotNull(listener2.getNewChat());
|
|
}
|
|
|
|
@Test
|
|
public void chatMatchedOnJIDWhenNoThreadNoneMode() {
|
|
DummyConnection con = getConnection();
|
|
TestMessageListener msgListener = new TestMessageListener();
|
|
TestChatManagerListener listener = new TestChatManagerListener(msgListener);
|
|
ChatManager cm = ChatManager.getInstanceFor(con);
|
|
cm.setMatchMode(MatchMode.NONE);
|
|
cm.addChatListener(listener);
|
|
Packet incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertEquals(1, msgListener.getNumMessages());
|
|
cm.removeChatListener(listener);
|
|
|
|
// Should not match on chat with full jid
|
|
TestChatManagerListener listener2 = new TestChatManagerListener();
|
|
cm.addChatListener(listener2);
|
|
incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(1, msgListener.getNumMessages());
|
|
assertNotNull(newChat);
|
|
cm.removeChatListener(listener2);
|
|
|
|
// Should not match on chat with bare jid
|
|
TestChatManagerListener listener3 = new TestChatManagerListener();
|
|
cm.addChatListener(listener3);
|
|
incomingChat = createChatPacket(null, false);
|
|
processServerMessage(incomingChat, con);
|
|
assertEquals(1, msgListener.getNumMessages());
|
|
assertNotNull(listener3.getNewChat());
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is matched to an incoming chat message that has no thread
|
|
* id and the user is a full jid.
|
|
*/
|
|
@Test
|
|
public void chatFoundWhenNoThreadFullJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(null, true);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertTrue(newChat == outgoing);
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is matched to an incoming chat message that has no thread
|
|
* id and the user is a base jid.
|
|
*/
|
|
@Test
|
|
public void chatFoundWhenNoThreadBaseJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(null, false);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertTrue(newChat == outgoing);
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is matched to an incoming chat message that has the same id
|
|
* and the user is a full jid.
|
|
*/
|
|
@Test
|
|
public void chatFoundWithSameThreadFullJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(outgoing.getThreadID(), true);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertTrue(newChat == outgoing);
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is matched to an incoming chat message that has the same id
|
|
* and the user is a base jid.
|
|
*/
|
|
@Test
|
|
public void chatFoundWithSameThreadBaseJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(outgoing.getThreadID(), false);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertTrue(newChat == outgoing);
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is not matched to an incoming chat message that has a
|
|
* different id and the same user as a base jid.
|
|
*/
|
|
@Test
|
|
public void chatNotFoundWithDiffThreadBaseJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(outgoing.getThreadID() + "ff", false);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertFalse(newChat == outgoing);
|
|
}
|
|
|
|
/**
|
|
* Confirm that an existing chat created with a base jid is not matched to an incoming chat message that has a
|
|
* different id and the same base jid.
|
|
*/
|
|
@Test
|
|
public void chatNotFoundWithDiffThreadFullJid() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
ChatManager cm = ChatManager.getInstanceFor(connection);
|
|
cm.addChatListener(listener);
|
|
Chat outgoing = cm.createChat("you@testserver", null);
|
|
|
|
Packet incomingChat = createChatPacket(outgoing.getThreadID() + "ff", true);
|
|
processServerMessage(incomingChat);
|
|
|
|
Chat newChat = listener.getNewChat();
|
|
assertNotNull(newChat);
|
|
assertFalse(newChat == outgoing);
|
|
}
|
|
|
|
@Test
|
|
public void chatNotMatchedWithTypeNormal() {
|
|
TestChatManagerListener listener = new TestChatManagerListener();
|
|
DummyConnection con = getConnection();
|
|
ChatManager cm = ChatManager.getInstanceFor(con);
|
|
cm.setNormalIncluded(false);
|
|
cm.addChatListener(listener);
|
|
|
|
Message incomingChat = createChatPacket(null, false);
|
|
incomingChat.setType(Type.normal);
|
|
processServerMessage(incomingChat);
|
|
|
|
assertNull(listener.getNewChat());
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
private ChatManager getChatManager(boolean includeNormal, MatchMode mode) {
|
|
ChatManager cm = ChatManager.getInstanceFor(getConnection());
|
|
cm.setMatchMode(mode);
|
|
cm.setNormalIncluded(includeNormal);
|
|
return cm;
|
|
}
|
|
|
|
private DummyConnection getConnection() {
|
|
DummyConnection con = new DummyConnection();
|
|
|
|
try {
|
|
con.connect();
|
|
con.login("me", "secret");
|
|
} catch (Exception e) {
|
|
// No need for handling in a dummy connection.
|
|
}
|
|
return con;
|
|
}
|
|
private Message createChatPacket(final String threadId, final boolean isFullJid) {
|
|
Message chatMsg = new Message("me@testserver", Message.Type.chat);
|
|
chatMsg.setBody("the body message - " + System.currentTimeMillis());
|
|
chatMsg.setFrom("you@testserver" + (isFullJid ? "/resource" : ""));
|
|
|
|
if (threadId != null)
|
|
chatMsg.setThread(threadId);
|
|
return chatMsg;
|
|
}
|
|
|
|
private void processServerMessage(Packet incomingChat) {
|
|
processServerMessage(incomingChat, connection);
|
|
}
|
|
|
|
private void processServerMessage(Packet incomingChat, DummyConnection con) {
|
|
TestChatServer chatServer = new TestChatServer(incomingChat, con);
|
|
chatServer.start();
|
|
try {
|
|
chatServer.join();
|
|
} catch (InterruptedException e) {
|
|
fail();
|
|
}
|
|
}
|
|
|
|
class TestChatManagerListener implements ChatManagerListener {
|
|
private Chat newChat;
|
|
private ChatMessageListener listener;
|
|
|
|
public TestChatManagerListener(TestMessageListener msgListener) {
|
|
listener = msgListener;
|
|
}
|
|
|
|
public TestChatManagerListener() {
|
|
}
|
|
|
|
@Override
|
|
public void chatCreated(Chat chat, boolean createdLocally) {
|
|
newChat = chat;
|
|
|
|
if (listener != null)
|
|
newChat.addMessageListener(listener);
|
|
}
|
|
|
|
public Chat getNewChat() {
|
|
return newChat;
|
|
}
|
|
}
|
|
|
|
private class TestChatServer extends Thread {
|
|
private Packet chatPacket;
|
|
private DummyConnection con;
|
|
|
|
TestChatServer(Packet chatMsg, DummyConnection conect) {
|
|
chatPacket = chatMsg;
|
|
con = conect;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
con.processPacket(chatPacket);
|
|
}
|
|
}
|
|
|
|
private class TestMessageListener implements ChatMessageListener {
|
|
private Chat msgChat;
|
|
private int counter = 0;
|
|
|
|
@Override
|
|
public void processMessage(Chat chat, Message message) {
|
|
msgChat = chat;
|
|
counter++;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public Chat getChat() {
|
|
return msgChat;
|
|
}
|
|
|
|
public int getNumMessages() {
|
|
return counter;
|
|
}
|
|
}
|
|
}
|