Refactor: Replace Whitebox with standard reflection in Analyzer, Server-Cluster-Plugin and Receiver & Fetcher Plugins.

### [Analyzer]

**General Refactoring (`agent-analyzer`, `log-analyzer`):**
- Systematically eliminated `Whitebox` usages across various analyzer tests.
- Migrated internal state manipulations to standard Java Reflection API (`Field.setAccessible()` etc.), ensuring proper checked exception handling to prevent polluting test method signatures.

**`AnalyzerTest` (meter-analyzer):**
- Replaced `Whitebox` with `MockedStatic` (using Mockito) to safely inject and mock the `MetricsStreamProcessor` singleton.
- Added explicit `.close()` calls in the `@AfterEach` (or `tearDownEach`) lifecycle methods to properly release the static mocks and prevent resource leaks or interference between tests.

**`K8sTagTest` (meter-analyzer):**
- Since `KubernetesPods` and `KubernetesServices` are implemented as Enum singletons, mocking the entire objects was problematic. To resolve this:
  - Handled the internal lazy-loading `LoadingCache` instances by injecting Mock objects directly into these fields via standard reflection.
  - Fixed potential `NullPointerException`s during cache misses by explicitly stubbing the mocked caches to return `Optional.empty()` or empty collections for non-matching keys, ensuring better test isolation and stability.

### [Server-Cluster-Plugin]

- Replaced all `Whitebox.setInternalState()` and `getInternalState()` usages with standard `java.lang.reflect.Field` to inject internal dependencies (e.g., `client`, `config`, `loadedProvider`, `healthChecker`) into Coordinators and Providers across all 5 cluster plugins (Zookeeper, Nacos, Etcd, Kubernetes, Consul).

- **Handled Checked Exceptions Safely:** Since standard Reflection APIs strictly throw checked exceptions (`NoSuchFieldException`, `IllegalAccessException`), explicitly wrapped them in `RuntimeException` within `try-catch` blocks. This successfully removed the PowerMock dependency while preserving the existing test lifecycle method signatures (like `@BeforeEach` or `@Test`) without adding unnecessary `throws` declarations.

### [Receiver & Fetcher Plugins]

** General Refactoring (`server-receiver-plugin`, `server-fetcher-plugin`):**

- Systematically removed `Whitebox` dependencies and migrated to standard Java Reflection API.

- Centralized reflection logic within `try-catch` blocks to wrap checked exceptions into `RuntimeException`, ensuring no changes were required to existing test method signatures.

`ZabbixMetricsTest` & `ZabbixBaseTest`:

- Static Mock Lifecycle Management: Replaced manual `Whitebox` field manipulation of the `MetricsStreamProcessor` singleton with `MockedStatic`.

- Implemented strict `.close()` logic within the `@AfterEach` lifecycle to prevent memory leaks and resource conflicts, which is particularly critical for stability in newer JVM environments.

- Resolved a legacy `NullPointerException` by combining `MockedStatic` with a `Mockito.spy()` of the actual processor instance, ensuring a safe and stateful mock return.

`TelegrafMetricsTest`:

- Clean Mocking: Eliminated redundant `CoreModule` mocks and unused stubbings, resolving `UnnecessaryStubbingException` and improving test performance

- Modernization: Fixed anti-patterns (spying on class literals) and aligned with JUnit 5 best practices.

`ClusterManagerMetricsAdapterTest`:

- Static State Isolation: Addressed potential flaky test behavior by explicitly clearing shared static maps (e.g., `initialized` flag in `FieldsHelper`) during `@BeforeEach`.

- This ensures complete test isolation by preventing state leakage between test cases, leading to a more deterministic and reliable test suite.

`CiliumNodeManagerTest` & Others:

- Successfully migrated internal state injections(remoteInstances and allNodes) to standard reflection, maintaining the original testing intent while removing the PowerMock requirement.

Author: Hyeon-moGu

docs/en/changes/changes.md

@@ -66,7 +66,7 @@
   | Schedulers + others                   | ~24                | ~24 | Mostly unchanged                            |
   | **Total (OAP threads)**               | **150+**           | **~72** | **~50% reduction, stable in high payload.** |
 
-* Replace PowerMock Whitebox with standard Java Reflection in `server-library`, `server-core`, and `server-configuration` to support JDK 25+.
+* Replace PowerMock Whitebox with standard Java Reflection in `server-library`, `server-core`, `server-configuration`, `analyzer`,  `server-cluster-plugin`, `server-receiver-plugin`, `server-fetcher-plugin` to support JDK 25+.
 
 #### OAP Server
 

oap-server/analyzer/agent-analyzer/src/test/java/org/apache/skywalking/oap/server/analyzer/provider/meter/process/MeterProcessorTest.java

@@ -42,20 +42,22 @@
 import org.apache.skywalking.oap.server.library.module.ModuleProviderHolder;
 import org.apache.skywalking.oap.server.library.module.ModuleServiceHolder;
 import org.apache.skywalking.oap.server.library.module.ModuleStartException;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.powermock.reflect.Whitebox;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
@@ -67,6 +69,8 @@ public class MeterProcessorTest {
     private MeterSystem meterSystem;
     private MeterProcessor processor;
 
+    private MockedStatic<MetricsStreamProcessor> mockedMetricsStreamProcessor;
+
     private String service = "test-service";
     private String serviceInstance = "test-service-instance";
 
@@ -83,18 +87,22 @@ public void setup() throws StorageException, ModuleStartException {
         when(moduleManager.find(CoreModule.NAME).provider()).thenReturn(mock(ModuleServiceHolder.class));
         when(moduleManager.find(CoreModule.NAME).provider().getService(MeterSystem.class)).thenReturn(meterSystem);
         MetricsStreamProcessor mockProcessor = mock(MetricsStreamProcessor.class);
-        Whitebox.setInternalState(
-                MetricsStreamProcessor.class,
-                "PROCESSOR",
-                mockProcessor
-        );
+        mockedMetricsStreamProcessor = mockStatic(MetricsStreamProcessor.class);
+        mockedMetricsStreamProcessor.when(MetricsStreamProcessor::getInstance).thenReturn(mockProcessor);
         doNothing().when(mockProcessor).create(any(), (StreamDefinition) any(), any());
         final MeterProcessService processService = new MeterProcessService(moduleManager);
         List<MeterConfig> config = MeterConfigs.loadConfig("meter-analyzer-config", Arrays.asList("config"));
         processService.start(config);
         processor = new MeterProcessor(processService);
     }
 
+    @AfterEach
+    public void tearDown() {
+        if (mockedMetricsStreamProcessor != null) {
+            mockedMetricsStreamProcessor.close();
+        }
+    }
+
     @Test
     public void testProcess() {
         AtomicReference<AvgHistogramFunction> data = new AtomicReference<>();

oap-server/analyzer/agent-analyzer/src/test/java/org/apache/skywalking/oap/server/analyzer/provider/trace/TraceSamplingPolicyWatcherTest.java

@@ -33,8 +33,7 @@
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.powermock.reflect.Whitebox;
-
+import java.lang.reflect.Field;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;
@@ -228,11 +227,13 @@ public Optional<GroupConfigTable> readGroupConfig(final Set<String> keys) {
 
     @Test
     @Timeout(20)
-    public void testServiceSampleRateDynamicUpdate() throws InterruptedException {
+    public void testServiceSampleRateDynamicUpdate() throws Exception {
         ConfigWatcherRegister register = new ServiceMockConfigWatcherRegister(3);
 
         TraceSamplingPolicyWatcher watcher = new TraceSamplingPolicyWatcher(moduleConfig, provider);
-        Whitebox.setInternalState(provider, "moduleConfig", moduleConfig);
+        Field moduleConfigField = AnalyzerModuleProvider.class.getDeclaredField("moduleConfig");
+        moduleConfigField.setAccessible(true);
+        moduleConfigField.set(provider, moduleConfig);
         provider.getModuleConfig().setTraceSamplingPolicyWatcher(watcher);
         register.registerConfigChangeWatcher(watcher);
         register.start();
@@ -250,7 +251,7 @@ public void testServiceSampleRateDynamicUpdate() throws InterruptedException {
     }
 
     @Test
-    public void testServiceSampleRateNotify() {
+    public void testServiceSampleRateNotify() throws Exception {
         TraceSamplingPolicyWatcher watcher = new TraceSamplingPolicyWatcher(moduleConfig, provider);
         ConfigChangeWatcher.ConfigChangeEvent value1 = new ConfigChangeWatcher.ConfigChangeEvent(
             "services:\n" +
@@ -368,9 +369,11 @@ private void globalDefaultDurationEquals(TraceSamplingPolicyWatcher watcher, int
         Assertions.assertFalse(watcher.shouldSample("", 10000, duration - 1));
     }
 
-    private SamplingPolicy getSamplingPolicy(String service, TraceSamplingPolicyWatcher watcher) {
-        AtomicReference<SamplingPolicySettings> samplingPolicySettings = Whitebox.getInternalState(
-            watcher, "samplingPolicySettings");
+    private SamplingPolicy getSamplingPolicy(String service, TraceSamplingPolicyWatcher watcher) throws Exception {
+        Field settingsField = TraceSamplingPolicyWatcher.class.getDeclaredField("samplingPolicySettings");
+        settingsField.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        AtomicReference<SamplingPolicySettings> samplingPolicySettings = (AtomicReference<SamplingPolicySettings>) settingsField.get(watcher);
         return samplingPolicySettings.get().get(service);
     }
 }

oap-server/analyzer/agent-analyzer/src/test/java/org/apache/skywalking/oap/server/analyzer/provider/trace/UninstrumentedGatewaysConfigTest.java

@@ -18,21 +18,23 @@
 
 package org.apache.skywalking.oap.server.analyzer.provider.trace;
 
+import java.lang.reflect.Method;
 import org.apache.skywalking.oap.server.library.module.ModuleDefine;
 import org.apache.skywalking.oap.server.library.module.ModuleProvider;
 import org.apache.skywalking.oap.server.library.module.ModuleStartException;
 import org.apache.skywalking.oap.server.library.module.ServiceNotProvidedException;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.powermock.reflect.Whitebox;
 
 public class UninstrumentedGatewaysConfigTest {
     @Test
     public void testParseGatewayYAML() throws Exception {
         final UninstrumentedGatewaysConfig uninstrumentedGatewaysConfig
             = new UninstrumentedGatewaysConfig(new MockProvider());
+        Method parseGatewaysFromFileMethod = UninstrumentedGatewaysConfig.class.getDeclaredMethod("parseGatewaysFromFile", String.class);
+        parseGatewaysFromFileMethod.setAccessible(true);
         UninstrumentedGatewaysConfig.GatewayInfos gatewayInfos
-            = Whitebox.invokeMethod(uninstrumentedGatewaysConfig, "parseGatewaysFromFile", "gateways.yml");
+            = (UninstrumentedGatewaysConfig.GatewayInfos) parseGatewaysFromFileMethod.invoke(uninstrumentedGatewaysConfig, "gateways.yml");
         Assertions.assertEquals(1, gatewayInfos.getGateways().size());
     }
 

oap-server/analyzer/log-analyzer/src/test/java/org/apache/skywalking/oap/log/analyzer/dsl/DSLSecurityTest.java

@@ -30,7 +30,8 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.powermock.reflect.Whitebox;
+
+import java.lang.reflect.Field;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -104,8 +105,10 @@ public static Collection<Object[]> data() {
     final ModuleManager manager = mock(ModuleManager.class);
 
     @BeforeEach
-    public void setup() {
-        Whitebox.setInternalState(manager, "isInPrepareStage", false);
+    public void setup() throws Exception {
+        Field isInPrepareStageField = ModuleManager.class.getDeclaredField("isInPrepareStage");
+        isInPrepareStageField.setAccessible(true);
+        isInPrepareStageField.set(manager, false);
         when(manager.find(anyString())).thenReturn(mock(ModuleProviderHolder.class));
         when(manager.find(CoreModule.NAME).provider()).thenReturn(mock(ModuleServiceHolder.class));
         when(manager.find(CoreModule.NAME).provider().getService(SourceReceiver.class))
@@ -124,9 +127,17 @@ public void setup() {
     public void testSecurity(String name, String script) {
         assertThrows(MultipleCompilationErrorsException.class, () -> {
             final DSL dsl = DSL.of(manager, new LogAnalyzerModuleConfig(), script);
-            Whitebox.setInternalState(
-                    Whitebox.getInternalState(dsl, "filterSpec"), "sinkListenerFactories", Collections.emptyList()
-            );
+            try {
+                Field filterSpecField = DSL.class.getDeclaredField("filterSpec");
+                filterSpecField.setAccessible(true);
+                Object filterSpec = filterSpecField.get(dsl);
+
+                Field sinkListenerFactoriesField = filterSpec.getClass().getDeclaredField("sinkListenerFactories");
+                sinkListenerFactoriesField.setAccessible(true);
+                sinkListenerFactoriesField.set(filterSpec, Collections.emptyList());
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
 
             dsl.bind(new Binding().log(LogData.newBuilder()));
             dsl.evaluate();

oap-server/analyzer/log-analyzer/src/test/java/org/apache/skywalking/oap/log/analyzer/dsl/DSLTest.java

@@ -28,12 +28,10 @@
 import org.apache.skywalking.oap.server.library.module.ModuleManager;
 import org.apache.skywalking.oap.server.library.module.ModuleProviderHolder;
 import org.apache.skywalking.oap.server.library.module.ModuleServiceHolder;
-import org.apache.skywalking.oap.server.library.module.ModuleStartException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.powermock.reflect.Whitebox;
-
+import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -196,8 +194,10 @@ public static Collection<Object[]> data() {
     final ModuleManager manager = mock(ModuleManager.class);
 
     @BeforeEach
-    public void setup() {
-        Whitebox.setInternalState(manager, "isInPrepareStage", false);
+    public void setup() throws Exception {
+        Field isInPrepareStageField = ModuleManager.class.getDeclaredField("isInPrepareStage");
+        isInPrepareStageField.setAccessible(true);
+        isInPrepareStageField.set(manager, false);
         when(manager.find(anyString())).thenReturn(mock(ModuleProviderHolder.class));
         ModuleProviderHolder logAnalyzerHolder = mock(ModuleProviderHolder.class);
         LogAnalyzerModuleProvider logAnalyzerProvider = mock(LogAnalyzerModuleProvider.class);
@@ -218,11 +218,15 @@ public void setup() {
 
     @ParameterizedTest(name = "{0}")
     @MethodSource("data")
-    public void testDslStaticCompile(String name, String script) throws ModuleStartException {
+    public void testDslStaticCompile(String name, String script) throws Exception {
         final DSL dsl = DSL.of(manager, new LogAnalyzerModuleConfig(), script);
-        Whitebox.setInternalState(
-            Whitebox.getInternalState(dsl, "filterSpec"), "sinkListenerFactories", Collections.emptyList()
-        );
+        Field filterSpecField = DSL.class.getDeclaredField("filterSpec");
+        filterSpecField.setAccessible(true);
+        Object filterSpec = filterSpecField.get(dsl);
+
+        Field sinkListenerFactoriesField = filterSpec.getClass().getDeclaredField("sinkListenerFactories");
+        sinkListenerFactoriesField.setAccessible(true);
+        sinkListenerFactoriesField.set(filterSpec, Collections.emptyList());
 
         dsl.bind(new Binding().log(LogData.newBuilder().build()));
         dsl.evaluate();

oap-server/analyzer/meter-analyzer/src/test/java/org/apache/skywalking/oap/meter/analyzer/dsl/AnalyzerTest.java

@@ -40,9 +40,8 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
-import org.mockito.Mockito;
+import org.mockito.MockedStatic;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.powermock.reflect.Whitebox;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -53,6 +52,7 @@
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.spy;
 
 @ExtendWith(MockitoExtension.class)
@@ -63,15 +63,17 @@ public class AnalyzerTest {
     private MeterSystem meterSystem;
     private Analyzer analyzer;
 
+    private MockedStatic<MetricsStreamProcessor> mockedMetricsStreamProcessor;
+
     @BeforeEach
     public void setup() throws StorageException {
         meterSystem = spy(new MeterSystem(moduleManager));
-        // Fix for JDK 25 / Mockito 5: Prevent double-spying on the singleton
-        MetricsStreamProcessor instance = MetricsStreamProcessor.getInstance();
-        if (!Mockito.mockingDetails(instance).isMock()) {
-            Whitebox.setInternalState(MetricsStreamProcessor.class, "PROCESSOR", Mockito.spy(instance));
-        }
-        doNothing().when(MetricsStreamProcessor.getInstance()).create(any(), (StreamDefinition) any(), any());
+        
+        MetricsStreamProcessor mockProcessor = spy(new MetricsStreamProcessor());
+        mockedMetricsStreamProcessor = mockStatic(MetricsStreamProcessor.class);
+        mockedMetricsStreamProcessor.when(MetricsStreamProcessor::getInstance).thenReturn(mockProcessor);
+        
+        doNothing().when(mockProcessor).create(any(), (StreamDefinition) any(), any());
 
     }
 
@@ -86,6 +88,13 @@ public static void tearDown() {
         MeterEntity.setNamingControl(null);
     }
 
+    @org.junit.jupiter.api.AfterEach
+    public void tearDownEach() {
+        if (mockedMetricsStreamProcessor != null) {
+            mockedMetricsStreamProcessor.close();
+        }
+    }
+
     @Test
     public void testSingle() {
         analyzer = Analyzer.build(

oap-server/analyzer/meter-analyzer/src/test/java/org/apache/skywalking/oap/meter/analyzer/dsl/K8sTagTest.java

@@ -39,11 +39,12 @@
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
-import org.powermock.reflect.Whitebox;
+
+import java.lang.reflect.Field;
+import com.google.common.cache.LoadingCache;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -53,6 +54,8 @@
 import static com.google.common.collect.ImmutableMap.of;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @Slf4j
@@ -237,29 +240,61 @@ public static Collection<Object[]> data() {
     @SneakyThrows
     @BeforeEach
     public void setup() {
-        Whitebox.setInternalState(KubernetesServices.class, "INSTANCE",
-                                  Mockito.mock(KubernetesServices.class)
-        );
-        Whitebox.setInternalState(KubernetesPods.class, "INSTANCE",
-                                  Mockito.mock(KubernetesPods.class)
-        );
+        LoadingCache<KubernetesServices, Object> mockServicesCache = mock(LoadingCache.class);
+        LoadingCache<ObjectID, Object> mockServiceByIDCache = mock(LoadingCache.class);
+
+        Field servicesField = KubernetesServices.class.getDeclaredField("services");
+        servicesField.setAccessible(true);
+        servicesField.set(KubernetesServices.INSTANCE, mockServicesCache);
+
+        Field serviceByIDField = KubernetesServices.class.getDeclaredField("serviceByID");
+        serviceByIDField.setAccessible(true);
+        serviceByIDField.set(KubernetesServices.INSTANCE, mockServiceByIDCache);
+
+        LoadingCache<String, Object> mockPodByIPCache = mock(LoadingCache.class);
+        LoadingCache<ObjectID, Object> mockPodByObjectIDCache = mock(LoadingCache.class);
+
+        Field podByIPField = KubernetesPods.class.getDeclaredField("podByIP");
+        podByIPField.setAccessible(true);
+        podByIPField.set(KubernetesPods.INSTANCE, mockPodByIPCache);
+
+        Field podByObjectIDField = KubernetesPods.class.getDeclaredField("podByObjectID");
+        podByObjectIDField.setAccessible(true);
+        podByObjectIDField.set(KubernetesPods.INSTANCE, mockPodByObjectIDCache);
 
-        when(KubernetesServices.INSTANCE.list()).thenReturn(ImmutableList.of(
+        try {
+            when(mockServicesCache.get(any())).thenReturn(ImmutableList.of());
+            when(mockServiceByIDCache.get(any())).thenReturn(Optional.empty());
+            when(mockPodByIPCache.get(any())).thenReturn(Optional.empty());
+            when(mockPodByObjectIDCache.get(any())).thenReturn(Optional.empty());
+        } catch (Exception e) {
+            // ignore
+        }
+
+        when(mockServicesCache.get(KubernetesServices.INSTANCE)).thenReturn(ImmutableList.of(
                 mockService("nginx-service", "default", of("run", "nginx"), "2.2.2.1"),
                 mockService("kube-state-metrics", "kube-system", of("run", "kube-state-metrics"), "2.2.2.2")));
         ImmutableList.of(
             mockService("nginx-service", "default", of("run", "nginx"), "2.2.2.1"),
             mockService("kube-state-metrics", "kube-system", of("run", "kube-state-metrics"), "2.2.2.2"))
-            .forEach(svc ->
-                when(KubernetesServices.INSTANCE.findByID(ObjectID.builder().namespace(svc.getMetadata().getNamespace()).name(svc.getMetadata().getName()).build()))
-                .thenReturn(Optional.of(svc))
-            );
+            .forEach(svc -> {
+                try {
+                    when(mockServiceByIDCache.get(ObjectID.builder().namespace(svc.getMetadata().getNamespace()).name(svc.getMetadata().getName()).build()))
+                    .thenReturn(Optional.of(svc));
+                } catch (Exception e) {
+            // ignore
+        }
+            });
         ImmutableList.of(
             mockPod("my-nginx-5dc4865748-mbczh", "default", of("run", "nginx"), "1.1.1.1"),
             mockPod("kube-state-metrics-6f979fd498-z7xwx", "kube-system", of("run", "kube-state-metrics"), "1.1.1.2"))
             .forEach(pod -> {
-                when(KubernetesPods.INSTANCE.findByIP(pod.getStatus().getPodIP())).thenReturn(Optional.of(pod));
-                when(KubernetesPods.INSTANCE.findByObjectID(ObjectID.builder().name(pod.getMetadata().getName()).namespace(pod.getMetadata().getNamespace()).build())).thenReturn(Optional.of(pod));
+                try {
+                    when(mockPodByIPCache.get(pod.getStatus().getPodIP())).thenReturn(Optional.of(pod));
+                    when(mockPodByObjectIDCache.get(ObjectID.builder().name(pod.getMetadata().getName()).namespace(pod.getMetadata().getNamespace()).build())).thenReturn(Optional.of(pod));
+                } catch (Exception e) {
+            // ignore
+        }
         });
     }