From 574fa61df11344dac50c13e6cf3d2131020995a6 Mon Sep 17 00:00:00 2001 From: =?utf8?q?David=20=E2=80=98Bombe=E2=80=99=20Roden?= Date: Sat, 23 Nov 2024 21:02:42 +0100 Subject: [PATCH] =?utf8?q?=E2=9C=85=20Add=20test=20for=20FcpListenerManage?= =?utf8?q?r?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../pterodactylus/fcp/DefaultFcpConnection.java | 2 +- .../net/pterodactylus/fcp/FcpListenerManager.java | 2 +- .../pterodactylus/fcp/FcpListenerManagerTest.java | 265 +++++++++++++++++++++ 3 files changed, 267 insertions(+), 2 deletions(-) create mode 100644 src/test/java/net/pterodactylus/fcp/FcpListenerManagerTest.java diff --git a/src/main/java/net/pterodactylus/fcp/DefaultFcpConnection.java b/src/main/java/net/pterodactylus/fcp/DefaultFcpConnection.java index 0171678..e3e49c2 100644 --- a/src/main/java/net/pterodactylus/fcp/DefaultFcpConnection.java +++ b/src/main/java/net/pterodactylus/fcp/DefaultFcpConnection.java @@ -277,7 +277,7 @@ public class DefaultFcpConnection implements FcpConnection { } else if ("CloseConnectionDuplicateClientName".equals(messageName)) { fcpListenerManager.fireReceivedCloseConnectionDuplicateClientName(new CloseConnectionDuplicateClientName(fcpMessage)); } else if ("SentFeed".equals(messageName)) { - fcpListenerManager.fireSentFeed(new SentFeed(fcpMessage)); + fcpListenerManager.fireReceivedSentFeed(new SentFeed(fcpMessage)); } else if ("ReceivedBookmarkFeed".equals(messageName)) { fcpListenerManager.fireReceivedBookmarkFeed(new ReceivedBookmarkFeed(fcpMessage)); } else { diff --git a/src/main/java/net/pterodactylus/fcp/FcpListenerManager.java b/src/main/java/net/pterodactylus/fcp/FcpListenerManager.java index b9f0bc8..c62b318 100644 --- a/src/main/java/net/pterodactylus/fcp/FcpListenerManager.java +++ b/src/main/java/net/pterodactylus/fcp/FcpListenerManager.java @@ -551,7 +551,7 @@ public class FcpListenerManager { * @param sentFeed * The “SentFeed” message. */ - public void fireSentFeed(SentFeed sentFeed) { + public void fireReceivedSentFeed(SentFeed sentFeed) { for (FcpListener fcpListener : getListeners()) { fcpListener.receivedSentFeed(getSource(), sentFeed); } diff --git a/src/test/java/net/pterodactylus/fcp/FcpListenerManagerTest.java b/src/test/java/net/pterodactylus/fcp/FcpListenerManagerTest.java new file mode 100644 index 0000000..b6add70 --- /dev/null +++ b/src/test/java/net/pterodactylus/fcp/FcpListenerManagerTest.java @@ -0,0 +1,265 @@ +package net.pterodactylus.fcp; + +import net.pterodactylus.fcp.test.NodeRefs; +import org.junit.Test; + +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.sameInstance; + +public class FcpListenerManagerTest { + + @Test + public void listenerCanBeAdded() { + DispatchingFcpAdapter fcpListener = new DispatchingFcpAdapter(); + AtomicReference receivedNodeHello = new AtomicReference<>(); + fcpListener.addListener("NodeHello", receivedNodeHello::set); + fcpListenerManager.addListener(fcpListener); + NodeHello nodeHello = new NodeHello(null); + fcpListenerManager.fireReceivedNodeHello(nodeHello); + assertThat(receivedNodeHello.get(), sameInstance(nodeHello)); + } + + @Test + public void listenerCanBeRemoved() { + DispatchingFcpAdapter fcpListener = new DispatchingFcpAdapter(); + AtomicBoolean nodeHelloReceived = new AtomicBoolean(); + fcpListener.addListener("NodeHello", nodeHello -> nodeHelloReceived.set(true)); + fcpListenerManager.addListener(fcpListener); + fcpListenerManager.removeListener(fcpListener); + fcpListenerManager.fireReceivedNodeHello(new NodeHello(null)); + assertThat(nodeHelloReceived.get(), equalTo(false)); + } + + @Test + public void nodeHelloIsForwardedToListeners() { + runTestForListenerMethod("NodeHello", () -> new NodeHello(null), fcpListenerManager::fireReceivedNodeHello); + } + + @Test + public void closeConnectionDuplicateClientNameIsForwardedToListeners() { + runTestForListenerMethod("CloseConnectionDuplicateClientName", () -> new CloseConnectionDuplicateClientName(null), fcpListenerManager::fireReceivedCloseConnectionDuplicateClientName); + } + + @Test + public void sskKeypairIsForwardedToListeners() { + runTestForListenerMethod("SSKKeypair", () -> new SSKKeypair(null), fcpListenerManager::fireReceivedSSKKeypair); + } + + @Test + public void peerIsForwardedToListeners() { + runTestForListenerMethod("Peer", () -> new Peer(null), fcpListenerManager::fireReceivedPeer); + } + + @Test + public void endListPeersIsForwardedToListeners() { + runTestForListenerMethod("EndListPeers", () -> new EndListPeers(null), fcpListenerManager::fireReceivedEndListPeers); + } + + @Test + public void peerNoteIsForwardedToListeners() { + runTestForListenerMethod("PeerNote", () -> new PeerNote(null), fcpListenerManager::fireReceivedPeerNote); + } + + @Test + public void endListPeerNotesIsForwardedToListeners() { + runTestForListenerMethod("EndListPeerNotes", () -> new EndListPeerNotes(null), fcpListenerManager::fireReceivedEndListPeerNotes); + } + + @Test + public void peerRemovedIsForwardedToListeners() { + runTestForListenerMethod("PeerRemoved", () -> new PeerRemoved(null), fcpListenerManager::fireReceivedPeerRemoved); + } + + @Test + public void nodeDataIsForwardedToListeners() { + FcpMessage baseMessage = new FcpMessage(""); + NodeRefs.copyNodeRefToMessage(NodeRefs.createNodeRef()).accept(baseMessage); + runTestForListenerMethod("NodeData", () -> new NodeData(baseMessage), fcpListenerManager::fireReceivedNodeData); + } + + @Test + public void testDDAReplyIsForwardedToListeners() { + runTestForListenerMethod("TestDDAReply", () -> new TestDDAReply(null), fcpListenerManager::fireReceivedTestDDAReply); + } + + @Test + public void testDDACompleteIsForwardedToListeners() { + runTestForListenerMethod("TestDDAComplete", () -> new TestDDAComplete(null), fcpListenerManager::fireReceivedTestDDAComplete); + } + + @Test + public void persistentGetIsForwardedToListeners() { + runTestForListenerMethod("PersistentGet", () -> new PersistentGet(null), fcpListenerManager::fireReceivedPersistentGet); + } + + @Test + public void persistentPutIsForwardedToListeners() { + runTestForListenerMethod("PersistentPut", () -> new PersistentPut(null), fcpListenerManager::fireReceivedPersistentPut); + } + + @Test + public void endListPersistentRequestsIsForwardedToListeners() { + runTestForListenerMethod("EndListPersistentRequests", () -> new EndListPersistentRequests(null), fcpListenerManager::fireReceivedEndListPersistentRequests); + } + + @Test + public void uriGeneratedIsForwardedToListeners() { + runTestForListenerMethod("URIGenerated", () -> new URIGenerated(null), fcpListenerManager::fireReceivedURIGenerated); + } + + @Test + public void dataFoundIsForwardedToListeners() { + runTestForListenerMethod("DataFound", () -> new DataFound(null), fcpListenerManager::fireReceivedDataFound); + } + + @Test + public void allDataIsForwardedToListeners() { + runTestForListenerMethod("AllData", () -> new AllData(null, null), fcpListenerManager::fireReceivedAllData); + } + + @Test + public void simpleProgressIsForwardedToListeners() { + runTestForListenerMethod("SimpleProgress", () -> new SimpleProgress(null), fcpListenerManager::fireReceivedSimpleProgress); + } + + @Test + public void startedCompressionIsForwardedToListeners() { + runTestForListenerMethod("StartedCompression", () -> new StartedCompression(null), fcpListenerManager::fireReceivedStartedCompression); + } + + @Test + public void finishedCompressionIsForwardedToListeners() { + runTestForListenerMethod("FinishedCompression", () -> new FinishedCompression(null), fcpListenerManager::fireReceivedFinishedCompression); + } + + @Test + public void unknownPeerNoteTypeIsForwardedToListeners() { + runTestForListenerMethod("UnknownPeerNoteType", () -> new UnknownPeerNoteType(null), fcpListenerManager::fireReceivedUnknownPeerNoteType); + } + + @Test + public void unknownNodeIdentifierIsForwardedToListeners() { + runTestForListenerMethod("UnknownNodeIdentifier", () -> new UnknownNodeIdentifier(null), fcpListenerManager::fireReceivedUnknownNodeIdentifier); + } + + @Test + public void configDataIsForwardedToListeners() { + runTestForListenerMethod("ConfigData", () -> new ConfigData(null), fcpListenerManager::fireReceivedConfigData); + } + + @Test + public void getFailedIsForwardedToListeners() { + runTestForListenerMethod("GetFailed", () -> new GetFailed(null), fcpListenerManager::fireReceivedGetFailed); + } + + @Test + public void putFailedIsForwardedToListeners() { + runTestForListenerMethod("PutFailed", () -> new PutFailed(null), fcpListenerManager::fireReceivedPutFailed); + } + + @Test + public void identifierCollisionIsForwardedToListeners() { + runTestForListenerMethod("IdentifierCollision", () -> new IdentifierCollision(null), fcpListenerManager::fireReceivedIdentifierCollision); + } + + @Test + public void persistentPutDirIsForwardedToListeners() { + runTestForListenerMethod("PersistentPutDir", () -> new PersistentPutDir(null), fcpListenerManager::fireReceivedPersistentPutDir); + } + + @Test + public void persistentRequestRemovedIsForwardedToListeners() { + runTestForListenerMethod("PersistentRequestRemoved", () -> new PersistentRequestRemoved(null), fcpListenerManager::fireReceivedPersistentRequestRemoved); + } + + @Test + public void subscribedUSKIsForwardedToListeners() { + runTestForListenerMethod("SubscribedUSK", () -> new SubscribedUSK(null), fcpListenerManager::fireReceivedSubscribedUSK); + } + + @Test + public void subscribedUSKUpdateIsForwardedToListeners() { + runTestForListenerMethod("SubscribedUSKUpdate", () -> new SubscribedUSKUpdate(null), fcpListenerManager::fireReceivedSubscribedUSKUpdate); + } + + @Test + public void pluginInfoIsForwardedToListeners() { + runTestForListenerMethod("PluginInfo", () -> new PluginInfo(null), fcpListenerManager::fireReceivedPluginInfo); + } + + @Test + public void pluginRemovedIsForwardedToListeners() { + runTestForListenerMethod("PluginRemoved", () -> new PluginRemoved(null), fcpListenerManager::fireReceivedPluginRemoved); + } + + @Test + public void fcpPluginReplyIsForwardedToListeners() { + runTestForListenerMethod("FCPPluginReply", () -> new FCPPluginReply(null, null), fcpListenerManager::fireReceivedFCPPluginReply); + } + + @Test + public void persistentRequestModifiedIsForwardedToListeners() { + runTestForListenerMethod("PersistentRequestModified", () -> new PersistentRequestModified(null), fcpListenerManager::fireReceivedPersistentRequestModified); + } + + @Test + public void putSuccessfulIsForwardedToListeners() { + runTestForListenerMethod("PutSuccessful", () -> new PutSuccessful(null), fcpListenerManager::fireReceivedPutSuccessful); + } + + @Test + public void putFetchableIsForwardedToListeners() { + runTestForListenerMethod("PutFetchable", () -> new PutFetchable(null), fcpListenerManager::fireReceivedPutFetchable); + } + + @Test + public void protocolErrorIsForwardedToListeners() { + runTestForListenerMethod("ProtocolError", () -> new ProtocolError(null), fcpListenerManager::fireReceivedProtocolError); + } + + @Test + public void sentFeedIsForwardedToListeners() { + runTestForListenerMethod("SentFeed", () -> new SentFeed(null), fcpListenerManager::fireReceivedSentFeed); + } + + @Test + public void receivedBookmarkFeedIsForwardedToListeners() { + runTestForListenerMethod("ReceivedBookmarkFeed", () -> new ReceivedBookmarkFeed(null), fcpListenerManager::fireReceivedBookmarkFeed); + } + + @Test + public void receivedMessageIsForwardedToListeners() { + runTestForListenerMethod("Message", () -> new FcpMessage(null), fcpListenerManager::fireMessageReceived); + } + + @Test + public void connectionClosedIsForwardedToListeners() { + runTestForListenerMethod("ConnectionClosed", Throwable::new, fcpListenerManager::fireConnectionClosed); + } + + private void runTestForListenerMethod(String eventName, Supplier creator, Consumer listener) { + AtomicReference firstReceivedCloseConnectionDuplicateClientName = createContainerAndAddListener(eventName); + AtomicReference secondReceivedCloseConnectionDuplicateClientName = createContainerAndAddListener(eventName); + T closeConnectionDuplicateClientName = creator.get(); + listener.accept(closeConnectionDuplicateClientName); + assertThat(firstReceivedCloseConnectionDuplicateClientName.get(), sameInstance(closeConnectionDuplicateClientName)); + assertThat(secondReceivedCloseConnectionDuplicateClientName.get(), sameInstance(closeConnectionDuplicateClientName)); + } + + private AtomicReference createContainerAndAddListener(String event) { + AtomicReference receivedEventObject = new AtomicReference<>(); + DispatchingFcpAdapter firstListener = new DispatchingFcpAdapter(); + firstListener.addListener(event, receivedEventObject::set); + fcpListenerManager.addListener(firstListener); + return receivedEventObject; + } + + private final FcpListenerManager fcpListenerManager = new FcpListenerManager(null); + +} -- 2.7.4