Skip to content

Commit 4f05715

Browse files
author
Lloyd Watkin
committed
Test for and add <target/> element
1 parent 36d0fd2 commit 4f05715

2 files changed

Lines changed: 89 additions & 59 deletions

File tree

‎src/main/java/org/buddycloud/channelserver/channel/ValidateEntry.java‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -216,6 +216,11 @@ public Element getPayload() {
216216
entry.add(media.createCopy());
217217
}
218218

219+
if (null != targetId) {
220+
GlobalItemIDImpl globalTargetId = new GlobalItemIDImpl(new JID(channelServerDomain), node, targetId);
221+
entry.addElement("activity:target").addElement("id").setText(globalTargetId.toString());
222+
}
223+
219224
return entry;
220225
}
221226

@@ -259,7 +264,7 @@ private boolean validateTargetElement(Element target) throws NodeStoreException
259264
if (null == target) {
260265
return true;
261266
}
262-
String targetId = target.elementText("id");
267+
targetId = target.elementText("id");
263268
if ((null == targetId) || (0 == targetId.length())) {
264269
this.errorMessage = MISSING_TARGET_ID;
265270
return false;

‎src/test/java/org/buddycloud/channelserver/channel/ValidateEntryTest.java‎

Lines changed: 83 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
import org.buddycloud.channelserver.packetHandler.iq.TestHandler;
1313
import org.buddycloud.channelserver.packetprocessor.iq.namespace.pubsub.get.RepliesGet;
1414
import org.buddycloud.channelserver.pubsub.model.NodeItem;
15+
import org.buddycloud.channelserver.pubsub.model.impl.GlobalItemIDImpl;
1516
import org.buddycloud.channelserver.pubsub.model.impl.NodeItemImpl;
1617
import org.dom4j.Element;
1718

@@ -31,14 +32,14 @@
3132
public class ValidateEntryTest extends TestHandler {
3233

3334
private ValidateEntry validateEntry;
34-
35+
3536
private IQ publishRequest;
3637
private Element publishEntry;
3738
private IQ replyRequest;
3839
private Element replyEntry;
3940
private IQ targetRequest;
4041
private Element targetEntry;
41-
42+
4243
private ChannelManager channelManager;
4344

4445
JID jid = new JID("juliet@shakespeare.lit/balcony");
@@ -56,7 +57,7 @@ public void setUp() throws Exception {
5657
targetRequest = readStanzaAsIq("/iq/pubsub/publish/target.stanza");
5758
targetEntry = targetRequest.getChildElement().element("publish")
5859
.element("item").element("entry");
59-
60+
6061
channelManager = Mockito.mock(ChannelManager.class);
6162

6263
NodeItem item = new NodeItemImpl(node, "1", new Date(), "<entry/>");
@@ -306,7 +307,7 @@ public void replyParentItemNotFoundResultsInError() throws Exception {
306307

307308
Element entry = (Element) this.replyEntry.clone();
308309
validateEntry = getEntryObject(entry);
309-
310+
310311
Assert.assertFalse(validateEntry.isValid());
311312
Assert.assertEquals(ValidateEntry.PARENT_ITEM_NOT_FOUND,
312313
validateEntry.getErrorMessage());
@@ -322,86 +323,86 @@ public void canNotReplyToAReply() throws Exception {
322323

323324
Element entry = (Element) this.replyEntry.clone();
324325
validateEntry = getEntryObject(entry);
325-
326+
326327
Assert.assertFalse(validateEntry.isValid());
327328
Assert.assertEquals(ValidateEntry.MAX_THREAD_DEPTH_EXCEEDED,
328329
validateEntry.getErrorMessage());
329330
}
330-
331+
331332
@Test
332333
public void targetElementWithoutInReplyToReturnsError() throws Exception {
333-
334+
334335
NodeItem item = new NodeItemImpl(node, "2", new Date(), "<entry/>", "1");
335336
Mockito.when(
336-
channelManager.getNodeItem(Mockito.eq(node),
337-
Mockito.eq("1"))).thenReturn(item);
337+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
338+
.thenReturn(item);
338339
Mockito.when(
339-
channelManager.getNodeItem(Mockito.eq(node),
340-
Mockito.eq("2"))).thenReturn(null);
340+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
341+
.thenReturn(null);
341342

342343
Element entry = (Element) this.targetEntry.clone();
343344

344345
entry.element("in-reply-to").detach();
345346
validateEntry = getEntryObject(entry);
346-
347+
347348
Assert.assertFalse(validateEntry.isValid());
348349
Assert.assertEquals(ValidateEntry.IN_REPLY_TO_MISSING,
349350
validateEntry.getErrorMessage());
350351
}
351-
352+
352353
@Test
353354
public void missingTargetIdElementReturnsError() throws Exception {
354-
355+
355356
NodeItem item = new NodeItemImpl(node, "2", new Date(), "<entry/>");
356357
Mockito.when(
357-
channelManager.getNodeItem(Mockito.eq(node),
358-
Mockito.eq("1"))).thenReturn(item);
358+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
359+
.thenReturn(item);
359360
Mockito.when(
360-
channelManager.getNodeItem(Mockito.eq(node),
361-
Mockito.eq("2"))).thenReturn(null);
361+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
362+
.thenReturn(null);
362363

363364
Element entry = (Element) this.targetEntry.clone();
364365

365366
entry.element("target").element("id").detach();
366367
validateEntry = getEntryObject(entry);
367-
368+
368369
Assert.assertFalse(validateEntry.isValid());
369370
Assert.assertEquals(ValidateEntry.MISSING_TARGET_ID,
370371
validateEntry.getErrorMessage());
371372
}
372-
373+
373374
@Test
374375
public void emptyTargetIdElementReturnsError() throws Exception {
375-
376+
376377
NodeItem item = new NodeItemImpl(node, "2", new Date(), "<entry/>");
377378
Mockito.when(
378-
channelManager.getNodeItem(Mockito.eq(node),
379-
Mockito.eq("1"))).thenReturn(item);
379+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
380+
.thenReturn(item);
380381
Mockito.when(
381-
channelManager.getNodeItem(Mockito.eq(node),
382-
Mockito.eq("2"))).thenReturn(null);
382+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
383+
.thenReturn(null);
383384

384385
Element entry = (Element) this.targetEntry.clone();
385386

386387
entry.element("target").element("id").detach();
387388
entry.element("target").addElement("id");
388389
validateEntry = getEntryObject(entry);
389-
390+
390391
Assert.assertFalse(validateEntry.isValid());
391392
Assert.assertEquals(ValidateEntry.MISSING_TARGET_ID,
392393
validateEntry.getErrorMessage());
393394
}
394-
395+
395396
@Test
396397
public void ifTargetedPostDoesntExistErrorIsReturned() throws Exception {
397-
398+
398399
NodeItem item = new NodeItemImpl(node, "1", new Date(), "<entry/>");
399400
Mockito.when(
400-
channelManager.getNodeItem(Mockito.eq(node),
401-
Mockito.eq("1"))).thenReturn(item);
401+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
402+
.thenReturn(item);
402403
Mockito.when(
403-
channelManager.getNodeItem(Mockito.eq(node),
404-
Mockito.eq("2"))).thenReturn(null);
404+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
405+
.thenReturn(null);
405406

406407
Element entry = (Element) this.targetEntry.clone();
407408
validateEntry = getEntryObject(entry);
@@ -410,63 +411,87 @@ public void ifTargetedPostDoesntExistErrorIsReturned() throws Exception {
410411
Assert.assertEquals(ValidateEntry.TARGETED_ITEM_NOT_FOUND,
411412
validateEntry.getErrorMessage());
412413
}
413-
414+
414415
@Test
415-
public void ifTargetedPostIsntInSameThreadErrorIsReturnedParentCheck() throws Exception {
416+
public void ifTargetedPostIsntInSameThreadErrorIsReturnedParentCheck()
417+
throws Exception {
416418
NodeItem item = new NodeItemImpl(node, "1", new Date(), "<entry/>");
417419
Mockito.when(
418-
channelManager.getNodeItem(Mockito.eq(node),
419-
Mockito.eq("1"))).thenReturn(item);
420+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
421+
.thenReturn(item);
420422
Mockito.when(
421-
channelManager.getNodeItem(Mockito.eq(node),
422-
Mockito.eq("2"))).thenReturn(item);
423+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
424+
.thenReturn(item);
423425

424426
Element entry = (Element) this.targetEntry.clone();
425427
validateEntry = getEntryObject(entry);
426-
428+
427429
Assert.assertFalse(validateEntry.isValid());
428430
Assert.assertEquals(ValidateEntry.TARGET_MUST_BE_IN_SAME_THREAD,
429431
validateEntry.getErrorMessage());
430432
}
431-
433+
432434
@Test
433-
public void ifTargetedPostIsntInSameThreadErrorIsReturnedThreadCheck() throws Exception {
435+
public void ifTargetedPostIsntInSameThreadErrorIsReturnedThreadCheck()
436+
throws Exception {
434437

435438
NodeItem item1 = new NodeItemImpl(node, "1", new Date(), "<entry/>");
436-
NodeItem item2 = new NodeItemImpl(node, "B", new Date(), "<entry/>", "A");
439+
NodeItem item2 = new NodeItemImpl(node, "B", new Date(), "<entry/>",
440+
"A");
437441
Mockito.when(
438-
channelManager.getNodeItem(Mockito.eq(node),
439-
Mockito.eq("1"))).thenReturn(item1);
442+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
443+
.thenReturn(item1);
440444
Mockito.when(
441-
channelManager.getNodeItem(Mockito.eq(node),
442-
Mockito.eq("2"))).thenReturn(item2);
445+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("2")))
446+
.thenReturn(item2);
443447

444448
Element entry = (Element) this.targetEntry.clone();
445449
entry.element("target").element("id").setText("B");
446450
validateEntry = getEntryObject(entry);
447-
451+
448452
Assert.assertFalse(validateEntry.isValid());
449453
Assert.assertEquals(ValidateEntry.TARGET_MUST_BE_IN_SAME_THREAD,
450454
validateEntry.getErrorMessage());
451455
}
452-
453-
456+
454457
@Test
455-
public void ifTargetedIdIsSameAsReplyToIdOnlyOneDatabaseLookupPerformed() throws Exception {
458+
public void ifTargetedIdIsSameAsReplyToIdOnlyOneDatabaseLookupPerformed()
459+
throws Exception {
456460
NodeItem item = new NodeItemImpl(node, "1", new Date(), "<entry/>");
457461
Mockito.when(
458-
channelManager.getNodeItem(Mockito.eq(node),
459-
Mockito.eq("1"))).thenReturn(item);
462+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
463+
.thenReturn(item);
460464

461465
Element entry = (Element) this.targetEntry.clone();
462466
entry.element("target").element("id").setText("1");
463-
467+
464468
validateEntry = getEntryObject(entry);
465-
469+
466470
validateEntry.isValid();
467-
468-
Mockito.verify(channelManager, Mockito.times(1)).getNodeItem(Mockito.eq(node),
469-
Mockito.eq("1"));
471+
472+
Mockito.verify(channelManager, Mockito.times(1)).getNodeItem(
473+
Mockito.eq(node), Mockito.eq("1"));
474+
}
475+
476+
@Test
477+
public void targetElementGetsAddedAsExpected() throws Exception {
478+
479+
NodeItem item = new NodeItemImpl(node, "1", new Date(), "<entry/>");
480+
Mockito.when(
481+
channelManager.getNodeItem(Mockito.eq(node), Mockito.eq("1")))
482+
.thenReturn(item);
483+
484+
Element entry = (Element) this.targetEntry.clone();
485+
entry.element("target").element("id").setText("1");
486+
487+
validateEntry = getEntryObject(entry);
488+
489+
Assert.assertTrue(validateEntry.isValid());
490+
491+
Element payload = validateEntry.getPayload();
492+
493+
String expectedId = "tag:channels.shakespeare.lit,/users/romeo@shakespeare.lit/posts,1";
494+
Assert.assertEquals(expectedId,
495+
payload.element("target").elementText("id"));
470496
}
471-
472497
}

0 commit comments

Comments
 (0)