Little help on test coverage for SPI and Verification plugins.

Signed-off-by: jasperpotts <[email protected]>

Author: jasperpotts

block-node/app/src/testFixtures/java/org/hiero/block/node/app/fixtures/plugintest/AllwaysRunningHealthFacility.java

@@ -52,7 +52,7 @@ public PluginTestBase(P plugin, HistoricalBlockFacility historicalBlockFacility)
         final Metrics metrics = metricsProvider.createGlobalMetrics();
         metricsProvider.start();
         // mock health facility
-        final HealthFacility healthFacility = new AllwaysRunningHealthFacility();
+        final HealthFacility healthFacility = new TestHealthFacility();
         // create block node context
         blockNodeContext = new BlockNodeContext() {
             @Override

block-node/app/src/testFixtures/java/org/hiero/block/node/app/fixtures/plugintest/PluginTestBase.java

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+package org.hiero.block.node.app.fixtures.plugintest;
+
+import java.lang.System.Logger.Level;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.hiero.block.node.spi.health.HealthFacility;
+
+/**
+ * A testing {@link HealthFacility} that always returns {@link State#RUNNING} for the block node state. And fails test
+ * if the shutdown method is called.
+ */
+public class TestHealthFacility implements HealthFacility {
+    /** The logger for this class. */
+    private final System.Logger LOGGER = System.getLogger(getClass().getName());
+    /** Track if shutdown method was called, for tests that need to know. */
+    public final AtomicBoolean shutdownCalled = new AtomicBoolean(false);
+    /** If the node is running. Can be set by tests that need it to be false */
+    public final AtomicBoolean isRunning = new AtomicBoolean(true);
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public State blockNodeState() {
+        return isRunning.get() ? State.RUNNING : State.SHUTTING_DOWN;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void shutdown(String className, String reason) {
+        LOGGER.log(Level.ERROR, "Shutting down " + className + " " + reason);
+        shutdownCalled.set(true);
+        isRunning.set(false);
+    }
+}

block-node/app/src/testFixtures/java/org/hiero/block/node/app/fixtures/plugintest/TestHealthFacility.java

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+package org.hiero.block.node.spi.historicalblocks;
+
+import static org.hiero.block.node.spi.BlockNodePlugin.UNKNOWN_BLOCK_NUMBER;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link BlockRangeSet}.
+ */
+class BlockRangeSetTest {
+
+    @Test
+    @DisplayName("Test EMPTY set contains no block numbers")
+    void testEmptySetContains() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertFalse(emptySet.contains(1), "EMPTY set should not contain any block number");
+        assertFalse(emptySet.contains(0, 10), "EMPTY set should not contain any range");
+    }
+
+    @Test
+    @DisplayName("Test EMPTY set size is zero")
+    void testEmptySetSize() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertEquals(0, emptySet.size(), "EMPTY set size should be zero");
+    }
+
+    @Test
+    @DisplayName("Test EMPTY set min and max return UNKNOWN_BLOCK_NUMBER")
+    void testEmptySetMinMax() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertEquals(UNKNOWN_BLOCK_NUMBER, emptySet.min(), "EMPTY set min should return UNKNOWN_BLOCK_NUMBER");
+        assertEquals(UNKNOWN_BLOCK_NUMBER, emptySet.max(), "EMPTY set max should return UNKNOWN_BLOCK_NUMBER");
+    }
+
+    @Test
+    @DisplayName("Test EMPTY set stream is empty")
+    void testEmptySetStream() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertEquals(0, emptySet.stream().count(), "Stream from EMPTY set should be empty");
+    }
+
+    @Test
+    @DisplayName("Test EMPTY set streamRanges is empty")
+    void testEmptySetStreamRanges() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertEquals(0, emptySet.streamRanges().count(), "Stream of ranges from EMPTY set should be empty");
+    }
+
+    @Test
+    @DisplayName("Test EMPTY set edge cases")
+    void testEmptySetEdgeCases() {
+        final BlockRangeSet emptySet = BlockRangeSet.EMPTY;
+
+        assertFalse(emptySet.contains(Long.MIN_VALUE), "EMPTY set should not contain Long.MIN_VALUE");
+        assertFalse(emptySet.contains(Long.MAX_VALUE), "EMPTY set should not contain Long.MAX_VALUE");
+        assertFalse(emptySet.contains(Long.MIN_VALUE, Long.MAX_VALUE), "EMPTY set should not contain full range");
+    }
+}

block-node/spi/src/test/java/org/hiero/block/node/spi/historicalblocks/BlockRangeSetTest.java

@@ -17,4 +17,5 @@ mainModuleInfo {
 testModuleInfo {
     requires("org.junit.jupiter.api")
     requires("org.hiero.block.node.app.test.fixtures")
+    requires("org.mockito")
 }

block-node/verification/build.gradle.kts

@@ -145,12 +145,4 @@ public void handleBlockItemsReceived(BlockItems blockItems) {
             context.serverHealth().shutdown(VerificationServicePlugin.class.getSimpleName(), e.getMessage());
         }
     }
-
-    public VerificationConfig verificationConfig() {
-        return verificationConfig;
-    }
-
-    public void setVerificationConfig(VerificationConfig verificationConfig) {
-        this.verificationConfig = verificationConfig;
-    }
 }

block-node/verification/src/main/java/org/hiero/block/node/verification/VerificationServicePlugin.java

@@ -4,19 +4,29 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
+import com.hedera.pbj.runtime.OneOf;
 import com.hedera.pbj.runtime.ParseException;
 import java.io.IOException;
 import java.util.List;
 import org.hiero.block.node.app.fixtures.blocks.BlockUtils;
 import org.hiero.block.node.app.fixtures.plugintest.NoBlocksHistoricalBlockFacility;
 import org.hiero.block.node.app.fixtures.plugintest.PluginTestBase;
+import org.hiero.block.node.app.fixtures.plugintest.TestHealthFacility;
 import org.hiero.block.node.spi.blockmessaging.BlockItems;
 import org.hiero.block.node.spi.blockmessaging.BlockNotification;
 import org.hiero.hapi.block.node.BlockItemUnparsed;
+import org.hiero.hapi.block.node.BlockItemUnparsed.ItemOneOfType;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-class VerificationServicePluginTest extends PluginTestBase {
+/**
+ * Unit test for {@link VerificationServicePlugin}.
+ */
+class VerificationServicePluginTest extends PluginTestBase<VerificationServicePlugin> {
 
     public VerificationServicePluginTest() {
         super(new VerificationServicePlugin(), new NoBlocksHistoricalBlockFacility());
@@ -82,4 +92,46 @@ void testFailedVerification() throws IOException, ParseException {
                 blockNotification.blockHash(),
                 "The block hash should NOT be the same");
     }
+
+    @Test
+    @DisplayName("Test handleBlockItemsReceived without a block header")
+    void testHandleBlockItemsReceived_NoCurrentSession() throws IOException, ParseException {
+        // create sample block data
+        BlockUtils.SampleBlockInfo sampleBlockInfo =
+                BlockUtils.getSampleBlockInfo(BlockUtils.SAMPLE_BLOCKS.GENERATED_10);
+        long blockNumber = sampleBlockInfo.blockNumber();
+        List<BlockItemUnparsed> blockItems = sampleBlockInfo.blockUnparsed().blockItems();
+        // remove the header to simulate a case where receive items and have never received a header
+        blockItems.removeFirst();
+        // send some items to the plugin, they should be ignored
+        plugin.handleBlockItemsReceived(new BlockItems(blockItems, blockNumber));
+        // check we did not receive a block verification
+        assertEquals(0, blockMessaging.getSentBlockNotifications().size());
+    }
+
+    @Test
+    @DisplayName("Test handleBlockItemsReceived with non-running server")
+    void testHandleBlockItemsReceived_NotRunning() {
+        // make the server state not running
+        ((TestHealthFacility) blockNodeContext.serverHealth()).isRunning.set(false);
+        // send some items to the plugin, they should be ignored
+        plugin.handleBlockItemsReceived(
+                new BlockItems(List.of(new BlockItemUnparsed(new OneOf<>(ItemOneOfType.BLOCK_HEADER, null))), -1));
+        // check we did not receive a block verification
+        assertEquals(0, blockMessaging.getSentBlockNotifications().size());
+    }
+
+    @Test
+    @DisplayName("Test handleBlockItemsReceived with BlockItems that throws an exception")
+    void testHandleBlockItemsReceived_ExceptionThrown() {
+        // mock a BlockItems object to throw an exception when isStartOfNewBlock is called
+        BlockItems blockItems = mock(BlockItems.class);
+        when(blockItems.isStartOfNewBlock()).thenThrow(new RuntimeException("Test Exception"));
+        // sent the mocked BlockItems to the plugin
+        plugin.handleBlockItemsReceived(blockItems);
+        // check the exception was thrown and resulted in a shutdown
+        assertTrue(
+                ((TestHealthFacility) blockNodeContext.serverHealth()).shutdownCalled.get(),
+                "The server should be shutdown after an exception is thrown");
+    }
 }