finished

Author: met4lk1tty

src/main/java/com/example/FakeNtfyConnection.java

@@ -3,29 +3,39 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 
+/**
+ * A fake implementation of {@link NtfyConnection} for testing purposes.
+ * Stores sent messages and files in memory and simulates incoming messages.
+ */
 public class FakeNtfyConnection implements NtfyConnection {
+
     private final List<String> sentMessages = new ArrayList<>();
     private final List<File> sentFiles = new ArrayList<>();
     private Consumer<NtfyMessageDto> messageHandler;
     private boolean shouldSucceed = true;
 
     /**
-     * Sends a text message
-     * @param message the message text to send
-     * @return true if operation should succeed (based on shouldSucceed flag), false otherwise
+     * Sends a text message.
+     * Stores the message in memory and returns success based on {@link #shouldSucceed}.
+     *
+     * @param message the message to send
+     * @return true if operation succeeds, false otherwise
      */
     @Override
     public boolean send(String message) {
-        sentMessages.add(message);
+        sentMessages.add(Objects.requireNonNull(message));
         return shouldSucceed;
     }
 
     /**
-     * Sends a file
-     * @param file the file to send, must exist and not be null
-     * @return true if file exists and operation should succeed, false otherwise
+     * Sends a file.
+     * Stores the file in memory if it exists and returns success based on {@link #shouldSucceed}.
+     *
+     * @param file the file to send
+     * @return true if file exists and operation succeeds, false otherwise
      */
     @Override
     public boolean sendFile(File file) {
@@ -37,17 +47,21 @@ public boolean sendFile(File file) {
     }
 
     /**
-     * Sets up the message handler for receiving incoming messages
-     * @param handler the consumer that will process incoming NtfyMessageDto objects
+     * Registers a message handler to receive incoming messages.
+     * Only the last registered handler will be active.
+     *
+     * @param handler the consumer that handles incoming messages
      */
     @Override
     public void receive(Consumer<NtfyMessageDto> handler) {
-        this.messageHandler = handler;
+        this.messageHandler = Objects.requireNonNull(handler);
     }
 
     /**
-     * Simulates an incoming message for testing purposes
-     * @param message the message DTO to simulate as incoming
+     * Simulates an incoming message.
+     * Calls the registered handler if present.
+     *
+     * @param message the message to simulate
      */
     public void simulateIncomingMessage(NtfyMessageDto message) {
         if (messageHandler != null) {
@@ -56,35 +70,38 @@ public void simulateIncomingMessage(NtfyMessageDto message) {
     }
 
     /**
-     * Gets all sent messages for verification
-     * @return a copy of the list of sent messages
+     * Returns a copy of all sent messages for verification.
+     *
+     * @return list of sent messages
      */
     public List<String> getSentMessages() {
         return new ArrayList<>(sentMessages);
     }
 
     /**
-     * Gets all sent files for verification
-     * @return a copy of the list of sent files
+     * Returns a copy of all sent files for verification.
+     *
+     * @return list of sent files
      */
     public List<File> getSentFiles() {
         return new ArrayList<>(sentFiles);
     }
 
     /**
-     * Configures whether operations should succeed or fail
-     * @param shouldSucceed true to make operations return success, false to make them fail
+     * Configures whether operations should succeed.
+     *
+     * @param shouldSucceed true for success, false for failure
      */
     public void setShouldSucceed(boolean shouldSucceed) {
         this.shouldSucceed = shouldSucceed;
     }
 
     /**
-     * Clears all stored state and resets the connection
+     * Clears all stored messages, files, and the message handler.
      */
     public void clear() {
         sentMessages.clear();
         sentFiles.clear();
         messageHandler = null;
     }
-}
+}

src/main/resources/icons/messages.png

@@ -16,248 +16,159 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Unit tests for {@link FakeNtfyConnection} class.
- * Tests the fake implementation of {@link NtfyConnection} used for isolated testing.
- * Verifies message sending, file sending, message receiving, and state management behavior.
+ * Unit tests for {@link FakeNtfyConnection}.
+ * Verifies sending messages/files, receiving messages, and internal state behavior.
  */
 class FakeNtfyConnectionTest {
 
     private FakeNtfyConnection fakeConnection;
 
-    /**
-     * Sets up a fresh {@link FakeNtfyConnection} instance before each test method.
-     */
     @BeforeEach
     void setUp() {
         fakeConnection = new FakeNtfyConnection();
     }
 
-    /**
-     * Tests that the send method stores messages and returns success when configured to succeed.
-     */
     @Test
     @DisplayName("send should store message and return success")
     void send_ShouldStoreMessageAndReturnSuccess() {
-        // Act
         boolean result = fakeConnection.send("Test message");
-
-        // Assert
         assertThat(result).isTrue();
         assertThat(fakeConnection.getSentMessages()).containsExactly("Test message");
     }
 
-    /**
-     * Tests that the send method returns false when the connection is configured to fail.
-     */
     @Test
     @DisplayName("send should return false when shouldSucceed is false")
     void send_ShouldReturnFalse_WhenShouldSucceedIsFalse() {
-        // Arrange
         fakeConnection.setShouldSucceed(false);
-
-        // Act
         boolean result = fakeConnection.send("Test message");
-
-        // Assert
         assertThat(result).isFalse();
         assertThat(fakeConnection.getSentMessages()).containsExactly("Test message");
     }
 
-    /**
-     * Tests that sendFile stores files and returns success for existing files.
-     *
-     * @param tempDir the temporary directory provided by JUnit for creating test files
-     * @throws IOException if test file creation fails
-     */
     @Test
     @DisplayName("sendFile should store file and return success for existing file")
     void sendFile_ShouldStoreFileAndReturnSuccess(@TempDir java.nio.file.Path tempDir) throws IOException {
-        // Arrange
         File testFile = tempDir.resolve("test.txt").toFile();
         Files.writeString(testFile.toPath(), "Test content");
 
-        // Act
         boolean result = fakeConnection.sendFile(testFile);
 
-        // Assert
         assertThat(result).isTrue();
         assertThat(fakeConnection.getSentFiles()).containsExactly(testFile);
     }
 
-    /**
-     * Tests that sendFile returns false for non-existent files.
-     */
     @Test
     @DisplayName("sendFile should return false for non-existent file")
     void sendFile_ShouldReturnFalseForNonExistentFile() {
-        // Act
         boolean result = fakeConnection.sendFile(new File("non_existent.txt"));
-
-        // Assert
         assertThat(result).isFalse();
         assertThat(fakeConnection.getSentFiles()).isEmpty();
     }
 
-    /**
-     * Tests that sendFile returns false for null file references.
-     */
     @Test
     @DisplayName("sendFile should return false for null file")
     void sendFile_ShouldReturnFalseForNullFile() {
-        // Act
         boolean result = fakeConnection.sendFile(null);
-
-        // Assert
         assertThat(result).isFalse();
         assertThat(fakeConnection.getSentFiles()).isEmpty();
     }
 
-    /**
-     * Tests that the receive method properly sets the message handler.
-     */
     @Test
     @DisplayName("receive should set message handler")
     void receive_ShouldSetMessageHandler() {
-        // Arrange
         AtomicBoolean handlerCalled = new AtomicBoolean(false);
-
-        // Act
         fakeConnection.receive(message -> handlerCalled.set(true));
-
-        // Assert - simulate a message to verify handler is set
         fakeConnection.simulateIncomingMessage(new NtfyMessageDto("1", 123L, "message", "topic", "test", null, null));
         assertThat(handlerCalled.get()).isTrue();
     }
 
-    /**
-     * Tests that simulateIncomingMessage calls the registered handler with the correct message.
-     */
     @Test
     @DisplayName("simulateIncomingMessage should call registered handler")
     void simulateIncomingMessage_ShouldCallRegisteredHandler() {
-        // Arrange
         AtomicReference<NtfyMessageDto> receivedMessage = new AtomicReference<>();
         fakeConnection.receive(receivedMessage::set);
-        NtfyMessageDto testMessage = new NtfyMessageDto("1", 123L, "message", "topic", "test", null, null);
 
-        // Act
+        NtfyMessageDto testMessage = new NtfyMessageDto("1", 123L, "message", "topic", "test", null, null);
         fakeConnection.simulateIncomingMessage(testMessage);
 
-        // Assert
         assertThat(receivedMessage.get()).isEqualTo(testMessage);
     }
 
-    /**
-     * Tests that simulateIncomingMessage doesn't throw exceptions when no handler is registered.
-     */
     @Test
     @DisplayName("simulateIncomingMessage should not throw when no handler is set")
     void simulateIncomingMessage_ShouldNotThrow_WhenNoHandlerIsSet() {
-        // Arrange
         NtfyMessageDto testMessage = new NtfyMessageDto("1", 123L, "message", "topic", "test", null, null);
-
-        // Act & Assert - Should not throw exception
-        fakeConnection.simulateIncomingMessage(testMessage);
+        fakeConnection.simulateIncomingMessage(testMessage); // No exception should occur
     }
 
-    /**
-     * Tests that the clear method resets all internal state including messages, files, and handler.
-     */
     @Test
     @DisplayName("clear should reset all state")
     void clear_ShouldResetAllState() {
-        // Arrange
-        fakeConnection.receive(msg -> {
-        });
         fakeConnection.send("Test message");
+        fakeConnection.receive(msg -> {});
 
-        // Act
         fakeConnection.clear();
 
-        // Assert
         assertThat(fakeConnection.getSentMessages()).isEmpty();
         assertThat(fakeConnection.getSentFiles()).isEmpty();
-        // Verify simulateIncomingMessage doesn't crash after clear
+
+        // simulateIncomingMessage should not throw
         fakeConnection.simulateIncomingMessage(new NtfyMessageDto("1", 123L, "message", "topic", "test", null, null));
     }
 
-    /**
-     * Tests that getSentMessages returns a defensive copy, not the internal list.
-     */
     @Test
     @DisplayName("getSentMessages should return copy of sent messages")
     void getSentMessages_ShouldReturnCopy() {
-        // Arrange
         fakeConnection.send("Message 1");
 
-        // Act
         List<String> messages1 = fakeConnection.getSentMessages();
         fakeConnection.send("Message 2");
         List<String> messages2 = fakeConnection.getSentMessages();
 
-        // Assert
         assertThat(messages1).containsExactly("Message 1");
         assertThat(messages2).containsExactly("Message 1", "Message 2");
     }
 
-    /**
-     * Tests that getSentFiles returns a defensive copy, not the internal list.
-     *
-     * @param tempDir the temporary directory provided by JUnit for creating test files
-     * @throws IOException if test file creation fails
-     */
     @Test
     @DisplayName("getSentFiles should return copy of sent files")
     void getSentFiles_ShouldReturnCopy(@TempDir java.nio.file.Path tempDir) throws IOException {
-        // Arrange
         File file1 = tempDir.resolve("file1.txt").toFile();
         Files.writeString(file1.toPath(), "Content 1");
         fakeConnection.sendFile(file1);
 
-        // Act
         List<File> files1 = fakeConnection.getSentFiles();
+
         File file2 = tempDir.resolve("file2.txt").toFile();
         Files.writeString(file2.toPath(), "Content 2");
         fakeConnection.sendFile(file2);
+
         List<File> files2 = fakeConnection.getSentFiles();
 
-        // Assert
         assertThat(files1).containsExactly(file1);
         assertThat(files2).containsExactly(file1, file2);
     }
 
-    /**
-     * Tests that the connection should succeed by default.
-     */
     @Test
     @DisplayName("shouldSucceed should be true by default")
     void shouldSucceed_ShouldBeTrueByDefault() {
-        // Act
-        boolean result = fakeConnection.send("Test");
-
-        // Assert
-        assertThat(result).isTrue();
+        assertThat(fakeConnection.send("Test")).isTrue();
     }
 
-    /**
-     * Tests that multiple message handlers can be set sequentially and each receives the appropriate messages.
-     */
     @Test
     @DisplayName("should handle multiple message handlers sequentially")
     void shouldHandleMultipleMessageHandlers_Sequentially() {
-        // Arrange
         AtomicInteger handler1Count = new AtomicInteger(0);
         AtomicInteger handler2Count = new AtomicInteger(0);
 
-        // Act - Set first handler, send message, then set second handler
+        // First handler
         fakeConnection.receive(msg -> handler1Count.incrementAndGet());
         fakeConnection.simulateIncomingMessage(new NtfyMessageDto("1", 123L, "message", "topic", "test1", null, null));
 
+        // Second handler overwrites first
         fakeConnection.receive(msg -> handler2Count.incrementAndGet());
         fakeConnection.simulateIncomingMessage(new NtfyMessageDto("2", 124L, "message", "topic", "test2", null, null));
 
-        // Assert
-        assertThat(handler1Count.get()).isEqualTo(1); // Should only receive first message
-        assertThat(handler2Count.get()).isEqualTo(1); // Should only receive second message
+        assertThat(handler1Count.get()).isEqualTo(1); // Received only the first message
+        assertThat(handler2Count.get()).isEqualTo(1); // Received only the second message
     }
-}
+}