Add test for the enable disable processor

Author: jacomago

src/main/java/org/phoebus/channelfinder/processors/ChannelProcessorService.java

@@ -19,12 +19,20 @@ public class ChannelProcessorService {
 
   private static final Logger logger = Logger.getLogger(ChannelProcessorService.class.getName());
 
-  @Autowired private List<ChannelProcessor> channelProcessors;
+  private final List<ChannelProcessor> channelProcessors;
 
-  @Autowired private TaskExecutor taskExecutor;
+  private final TaskExecutor taskExecutor;
 
-  @Value("${processors.chunking.size:10000}")
-  private int chunkSize;
+  private final int chunkSize;
+
+  public ChannelProcessorService(
+      @Autowired List<ChannelProcessor> channelProcessors,
+      @Autowired TaskExecutor taskExecutor,
+      @Value("${processors.chunking.size:10000}") int chunkSize) {
+    this.channelProcessors = channelProcessors;
+    this.taskExecutor = taskExecutor;
+    this.chunkSize = chunkSize;
+  }
 
   long getProcessorCount() {
     return channelProcessors.size();
@@ -68,7 +76,6 @@ public void sendToProcessors(List<Channel> channels) {
                         while (true) {
                           List<Channel> chunk = new ArrayList<>(chunkSize);
                           for (int i = 0; i < chunkSize && split.tryAdvance(chunk::add); i++) {}
-                          ;
                           if (chunk.isEmpty()) break;
                           channelProcessor.process(chunk);
                         }

src/test/java/org/phoebus/channelfinder/processors/ChannelProcessorServiceTest.java

@@ -0,0 +1,112 @@
+package org.phoebus.channelfinder.processors;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.phoebus.channelfinder.entity.Channel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.TestPropertySource;
+
+@SpringBootTest()
+@TestPropertySource(value = "classpath:application_test.properties")
+class ChannelProcessorServiceTest {
+
+  private ChannelProcessorService channelProcessorService;
+
+  @Autowired private DummyProcessor dummyProcessor;
+
+  @Configuration
+  static class TestConfig {
+    @Bean
+    public DummyProcessor dummyProcessor() {
+      return new DummyProcessor();
+    }
+  }
+
+  static class DummyProcessor implements ChannelProcessor {
+    private final AtomicBoolean enabled = new AtomicBoolean(false);
+    private final AtomicBoolean processed = new AtomicBoolean(false);
+
+    @Override
+    public boolean enabled() {
+      return enabled.get();
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+      this.enabled.set(enabled);
+    }
+
+    @Override
+    public ChannelProcessorInfo processorInfo() {
+      return new ChannelProcessorInfo("DummyProcessor", enabled.get(), Map.of());
+    }
+
+    @Override
+    public long process(List<Channel> channels) throws JsonProcessingException {
+      processed.set(true);
+      return channels.size();
+    }
+
+    public boolean hasBeenProcessed() {
+      return processed.get();
+    }
+
+    public void reset() {
+      processed.set(false);
+    }
+  }
+
+  @BeforeEach
+  void setUp() {
+    channelProcessorService =
+        new ChannelProcessorService(List.of(dummyProcessor), Runnable::run, 10);
+  }
+
+  @Test
+  void testEnableAndDisableDummyProcessor() {
+    // Initially, the dummy processor should be disabled
+    Assertions.assertFalse(
+        dummyProcessor.enabled(), "Dummy processor should be disabled initially");
+
+    // Enable the dummy processor
+    channelProcessorService.setProcessorEnabled("DummyProcessor", true);
+    Assertions.assertTrue(dummyProcessor.enabled(), "Dummy processor should be enabled");
+
+    // Disable the dummy processor
+    channelProcessorService.setProcessorEnabled("DummyProcessor", false);
+    Assertions.assertFalse(dummyProcessor.enabled(), "Dummy processor should be disabled");
+  }
+
+  @Test
+  void testDummyProcessorProcessing() {
+    // Disable the dummy processor
+    dummyProcessor.reset();
+    channelProcessorService.setProcessorEnabled("DummyProcessor", false);
+    Assertions.assertFalse(dummyProcessor.enabled(), "Dummy processor should be disabled");
+
+    // Process a channel - dummy processor should not be called
+    channelProcessorService.sendToProcessors(
+        Collections.singletonList(new Channel("test-channel")));
+    Assertions.assertFalse(
+        dummyProcessor.hasBeenProcessed(), "Dummy processor should not have been called");
+
+    // Enable the dummy processor
+    channelProcessorService.setProcessorEnabled("DummyProcessor", true);
+    Assertions.assertTrue(dummyProcessor.enabled(), "Dummy processor should be enabled");
+
+    // Process a channel - dummy processor should be called
+    channelProcessorService.sendToProcessors(
+        Collections.singletonList(new Channel("test-channel")));
+    Assertions.assertTrue(
+        dummyProcessor.hasBeenProcessed(), "Dummy processor should have been called");
+  }
+}

src/test/resources/application_test.properties

@@ -85,6 +85,9 @@ [email protected]@
 # DEBUG level will log all requests and responses to and from the REST end points
 logging.level.org.springframework.web.filter.CommonsRequestLoggingFilter=INFO
 
+################ Processor ##################################################
+processors.chunking.size=10000
+
 ################ Archiver Appliance Configuration Processor #################
 aa.urls={'default': 'http://localhost:17665'}
 aa.default_alias=default