From 9aff6c905c3c6eb5677f30905b344b3505b99c92 Mon Sep 17 00:00:00 2001 From: Norbert Bartels Date: Tue, 9 Jun 2020 18:08:50 +0200 Subject: [PATCH] Issue #946 - webhook listeners added --- .../AbstractWebhookChangeListener.java | 109 +++ .../AbstractWebhookMessagingListener.java | 82 +++ src/main/java/com/restfb/webhook/Webhook.java | 226 +++++++ .../restfb/webhook/WebhookChangeListener.java | 83 +++ .../webhook/WebhookMessagingListener.java | 65 ++ .../com/restfb/types/webhook/ChangeValue.java | 4 + .../restfb/types/WebhookMessagingTest.java | 178 ++++- .../java/com/restfb/types/WebhookTest.java | 629 +++++++++++++++--- 8 files changed, 1282 insertions(+), 94 deletions(-) create mode 100644 src/main/java/com/restfb/webhook/AbstractWebhookChangeListener.java create mode 100644 src/main/java/com/restfb/webhook/AbstractWebhookMessagingListener.java create mode 100644 src/main/java/com/restfb/webhook/Webhook.java create mode 100644 src/main/java/com/restfb/webhook/WebhookChangeListener.java create mode 100644 src/main/java/com/restfb/webhook/WebhookMessagingListener.java diff --git a/src/main/java/com/restfb/webhook/AbstractWebhookChangeListener.java b/src/main/java/com/restfb/webhook/AbstractWebhookChangeListener.java new file mode 100644 index 000000000..fadea005e --- /dev/null +++ b/src/main/java/com/restfb/webhook/AbstractWebhookChangeListener.java @@ -0,0 +1,109 @@ +/** + * Copyright (c) 2010-2020 Mark Allen, Norbert Bartels. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.restfb.webhook; + +import com.restfb.types.webhook.*; +import com.restfb.types.webhook.instagram.InstagramCommentsValue; +import com.restfb.types.webhook.instagram.InstagramMentionsValue; +import com.restfb.types.webhook.instagram.InstagramStoryInsightsValue; + +/** + * abstract class as base for custom webhook change listener, with this abstract class it is possible to implement only + * a subset of the need methods and ignore the other ones. + */ +public abstract class AbstractWebhookChangeListener implements WebhookChangeListener { + + @Override + public void feedCommentValue(FeedCommentValue feedCommentValue) {} + + @Override + public void feedPhotoAddValue(FeedPhotoAddValue feedPhotoAddValue) {} + + @Override + public void feedPhotoRemoveValue(FeedPhotoRemoveValue feedPhotoRemoveValue) {} + + @Override + public void feedVideoValue(FeedVideoValue feedVideoValue) {} + + @Override + public void feedVideoRemoveValue(FeedVideoRemoveValue feedVideoRemoveValue) {} + + @Override + public void feedStatusValue(FeedStatusValue feedStatusValue) {} + + @Override + public void feedAlbumAddValue(FeedAlbumAddValue feedAlbumAddValue) {} + + @Override + public void feedLikeValue(FeedLikeValue feedLikeValue) {} + + @Override + public void feedEventValue(FeedEventValue feedEventValue) {} + + @Override + public void feedPostValue(FeedPostValue feedPostValue) {} + + @Override + public void feedVideoBlockMute(FeedVideoBlockMute feedVideoBlockMute) {} + + @Override + public void feedReactionValue(FeedReactionValue feedReactionValue) {} + + @Override + public void feedShareValue(FeedShareValue feedShareValue) {} + + @Override + public void feedAlbumEditedValue(FeedAlbumEditedValue feedAlbumEditedValue) {} + + @Override + public void instagramCommentsValue(InstagramCommentsValue instagramCommentsValue) {} + + @Override + public void instagramMentionsValue(InstagramMentionsValue instagramMentionsValue) {} + + @Override + public void instagramStoryInsightsValue(InstagramStoryInsightsValue instagramStoryInsightsValue) {} + + @Override + public void pageLeadgen(PageLeadgen pageLeadgen) {} + + @Override + public void permissionChangeValue(PermissionChangeValue permissionChangeValue) {} + + @Override + public void mentionPostAddValue(MentionPostAddValue mentionPostAddValue) {} + + @Override + public void userPageValue(UserPageValue userPageValue) {} + + @Override + public void ratingsReactionValue(RatingsReactionValue ratingsReactionValue) {} + + @Override + public void ratingsLikeValue(RatingsLikeValue ratingsLikeValue) {} + + @Override + public void ratingsCommentValue(RatingsCommentValue ratingsCommentValue) {} + + @Override + public void ratingsRatingValue(RatingsRatingValue ratingsRatingValue) {} +} diff --git a/src/main/java/com/restfb/webhook/AbstractWebhookMessagingListener.java b/src/main/java/com/restfb/webhook/AbstractWebhookMessagingListener.java new file mode 100644 index 000000000..e34592a2c --- /dev/null +++ b/src/main/java/com/restfb/webhook/AbstractWebhookMessagingListener.java @@ -0,0 +1,82 @@ +/** + * Copyright (c) 2010-2020 Mark Allen, Norbert Bartels. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.restfb.webhook; + +import com.restfb.types.webhook.messaging.*; + +/** + * abstract class as base for custom webhook messaging listener, with this abstract class it is possible to implement + * only a subset of the need methods and ignore the other ones. + */ +public abstract class AbstractWebhookMessagingListener implements WebhookMessagingListener { + + @Override + public void accountLinking(final AccountLinkingItem item, MessagingParticipant recipient, + MessagingParticipant sender) {} + + @Override + public void appRoles(final AppRoles appRoles, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void checkoutUpdate(final CheckoutUpdateItem checkoutUpdate, MessagingParticipant recipient, + MessagingParticipant sender) {} + + @Override + public void delivery(final DeliveryItem delivery, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void message(final MessageItem message, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void optin(final OptinItem optin, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void passThreadControl(final PassThreadControlItem passThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) {} + + @Override + public void payment(final PaymentItem payment, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void policyEnforcement(final PolicyEnforcementItem policyEnforcement, MessagingParticipant recipient, + MessagingParticipant sender) {} + + @Override + public void postback(final PostbackItem postback, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void reaction(final MessageReaction reaction, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void read(final ReadItem read, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void referral(final ReferralItem referral, MessagingParticipant recipient, MessagingParticipant sender) {} + + @Override + public void requestThreadControl(final RequestThreadControlItem requestThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) {} + + @Override + public void takeThreadControl(final TakeThreadControlItem takeThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) {} +} diff --git a/src/main/java/com/restfb/webhook/Webhook.java b/src/main/java/com/restfb/webhook/Webhook.java new file mode 100644 index 000000000..1f503ddcc --- /dev/null +++ b/src/main/java/com/restfb/webhook/Webhook.java @@ -0,0 +1,226 @@ +/** + * Copyright (c) 2010-2020 Mark Allen, Norbert Bartels. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.restfb.webhook; + +import com.restfb.types.webhook.*; +import com.restfb.types.webhook.instagram.InstagramCommentsValue; +import com.restfb.types.webhook.instagram.InstagramMentionsValue; +import com.restfb.types.webhook.instagram.InstagramStoryInsightsValue; + +public class Webhook { + + private WebhookMessagingListener messagingListener; + + private WebhookChangeListener eventListener; + + /** + * registers an listener that handles the messaging Items of an incoming webhook request + * + * @param listener + */ + public void registerListener(WebhookMessagingListener listener) { + this.messagingListener = listener; + } + + /** + * registers a listener that handles the change values of an incoming webhook request + * + * @param listener + */ + public void registerListener(WebhookChangeListener listener) { + this.eventListener = listener; + } + + public void process(WebhookObject webhookObject) { + if (messagingListener != null) { + handleMessaging(webhookObject); + } + if (eventListener != null) { + handleEvents(webhookObject); + } + } + + private void handleEvents(WebhookObject webhookObject) { + webhookObject.getEntryList().stream().flatMap(entry -> entry.getChanges().stream()).forEach(change -> { + if (change.getValue() instanceof FeedCommentValue) { + eventListener.feedCommentValue(change.getValue().convertChangeValue(FeedCommentValue.class)); + } + + if (change.getValue() instanceof FeedPhotoAddValue) { + eventListener.feedPhotoAddValue(change.getValue().convertChangeValue(FeedPhotoAddValue.class)); + } + + if (change.getValue() instanceof FeedPhotoRemoveValue) { + eventListener.feedPhotoRemoveValue(change.getValue().convertChangeValue(FeedPhotoRemoveValue.class)); + } + + if (change.getValue() instanceof FeedVideoValue) { + eventListener.feedVideoValue(change.getValue().convertChangeValue(FeedVideoValue.class)); + } + + if (change.getValue() instanceof FeedVideoRemoveValue) { + eventListener.feedVideoRemoveValue(change.getValue().convertChangeValue(FeedVideoRemoveValue.class)); + } + + if (change.getValue() instanceof FeedStatusValue) { + eventListener.feedStatusValue(change.getValue().convertChangeValue(FeedStatusValue.class)); + } + + if (change.getValue() instanceof FeedPostValue) { + eventListener.feedPostValue(change.getValue().convertChangeValue(FeedPostValue.class)); + } + + if (change.getValue() instanceof FeedVideoBlockMute) { + eventListener.feedVideoBlockMute(change.getValue().convertChangeValue(FeedVideoBlockMute.class)); + } + + if (change.getValue() instanceof FeedReactionValue) { + eventListener.feedReactionValue(change.getValue().convertChangeValue(FeedReactionValue.class)); + } + + if (change.getValue() instanceof FeedShareValue) { + eventListener.feedShareValue(change.getValue().convertChangeValue(FeedShareValue.class)); + } + + if (change.getValue() instanceof FeedAlbumEditedValue) { + eventListener.feedAlbumEditedValue(change.getValue().convertChangeValue(FeedAlbumEditedValue.class)); + } + + if (change.getValue() instanceof FeedEventValue) { + eventListener.feedEventValue(change.getValue().convertChangeValue(FeedEventValue.class)); + } + + if (change.getValue() instanceof FeedLikeValue) { + eventListener.feedLikeValue(change.getValue().convertChangeValue(FeedLikeValue.class)); + } + + if (change.getValue() instanceof FeedAlbumAddValue) { + eventListener.feedAlbumAddValue(change.getValue().convertChangeValue(FeedAlbumAddValue.class)); + } + + if (change.getValue() instanceof RatingsRatingValue) { + eventListener.ratingsRatingValue(change.getValue().convertChangeValue(RatingsRatingValue.class)); + } + if (change.getValue() instanceof MentionPostAddValue) { + eventListener.mentionPostAddValue(change.getValue().convertChangeValue(MentionPostAddValue.class)); + } + + if (change.getValue() instanceof RatingsCommentValue) { + eventListener.ratingsCommentValue(change.getValue().convertChangeValue(RatingsCommentValue.class)); + } + + if (change.getValue() instanceof RatingsLikeValue) { + eventListener.ratingsLikeValue(change.getValue().convertChangeValue(RatingsLikeValue.class)); + } + + if (change.getValue() instanceof RatingsReactionValue) { + eventListener.ratingsReactionValue(change.getValue().convertChangeValue(RatingsReactionValue.class)); + } + + if (change.getValue() instanceof UserPageValue) { + eventListener.userPageValue(change.getValue().convertChangeValue(UserPageValue.class)); + } + + if (change.getValue() instanceof PermissionChangeValue) { + eventListener.permissionChangeValue(change.getValue().convertChangeValue(PermissionChangeValue.class)); + } + + if (change.getValue() instanceof PageLeadgen) { + eventListener.pageLeadgen(change.getValue().convertChangeValue(PageLeadgen.class)); + } + + if (change.getValue() instanceof InstagramStoryInsightsValue) { + eventListener + .instagramStoryInsightsValue(change.getValue().convertChangeValue(InstagramStoryInsightsValue.class)); + } + + if (change.getValue() instanceof InstagramMentionsValue) { + eventListener.instagramMentionsValue(change.getValue().convertChangeValue(InstagramMentionsValue.class)); + } + + if (change.getValue() instanceof InstagramCommentsValue) { + eventListener.instagramCommentsValue(change.getValue().convertChangeValue(InstagramCommentsValue.class)); + } + }); + } + + private void handleMessaging(WebhookObject webhookObject) { + webhookObject.getEntryList().stream().flatMap(entry -> entry.getMessaging().stream()).forEach(messagingItem -> { + if (messagingItem.isAccountLinking()) { + messagingListener.accountLinking(messagingItem.getAccountLinking(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isAppRoles()) { + messagingListener.appRoles(messagingItem.getAppRoles(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isCheckoutUpdate()) { + messagingListener.checkoutUpdate(messagingItem.getCheckoutUpdate(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isDelivery()) { + messagingListener.delivery(messagingItem.getDelivery(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isMessage()) { + messagingListener.message(messagingItem.getMessage(), messagingItem.getRecipient(), messagingItem.getSender()); + } + if (messagingItem.isOptin()) { + messagingListener.optin(messagingItem.getOptin(), messagingItem.getRecipient(), messagingItem.getSender()); + } + if (messagingItem.isPassThreadControl()) { + messagingListener.passThreadControl(messagingItem.getPassThreadControl(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isPayment()) { + messagingListener.payment(messagingItem.getPayment(), messagingItem.getRecipient(), messagingItem.getSender()); + } + if (messagingItem.isPolicyEnforcement()) { + messagingListener.policyEnforcement(messagingItem.getPolicyEnforcement(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isPostback()) { + messagingListener.postback(messagingItem.getPostback(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isReaction()) { + messagingListener.reaction(messagingItem.getReaction(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isRead()) { + messagingListener.read(messagingItem.getRead(), messagingItem.getRecipient(), messagingItem.getSender()); + } + if (messagingItem.isReferral()) { + messagingListener.referral(messagingItem.getReferral(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isRequestThreadControl()) { + messagingListener.requestThreadControl(messagingItem.getRequestThreadControl(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + if (messagingItem.isTakeThreadControl()) { + messagingListener.takeThreadControl(messagingItem.getTakeThreadControl(), messagingItem.getRecipient(), + messagingItem.getSender()); + } + }); + } +} diff --git a/src/main/java/com/restfb/webhook/WebhookChangeListener.java b/src/main/java/com/restfb/webhook/WebhookChangeListener.java new file mode 100644 index 000000000..acc43d2ae --- /dev/null +++ b/src/main/java/com/restfb/webhook/WebhookChangeListener.java @@ -0,0 +1,83 @@ +/** + * Copyright (c) 2010-2020 Mark Allen, Norbert Bartels. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.restfb.webhook; + +import com.restfb.types.webhook.*; +import com.restfb.types.webhook.instagram.InstagramCommentsValue; +import com.restfb.types.webhook.instagram.InstagramMentionsValue; +import com.restfb.types.webhook.instagram.InstagramStoryInsightsValue; + +/** + * interface to provide methods a listener can implement to handle the different change values + */ +public interface WebhookChangeListener { + + void feedCommentValue(FeedCommentValue feedCommentValue); + + void feedPhotoAddValue(FeedPhotoAddValue feedPhotoAddValue); + + void feedPhotoRemoveValue(FeedPhotoRemoveValue feedPhotoRemoveValue); + + void feedVideoValue(FeedVideoValue feedVideoValue); + + void feedVideoRemoveValue(FeedVideoRemoveValue feedVideoRemoveValue); + + void feedStatusValue(FeedStatusValue feedStatusValue); + + void feedAlbumAddValue(FeedAlbumAddValue feedAlbumAddValue); + + void feedLikeValue(FeedLikeValue feedLikeValue); + + void feedEventValue(FeedEventValue feedEventValue); + + void feedPostValue(FeedPostValue feedPostValue); + + void feedVideoBlockMute(FeedVideoBlockMute feedVideoBlockMute); + + void feedReactionValue(FeedReactionValue feedReactionValue); + + void feedShareValue(FeedShareValue feedShareValue); + + void feedAlbumEditedValue(FeedAlbumEditedValue feedAlbumEditedValue); + + void instagramCommentsValue(InstagramCommentsValue instagramCommentsValue); + + void instagramMentionsValue(InstagramMentionsValue instagramMentionsValue); + + void instagramStoryInsightsValue(InstagramStoryInsightsValue instagramStoryInsightsValue); + + void pageLeadgen(PageLeadgen pageLeadgen); + + void permissionChangeValue(PermissionChangeValue permissionChangeValue); + + void mentionPostAddValue(MentionPostAddValue mentionPostAddValue); + + void userPageValue(UserPageValue userPageValue); + + void ratingsReactionValue(RatingsReactionValue ratingsReactionValue); + + void ratingsLikeValue(RatingsLikeValue ratingsLikeValue); + + void ratingsCommentValue(RatingsCommentValue ratingsCommentValue); + + void ratingsRatingValue(RatingsRatingValue ratingsRatingValue); +} diff --git a/src/main/java/com/restfb/webhook/WebhookMessagingListener.java b/src/main/java/com/restfb/webhook/WebhookMessagingListener.java new file mode 100644 index 000000000..90b239f1d --- /dev/null +++ b/src/main/java/com/restfb/webhook/WebhookMessagingListener.java @@ -0,0 +1,65 @@ +/** + * Copyright (c) 2010-2020 Mark Allen, Norbert Bartels. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.restfb.webhook; + +import com.restfb.types.webhook.messaging.*; + +/** + * interface to provide methods a listener can implement to handle the different messaging items + */ +public interface WebhookMessagingListener { + + void accountLinking(final AccountLinkingItem item, MessagingParticipant recipient, MessagingParticipant sender); + + void appRoles(final AppRoles appRoles, MessagingParticipant recipient, MessagingParticipant sender); + + void checkoutUpdate(final CheckoutUpdateItem checkoutUpdate, MessagingParticipant recipient, + MessagingParticipant sender); + + void delivery(final DeliveryItem delivery, MessagingParticipant recipient, MessagingParticipant sender); + + void message(final MessageItem message, MessagingParticipant recipient, MessagingParticipant sender); + + void optin(final OptinItem optin, MessagingParticipant recipient, MessagingParticipant sender); + + void passThreadControl(final PassThreadControlItem passThreadControl, MessagingParticipant recipient, + MessagingParticipant sender); + + void payment(final PaymentItem payment, MessagingParticipant recipient, MessagingParticipant sender); + + void policyEnforcement(final PolicyEnforcementItem policyEnforcement, MessagingParticipant recipient, + MessagingParticipant sender); + + void postback(final PostbackItem postback, MessagingParticipant recipient, MessagingParticipant sender); + + void reaction(final MessageReaction reaction, MessagingParticipant recipient, MessagingParticipant sender); + + void read(final ReadItem read, MessagingParticipant recipient, MessagingParticipant sender); + + void referral(final ReferralItem referral, MessagingParticipant recipient, MessagingParticipant sender); + + void requestThreadControl(final RequestThreadControlItem requestThreadControl, MessagingParticipant recipient, + MessagingParticipant sender); + + void takeThreadControl(final TakeThreadControlItem takeThreadControl, MessagingParticipant recipient, + MessagingParticipant sender); +} diff --git a/src/main/lombok/com/restfb/types/webhook/ChangeValue.java b/src/main/lombok/com/restfb/types/webhook/ChangeValue.java index f758cdf70..5da3b3846 100644 --- a/src/main/lombok/com/restfb/types/webhook/ChangeValue.java +++ b/src/main/lombok/com/restfb/types/webhook/ChangeValue.java @@ -57,4 +57,8 @@ public boolean equals(Object that) { public String toString() { return ReflectionUtils.toString(this); } + + public T convertChangeValue(Class clazz) { + return (T) this; + } } diff --git a/src/test/java/com/restfb/types/WebhookMessagingTest.java b/src/test/java/com/restfb/types/WebhookMessagingTest.java index da22bea25..82622d967 100644 --- a/src/test/java/com/restfb/types/WebhookMessagingTest.java +++ b/src/test/java/com/restfb/types/WebhookMessagingTest.java @@ -23,7 +23,7 @@ import static org.junit.jupiter.api.Assertions.*; -import java.text.ParseException; +import java.util.concurrent.atomic.AtomicBoolean; import org.junit.jupiter.api.Test; @@ -33,9 +33,13 @@ import com.restfb.types.webhook.messaging.*; import com.restfb.types.webhook.messaging.airline.PassengerInfoItem; import com.restfb.types.webhook.messaging.airline.PassengerSegmentInfoItem; +import com.restfb.webhook.AbstractWebhookMessagingListener; +import com.restfb.webhook.Webhook; class WebhookMessagingTest extends AbstractJsonMapperTests { + private final Webhook webhookListener = new Webhook(); + @Test void messagingDelivery() { WebhookObject webhookObject = @@ -51,6 +55,17 @@ void messagingDelivery() { assertFalse(item.getMids().isEmpty()); assertEquals("1458668856253", item.getWatermark()); assertEquals(37L, item.getSeq().longValue()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + @Override + public void delivery(DeliveryItem delivery, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(delivery); + assertEquals("1458668856253", delivery.getWatermark()); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -68,6 +83,18 @@ void messagingRead() { assertNotNull(item); assertEquals("1458668856253", item.getWatermark()); assertEquals(38L, item.getSeq().longValue()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void read(ReadItem read, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(read); + assertEquals("1458668856253", read.getWatermark()); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -93,6 +120,19 @@ void messagingMessageMediaAttachment() { assertEquals("image", attachment.getType()); assertTrue(attachment.isImage()); assertEquals("IMAGE_URL", attachment.getPayload().getUrl()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void message(MessageItem message, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(message); + assertEquals("mid.1458696618141:b4ef9d19ec21086067", message.getMid()); + assertNull(message.getText()); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -119,6 +159,19 @@ void messagingMessageLocationAttachment() { assertTrue(attachment.isLocation()); assertEquals(12.34, attachment.getPayload().getCoordinates().getLat().doubleValue()); assertEquals(43.21, attachment.getPayload().getCoordinates().getLongVal().doubleValue()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void message(MessageItem message, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(message); + assertEquals("mid.1458696618141:b4ef9d19ec21086067", message.getMid()); + assertTrue(message.hasAttachment()); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -189,7 +242,7 @@ void messagingMessageReply() { @Test void messagingReactionREACT() { WebhookObject webhookObject = - createJsonMapper().toJavaObject(jsonFromClasspath("webhooks/messaging-reaction-1"), WebhookObject.class); + createJsonMapper().toJavaObject(jsonFromClasspath("webhooks/messaging-reaction-1"), WebhookObject.class); assertNotNull(webhookObject); WebhookEntry entry = webhookObject.getEntryList().get(0); assertFalse(entry.getMessaging().isEmpty()); @@ -200,12 +253,26 @@ void messagingReactionREACT() { assertEquals(MessageReaction.Action.REACT, reaction.getAction()); assertEquals("\uD83D\uDE22", reaction.getEmoji()); assertEquals("sad", reaction.getReaction()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void reaction(MessageReaction reaction, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(reaction); + assertEquals("original_message_id", reaction.getMid()); + assertEquals("sad", reaction.getReaction()); + found.set(true); + } + + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test void messagingReactionUNREACT() { WebhookObject webhookObject = - createJsonMapper().toJavaObject(jsonFromClasspath("webhooks/messaging-reaction-2"), WebhookObject.class); + createJsonMapper().toJavaObject(jsonFromClasspath("webhooks/messaging-reaction-2"), WebhookObject.class); assertNotNull(webhookObject); WebhookEntry entry = webhookObject.getEntryList().get(0); assertFalse(entry.getMessaging().isEmpty()); @@ -259,6 +326,17 @@ void messagingAppRoles() { assertEquals("123456789", roles.getAppIds().iterator().next()); assertFalse(roles.getRoles("123456789").isEmpty()); assertEquals("primary_receiver", roles.getRoles("123456789").get(0)); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void appRoles(AppRoles appRoles, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(appRoles); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -277,6 +355,17 @@ void messagingReferralBasic() { assertEquals("ref_data_in_m_dot_me_param", referral.getRef()); assertEquals("SHORTLINK", referral.getSource()); assertEquals("OPEN_THREAD", referral.getType()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void referral(ReferralItem referral, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(referral); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -340,6 +429,17 @@ void messagingOptinBasic() { assertEquals("PASS_THROUGH_PARAM", item.getRef()); assertNull(item.getUserRef()); assertNull(item.getUserRefMessageRecipient()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void optin(OptinItem optin, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(optin); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -377,6 +477,18 @@ void messagingPolicyCallbackBlock() { assertTrue(item.isBlock()); assertFalse(item.isUnblock()); assertNotNull(item.getReason()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void policyEnforcement(PolicyEnforcementItem policyEnforcement, MessagingParticipant recipient, + MessagingParticipant sender) { + assertNotNull(policyEnforcement); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -412,6 +524,17 @@ void messagingPostbackBasic() { assertNotNull(item); assertEquals("USER_DEFINED_PAYLOAD", item.getPayload()); assertNull(item.getReferral()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void postback(PostbackItem postback, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(postback); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -451,6 +574,17 @@ void messagingAccountLinkingLinked() { assertFalse(item.isUnlinked()); assertEquals("linked", item.getStatus()); assertEquals("PASS_THROUGH_AUTHORIZATION_CODE", item.getAuthorizationCode()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void accountLinking(AccountLinkingItem item, MessagingParticipant recipient, MessagingParticipant sender) { + assertNotNull(item); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -493,7 +627,7 @@ void messagingButtonTemplate() { } @Test - void messagingAirlineItineraryTemplate() throws ParseException { + void messagingAirlineItineraryTemplate() { WebhookObject webhookObject = createJsonMapper() .toJavaObject(jsonFromClasspath("webhooks/messaging-airline-itinerary-template"), WebhookObject.class); assertNotNull(webhookObject); @@ -547,6 +681,18 @@ void passThreadControl() { assertNotNull(passThreadControlItem); assertEquals("NEW_OWNER_APP_ID", passThreadControlItem.getNewOwnerAppId()); assertEquals("METADATA", passThreadControlItem.getMetadata()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void passThreadControl(PassThreadControlItem passThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) { + assertNotNull(passThreadControl); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -564,6 +710,18 @@ void takeThreadControl() { assertNotNull(takeThreadControlItem); assertEquals("PREVIOUS_OWNER_APP_ID", takeThreadControlItem.getPreviousOwnerAppId()); assertEquals("METADATA", takeThreadControlItem.getMetadata()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void takeThreadControl(TakeThreadControlItem takeThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) { + assertNotNull(takeThreadControl); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } @Test @@ -582,5 +740,17 @@ void requestThreadControl() { assertNotNull(requestThreadControlItem); assertEquals("REQUESTED_OWNER_APP_ID", requestThreadControlItem.getRequestedOwnerAppId()); assertEquals("METADATA", requestThreadControlItem.getMetadata()); + AtomicBoolean found = new AtomicBoolean(false); + webhookListener.registerListener(new AbstractWebhookMessagingListener() { + + @Override + public void requestThreadControl(RequestThreadControlItem requestThreadControl, MessagingParticipant recipient, + MessagingParticipant sender) { + assertNotNull(requestThreadControl); + found.set(true); + } + }); + webhookListener.process(webhookObject); + assertTrue(found.get()); } } diff --git a/src/test/java/com/restfb/types/WebhookTest.java b/src/test/java/com/restfb/types/WebhookTest.java index 0ea0dbd55..2251ff5b9 100644 --- a/src/test/java/com/restfb/types/WebhookTest.java +++ b/src/test/java/com/restfb/types/WebhookTest.java @@ -24,7 +24,9 @@ import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; +import java.util.concurrent.atomic.AtomicBoolean; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import com.restfb.AbstractJsonMapperTests; @@ -39,6 +41,9 @@ import com.restfb.types.webhook.messaging.payment.PaymentCredential; import com.restfb.types.webhook.messaging.payment.ReuqestedUserInfo; import com.restfb.types.webhook.messaging.payment.ShippingAddress; +import com.restfb.webhook.AbstractWebhookChangeListener; +import com.restfb.webhook.Webhook; +import com.restfb.webhook.WebhookChangeListener; class WebhookTest extends AbstractJsonMapperTests { @@ -56,29 +61,58 @@ class WebhookTest extends AbstractJsonMapperTests { private static final String FIELD_RATINGS = "ratings"; private static final String FIELD_CONVERSATIONS = "conversations"; + private final Webhook webhookListener = new Webhook(); + + private AtomicBoolean listenerTriggered = new AtomicBoolean(); + + @BeforeEach + void cleanEnv() { + listenerTriggered.set(false); + } + @Test void feedAlbumAdd() { - FeedAlbumAddValue value = - openAndCheckFeedPostBasics("feed-album-add", FeedAlbumAddValue.class, ITEM_ALBUM, ChangeValue.Verb.ADD); + FeedAlbumAddValue value = openAndCheckFeedPostBasics("feed-album-add", FeedAlbumAddValue.class, ITEM_ALBUM, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedAlbumAddValue(FeedAlbumAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("900767076685784", value.getAlbumId()); assertTrue(value.getPublished()); assertEquals(1467894325000L, value.getCreatedTime().getTime()); assertEquals(Arrays.asList("900767076685784", "900767076685785", "900767076685786"), value.getPhotoIds()); + assertTrue(listenerTriggered.get()); } @Test void feedAlbumEdited() { FeedAlbumEditedValue value = openAndCheckFeedPostBasics("feed-album-edited", FeedAlbumEditedValue.class, ITEM_ALBUM, - ChangeValue.Verb.EDITED); + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedAlbumEditedValue(FeedAlbumEditedValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("900767076685784", value.getAlbumId()); assertFalse(value.getPublished()); assertEquals(1470322909000L, value.getCreatedTime().getTime()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentAdd() { - FeedCommentValue value = - openAndCheckFeedPostBasics("feed-comment-add-25", FeedCommentValue.class, ITEM_COMMENT, ChangeValue.Verb.ADD); + FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-add-25", FeedCommentValue.class, ITEM_COMMENT, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); @@ -92,12 +126,19 @@ void feedCommentAdd() { assertEquals("1234567890321", value.getSenderId()); assertNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentAdd_v2_11() { - FeedCommentValue value = - openAndCheckFeedPostBasics("feed-comment-add-211", FeedCommentValue.class, ITEM_COMMENT, ChangeValue.Verb.ADD); + FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-add-211", FeedCommentValue.class, ITEM_COMMENT, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); @@ -111,12 +152,19 @@ void feedCommentAdd_v2_11() { assertEquals(1449135003000L, value.getCreatedTime().getTime()); assertNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentAddWithPhoto() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-add-with-photo", FeedCommentValue.class, - ITEM_COMMENT, ChangeValue.Verb.ADD); + ITEM_COMMENT, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); @@ -124,12 +172,19 @@ void feedCommentAddWithPhoto() { assertEquals("901097836652708_903438993085259", value.getCommentId()); assertEquals(1449135003000L, value.getCreatedTime().getTime()); assertNotNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentAddWithVideo() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-add-with-video", FeedCommentValue.class, - ITEM_COMMENT, ChangeValue.Verb.ADD); + ITEM_COMMENT, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); @@ -138,12 +193,19 @@ void feedCommentAddWithVideo() { assertEquals(1449135003000L, value.getCreatedTime().getTime()); assertNotNull(value.getVideo()); assertNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentEdited() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-edited-25", FeedCommentValue.class, ITEM_COMMENT, - ChangeValue.Verb.EDITED); + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("Let's see the Webhooks in action :D", value.getMessage()); assertEquals("1234567890321_900728623356296", value.getPostId()); @@ -151,12 +213,19 @@ void feedCommentEdited() { assertEquals("900728623356296_900744590021366", value.getCommentId()); assertEquals(1448555737000L, value.getCreatedTime().getTime()); assertNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentEditedWithPhoto() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-edited-with-photo", FeedCommentValue.class, - ITEM_COMMENT, ChangeValue.Verb.EDITED); + ITEM_COMMENT, ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("Let's see the Webhooks in action :D", value.getMessage()); assertEquals("1234567890321_900728623356296", value.getPostId()); @@ -164,12 +233,19 @@ void feedCommentEditedWithPhoto() { assertEquals("900728623356296_900744590021366", value.getCommentId()); assertEquals(1448555737000L, value.getCreatedTime().getTime()); assertNotNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentEditedWithVideo() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-edited-with-video", FeedCommentValue.class, - ITEM_COMMENT, ChangeValue.Verb.EDITED); + ITEM_COMMENT, ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("Let's see the Webhooks in action :D", value.getMessage()); assertEquals("1234567890321_900728623356296", value.getPostId()); @@ -178,95 +254,158 @@ void feedCommentEditedWithVideo() { assertEquals(1448555737000L, value.getCreatedTime().getTime()); assertNotNull(value.getVideo()); assertNull(value.getPhoto()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentHide() { - FeedCommentValue value = - openAndCheckFeedPostBasics("feed-comment-hide", FeedCommentValue.class, ITEM_COMMENT, ChangeValue.Verb.HIDE); + FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-hide", FeedCommentValue.class, ITEM_COMMENT, + ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); assertEquals("1234567890321_901097836652708", value.getParentId()); assertEquals("900728623356296_900744590021366", value.getCommentId()); assertEquals(1467894562000L, value.getCreatedTime().getTime()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentUnhide() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-unhide", FeedCommentValue.class, ITEM_COMMENT, - ChangeValue.Verb.UNHIDE); + ChangeValue.Verb.UNHIDE, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("and the next one", value.getMessage()); assertEquals("1234567890321_901097836652708", value.getPostId()); assertEquals("1234567890321_901097836652708", value.getParentId()); assertEquals("900728623356296_900744590021366", value.getCommentId()); assertEquals(1467894562000L, value.getCreatedTime().getTime()); + assertTrue(listenerTriggered.get()); } @Test void feedCommentRemove() { FeedCommentValue value = openAndCheckFeedPostBasics("feed-comment-remove-25", FeedCommentValue.class, ITEM_COMMENT, - ChangeValue.Verb.REMOVE); + ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedCommentValue(FeedCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isReply()); assertEquals("1234567890321_905578656204626", value.getPostId()); assertEquals("1234567890321_905578656204626", value.getParentId()); assertEquals("905578656204626_905579239537901", value.getCommentId()); assertNull(value.getCreatedTime()); + assertTrue(listenerTriggered.get()); } @Test void feedPostAdd() { - FeedPostValue value = - openAndCheckFeedPostBasics("feed-post-add-25", FeedPostValue.class, ITEM_POST, ChangeValue.Verb.ADD); + FeedPostValue value = openAndCheckFeedPostBasics("feed-post-add-25", FeedPostValue.class, ITEM_POST, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedPostValue(FeedPostValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_7293787835232", value.getPostId()); assertEquals("8423678347823", value.getSenderId()); assertFalse(value.getIsHidden()); assertEquals("Let's check this", value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPostHide() { - FeedPostValue value = - openAndCheckFeedPostBasics("feed-post-hide", FeedPostValue.class, ITEM_POST, ChangeValue.Verb.HIDE); + FeedPostValue value = openAndCheckFeedPostBasics("feed-post-hide", FeedPostValue.class, ITEM_POST, + ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedPostValue(FeedPostValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_7293787835232", value.getPostId()); assertEquals("8423678347823", value.getSenderId()); assertEquals("Let's check this", value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPostEdit() { - FeedPostValue value = - openAndCheckFeedPostBasics("feed-post-edit", FeedPostValue.class, ITEM_POST, ChangeValue.Verb.EDIT); + FeedPostValue value = openAndCheckFeedPostBasics("feed-post-edit", FeedPostValue.class, ITEM_POST, + ChangeValue.Verb.EDIT, new AbstractWebhookChangeListener() { + @Override + public void feedPostValue(FeedPostValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_7293787835232", value.getPostId()); assertEquals("8423678347823", value.getSenderId()); assertEquals("Let's check this", value.getMessage()); assertEquals("753215778164799", value.getRecipientId()); + assertTrue(listenerTriggered.get()); } @Test void feedPostRemove() { - FeedPostValue value = - openAndCheckFeedPostBasics("feed-post-remove-25", FeedPostValue.class, ITEM_POST, ChangeValue.Verb.REMOVE); + FeedPostValue value = openAndCheckFeedPostBasics("feed-post-remove-25", FeedPostValue.class, ITEM_POST, + ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedPostValue(FeedPostValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_901097836652708", value.getPostId()); assertEquals("1234567890321", value.getSenderId()); assertEquals(1452098986000L, value.getCreatedTime().getTime()); assertEquals("1234567890321", value.getRecipientId()); + assertTrue(listenerTriggered.get()); } @Test void feedPostUnhide() { - FeedPostValue value = - openAndCheckFeedPostBasics("feed-post-unhide", FeedPostValue.class, ITEM_POST, ChangeValue.Verb.UNHIDE); + FeedPostValue value = openAndCheckFeedPostBasics("feed-post-unhide", FeedPostValue.class, ITEM_POST, + ChangeValue.Verb.UNHIDE, new AbstractWebhookChangeListener() { + @Override + public void feedPostValue(FeedPostValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_7293787835232", value.getPostId()); assertEquals("8423678347823", value.getSenderId()); assertEquals("Let's check this", value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedReactionAdd() { - FeedReactionValue value = - openAndCheckFeedPostBasics("feed-reaction-add", FeedReactionValue.class, ITEM_REACTION, ChangeValue.Verb.ADD); + FeedReactionValue value = openAndCheckFeedPostBasics("feed-reaction-add", FeedReactionValue.class, ITEM_REACTION, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedReactionValue(FeedReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321_901097836652708", value.getParentId()); assertEquals("1234567890321", value.getSenderId()); @@ -274,12 +413,19 @@ void feedReactionAdd() { assertTrue(value.isPostReaction()); assertFalse(value.isCommentReaction()); assertFalse(value.isReplyReaction()); + assertTrue(listenerTriggered.get()); } @Test void feedReactionCommentAdd() { FeedReactionValue value = openAndCheckFeedPostBasics("feed-reaction-add-comment", FeedReactionValue.class, - ITEM_REACTION, ChangeValue.Verb.ADD); + ITEM_REACTION, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedReactionValue(FeedReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321_98735342324352", value.getParentId()); assertEquals("1234567890321_1264545546974600", value.getCommentId()); @@ -288,12 +434,19 @@ void feedReactionCommentAdd() { assertFalse(value.isPostReaction()); assertTrue(value.isCommentReaction()); assertFalse(value.isReplyReaction()); + assertTrue(listenerTriggered.get()); } @Test void feedReactionReplyAdd() { FeedReactionValue value = openAndCheckFeedPostBasics("feed-reaction-add-reply", FeedReactionValue.class, - ITEM_REACTION, ChangeValue.Verb.ADD); + ITEM_REACTION, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedReactionValue(FeedReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321_1264545546974600", value.getParentId()); assertEquals("1234567890321_1357555177673636", value.getCommentId()); @@ -302,78 +455,127 @@ void feedReactionReplyAdd() { assertFalse(value.isPostReaction()); assertTrue(value.isCommentReaction()); assertTrue(value.isReplyReaction()); + assertTrue(listenerTriggered.get()); } @Test void feedReactionEdit() { - FeedReactionValue value = - openAndCheckFeedPostBasics("feed-reaction-edit", FeedReactionValue.class, ITEM_REACTION, ChangeValue.Verb.EDIT); + FeedReactionValue value = openAndCheckFeedPostBasics("feed-reaction-edit", FeedReactionValue.class, ITEM_REACTION, + ChangeValue.Verb.EDIT, new AbstractWebhookChangeListener() { + @Override + public void feedReactionValue(FeedReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321_901097836652708", value.getParentId()); assertEquals("1234567890321", value.getSenderId()); assertEquals("wow", value.getReactionType()); + assertTrue(listenerTriggered.get()); } @Test void feedReactionRemove() { FeedReactionValue value = openAndCheckFeedPostBasics("feed-reaction-remove", FeedReactionValue.class, ITEM_REACTION, - ChangeValue.Verb.REMOVE); + ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedReactionValue(FeedReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321_901097836652708", value.getParentId()); assertEquals("1234567890321", value.getSenderId()); assertEquals("wow", value.getReactionType()); + assertTrue(listenerTriggered.get()); } @Test void feedShareAdd() { FeedShareValue value = - openAndCheckFeedPostBasics("feed-share-add-25", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.ADD); + openAndCheckFeedPostBasics("feed-share-add-25", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedShareValue(FeedShareValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321", value.getSenderId()); assertTrue(value.getPublished()); assertNotNull(value.getMessage()); assertEquals("http://www.google.com/", value.getLink()); assertEquals("98735342324352", value.getShareId()); + assertTrue(listenerTriggered.get()); } @Test void feedShareHide() { FeedShareValue value = - openAndCheckFeedPostBasics("feed-share-hide", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.HIDE); + openAndCheckFeedPostBasics("feed-share-hide", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedShareValue(FeedShareValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321", value.getSenderId()); assertEquals("Let me google that for you", value.getMessage()); assertEquals("http://www.google.com/", value.getLink()); assertEquals("98735342324352", value.getShareId()); + assertTrue(listenerTriggered.get()); } @Test void feedShareUnhide() { FeedShareValue value = - openAndCheckFeedPostBasics("feed-share-unhide", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.UNHIDE); + openAndCheckFeedPostBasics("feed-share-unhide", FeedShareValue.class, ITEM_SHARE, ChangeValue.Verb.UNHIDE, new AbstractWebhookChangeListener() { + @Override + public void feedShareValue(FeedShareValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_98735342324352", value.getPostId()); assertEquals("1234567890321", value.getSenderId()); assertEquals("Let me google that for you", value.getMessage()); assertEquals("http://www.google.com/", value.getLink()); assertEquals("98735342324352", value.getShareId()); + assertTrue(listenerTriggered.get()); } @Test void feedStatusEdited() { FeedStatusValue value = openAndCheckFeedPostBasics("feed-status-edited-25", FeedStatusValue.class, ITEM_STATUS, - ChangeValue.Verb.EDITED); + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("edited", value.getVerbAsString()); assertEquals("Tester", value.getSenderName()); assertEquals("status", value.getItem()); assertEquals("This is an edited test message", value.getMessage()); assertTrue(value.getPublished()); assertEquals(0, value.getPhotos().size()); + assertTrue(listenerTriggered.get()); } @Test void feedStatusEdited_withPhotos() { FeedStatusValue value = openAndCheckFeedPostBasics("feed-status-edited-photos", FeedStatusValue.class, ITEM_STATUS, - ChangeValue.Verb.EDITED); + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("edited", value.getVerbAsString()); assertEquals("Tester", value.getSenderName()); assertEquals("status", value.getItem()); @@ -383,23 +585,37 @@ void feedStatusEdited_withPhotos() { assertTrue(value.getPhotos().get(0).contains("exampleimage1.png")); assertTrue(value.getPhotos().get(1).contains("exampleimage2.png")); assertTrue(value.getPhotos().get(2).contains("exampleimage3.png")); + assertTrue(listenerTriggered.get()); } @Test void feedStatusAdd() { FeedStatusValue value = - openAndCheckFeedPostBasics("feed-status-add-25", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.ADD); + openAndCheckFeedPostBasics("feed-status-add-25", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("1234567890321_930145403745849", value.getPostId()); assertEquals("Tester", value.getSenderName()); assertEquals(1448633038000L, value.getCreatedTime().getTime()); assertEquals(0, value.getPhotos().size()); + assertTrue(listenerTriggered.get()); } @Test void feedStatusAdd_withPhotos() { FeedStatusValue value = - openAndCheckFeedPostBasics("feed-status-add-photos", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.ADD); + openAndCheckFeedPostBasics("feed-status-add-photos", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("1234567890321_930145403745849", value.getPostId()); assertEquals("Tester", value.getSenderName()); @@ -408,315 +624,546 @@ void feedStatusAdd_withPhotos() { assertTrue(value.getPhotos().get(0).contains("exampleimage1.png")); assertTrue(value.getPhotos().get(1).contains("exampleimage2.png")); assertTrue(value.getPhotos().get(2).contains("exampleimage3.png")); + assertTrue(listenerTriggered.get()); } @Test void feedStatusHide() { FeedStatusValue value = - openAndCheckFeedPostBasics("feed-status-hide-25", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.HIDE); + openAndCheckFeedPostBasics("feed-status-hide-25", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_7293787835232", value.getPostId()); assertEquals("Some Tester", value.getSenderName()); + assertTrue(listenerTriggered.get()); } @Test void feedStatusUnhide() { FeedStatusValue value = - openAndCheckFeedPostBasics("feed-status-unhide", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.UNHIDE); + openAndCheckFeedPostBasics("feed-status-unhide", FeedStatusValue.class, ITEM_STATUS, ChangeValue.Verb.UNHIDE, new AbstractWebhookChangeListener() { + @Override + public void feedStatusValue(FeedStatusValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("123456789_64352426", value.getPostId()); assertEquals("Tester", value.getSenderName()); + assertTrue(listenerTriggered.get()); } @Test void feedLikeAdd() { - FeedLikeValue value = - openAndCheckFeedPostBasics("feed-like-add-25", FeedLikeValue.class, ITEM_LIKE, ChangeValue.Verb.ADD); + FeedLikeValue value = openAndCheckFeedPostBasics("feed-like-add-25", FeedLikeValue.class, ITEM_LIKE, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedLikeValue(FeedLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isPageLike()); assertEquals("909653922461664_940663242694065", value.getParentId()); assertNull(value.getUserId()); assertEquals("909653922461664_940663242694065", value.getPostId()); assertTrue(value.isPostLike()); + assertTrue(listenerTriggered.get()); } @Test void feedLikeAddComment() { - FeedLikeValue value = - openAndCheckFeedPostBasics("feed-like-add-comment-25", FeedLikeValue.class, ITEM_LIKE, ChangeValue.Verb.ADD); + FeedLikeValue value = openAndCheckFeedPostBasics("feed-like-add-comment-25", FeedLikeValue.class, ITEM_LIKE, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedLikeValue(FeedLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertFalse(value.isPageLike()); assertNull(value.getUserId()); assertEquals("940663242694065_659751347534292", value.getCommentId()); assertFalse(value.isPostLike()); assertTrue(value.isCommentLike()); + assertTrue(listenerTriggered.get()); } @Test void feedLikeAddPage() { - FeedLikeValue value = - openAndCheckFeedPostBasics("feed-like-add-page-25", FeedLikeValue.class, ITEM_LIKE, ChangeValue.Verb.ADD); + FeedLikeValue value = openAndCheckFeedPostBasics("feed-like-add-page-25", FeedLikeValue.class, ITEM_LIKE, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedLikeValue(FeedLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.isPageLike()); assertEquals("10201978818232600", value.getUserId()); + assertTrue(listenerTriggered.get()); } @Test void feedLikeRemove() { - FeedLikeValue value = - openAndCheckFeedPostBasics("feed-like-remove-25", FeedLikeValue.class, ITEM_LIKE, ChangeValue.Verb.REMOVE); + FeedLikeValue value = openAndCheckFeedPostBasics("feed-like-remove-25", FeedLikeValue.class, ITEM_LIKE, + ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedLikeValue(FeedLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321_940663242694065", value.getParentId()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoAdd() { - FeedPhotoAddValue value = - openAndCheckFeedPostBasics("feed-photo-add-25", FeedPhotoAddValue.class, ITEM_PHOTO, ChangeValue.Verb.ADD); + FeedPhotoAddValue value = openAndCheckFeedPostBasics("feed-photo-add-25", FeedPhotoAddValue.class, ITEM_PHOTO, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoAddValue(FeedPhotoAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("https://www.example.org/test.jpg", value.getLink()); assertEquals("900767076685784", value.getPhotoId()); assertNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoAddWithMessage() { - FeedPhotoAddValue value = - openAndCheckFeedPostBasics("feed-photo-add-message", FeedPhotoAddValue.class, ITEM_PHOTO, ChangeValue.Verb.ADD); + FeedPhotoAddValue value = openAndCheckFeedPostBasics("feed-photo-add-message", FeedPhotoAddValue.class, ITEM_PHOTO, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoAddValue(FeedPhotoAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("https://www.example.org/test.jpg", value.getLink()); assertEquals("900767076685784", value.getPhotoId()); assertNotNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoEdited() { - FeedPhotoAddValue value = - openAndCheckFeedPostBasics("feed-photo-edited", FeedPhotoAddValue.class, ITEM_PHOTO, ChangeValue.Verb.EDITED); + FeedPhotoAddValue value = openAndCheckFeedPostBasics("feed-photo-edited", FeedPhotoAddValue.class, ITEM_PHOTO, + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoAddValue(FeedPhotoAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("https://www.example.org/test.jpg", value.getLink()); assertEquals("900767076685784", value.getPhotoId()); assertNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoEditedWithMessage() { FeedPhotoAddValue value = openAndCheckFeedPostBasics("feed-photo-edited-message", FeedPhotoAddValue.class, - ITEM_PHOTO, ChangeValue.Verb.EDITED); + ITEM_PHOTO, ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoAddValue(FeedPhotoAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertTrue(value.getPublished()); assertEquals("https://www.example.org/test.jpg", value.getLink()); assertEquals("900767076685784", value.getPhotoId()); assertNotNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoHide() { - FeedPhotoAddValue value = - openAndCheckFeedPostBasics("feed-photo-hide", FeedPhotoAddValue.class, ITEM_PHOTO, ChangeValue.Verb.HIDE); + FeedPhotoAddValue value = openAndCheckFeedPostBasics("feed-photo-hide", FeedPhotoAddValue.class, ITEM_PHOTO, + ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoAddValue(FeedPhotoAddValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(ChangeValue.Verb.HIDE, value.getVerb()); assertEquals("https://www.example.org/test.jpg", value.getLink()); assertEquals("1063068383729088", value.getPhotoId()); + assertTrue(listenerTriggered.get()); } @Test void feedPhotoRemove() { FeedPhotoRemoveValue value = openAndCheckFeedPostBasics("feed-photo-remove-25", FeedPhotoRemoveValue.class, - ITEM_PHOTO, ChangeValue.Verb.REMOVE); + ITEM_PHOTO, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedPhotoRemoveValue(FeedPhotoRemoveValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321", value.getRecipientId()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoAdd() { - FeedVideoValue value = - openAndCheckFeedPostBasics("feed-video-add", FeedVideoValue.class, ITEM_VIDEO, ChangeValue.Verb.ADD); + FeedVideoValue value = openAndCheckFeedPostBasics("feed-video-add", FeedVideoValue.class, ITEM_VIDEO, + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void feedVideoValue(FeedVideoValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertNotNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoUnblock() { FeedVideoBlockMute value = openAndCheckFeedPostBasics("feed-video-unblock", FeedVideoBlockMute.class, ITEM_VIDEO, - ChangeValue.Verb.UNBLOCK); + ChangeValue.Verb.UNBLOCK, new AbstractWebhookChangeListener() { + @Override + public void feedVideoBlockMute(FeedVideoBlockMute convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertNotNull(value.getMessage()); assertEquals(1, value.getVideoFlagReason().intValue()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoBlock() { - FeedVideoBlockMute value = - openAndCheckFeedPostBasics("feed-video-block", FeedVideoBlockMute.class, ITEM_VIDEO, ChangeValue.Verb.BLOCK); + FeedVideoBlockMute value = openAndCheckFeedPostBasics("feed-video-block", FeedVideoBlockMute.class, ITEM_VIDEO, + ChangeValue.Verb.BLOCK, new AbstractWebhookChangeListener() { + @Override + public void feedVideoBlockMute(FeedVideoBlockMute convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertNotNull(value.getMessage()); assertEquals(1, value.getVideoFlagReason().intValue()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoMute() { - FeedVideoBlockMute value = - openAndCheckFeedPostBasics("feed-video-mute", FeedVideoBlockMute.class, ITEM_VIDEO, ChangeValue.Verb.MUTE); + FeedVideoBlockMute value = openAndCheckFeedPostBasics("feed-video-mute", FeedVideoBlockMute.class, ITEM_VIDEO, + ChangeValue.Verb.MUTE, new AbstractWebhookChangeListener() { + @Override + public void feedVideoBlockMute(FeedVideoBlockMute convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertNotNull(value.getMessage()); assertEquals(1, value.getVideoFlagReason().intValue()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoEdited() { - FeedVideoValue value = - openAndCheckFeedPostBasics("feed-video-edited", FeedVideoValue.class, ITEM_VIDEO, ChangeValue.Verb.EDITED); + FeedVideoValue value = openAndCheckFeedPostBasics("feed-video-edited", FeedVideoValue.class, ITEM_VIDEO, + ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void feedVideoValue(FeedVideoValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertTrue(value.getPublished()); assertNotNull(value.getMessage()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoHide() { - FeedVideoValue value = - openAndCheckFeedPostBasics("feed-video-hide", FeedVideoValue.class, ITEM_VIDEO, ChangeValue.Verb.HIDE); + FeedVideoValue value = openAndCheckFeedPostBasics("feed-video-hide", FeedVideoValue.class, ITEM_VIDEO, + ChangeValue.Verb.HIDE, new AbstractWebhookChangeListener() { + @Override + public void feedVideoValue(FeedVideoValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("https://www.example.org/test.mp4", value.getLink()); assertEquals("900767076685784", value.getVideoId()); assertTrue(value.getPublished()); assertNull(value.getMessage()); assertEquals(1549019010000L, value.getCreatedTime().getTime()); + assertTrue(listenerTriggered.get()); } @Test void feedVideoRemove() { FeedVideoRemoveValue value = openAndCheckFeedPostBasics("feed-video-remove-25", FeedVideoRemoveValue.class, - ITEM_VIDEO, ChangeValue.Verb.REMOVE); + ITEM_VIDEO, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void feedVideoRemoveValue(FeedVideoRemoveValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321", value.getRecipientId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsCommentAdd() { RatingsCommentValue value = openAndCheckBasics("ratings-comment-add-25", RatingsCommentValue.class, FIELD_RATINGS, - ITEM_COMMENT, ChangeValue.Verb.ADD); + ITEM_COMMENT, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsCommentValue(RatingsCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("6767676767", value.getOpenGraphStoryId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsCommentEdited() { RatingsCommentValue value = openAndCheckBasics("ratings-comment-edited-25", RatingsCommentValue.class, - FIELD_RATINGS, ITEM_COMMENT, ChangeValue.Verb.EDITED); + FIELD_RATINGS, ITEM_COMMENT, ChangeValue.Verb.EDITED, new AbstractWebhookChangeListener() { + @Override + public void ratingsCommentValue(RatingsCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("716630661754264_994838177266843", value.getCommentId()); assertFalse(value.isReply()); + assertTrue(listenerTriggered.get()); } @Test void ratingsCommentRemove() { RatingsCommentValue value = openAndCheckBasics("ratings-comment-remove-25", RatingsCommentValue.class, - FIELD_RATINGS, ITEM_COMMENT, ChangeValue.Verb.REMOVE); + FIELD_RATINGS, ITEM_COMMENT, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void ratingsCommentValue(RatingsCommentValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("1234567890321", value.getSenderId()); assertEquals("100002220109526_716630661754264", value.getParentId()); - + assertTrue(listenerTriggered.get()); } @Test void ratingsRatingAdd() { RatingsRatingValue value = openAndCheckBasics("ratings-rating-add-25", RatingsRatingValue.class, FIELD_RATINGS, - ITEM_RATING, ChangeValue.Verb.ADD); + ITEM_RATING, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsRatingValue(RatingsRatingValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(3L, value.getRating().longValue()); assertEquals("Tester", value.getReviewerName()); assertEquals("Ja ziemlich coole Sache", value.getReviewText()); + assertTrue(listenerTriggered.get()); } @Test void ratingsRatingAddWithRecommendation() { RatingsRatingValue value = openAndCheckBasics("ratings-rating-add-31", RatingsRatingValue.class, FIELD_RATINGS, - ITEM_RATING, ChangeValue.Verb.ADD); + ITEM_RATING, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsRatingValue(RatingsRatingValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(3L, value.getRating().longValue()); assertEquals("Tester", value.getReviewerName()); assertEquals("Ja ziemlich coole Sache", value.getReviewText()); assertEquals(RecommendationType.POSITIVE, value.getRecommendationType()); + assertTrue(listenerTriggered.get()); } @Test void ratingsRatingEdit() { RatingsRatingValue value = openAndCheckBasics("ratings-rating-edit-25", RatingsRatingValue.class, FIELD_RATINGS, - ITEM_RATING, ChangeValue.Verb.EDIT); + ITEM_RATING, ChangeValue.Verb.EDIT, new AbstractWebhookChangeListener() { + @Override + public void ratingsRatingValue(RatingsRatingValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(3L, value.getRating().longValue()); assertEquals("Tester", value.getReviewerName()); assertEquals("Ja ziemlich coole Sache", value.getReviewText()); assertNull(value.getCommentId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsRatingRemove() { RatingsRatingValue value = openAndCheckBasics("ratings-rating-remove-25", RatingsRatingValue.class, FIELD_RATINGS, - ITEM_RATING, ChangeValue.Verb.REMOVE); + ITEM_RATING, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void ratingsRatingValue(RatingsRatingValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals("904801129604590", value.getOpenGraphStoryId()); assertEquals("705955836155788", value.getReviewerId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsLikeAdd() { RatingsLikeValue value = openAndCheckBasics("ratings-like-add-25", RatingsLikeValue.class, FIELD_RATINGS, ITEM_LIKE, - ChangeValue.Verb.ADD); + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsLikeValue(RatingsLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(1451775296000L, value.getCreatedTime().getTime()); assertEquals("Tester", value.getSenderName()); assertEquals("100002241334695_904801129604590", value.getParentId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsLikeAdd40() { RatingsLikeValue value = openAndCheckBasics("ratings-like-add-40", RatingsLikeValue.class, FIELD_RATINGS, ITEM_LIKE, - ChangeValue.Verb.ADD); + ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsLikeValue(RatingsLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertEquals(1451775296000L, value.getCreatedTime().getTime()); assertEquals("Tester", value.getSenderName()); assertEquals("100002241334695_904801129604590", value.getParentId()); assertNull(value.getReviewText()); assertEquals("2782258465134925", value.getOpenGraphStoryId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsLikeRemove() { RatingsLikeValue value = openAndCheckBasics("ratings-like-remove-25", RatingsLikeValue.class, FIELD_RATINGS, - ITEM_LIKE, ChangeValue.Verb.REMOVE); + ITEM_LIKE, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void ratingsLikeValue(RatingsLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertNotNull(value); assertEquals(1451775365000L, value.getCreatedTime().getTime()); assertEquals("100002241334695_904801129604590", value.getParentId()); assertNull(value.getReviewText()); + assertTrue(listenerTriggered.get()); } @Test void ratingsLikeRemove40() { RatingsLikeValue value = openAndCheckBasics("ratings-like-remove-40", RatingsLikeValue.class, FIELD_RATINGS, - ITEM_LIKE, ChangeValue.Verb.REMOVE); + ITEM_LIKE, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void ratingsLikeValue(RatingsLikeValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertNotNull(value); assertEquals(1451775296000L, value.getCreatedTime().getTime()); assertEquals("Tester", value.getSenderName()); assertEquals("100002241334695_904801129604590", value.getParentId()); assertNull(value.getReviewText()); assertEquals("2782258465134925", value.getOpenGraphStoryId()); + assertTrue(listenerTriggered.get()); } @Test void ratingsReactionAdd() { RatingsReactionValue value = openAndCheckBasics("ratings-reaction-add", RatingsReactionValue.class, FIELD_RATINGS, - ITEM_REACTION, ChangeValue.Verb.ADD); + ITEM_REACTION, ChangeValue.Verb.ADD, new AbstractWebhookChangeListener() { + @Override + public void ratingsReactionValue(RatingsReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertNull(value.getReviewText()); assertNull(value.getCommentId()); assertEquals("716630661754264", value.getOpenGraphStoryId()); assertEquals("haha", value.getReactionType()); + assertTrue(listenerTriggered.get()); } @Test void ratingsReactionEdit() { RatingsReactionValue value = openAndCheckBasics("ratings-reaction-edit", RatingsReactionValue.class, FIELD_RATINGS, - ITEM_REACTION, ChangeValue.Verb.EDIT); + ITEM_REACTION, ChangeValue.Verb.EDIT, new AbstractWebhookChangeListener() { + @Override + public void ratingsReactionValue(RatingsReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertNull(value.getReviewText()); assertNull(value.getCommentId()); assertEquals("716630661754264", value.getOpenGraphStoryId()); assertEquals("angry", value.getReactionType()); + assertTrue(listenerTriggered.get()); } @Test void ratingsReactionRemove() { RatingsReactionValue value = openAndCheckBasics("ratings-reaction-remove", RatingsReactionValue.class, - FIELD_RATINGS, ITEM_REACTION, ChangeValue.Verb.REMOVE); + FIELD_RATINGS, ITEM_REACTION, ChangeValue.Verb.REMOVE, new AbstractWebhookChangeListener() { + @Override + public void ratingsReactionValue(RatingsReactionValue convertChangeValue) { + assertNotNull(convertChangeValue); + listenerTriggered.set(true); + } + }); assertNull(value.getReviewText()); assertNull(value.getCommentId()); assertEquals("716630661754264", value.getOpenGraphStoryId()); assertEquals("angry", value.getReactionType()); + assertTrue(listenerTriggered.get()); } @Test @@ -956,18 +1403,20 @@ private void checkUserPageValueWithField(String s, String movies) { } private T openAndCheckFeedPostBasics(String jsonName, Class changeValueClass, - String expectedItem, ChangeValue.Verb expectedVerb) { - return openAndCheckBasics(jsonName, changeValueClass, FIELD_FEED, expectedItem, expectedVerb); + String expectedItem, ChangeValue.Verb expectedVerb, WebhookChangeListener listener) { + return openAndCheckBasics(jsonName, changeValueClass, FIELD_FEED, expectedItem, expectedVerb, listener); } private T openAndCheckBasics(String jsonName, Class changeValueClass, - String expectedField, String expectedItem, ChangeValue.Verb expectedVerb) { + String expectedField, String expectedItem, ChangeValue.Verb expectedVerb, WebhookChangeListener listener) { WebhookObject webhookObject = openJson(jsonName); Change change = webhookObject.getEntryList().get(0).getChanges().get(0); assertEquals(expectedField, change.getField(), "change field"); assertEquals(change.getValue().getClass(), changeValueClass, "change value class"); assertEquals(expectedItem, ((T) change.getValue()).getItem(), "change item"); assertEquals(expectedVerb, ((T) change.getValue()).getVerb(), "change verb"); + webhookListener.registerListener(listener); + webhookListener.process(webhookObject); return (T) change.getValue(); }