From f5c5213e61651be3d0376b827c8de62e10d0f0e7 Mon Sep 17 00:00:00 2001 From: Matt Tucker Date: Sun, 23 Jul 2006 22:15:43 +0000 Subject: [PATCH] Privacy and error test cases. git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@4651 b35dd754-fafc-0310-a699-88a17e54d16e --- .../org/jivesoftware/smack/PrivacyClient.java | 41 ++ test/org/jivesoftware/smack/PrivacyTest.java | 455 ++++++++++++++++++ .../smack/packet/PrivacyProviderTest.java | 370 ++++++++++++++ .../smack/util/XMPPErrorTest.java | 187 +++++++ 4 files changed, 1053 insertions(+) create mode 100644 test/org/jivesoftware/smack/PrivacyClient.java create mode 100644 test/org/jivesoftware/smack/PrivacyTest.java create mode 100644 test/org/jivesoftware/smack/packet/PrivacyProviderTest.java create mode 100644 test/org/jivesoftware/smack/util/XMPPErrorTest.java diff --git a/test/org/jivesoftware/smack/PrivacyClient.java b/test/org/jivesoftware/smack/PrivacyClient.java new file mode 100644 index 000000000..4f31c76ef --- /dev/null +++ b/test/org/jivesoftware/smack/PrivacyClient.java @@ -0,0 +1,41 @@ +package org.jivesoftware.smack; + +import java.util.List; + +import org.jivesoftware.smack.packet.Privacy; + +/** + * This class supports automated tests about privacy communication from the + * server to the client. + * + * @author Francisco Vives + */ + +public class PrivacyClient implements PrivacyListListener { + /** + * holds if the receiver list was modified + */ + private boolean wasModified = false; + + /** + * holds a privacy to hold server requests Clients should not use Privacy + * class since it is private for the smack framework. + */ + private Privacy privacy = new Privacy(); + + public PrivacyClient(PrivacyListManager manager) { + super(); + } + + public void setPrivacyList(String listName, List listItem) { + privacy.setPrivacyList(listName, listItem); + } + + public void updatedPrivacyList(String listName) { + this.wasModified = true; + } + + public boolean wasModified() { + return this.wasModified; + } +} diff --git a/test/org/jivesoftware/smack/PrivacyTest.java b/test/org/jivesoftware/smack/PrivacyTest.java new file mode 100644 index 000000000..0e41d5f4f --- /dev/null +++ b/test/org/jivesoftware/smack/PrivacyTest.java @@ -0,0 +1,455 @@ +package org.jivesoftware.smack; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.jivesoftware.smack.packet.PrivacyItem; +import org.jivesoftware.smack.packet.PrivacyItem.PrivacyRule; +import org.jivesoftware.smack.test.SmackTestCase; + +public class PrivacyTest extends SmackTestCase { + + public PrivacyTest(String arg0) { + super(arg0); + } + + + /** + * Check when a client set a new active list. + */ + public void testCreateActiveList() { + try { + String listName = "testCreateActiveList"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + // Add the list that will be set as the active + ArrayList items = new ArrayList(); + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, 1); + item.setValue(getConnection(0).getUser()); + items.add(item); + privacyManager.createPrivacyList(listName, items); + + Thread.sleep(500); + + // Set the active list + privacyManager.setActiveListName(listName); + + Thread.sleep(500); + + // Assert the list composition. + assertEquals(listName, privacyManager.getActiveList().toString()); + List privacyItems = privacyManager.getPrivacyList(listName).getItems(); + assertEquals(1, privacyItems.size()); + + // Assert the privacy item composition + PrivacyItem receivedItem = (PrivacyItem) privacyItems.get(0); + assertEquals(1, receivedItem.getOrder()); + assertEquals(PrivacyRule.JID, receivedItem.getType()); + assertEquals(true, receivedItem.isAllow()); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client set more than one list. + */ + public void testCreateTwoLists() { + try { + String listName1 = "1testCreateTwoLists"; + String listName2 = "2testCreateTwoLists"; + String groupName = "testCreateTwoListsGroup"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + // Add a list + ArrayList items = new ArrayList(); + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, 1); + item.setValue(getConnection(0).getUser()); + items.add(item); + privacyManager.createPrivacyList(listName1, items); + + // Add the another list + ArrayList itemsList2 = new ArrayList(); + item = new PrivacyItem(PrivacyRule.GROUP, false, 2); + item.setValue(groupName); + item.setFilterMessage(true); + itemsList2.add(item); + privacyManager.createPrivacyList(listName2, itemsList2); + + Thread.sleep(500); + + // Assert the list composition. + PrivacyList[] privacyItems = privacyManager.getPrivacyLists(); + PrivacyList receivedList1 = null; + PrivacyList receivedList2 = null; + for (int i = 0; i < privacyItems.length; i++) { + if (listName1.equals(privacyItems[i].toString())) { + receivedList1 = privacyItems[i]; + } + if (listName2.equals(privacyItems[i].toString())) { + receivedList2 = privacyItems[i]; + } + } + + + PrivacyItem receivedItem; + // Assert the list 1 + assertNotNull(receivedList1); + assertEquals(1, receivedList1.getItems().size()); + receivedItem = (PrivacyItem) receivedList1.getItems().get(0); + assertEquals(1, receivedItem.getOrder()); + assertEquals(PrivacyRule.JID, receivedItem.getType()); + assertEquals(true, receivedItem.isAllow()); + + // Assert the list 2 + assertNotNull(receivedList2); + assertEquals(1, receivedList2.getItems().size()); + receivedItem = (PrivacyItem) receivedList2.getItems().get(0); + assertEquals(2, receivedItem.getOrder()); + assertEquals(PrivacyRule.GROUP, receivedItem.getType()); + assertEquals(false, receivedItem.isAllow()); + assertEquals(groupName, receivedItem.getValue()); + assertEquals(false, receivedItem.isFilterEverything()); + assertEquals(true, receivedItem.isFilterMessage()); + assertEquals(false, receivedItem.isFilterPresence_in()); + assertEquals(false, receivedItem.isFilterPresence_out()); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client set a new list and then update its content. + */ + public void testCreateAndUpdateList() { + try { + String listName = "testCreateAndUpdateList"; + String user = "tybalt@example.com"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + // Add the list that will be set as the active + ArrayList items = new ArrayList(); + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, 1); + item.setValue(getConnection(0).getUser()); + items.add(item); + privacyManager.createPrivacyList(listName, items); + + Thread.sleep(500); + + // Remove the existing item and add a new one. + items.remove(item); + item = new PrivacyItem(PrivacyRule.JID, false, 2); + item.setValue(user); + item.setFilterPresence_out(true); + item.setFilterPresence_in(true); + item.setFilterMessage(true); + items.add(item); + + // Update the list on server + privacyManager.updatePrivacyList(listName, items); + + Thread.sleep(500); + + // Assert the list composition. + PrivacyList list = privacyManager.getPrivacyList(listName); + assertEquals(1, list.getItems().size()); + + // Assert the privacy item composition + PrivacyItem receivedItem = (PrivacyItem) list.getItems().get(0); + assertEquals(2, receivedItem.getOrder()); + assertEquals(PrivacyRule.JID, receivedItem.getType()); + assertEquals(false, receivedItem.isAllow()); + assertEquals(user, receivedItem.getValue()); + assertEquals(false, receivedItem.isFilterEverything()); + assertEquals(true, receivedItem.isFilterMessage()); + assertEquals(true, receivedItem.isFilterPresence_in()); + assertEquals(true, receivedItem.isFilterPresence_out()); + assertEquals(true, client.wasModified()); + + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client denies the use of a default list. + */ + public void testDenyDefaultList() { + try { + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + privacyManager.declineDefaultList(); + + Thread.sleep(500); + + try { + // The list should not exist and an error will be raised + privacyManager.getDefaultList(); + } catch (XMPPException xmppException) { + assertEquals(404, xmppException.getXMPPError().getCode()); + } + + assertEquals(null, null); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client denies the use of the active list. + */ + public void testDenyActiveList() { + try { + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + privacyManager.declineActiveList(); + + Thread.sleep(500); + + try { + // The list should not exist and an error will be raised + privacyManager.getActiveList(); + } catch (XMPPException xmppException) { + assertEquals(404, xmppException.getXMPPError().getCode()); + } + + assertEquals(null, null); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client set a new default list. + */ + public void testCreateDefaultList() { + try { + String listName = "testCreateDefaultList"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + // Add the list that will be set as the Default + ArrayList items = new ArrayList(); + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, 1); + item.setValue(getConnection(0).getUser()); + items.add(item); + privacyManager.createPrivacyList(listName, items); + + Thread.sleep(500); + + // Set the Default list + privacyManager.setDefaultListName(listName); + + Thread.sleep(500); + + // Assert the list composition. + assertEquals(listName, privacyManager.getDefaultList().toString()); + List privacyItems = privacyManager.getPrivacyList(listName).getItems(); + assertEquals(1, privacyItems.size()); + + // Assert the privacy item composition + PrivacyItem receivedItem = (PrivacyItem) privacyItems.get(0); + assertEquals(1, receivedItem.getOrder()); + assertEquals(PrivacyRule.JID, receivedItem.getType()); + assertEquals(true, receivedItem.isAllow()); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check when a client add a new list and then remove it. + */ + public void testRemoveList() { + try { + String listName = "testRemoveList"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + // Add the list that will be set as the Default + ArrayList items = new ArrayList(); + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, 1); + item.setValue(getConnection(0).getUser()); + items.add(item); + privacyManager.createPrivacyList(listName, items); + + Thread.sleep(500); + + // Set the Default list + privacyManager.setDefaultListName(listName); + + Thread.sleep(500); + + privacyManager.deletePrivacyList(listName); + + Thread.sleep(500); + + try { + // The list should not exist and an error will be raised + privacyManager.getPrivacyList(listName); + } catch (XMPPException xmppException) { + assertEquals(404, xmppException.getXMPPError().getCode()); + } + + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check different types of privacy items. + */ + public void testPrivacyItems() { + try { + String listName = "testPrivacyItems"; + String user = "tybalt@example.com"; + String groupName = "enemies"; + + PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0)); + PrivacyClient client = new PrivacyClient(privacyManager); + privacyManager.addListener(client); + + PrivacyItem[] originalPrivacyItems = new PrivacyItem[12]; + int i=0; + + // Items to test JID + PrivacyItem item = new PrivacyItem(PrivacyRule.JID, true, i); + item.setValue(i + "_" + user); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.JID, false, i); + item.setValue(i + "_" + user); + originalPrivacyItems[i] = item; + i = i + 1; + + // Items to test suscription + item = new PrivacyItem(PrivacyRule.SUBSCRIPTION, true, i); + item.setValue(PrivacyRule.SUBSCRIPTION_BOTH); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.SUBSCRIPTION, false, i); + item.setValue(PrivacyRule.SUBSCRIPTION_FROM); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.SUBSCRIPTION, true, i); + item.setValue(PrivacyRule.SUBSCRIPTION_TO); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.SUBSCRIPTION, false, i); + item.setValue(PrivacyRule.SUBSCRIPTION_NONE); + originalPrivacyItems[i] = item; + i = i + 1; + + // Items to test Group + item = new PrivacyItem(PrivacyRule.GROUP, false, i); + item.setValue(groupName); + originalPrivacyItems[i] = item; + i = i + 1; + + // Items to test messages + item = new PrivacyItem(PrivacyRule.GROUP, false, i); + item.setValue(groupName); + item.setFilterMessage(true); + originalPrivacyItems[i] = item; + i = i + 1; + + // Items to test presence notifications + item = new PrivacyItem(PrivacyRule.GROUP, false, i); + item.setValue(groupName); + item.setFilterMessage(true); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(null, false, i); + item.setFilterPresence_in(true); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.SUBSCRIPTION, false, i); + item.setValue(PrivacyRule.SUBSCRIPTION_TO); + item.setFilterPresence_out(true); + originalPrivacyItems[i] = item; + i = i + 1; + + item = new PrivacyItem(PrivacyRule.JID, false, i); + item.setValue(i + "_" + user); + item.setFilterPresence_out(true); + item.setFilterPresence_in(true); + item.setFilterMessage(true); + originalPrivacyItems[i] = item; + i = i + 1; + + + // Set the new privacy list + privacyManager.createPrivacyList(listName, Arrays.asList(originalPrivacyItems)); + + Thread.sleep(500); + + // Assert the server list composition. + List privacyItems = privacyManager.getPrivacyList(listName).getItems(); + assertEquals(originalPrivacyItems.length, privacyItems.size()); + + // Assert the local and server privacy item composition + PrivacyItem originalItem; + PrivacyItem receivedItem; + int index = 0; + for (int j = 0; j < originalPrivacyItems.length; j++) { + // Look for the same server and original items + receivedItem = (PrivacyItem) privacyItems.get(j); + index = 0; + while ((index < originalPrivacyItems.length) + && (originalPrivacyItems[index].getOrder() != receivedItem.getOrder())) { + index++; + } + originalItem = originalPrivacyItems[index]; + + // Assert the items + assertEquals(originalItem.getOrder(), receivedItem.getOrder()); + assertEquals(originalItem.getType(), receivedItem.getType()); + assertEquals(originalItem.isAllow(), receivedItem.isAllow()); + assertEquals(originalItem.getValue(), receivedItem.getValue()); + assertEquals(originalItem.isFilterEverything(), receivedItem.isFilterEverything()); + assertEquals(originalItem.isFilterIQ(), receivedItem.isFilterIQ()); + assertEquals(originalItem.isFilterMessage(), receivedItem.isFilterMessage()); + assertEquals(originalItem.isFilterPresence_in(), receivedItem.isFilterPresence_in()); + assertEquals(originalItem.isFilterPresence_out(), receivedItem.isFilterPresence_out()); + } + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + protected int getMaxConnections() { + return 1; + } +} diff --git a/test/org/jivesoftware/smack/packet/PrivacyProviderTest.java b/test/org/jivesoftware/smack/packet/PrivacyProviderTest.java new file mode 100644 index 000000000..9e5a0ca91 --- /dev/null +++ b/test/org/jivesoftware/smack/packet/PrivacyProviderTest.java @@ -0,0 +1,370 @@ +package org.jivesoftware.smack.packet; + +import java.io.StringReader; + +import org.jivesoftware.smack.provider.PrivacyProvider; +import org.jivesoftware.smack.test.SmackTestCase; +import org.xmlpull.mxp1.MXParser; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +/** + * Test the PrivacyProvider class with valids privacy xmls + * + * @author Francisco Vives + */ +public class PrivacyProviderTest extends SmackTestCase { + + /** + * Constructor for PrivacyTest. + * @param arg0 + */ + public PrivacyProviderTest(String arg0) { + super(arg0); + } + + public static void main(String args[]) { + try { + new PrivacyProviderTest(null).testFull(); + } catch (Exception e) { + e.printStackTrace(); + System.exit(1); + } + } + + /** + * Check the parser with an xml with all kind of stanzas. + * To create the xml string based from an xml file, replace:\n with: "\n + " + */ + public void testFull() { + // Make the XML to test + String xml = "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " "; + + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser); + + // check if it exist + assertNotNull(packet); + // assertEquals(xml, packet.getChildElementXML()); + + // check the default and active names + assertEquals("testFilter", packet.getActiveName()); + assertEquals("testSubscription", packet.getDefaultName()); + + // check the list + assertEquals(2, packet.getPrivacyList("testFilter").size()); + assertEquals(5, packet.getPrivacyList("testSubscription").size()); + assertEquals(4, packet.getPrivacyList("testJID").size()); + assertEquals(2, packet.getPrivacyList("testGroup").size()); + assertEquals(0, packet.getPrivacyList("testEmpty").size()); + + // check each privacy item + PrivacyItem item = packet.getItem("testGroup", 4); + assertEquals("Enemies", item.getValue()); + assertEquals("group", item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(true, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(false, item.isFilterEverything()); + + item = packet.getItem("testFilter", 1); + assertEquals("tybalt@example.com", item.getValue()); + assertEquals("jid", item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testFilter", 2); + assertEquals(null, item.getValue()); + assertEquals(null, item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(true, item.isFilterMessage()); + assertEquals(true, item.isFilterIQ()); + assertEquals(true, item.isFilterPresence_in()); + assertEquals(true, item.isFilterPresence_out()); + assertEquals(false, item.isFilterEverything()); + + // TEST THE testSubscription LIST + item = packet.getItem("testSubscription", 10); + assertEquals("both", item.getValue()); + assertEquals("subscription", item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testSubscription", 11); + assertEquals("to", item.getValue()); + assertEquals("subscription", item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testSubscription", 12); + assertEquals("from", item.getValue()); + assertEquals("subscription", item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testSubscription", 5); + assertEquals("none", item.getValue()); + assertEquals("subscription", item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(true, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(false, item.isFilterEverything()); + + item = packet.getItem("testSubscription", 15); + assertEquals(null, item.getValue()); + assertEquals(null, item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + // TEST THE testJID LIST + + item = packet.getItem("testJID", 6); + assertEquals("juliet@example.com", item.getValue()); + assertEquals("jid", item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testJID", 7); + assertEquals("benvolio@example.org/palm", item.getValue()); + assertEquals("jid", item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testJID", 42); + assertEquals(null, item.getValue()); + assertEquals("jid", item.getType()); + assertEquals(true, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + item = packet.getItem("testJID", 666); + assertEquals(null, item.getValue()); + assertEquals(null, item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + // TEST THE testGroup LIST + + item = packet.getItem("testGroup", 4); + assertEquals("Enemies", item.getValue()); + assertEquals("group", item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(true, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(false, item.isFilterEverything()); + + item = packet.getItem("testGroup", 666); + assertEquals(null, item.getValue()); + assertEquals(null, item.getType()); + assertEquals(false, item.isAllow()); + assertEquals(false, item.isFilterMessage()); + assertEquals(false, item.isFilterIQ()); + assertEquals(false, item.isFilterPresence_in()); + assertEquals(false, item.isFilterPresence_out()); + assertEquals(true, item.isFilterEverything()); + + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + + /** + * Check the parser with an xml with empty lists. It includes the active, + * default and special list. + * To create the xml string based from an xml file, replace:\n with: "\n + " + */ + public void testEmptyLists() { + // Make the XML to test + String xml = "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " "; + + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser); + + assertNotNull(packet); + assertNotNull(packet.getChildElementXML()); + + assertEquals("public", packet.getDefaultName()); + assertEquals(null, packet.getActiveName()); + + assertEquals(0, packet.getPrivacyList("public").size()); + assertEquals(0, packet.getPrivacyList("private").size()); + assertEquals(0, packet.getPrivacyList("special").size()); + + assertEquals(true, packet.isDeclineActiveList()); + assertEquals(false, packet.isDeclineDefaultList()); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check the parser with an xml with empty lists. It includes the active, + * default and special list. + * To create the xml string based from an xml file, replace:\n with: "\n + " + */ + public void testDeclineLists() { + // Make the XML to test + String xml = "" + + " " + + " " + + " " + + " " + + " " + + " "; + + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser); + + assertNotNull(packet); + + assertEquals(null, packet.getDefaultName()); + assertEquals(null, packet.getActiveName()); + + assertEquals(true, packet.isDeclineActiveList()); + assertEquals(true, packet.isDeclineDefaultList()); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + private XmlPullParser getParserFromXML(String xml) throws XmlPullParserException { + MXParser parser = new MXParser(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + parser.setInput(new StringReader(xml)); + return parser; + } + + protected int getMaxConnections() { + return 0; + } +} diff --git a/test/org/jivesoftware/smack/util/XMPPErrorTest.java b/test/org/jivesoftware/smack/util/XMPPErrorTest.java new file mode 100644 index 000000000..0468f3a59 --- /dev/null +++ b/test/org/jivesoftware/smack/util/XMPPErrorTest.java @@ -0,0 +1,187 @@ +package org.jivesoftware.smack.util; + +import java.io.StringReader; + +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.test.SmackTestCase; +import org.xmlpull.mxp1.MXParser; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +public class XMPPErrorTest extends SmackTestCase { + + public XMPPErrorTest(String arg0) { + super(arg0); + } + + /** + * Check the creation of a new xmppError locally. + */ + public void testLocalErrorCreation() { + XMPPError error = new XMPPError(XMPPError.Condition.item_not_found); + error.toXML(); + + assertEquals(error.getCondition(), "item-not-found"); + assertEquals(error.getCode(), 404); + assertEquals(error.getType(), XMPPError.Type.CANCEL); + assertNull(error.getMessage()); + } + + /** + * Check the creation of a new xmppError locally. + */ + public void testLocalErrorWithCommentCreation() { + String message = "Error Message"; + XMPPError error = new XMPPError(XMPPError.Condition.item_not_found, message); + error.toXML(); + + assertEquals(error.getCondition(), "item-not-found"); + assertEquals(error.getCode(), 404); + assertEquals(error.getType(), XMPPError.Type.CANCEL); + assertEquals(error.getMessage(), message); + } + + /** + * Check the creation of a new xmppError locally where there is not a default defined. + */ + public void testUserDefinedErrorWithCommentCreation() { + String message = "Error Message"; + XMPPError error = new XMPPError(new XMPPError.Condition("my_own_error"), message); + error.toXML(); + + assertEquals(error.getCondition(), "my_own_error"); + assertEquals(error.getCode(), 0); + assertNull(error.getType()); + assertEquals(error.getMessage(), message); + } + + /** + * Check the parser with an xml with the 404 error. + */ + public void test404() { + // Make the XML to test + String xml = "" + + "" + + ""; + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + XMPPError packet = parseError(parser); + + assertNotNull(packet); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check the parser with an xml with the 404 error. + */ + public void testCancel() { + // Make the XML to test + String xml = "" + + "" + + ""; + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + XMPPError error = parseError(parser); + + assertNotNull(error); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + public void testMessageAndApplicationDefinedError() { + String xml = "" + + "" + + "" + + "Some special application diagnostic information..." + + "" + + "" + + ""; + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + XMPPError error = parseError(parser); + + String sendingXML = error.toXML(); + + assertNotNull(error); + assertNotNull(sendingXML); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + /** + * Check the parser with an xml with the 404 error. + */ + public void testCancelWithMessage() { + // Make the XML to test + String xml = "" + + "" + + "" + + "Some special application diagnostic information!" + + "" + + ""; + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + XMPPError error = parseError(parser); + + assertNotNull(error); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + /** + * Check the parser with an xml with the 404 error. + */ + public void testCancelWithMessageAndApplicationError() { + // Make the XML to test + String xml = "" + + "" + + "" + + "Some special application diagnostic information!" + + "" + + "" + + ""; + try { + // Create the xml parser + XmlPullParser parser = getParserFromXML(xml); + // Create a packet from the xml + XMPPError error = parseError(parser); + + assertNotNull(error); + } catch (Exception e) { + e.printStackTrace(); + fail(e.getMessage()); + } + } + + private XMPPError parseError(XmlPullParser parser) throws Exception { + parser.next(); + return PacketParserUtils.parseError(parser); + } + + private XmlPullParser getParserFromXML(String xml) throws XmlPullParserException { + MXParser parser = new MXParser(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + parser.setInput(new StringReader(xml)); + return parser; + } + + protected int getMaxConnections() { + return 0; + } +}