SMACK-272 Add support for XEP-0060 (pubsub)

git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@11346 b35dd754-fafc-0310-a699-88a17e54d16e

test/org/jivesoftware/smackx/pubsub/CarExtension.java

@@ -0,0 +1,45 @@
+/*
+ * Created on 2009-05-05
+ */
+package org.jivesoftware.smackx.pubsub;
+
+import org.jivesoftware.smack.packet.PacketExtension;
+
+class CarExtension implements PacketExtension
+{
+	private String color;
+	private int numTires;
+
+	public CarExtension(String col, int num)
+	{
+		color = col;
+		numTires = num;
+	}
+	
+	public String getColor()
+	{
+		return color;
+	}
+
+	public int getNumTires()
+	{
+		return numTires;
+	}
+
+	public String getElementName()
+	{
+		return "car";
+	}
+
+	public String getNamespace()
+	{
+		return "pubsub:test:vehicle";
+	}
+
+	public String toXML()
+	{
+		return "<" + getElementName() + " xmlns='" + getNamespace() + "'><paint color='" + 
+			getColor() + "'/><tires num='" + getNumTires() + "'/></" + getElementName() + ">";
+	}
+	
+}

test/org/jivesoftware/smackx/pubsub/CarExtensionProvider.java

@@ -0,0 +1,35 @@
+/*
+ * Created on 2009-05-05
+ */
+package org.jivesoftware.smackx.pubsub;
+
+import org.jivesoftware.smack.packet.PacketExtension;
+import org.jivesoftware.smack.provider.PacketExtensionProvider;
+import org.xmlpull.v1.XmlPullParser;
+
+public class CarExtensionProvider implements PacketExtensionProvider
+{
+
+	public PacketExtension parseExtension(XmlPullParser parser) throws Exception
+	{
+		String color = null;
+		int numTires = 0;
+		
+		for (int i=0; i<2; i++)
+		{
+			while (parser.next() != XmlPullParser.START_TAG);
+			
+			if (parser.getName().equals("paint"))
+			{
+				color = parser.getAttributeValue(0);
+			}
+			else
+			{
+				numTires = Integer.parseInt(parser.getAttributeValue(0));
+			}
+		}
+		while (parser.next() != XmlPullParser.END_TAG);
+		return new CarExtension(color, numTires);
+	}
+	
+}

test/org/jivesoftware/smackx/pubsub/EntityUseCases.java

@@ -0,0 +1,72 @@
+/*
+ * Created on 2009-04-09
+ */
+package org.jivesoftware.smackx.pubsub;
+ 
+import java.util.Iterator;
+import java.util.List;
+
+import org.jivesoftware.smackx.packet.DiscoverInfo;
+import org.jivesoftware.smackx.packet.DiscoverItems;
+import org.jivesoftware.smackx.packet.DiscoverInfo.Identity;
+import org.jivesoftware.smackx.pubsub.test.SingleUserTestCase;
+import org.jivesoftware.smackx.pubsub.util.XmlUtils;
+
+public class EntityUseCases extends SingleUserTestCase
+{
+	public void testDiscoverPubsubInfo() throws Exception
+	{
+		DiscoverInfo supportedFeatures = getManager().getSupportedFeatures();
+		assertNotNull(supportedFeatures);
+	}
+
+	public void testDiscoverNodeInfo() throws Exception
+	{
+		LeafNode myNode = getManager().createNode("DiscoNode" + System.currentTimeMillis());
+		DiscoverInfo info = myNode.discoverInfo();
+		assertTrue(info.getIdentities().hasNext());
+		Identity ident = info.getIdentities().next();
+		
+		assertEquals("leaf", ident.getType());
+	}
+	
+	public void testDiscoverNodeItems() throws Exception
+	{
+		LeafNode myNode = getRandomPubnode(getManager(), true, false);
+		myNode.send(new Item());
+		myNode.send(new Item());
+		myNode.send(new Item());
+		myNode.send(new Item());
+		DiscoverItems items = myNode.discoverItems();
+		
+		int count = 0;
+		
+		for(Iterator it = items.getItems(); it.hasNext(); it.next(),count++);
+		
+		assertEquals(4, count);
+	}
+	
+	public void testDiscoverSubscriptions() throws Exception
+	{
+		getManager().getSubscriptions();
+	}
+	
+	public void testDiscoverNodeSubscriptions() throws Exception
+	{
+		LeafNode myNode = getRandomPubnode(getManager(), true, true);
+		myNode.subscribe(getConnection(0).getUser());
+		List<Subscription> subscriptions = myNode.getSubscriptions();
+		
+		assertTrue(subscriptions.size() < 3);
+		
+		for (Subscription subscription : subscriptions) 
+		{
+			assertNull(subscription.getNode());
+		}
+	}
+	
+	public void testRetrieveAffiliation() throws Exception
+	{
+		getManager().getAffiliations();
+	}
+}

test/org/jivesoftware/smackx/pubsub/OwnerUseCases.java

@@ -0,0 +1,130 @@
+/*
+ * Created on 2009-04-09
+ */
+package org.jivesoftware.smackx.pubsub;
+ 
+import java.util.Collection;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smackx.pubsub.test.SingleUserTestCase;
+
+public class OwnerUseCases extends SingleUserTestCase
+{
+	public void testCreateInstantNode() throws Exception
+	{
+		LeafNode node = getManager().createNode();
+		assertNotNull(node);
+		assertNotNull(node.getId());
+	}
+
+	public void testCreateNamedNode() throws Exception
+	{
+		String id = "TestNamedNode" + System.currentTimeMillis();
+		LeafNode node = getManager().createNode(id);
+		assertEquals(id, node.getId());
+	}
+
+	public void testCreateConfiguredNode() throws Exception
+	{
+		// Generate reasonably unique for multiple tests
+		String id = "TestConfigNode" + System.currentTimeMillis();
+		
+		// Create and configure a node
+		ConfigureForm form = new ConfigureForm(FormType.submit);
+		form.setAccessModel(AccessModel.open);
+		form.setDeliverPayloads(false);
+		form.setNotifyRetract(true);
+		form.setPersistentItems(true);
+		form.setPublishModel(PublishModel.open);
+
+		LeafNode node = (LeafNode)getManager().createNode(id, form);
+		
+		ConfigureForm currentForm = node.getNodeConfiguration();
+		assertEquals(AccessModel.open, currentForm.getAccessModel());
+		assertFalse(currentForm.isDeliverPayloads());
+		assertTrue(currentForm.isNotifyRetract());
+		assertTrue(currentForm.isPersistItems());
+		assertEquals(PublishModel.open, currentForm.getPublishModel());
+	}
+
+	public void testCreateAndUpdateConfiguredNode() throws Exception
+	{
+		// Generate reasonably unique for multiple tests
+		String id = "TestConfigNode2" + System.currentTimeMillis();
+		
+		// Create and configure a node
+		ConfigureForm form = new ConfigureForm(FormType.submit);
+		form.setAccessModel(AccessModel.open);
+		form.setDeliverPayloads(false);
+		form.setNotifyRetract(true);
+		form.setPersistentItems(true);
+		form.setPublishModel(PublishModel.open);
+		
+		LeafNode myNode = (LeafNode)getManager().createNode(id, form);
+		ConfigureForm config = myNode.getNodeConfiguration();
+		
+		assertEquals(AccessModel.open, config.getAccessModel());
+		assertFalse(config.isDeliverPayloads());
+		assertTrue(config.isNotifyRetract());
+		assertTrue(config.isPersistItems());
+		assertEquals(PublishModel.open, config.getPublishModel());
+			
+		ConfigureForm submitForm = new ConfigureForm(config.createAnswerForm());
+		submitForm.setAccessModel(AccessModel.whitelist);
+		submitForm.setDeliverPayloads(true);
+		submitForm.setNotifyRetract(false);
+		submitForm.setPersistentItems(false);
+		submitForm.setPublishModel(PublishModel.publishers);
+		myNode.sendConfigurationForm(submitForm);
+
+		ConfigureForm newConfig = myNode.getNodeConfiguration();
+		assertEquals(AccessModel.whitelist, newConfig.getAccessModel());
+		assertTrue(newConfig.isDeliverPayloads());
+		assertFalse(newConfig.isNotifyRetract());
+		assertFalse(newConfig.isPersistItems());
+		assertEquals(PublishModel.publishers, newConfig.getPublishModel());
+	}
+
+	public void testGetDefaultConfig() throws Exception
+	{
+		ConfigureForm form = getManager().getDefaultConfiguration();
+		assertNotNull(form);
+	}
+	
+	public void testDeleteNode() throws Exception
+	{
+		LeafNode myNode = getManager().createNode();
+		assertNotNull(getManager().getNode(myNode.getId()));
+		
+		getManager(0).deleteNode(myNode.getId());
+		
+		try
+		{
+			assertNull(getManager().getNode(myNode.getId()));
+			fail("Node should not exist");
+		}
+		catch (XMPPException e)
+		{
+		}
+	}
+	
+	public void testPurgeItems() throws XMPPException
+	{
+		LeafNode node = getRandomPubnode(getManager(), true, false);
+		
+		node.send(new Item());
+		node.send(new Item());
+		node.send(new Item());
+		node.send(new Item());
+		node.send(new Item());
+		
+		Collection<? extends Item> items = node.getItems();
+		assertTrue(items.size() == 5);
+
+		node.deleteAllItems();
+		items = node.getItems();
+		
+		// Pubsub service may keep the last notification (in spec), so 0 or 1 may be returned on get items.
+		assertTrue(items.size() < 2);
+	}
+}

test/org/jivesoftware/smackx/pubsub/PublisherUseCases.java

@@ -0,0 +1,150 @@
+/*
+ * Created on 2009-04-09
+ */
+package org.jivesoftware.smackx.pubsub;
+ 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.packet.XMPPError;
+import org.jivesoftware.smack.packet.XMPPError.Condition;
+import org.jivesoftware.smackx.pubsub.packet.PubSubNamespace;
+import org.jivesoftware.smackx.pubsub.test.SingleUserTestCase;
+
+public class PublisherUseCases extends SingleUserTestCase
+{
+	public void testSendNodeTrNot() throws Exception
+	{
+		getPubnode(false, false).send();
+	}
+
+	public void testSendNodeTrPay_WithOutPayload() throws XMPPException
+	{
+		LeafNode node = getPubnode(false, true);
+
+		try
+		{
+			node.send(new Item());
+			fail("Exception should be thrown when there is no payload");
+		}
+		catch (XMPPException e) {
+			XMPPError err = e.getXMPPError();
+			assertTrue(err.getType().equals(XMPPError.Type.MODIFY));
+			assertTrue(err.getCondition().equals(Condition.bad_request.toString()));
+			assertNotNull(err.getExtension("payload-required", PubSubNamespace.ERROR.getXmlns()));
+		}
+
+		try
+		{
+			node.send(new Item("test" + System.currentTimeMillis()));
+			fail("Exception should be thrown when there is no payload");
+		}
+		catch (XMPPException e) {
+			XMPPError err = e.getXMPPError();
+			assertTrue(err.getType().equals(XMPPError.Type.MODIFY));
+			assertTrue(err.getCondition().equals(Condition.bad_request.toString()));
+			assertNotNull(err.getExtension("payload-required", PubSubNamespace.ERROR.getXmlns()));
+		}
+	}
+
+	public void testSendNodeTrPay_WithPayload() throws XMPPException
+	{
+		LeafNode node = getPubnode(false, true);
+		node.send(new PayloadItem<SimplePayload>(null, 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Lord of the Rings</title></book>")));
+		node.send(new PayloadItem<SimplePayload>("test" + System.currentTimeMillis(), 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Two Towers</title></book>")));
+	}
+
+	public void testSendNodePerNot() throws Exception
+	{
+		LeafNode node = getPubnode(true, false);
+		node.send(new Item());
+		node.send(new Item("test" + System.currentTimeMillis()));
+		node.send(new PayloadItem<SimplePayload>(null, 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Lord of the Rings</title></book>")));
+		node.send(new PayloadItem<SimplePayload>("test" + System.currentTimeMillis(), 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Two Towers</title></book>")));
+	}
+
+	public void testSendPerPay_WithPayload() throws Exception
+	{
+		LeafNode node = getPubnode(true, true);
+		node.send(new PayloadItem<SimplePayload>(null, 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Lord of the Rings</title></book>")));
+		node.send(new PayloadItem<SimplePayload>("test" + System.currentTimeMillis(), 
+						new SimplePayload("book", "pubsub:test:book", "<book xmlns='pubsub:test:book'><title>Two Towers</title></book>")));
+	}
+
+	public void testSendPerPay_NoPayload() throws Exception
+	{
+		LeafNode node = getPubnode(true, true);
+		try
+		{
+			node.send(new Item());
+			fail("Exception should be thrown when there is no payload");
+		}
+		catch (XMPPException e) {
+			XMPPError err = e.getXMPPError();
+			assertTrue(err.getType().equals(XMPPError.Type.MODIFY));
+			assertTrue(err.getCondition().equals(Condition.bad_request.toString()));
+			assertNotNull(err.getExtension("payload-required", PubSubNamespace.ERROR.getXmlns()));
+		}
+
+		try
+		{
+			node.send(new Item("test" + System.currentTimeMillis()));
+			fail("Exception should be thrown when there is no payload");
+		}
+		catch (XMPPException e) {
+			XMPPError err = e.getXMPPError();
+			assertTrue(err.getType().equals(XMPPError.Type.MODIFY));
+			assertTrue(err.getCondition().equals(Condition.bad_request.toString()));
+			assertNotNull(err.getExtension("payload-required", PubSubNamespace.ERROR.getXmlns()));
+		}
+	}
+		
+	public void testDeleteItems() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, false);
+		
+		node.send(new Item("1"));
+		node.send(new Item("2"));
+		node.send(new Item("3"));
+		node.send(new Item("4"));
+		
+		node.deleteItem("1");
+		Collection<? extends Item> items = node.getItems();
+		
+		assertTrue(items.size() == 3);
+		assertEquals(items.iterator().next().getId(), "2");
+	}
+
+	public void testPersistItems() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, false);
+		
+		node.send(new Item("1"));
+		node.send(new Item("2"));
+		node.send(new Item("3"));
+		node.send(new Item("4"));
+		
+		Collection<? extends Item> items = node.getItems();
+		
+		assertTrue(items.size() == 4);
+	}
+	
+	public void testItemOverwritten() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, false);
+		
+		node.send(new PayloadItem<SimplePayload>("1", new SimplePayload("test", null, "<test/>")));
+		node.send(new PayloadItem<SimplePayload>("1", new SimplePayload("test2", null, "<test2/>")));
+		
+		List<? extends Item> items = node.getItems();
+		assertEquals(1, items.size());
+		assertEquals("1", items.get(0).getId());
+	}
+}

test/org/jivesoftware/smackx/pubsub/SubscriberUseCases.java

@@ -0,0 +1,224 @@
+/*
+ * Created on 2009-04-09
+ */
+package org.jivesoftware.smackx.pubsub;
+ 
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smackx.FormField;
+import org.jivesoftware.smackx.pubsub.test.SingleUserTestCase;
+
+public class SubscriberUseCases extends SingleUserTestCase
+{
+	public void testSubscribe() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		Subscription sub = node.subscribe(getJid());
+		
+		assertEquals(getJid(), sub.getJid());
+		assertNotNull(sub.getId());
+		assertEquals(node.getId(), sub.getNode());
+		assertEquals(Subscription.State.subscribed, sub.getState());
+	}
+
+	public void testSubscribeBadJid() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		
+		try
+		{
+			node.subscribe("this@over.here");
+			fail();
+		}
+		catch (XMPPException e)
+		{
+		}
+	}
+
+	public void testSubscribeWithOptions() throws Exception
+	{
+		SubscribeForm form = new SubscribeForm(FormType.submit);
+		form.setDeliverOn(true);
+		Calendar expire = Calendar.getInstance();
+		expire.set(2020, 1, 1);
+		form.setExpiry(expire.getTime());
+		LeafNode node = getPubnode(false, false);
+		node.subscribe(getJid(), form);
+	}
+	
+	public void testSubscribeConfigRequired() throws Exception
+	{
+		ConfigureForm form = new ConfigureForm(FormType.submit);
+		form.setAccessModel(AccessModel.open);
+		
+		// Openfire specific field - nothing in the spec yet
+		FormField required = new FormField("pubsub#subscription_required");
+		required.setType(FormField.TYPE_BOOLEAN);
+		form.addField(required);
+		form.setAnswer("pubsub#subscription_required", true);
+		LeafNode node = (LeafNode)getManager().createNode("Pubnode" + System.currentTimeMillis(), form);
+
+		Subscription sub = node.subscribe(getJid());
+		
+		assertEquals(getJid(), sub.getJid());
+		assertNotNull(sub.getId());
+		assertEquals(node.getId(), sub.getNode());
+		assertEquals(true, sub.isConfigRequired());
+	}
+	
+	public void testUnsubscribe() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		node.subscribe(getJid());
+		Collection<Subscription> subs = node.getSubscriptions();
+		
+		node.unsubscribe(getJid());
+		Collection<Subscription> afterSubs = node.getSubscriptions();
+		assertEquals(subs.size()-1, afterSubs.size());
+	}
+	
+	public void testUnsubscribeWithMultipleNoSubId() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		node.subscribe(getBareJID(0));
+		node.subscribe(getBareJID(0));
+		node.subscribe(getBareJID(0));
+		
+		try
+		{
+			node.unsubscribe(getBareJID(0));
+			fail("Unsubscribe with no subid should fail");
+		}
+		catch (XMPPException e)
+		{
+		}
+	}
+	
+	public void testUnsubscribeWithMultipleWithSubId() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		node.subscribe(getJid());
+		Subscription sub = node.subscribe(getJid());
+		node.subscribe(getJid());
+		node.unsubscribe(getJid(), sub.getId());
+	}
+	
+	public void testGetOptions() throws Exception
+	{
+		LeafNode node = getPubnode(false, false);
+		Subscription sub = node.subscribe(getJid());
+		SubscribeForm form = node.getSubscriptionOptions(getJid(), sub.getId());
+		assertNotNull(form);
+	}
+	
+//	public void testSubscribeWithConfig() throws Exception
+//	{		
+//		LeafNode node = getPubnode(false, false);
+//
+//		Subscription sub = node.subscribe(getBareJID(0));
+//		
+//		assertEquals(getBareJID(0), sub.getJid());
+//		assertNotNull(sub.getId());
+//		assertEquals(node.getId(), sub.getNode());
+//		assertEquals(true, sub.isConfigRequired());
+//	}
+//	
+	public void testGetItems() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, false);
+		
+		node.send((Item)null);
+		node.send((Item)null);
+		node.send((Item)null);
+		node.send((Item)null);
+		node.send((Item)null);
+		
+		Collection<? extends Item> items = node.getItems();
+		assertTrue(items.size() == 5);
+		
+		long curTime = System.currentTimeMillis();
+		node.send(new Item("1-" + curTime));
+		node.send(new Item("2-" + curTime));
+		node.send(new Item("3-" + curTime));
+		node.send(new Item("4-" + curTime));
+		node.send(new Item("5-" + curTime));
+		
+		items = node.getItems();
+		assertTrue(items.size() == 10);
+
+		LeafNode payloadNode = getPubnode(true, true);
+
+		Map<String , String> idPayload = new HashMap<String, String>();
+		idPayload.put("6-" + curTime, "<a/>");
+		idPayload.put("7-" + curTime, "<a href=\"/up/here\"/>");
+		idPayload.put("8-" + curTime, "<entity>text<inner></inner></entity>");
+		idPayload.put("9-" + curTime, "<entity><inner><text></text></inner></entity>");
+		
+		for (Map.Entry<String, String> payload : idPayload.entrySet())
+		{
+			payloadNode.send(new PayloadItem<SimplePayload>(payload.getKey(), new SimplePayload("a", "pubsub:test", payload.getValue())));
+		}
+		
+		payloadNode.send(new PayloadItem<SimplePayload>("6-" + curTime, new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test'/>")));
+		payloadNode.send(new PayloadItem<SimplePayload>("7-" + curTime, new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href=\"/up/here\"/>")));
+		payloadNode.send(new PayloadItem<SimplePayload>("8-" + curTime, new SimplePayload("entity", "pubsub:test", "<entity xmlns='pubsub:test'>text<inner></inner></entity>")));
+		payloadNode.send(new PayloadItem<SimplePayload>("9-" + curTime, new SimplePayload("entity", "pubsub:test", "<entity xmlns='pubsub:test'><inner><text></text></inner></entity>")));
+		
+		Collection<PayloadItem<SimplePayload>> payloadItems = payloadNode.getItems();
+		assertTrue(payloadItems.size() == 4);
+	}
+
+	public void getSpecifiedItems() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, true);
+		
+		node.send(new PayloadItem<SimplePayload>("1", new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href='/1'/>")));
+		node.send(new PayloadItem<SimplePayload>("2", new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href='/2'/>")));
+		node.send(new PayloadItem<SimplePayload>("3", new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href='/3'/>")));
+		node.send(new PayloadItem<SimplePayload>("4", new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href='/4'/>")));
+		node.send(new PayloadItem<SimplePayload>("5", new SimplePayload("a", "pubsub:test", "<a xmlns='pubsub:test' href='/5'/>")));
+		
+		Collection<String> ids = new ArrayList<String>(3);
+		ids.add("1");
+		ids.add("3");
+		ids.add("4");
+
+		List<PayloadItem<SimplePayload>> items = node.getItems(ids);
+		assertEquals(3, items.size());
+		assertEquals(items.get(0).getId(), "1");
+		assertEquals(items.get(0).getPayload().toXML(), "<a xmlns='pubsub:test' href='/1'/>");
+		assertEquals(items.get(1).getId(), "3");
+		assertEquals(items.get(1).getPayload().toXML(), "<a xmlns='pubsub:test' href='/3'/>");
+		assertEquals(items.get(2).getId(), "5");
+		assertEquals(items.get(2).getPayload().toXML(), "<a xmlns='pubsub:test' href='/5'/>");
+	}
+
+	public void testGetLastNItems() throws XMPPException
+	{
+		LeafNode node = getPubnode(true, false);
+		
+		node.send(new Item("1"));
+		node.send(new Item("2"));
+		node.send(new Item("3"));
+		node.send(new Item("4"));
+		node.send(new Item("5"));
+		
+		List<Item> items = node.getItems(2);
+		assertEquals(2, items.size());
+		assertEquals(items.get(0).getId(), "4");
+		assertEquals(items.get(1).getId(), "5");
+	}
+
+	private String getJid()
+	{
+		return getConnection(0).getUser();
+	}
+
+}

test/org/jivesoftware/smackx/pubsub/TestAPI.java

@@ -0,0 +1,22 @@
+/*
+ * Created on 2009-04-09
+ */
+package org.jivesoftware.smackx.pubsub;
+ 
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smackx.pubsub.test.SingleUserTestCase;
+
+public class TestAPI extends SingleUserTestCase
+{
+	public void testGetNonexistentNode()
+	{
+		try
+		{
+			getManager().getNode("" + System.currentTimeMillis());
+			assertTrue(false);
+		}
+		catch (XMPPException e)
+		{
+		}
+	}
+}

test/org/jivesoftware/smackx/pubsub/TestEvents.java

@@ -0,0 +1,575 @@
+/*
+ * Created on 2009-04-22
+ */
+package org.jivesoftware.smackx.pubsub;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.packet.XMPPError.Type;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smackx.pubsub.listener.ItemDeleteListener;
+import org.jivesoftware.smackx.pubsub.listener.ItemEventListener;
+import org.jivesoftware.smackx.pubsub.listener.NodeConfigListener;
+
+public class TestEvents extends SmackTestCase
+{
+
+	public TestEvents(String str)
+	{
+		super(str);
+	}
+
+	@Override
+	protected int getMaxConnections()
+	{
+		return 2;
+	}
+
+	private String getService()
+	{
+		return "pubsub." + getServiceName();
+	}
+
+	public void testCreateAndGetNode() throws Exception
+	{
+		String nodeId = "MyTestNode";
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = null;
+		try
+		{
+			creatorNode = (LeafNode)creatorMgr.getNode(nodeId);
+		}
+		catch (XMPPException e)
+		{
+			if (e.getXMPPError().getType() == Type.CANCEL && e.getXMPPError().getCondition().equals("item-not-found"))
+				creatorNode = creatorMgr.createNode(nodeId);
+			else
+				throw e;
+		}
+		
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+		
+		assertNotNull(subNode);
+	}
+
+	public void testConfigureAndNotify() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, false, true);
+
+		BlockingQueue<NodeConfigCoordinator> queue = new ArrayBlockingQueue<NodeConfigCoordinator>(3);
+
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		NodeConfigListener sub1Handler = new NodeConfigCoordinator(queue, "sub1");
+		subNode.subscribe(getConnection(1).getUser());
+		subNode.addConfigurationListener(sub1Handler);
+		
+		ConfigureForm currentConfig = creatorNode.getNodeConfiguration(); 
+		ConfigureForm form = new ConfigureForm(currentConfig.createAnswerForm());
+		form.setPersistentItems(true);
+		form.setDeliverPayloads(false);
+		form.setNotifyConfig(true);
+		creatorNode.sendConfigurationForm(form);
+
+   		ConfigurationEvent event = queue.poll(5, TimeUnit.SECONDS).event;
+   		assertEquals(nodeId, event.getNode());
+   		assertNull(event.getConfiguration());
+   		
+		currentConfig = creatorNode.getNodeConfiguration(); 
+		form = new ConfigureForm(currentConfig.createAnswerForm());
+		form.setDeliverPayloads(true);
+		creatorNode.sendConfigurationForm(form);
+
+   		event = queue.poll(5, TimeUnit.SECONDS).event;
+   		assertEquals(nodeId, event.getNode());
+   		assertNotNull(event.getConfiguration());
+   		assertTrue(event.getConfiguration().isPersistItems());
+   		assertTrue(event.getConfiguration().isDeliverPayloads());
+	}
+
+	public void testSendAndReceiveNoPayload() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemEventCoordinator<Item>> queue = new ArrayBlockingQueue<ItemEventCoordinator<Item>>(3);
+		ItemEventCoordinator<Item> creatorHandler = new ItemEventCoordinator<Item>(queue, "creator");
+		creatorNode.addItemEventListener(creatorHandler);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<Item> sub1Handler = new ItemEventCoordinator<Item>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+        // Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        creatorNode.send(new Item(itemId));
+        
+        for(int i=0; i<2; i++)
+        {
+    		ItemEventCoordinator<Item> coord = queue.take();
+        	assertEquals(1, coord.events.getItems().size());
+        	assertEquals(itemId, coord.events.getItems().iterator().next().getId());
+        }
+	}
+	
+	public void testPublishAndReceiveNoPayload() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemEventCoordinator<Item>> queue = new ArrayBlockingQueue<ItemEventCoordinator<Item>>(3);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<Item> sub1Handler = new ItemEventCoordinator<Item>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+        // Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        creatorNode.publish(new Item(itemId));
+        
+   		ItemEventCoordinator<Item> coord = queue.take();
+       	assertEquals(1, coord.events.getItems().size());
+       	assertEquals(itemId, coord.events.getItems().get(0).getId());
+	}
+
+	public void testSendAndReceiveSimplePayload() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, true);
+
+		BlockingQueue<ItemEventCoordinator<PayloadItem<SimplePayload>>> queue = new ArrayBlockingQueue<ItemEventCoordinator<PayloadItem<SimplePayload>>>(3);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<PayloadItem<SimplePayload>> sub1Handler = new ItemEventCoordinator<PayloadItem<SimplePayload>>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+        // Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        String payloadString = "<book xmlns=\"pubsub:test:book\"><author>Sir Arthur Conan Doyle</author></book>";
+        creatorNode.send(new PayloadItem<SimplePayload>(itemId, new SimplePayload("book", "pubsub:test:book", payloadString)));
+        
+   		ItemEventCoordinator<PayloadItem<SimplePayload>> coord = queue.take();
+       	assertEquals(1, coord.events.getItems().size());
+       	PayloadItem<SimplePayload> item = coord.events.getItems().get(0);
+       	assertEquals(itemId, item.getId());
+       	assertTrue(item.getPayload() instanceof SimplePayload);
+       	assertEquals(payloadString, item.getPayload().toXML());
+       	assertEquals("book", item.getPayload().getElementName());
+	}
+
+	/*
+	 * For this test, the following extension needs to be added to the meta-inf/smack.providers file
+	 * 
+	 * 	 <extensionProvider>
+	 *     	<elementName>car</elementName>
+	 *      <namespace>pubsub:test:vehicle</namespace>
+	 *      <className>org.jivesoftware.smackx.pubsub.CarExtensionProvider</className>
+	 *   </extensionProvider>
+	 */
+	/* 
+	public void testSendAndReceiveCarPayload() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		Node creatorNode = getPubnode(creatorMgr, nodeId, true, true);
+
+		BlockingQueue<ItemEventCoordinator> queue = new ArrayBlockingQueue<ItemEventCoordinator>(3);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		Node subNode = subMgr.getNode(nodeId);
+
+		ItemEventCoordinator sub1Handler = new ItemEventCoordinator(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+        // Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        String payloadString = "<car xmlns='pubsub:test:vehicle'><paint color='green'/><tires num='4'/></car>";
+        creatorNode.send(new Item(itemId, new SimplePayload("car", "pubsub:test:vehicle", payloadString)));
+        
+   		ItemEventCoordinator coord = queue.take();
+       	assertEquals(1, coord.events.getItems().size());
+       	Item item = coord.events.getItems().get(0);
+       	assertEquals(itemId, item.getId());
+       	assertTrue(item.getPayload() instanceof CarExtension);
+
+       	CarExtension car = (CarExtension)item.getPayload();
+       	assertEquals("green", car.getColor());
+       	assertEquals(4, car.getNumTires());
+	}
+	*/
+
+	public void testSendAndReceiveMultipleSubs() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemEventCoordinator<Item>> queue = new ArrayBlockingQueue<ItemEventCoordinator<Item>>(3);
+		ItemEventCoordinator<Item> creatorHandler = new ItemEventCoordinator<Item>(queue, "creator");
+		creatorNode.addItemEventListener(creatorHandler);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<Item> sub1Handler = new ItemEventCoordinator<Item>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+		ItemEventCoordinator<Item> sub2Handler = new ItemEventCoordinator<Item>(queue, "sub2");
+		subNode.addItemEventListener(sub2Handler);
+		Subscription sub2 = subNode.subscribe(getConnection(1).getUser());
+
+		// Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        creatorNode.send(new Item(itemId));
+        
+        for(int i=0; i<3; i++)
+        {
+    		ItemEventCoordinator<Item> coord = queue.take();
+        	assertEquals(1, coord.events.getItems().size());
+        	assertEquals(itemId, coord.events.getItems().iterator().next().getId());
+        	
+        	if (coord.id.equals("sub1") || coord.id.equals("sub2"))
+        	{
+        		assertEquals(2, coord.events.getSubscriptions().size());
+        	}
+        }
+	}
+
+	public void testSendAndReceiveMultipleItems() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemEventCoordinator<Item>> queue = new ArrayBlockingQueue<ItemEventCoordinator<Item>>(3);
+		ItemEventCoordinator<Item> creatorHandler = new ItemEventCoordinator<Item>(queue, "creator");
+		creatorNode.addItemEventListener(creatorHandler);
+		creatorNode.subscribe(getConnection(0).getUser());
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<Item> sub1Handler = new ItemEventCoordinator<Item>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+		
+		ItemEventCoordinator<Item> sub2Handler = new ItemEventCoordinator<Item>(queue, "sub2");
+		subNode.addItemEventListener(sub2Handler);
+		Subscription sub2 = subNode.subscribe(getConnection(1).getUser());
+		
+		assertEquals(Subscription.State.subscribed, sub1.getState());
+		assertEquals(Subscription.State.subscribed, sub2.getState());
+
+        // Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        
+        Collection<Item> items = new ArrayList<Item>(3);
+        items.add(new Item("First-" + itemId));
+        items.add(new Item("Second-" + itemId));
+        items.add(new Item("Third-" + itemId));
+        creatorNode.send(items);
+        
+        for(int i=0; i<3; i++)
+        {
+    		ItemEventCoordinator<Item> coord = queue.poll(5, TimeUnit.SECONDS);
+        	if (coord == creatorHandler)
+        		assertEquals(1, coord.events.getSubscriptions().size());
+        	else
+        		assertEquals(2, coord.events.getSubscriptions().size());
+        	assertEquals(3, coord.events.getItems().size());
+        }
+	}
+
+	public void testSendAndReceiveDelayed() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		// Send event
+        String itemId = String.valueOf("DelayId-" + System.currentTimeMillis());
+        String payloadString = "<book xmlns='pubsub:test:book'><author>Sir Arthur Conan Doyle</author></book>";
+        creatorNode.send(new PayloadItem<SimplePayload>(itemId, new SimplePayload("book", "pubsub:test:book", payloadString)));
+
+        Thread.sleep(1000);
+
+        BlockingQueue<ItemEventCoordinator<PayloadItem<SimplePayload>>> queue = new ArrayBlockingQueue<ItemEventCoordinator<PayloadItem<SimplePayload>>>(3);
+
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemEventCoordinator<PayloadItem<SimplePayload>> sub1Handler = new ItemEventCoordinator<PayloadItem<SimplePayload>>(queue, "sub1");
+		subNode.addItemEventListener(sub1Handler);
+		Subscription sub1 = subNode.subscribe(getConnection(1).getUser());
+
+		ItemEventCoordinator<PayloadItem<SimplePayload>> coord = queue.take();
+   		assertTrue(coord.events.isDelayed());
+   		assertNotNull(coord.events.getPublishedDate());
+	}
+
+	public void testDeleteItemAndNotify() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemDeleteCoordinator> queue = new ArrayBlockingQueue<ItemDeleteCoordinator>(3);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemDeleteCoordinator sub1Handler = new ItemDeleteCoordinator(queue, "sub1");
+		subNode.addItemDeleteListener(sub1Handler);
+		subNode.subscribe(getConnection(1).getUser());
+
+		// Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        
+        Collection<Item> items = new ArrayList<Item>(3);
+        String id1 = "First-" + itemId;
+        String id2 = "Second-" + itemId;
+        String id3 = "Third-" + itemId;
+        items.add(new Item(id1));
+        items.add(new Item(id2));
+        items.add(new Item(id3));
+        creatorNode.send(items);
+        
+        creatorNode.deleteItem(id1);
+        
+   		ItemDeleteCoordinator coord = queue.poll(5, TimeUnit.SECONDS);
+   		assertEquals(1, coord.event.getItemIds().size());
+   		assertEquals(id1, coord.event.getItemIds().get(0));
+
+   		creatorNode.deleteItem(Arrays.asList(id2, id3));
+
+   		coord = queue.poll(5, TimeUnit.SECONDS);
+   		assertEquals(2, coord.event.getItemIds().size());
+   		assertTrue(coord.event.getItemIds().contains(id2));
+   		assertTrue(coord.event.getItemIds().contains(id3));
+	}
+
+	public void testPurgeAndNotify() throws Exception
+	{
+		// Setup event source
+		String nodeId = "TestNode" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		
+		LeafNode creatorNode = getPubnode(creatorMgr, nodeId, true, false);
+
+		BlockingQueue<ItemDeleteCoordinator> queue = new ArrayBlockingQueue<ItemDeleteCoordinator>(3);
+		
+		// Setup event receiver
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode = (LeafNode)subMgr.getNode(nodeId);
+
+		ItemDeleteCoordinator sub1Handler = new ItemDeleteCoordinator(queue, "sub1");
+		subNode.addItemDeleteListener(sub1Handler);
+		subNode.subscribe(getConnection(1).getUser());
+
+		// Send event
+        String itemId = String.valueOf(System.currentTimeMillis());
+        
+        Collection<Item> items = new ArrayList<Item>(3);
+        String id1 = "First-" + itemId;
+        String id2 = "Second-" + itemId;
+        String id3 = "Third-" + itemId;
+        items.add(new Item(id1));
+        items.add(new Item(id2));
+        items.add(new Item(id3));
+        creatorNode.send(items);
+        
+        creatorNode.deleteAllItems();
+        
+   		ItemDeleteCoordinator coord = queue.poll(5, TimeUnit.SECONDS);
+   		assertNull(nodeId, coord.event);
+	}
+
+	public void testListenerMultipleNodes() throws Exception
+	{
+		// Setup event source
+		String nodeId1 = "Node-1-" + System.currentTimeMillis();
+		PubSubManager creatorMgr = new PubSubManager(getConnection(0), getService());
+		String nodeId2 = "Node-2-" + System.currentTimeMillis();
+		
+		LeafNode creatorNode1 = getPubnode(creatorMgr, nodeId1, true, false);
+		LeafNode creatorNode2 = getPubnode(creatorMgr, nodeId2, true, false);
+
+		BlockingQueue<ItemEventCoordinator<Item>> queue = new ArrayBlockingQueue<ItemEventCoordinator<Item>>(3);
+		
+		PubSubManager subMgr = new PubSubManager(getConnection(1), getService());
+		LeafNode subNode1 = (LeafNode)subMgr.getNode(nodeId1);
+		LeafNode subNode2 = (LeafNode)subMgr.getNode(nodeId2);
+		
+		subNode1.addItemEventListener(new ItemEventCoordinator<Item>(queue, "sub1"));
+		subNode2.addItemEventListener(new ItemEventCoordinator<Item>(queue, "sub2"));
+		
+		subNode1.subscribe(getConnection(1).getUser());
+		subNode2.subscribe(getConnection(1).getUser());
+		
+		creatorNode1.send(new Item("item1"));
+		creatorNode2.send(new Item("item2"));
+		boolean check1 = false;
+		boolean check2 = false;
+		
+		for (int i=0; i<2; i++)
+		{
+			ItemEventCoordinator<Item> event = queue.take();
+			
+			if (event.id.equals("sub1"))
+			{
+				assertEquals(event.events.getNodeId(), nodeId1);
+				check1 = true;
+			}
+			else
+			{
+				assertEquals(event.events.getNodeId(), nodeId2);
+				check2 = true;
+			}
+		}
+		assertTrue(check1);
+		assertTrue(check2);
+	}
+	
+	class ItemEventCoordinator <T extends Item> implements ItemEventListener<T>
+	{
+		private BlockingQueue<ItemEventCoordinator<T>> theQueue;
+		private ItemPublishEvent<T> events;
+		private String id;
+		
+		ItemEventCoordinator(BlockingQueue<ItemEventCoordinator<T>> queue, String id)
+		{
+			theQueue = queue;
+			this.id = id;
+		}
+
+		@Override
+		public void handlePublishedItems(ItemPublishEvent<T> items)
+		{
+			events = items;
+			theQueue.add(this);
+		}
+
+		@Override
+		public String toString()
+		{
+			return "ItemEventCoordinator: " + id;
+		}
+		
+	}
+	
+	class NodeConfigCoordinator implements NodeConfigListener
+	{
+		private BlockingQueue<NodeConfigCoordinator> theQueue;
+		private String id;
+		private ConfigurationEvent event;
+		
+		NodeConfigCoordinator(BlockingQueue<NodeConfigCoordinator> queue, String id)
+		{
+			theQueue = queue;
+			this.id = id;
+		}
+
+		public void handleNodeConfiguration(ConfigurationEvent config)
+		{
+			event = config;
+			theQueue.add(this);
+		}
+
+		@Override
+		public String toString()
+		{
+			return "NodeConfigCoordinator: " + id;
+		}
+
+	}
+
+	class ItemDeleteCoordinator implements ItemDeleteListener
+	{
+		private BlockingQueue<ItemDeleteCoordinator> theQueue;
+		private String id;
+		private ItemDeleteEvent event;
+		
+		ItemDeleteCoordinator(BlockingQueue<ItemDeleteCoordinator> queue, String id)
+		{
+			theQueue = queue;
+			this.id = id;
+		}
+
+		public void handleDeletedItems(ItemDeleteEvent delEvent)
+		{
+			event = delEvent;
+			theQueue.add(this);
+		}
+
+
+		public void handlePurge()
+		{
+			event = null;
+			theQueue.add(this);
+		}
+
+		@Override
+		public String toString()
+		{
+			return "ItemDeleteCoordinator: " + id;
+		}
+	}
+
+	static private LeafNode getPubnode(PubSubManager manager, String id, boolean persistItems, boolean deliverPayload) 
+		throws XMPPException
+	{
+		ConfigureForm form = new ConfigureForm(FormType.submit);
+		form.setPersistentItems(persistItems);
+		form.setDeliverPayloads(deliverPayload);
+		form.setAccessModel(AccessModel.open);
+		return (LeafNode)manager.createNode(id, form);
+	}
+
+}

test/org/jivesoftware/smackx/pubsub/TestMessageContent.java

@@ -0,0 +1,101 @@
+/*
+ * Created on 2009-08-05
+ */
+package org.jivesoftware.smackx.pubsub;
+
+import junit.framework.TestCase;
+
+public class TestMessageContent extends TestCase
+{
+	String payloadXmlWithNS = "<book xmlns='pubsub:test:book'><author name='Stephen King'/></book>";
+	
+	public void testItemWithId() 
+	{
+		Item item = new Item("123");
+		assertEquals("<item id='123'/>", item.toXML());
+		assertEquals("item", item.getElementName());
+		assertNull(item.getNamespace());
+	}
+
+	public void testItemWithNoId() 
+	{
+		Item item = new Item();
+		assertEquals("<item/>", item.toXML());
+
+		Item itemNull = new Item(null);
+		assertEquals("<item/>", itemNull.toXML());
+	}
+
+	public void testSimplePayload() 
+	{
+		SimplePayload payloadNS = new SimplePayload("book", "pubsub:test:book", payloadXmlWithNS);
+		
+		assertEquals(payloadXmlWithNS, payloadNS.toXML());
+		
+		String payloadXmlWithNoNS = "<book><author name='Stephen King'/></book>";
+		SimplePayload payloadNoNS = new SimplePayload("book", null, "<book><author name='Stephen King'/></book>");
+		
+		assertEquals(payloadXmlWithNoNS, payloadNoNS.toXML());
+		
+	}
+	
+	public void testPayloadItemWithId()
+	{
+		SimplePayload payload = new SimplePayload("book", "pubsub:test:book", payloadXmlWithNS);
+		PayloadItem<SimplePayload> item = new PayloadItem<SimplePayload>("123", payload);
+		
+		String xml = "<item id='123'>" + payloadXmlWithNS + "</item>";
+		assertEquals(xml, item.toXML());
+		assertEquals("item", item.getElementName());
+	}
+
+	public void testPayloadItemWithNoId()
+	{
+		SimplePayload payload = new SimplePayload("book", "pubsub:test:book", payloadXmlWithNS);
+		PayloadItem<SimplePayload> item = new PayloadItem<SimplePayload>(null, payload);
+		
+		String xml = "<item>" + payloadXmlWithNS + "</item>";
+		assertEquals(xml, item.toXML());
+	}
+
+	public void testPayloadItemWithIdNoPayload()
+	{
+		try
+		{
+			PayloadItem<SimplePayload> item = new PayloadItem<SimplePayload>("123", null);
+			fail("Should have thrown IllegalArgumentException");
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+	}
+
+	public void testPayloadItemWithNoIdNoPayload()
+	{
+		try
+		{
+			PayloadItem<SimplePayload> item = new PayloadItem<SimplePayload>(null, null);
+			fail("Should have thrown IllegalArgumentException");
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+	}
+	
+	public void testRetractItem()
+	{
+		RetractItem item = new RetractItem("1234");
+		
+		assertEquals("<retract id='1234'/>", item.toXML());
+		assertEquals("retract", item.getElementName());
+		
+		try
+		{
+			new RetractItem(null);
+			fail("Should have thrown IllegalArgumentException");
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+	}
+}

test/org/jivesoftware/smackx/pubsub/test/PubSubTestCase.java

@@ -0,0 +1,74 @@
+/*
+ * Created on 2009-05-05
+ */
+package org.jivesoftware.smackx.pubsub.test;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smackx.pubsub.AccessModel;
+import org.jivesoftware.smackx.pubsub.ConfigureForm;
+import org.jivesoftware.smackx.pubsub.FormType;
+import org.jivesoftware.smackx.pubsub.LeafNode;
+import org.jivesoftware.smackx.pubsub.PubSubManager;
+
+abstract public class PubSubTestCase extends SmackTestCase
+{
+	private PubSubManager[] manager;
+
+	public PubSubTestCase(String arg0)
+	{
+		super(arg0);
+	}
+
+	public PubSubTestCase()
+	{
+		super("PubSub Test Case");
+	}
+
+	protected LeafNode getRandomPubnode(PubSubManager pubMgr, boolean persistItems, boolean deliverPayload) throws XMPPException
+	{
+		ConfigureForm form = new ConfigureForm(FormType.submit);
+		form.setPersistentItems(persistItems);
+		form.setDeliverPayloads(deliverPayload);
+		form.setAccessModel(AccessModel.open);
+		return (LeafNode)pubMgr.createNode("/test/Pubnode" + System.currentTimeMillis(), form);
+	}
+
+	protected LeafNode getPubnode(PubSubManager pubMgr, boolean persistItems, boolean deliverPayload, String nodeId) throws XMPPException
+	{
+		LeafNode node = null;
+		
+		try
+		{
+			node = (LeafNode)pubMgr.getNode(nodeId);
+		}
+		catch (XMPPException e)
+		{
+			ConfigureForm form = new ConfigureForm(FormType.submit);
+			form.setPersistentItems(persistItems);
+			form.setDeliverPayloads(deliverPayload);
+			form.setAccessModel(AccessModel.open);
+			node = (LeafNode)pubMgr.createNode(nodeId, form);
+		}
+		return node;
+	}
+
+	protected PubSubManager getManager(int idx)
+	{
+		if (manager == null)
+		{
+			manager = new PubSubManager[getMaxConnections()];
+			
+			for(int i=0; i<manager.length; i++)
+			{
+				manager[i] = new PubSubManager(getConnection(i), getService());
+			}
+		}
+		return manager[idx];
+	}
+	
+	protected String getService()
+	{
+		return "pubsub." + getServiceName();
+	}
+}

test/org/jivesoftware/smackx/pubsub/test/SingleUserTestCase.java

@@ -0,0 +1,28 @@
+/*
+ * Created on 2009-05-05
+ */
+package org.jivesoftware.smackx.pubsub.test;
+
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smackx.pubsub.LeafNode;
+import org.jivesoftware.smackx.pubsub.PubSubManager;
+
+public class SingleUserTestCase extends PubSubTestCase
+{
+	protected PubSubManager getManager()
+	{
+		return getManager(0);
+	}
+	
+	protected LeafNode getPubnode(boolean persistItems, boolean deliverPayload) throws XMPPException
+	{
+		return getRandomPubnode(getManager(), persistItems, deliverPayload);
+	}
+
+	@Override
+	protected int getMaxConnections()
+	{
+		return 1;
+	}
+
+}