From a9ab84e15addb93a841b92d8506b4535083da5e5 Mon Sep 17 00:00:00 2001 From: EddeCCC Date: Mon, 22 Jul 2024 17:26:58 +0200 Subject: [PATCH] add more tests --- .../InstrumentationManager.java | 20 +++-- .../filling/ClassDiscoveryService.java | 6 +- .../filling/ConfigurationReceiver.java | 6 +- .../processing/BatchInstrumenter.java | 20 ++--- .../filling/ClassDiscoveryServiceTest.java | 32 +++++++ .../filling/ConfigurationReceiverTest.java | 33 +++++++ .../processing/BatchInstrumenterTest.java | 89 +++++++++++++++++++ .../ConfigurationHolderTest.java | 10 +-- .../ConfigurationReceivedSubjectTest.java | 23 +++++ .../util/ConfigurationResolverTest.java | 87 ++++++++++++++++++ .../util/ConfigurationUtilTest.java | 39 ++++++++ .../internal/http/HttpRequestSenderTest.java | 2 +- .../schedule/InspectitSchedulerTest.java | 2 +- .../TransformationManagerTest.java | 38 ++++++++ 14 files changed, 377 insertions(+), 30 deletions(-) create mode 100644 src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryServiceTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiverTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenterTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/internal/configuration/observer/ConfigurationReceivedSubjectTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationResolverTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationUtilTest.java create mode 100644 src/test/java/rocks/inspectit/gepard/agent/transformation/TransformationManagerTest.java diff --git a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/InstrumentationManager.java b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/InstrumentationManager.java index 94bf4e8..cbdde51 100644 --- a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/InstrumentationManager.java +++ b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/InstrumentationManager.java @@ -1,5 +1,7 @@ package rocks.inspectit.gepard.agent.instrumentation; +import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; +import java.lang.instrument.Instrumentation; import java.time.Duration; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -15,8 +17,12 @@ public class InstrumentationManager { private final PendingClassesCache pendingClassesCache; - private InstrumentationManager(PendingClassesCache pendingClassesCache) { + private final Instrumentation instrumentation; + + private InstrumentationManager( + PendingClassesCache pendingClassesCache, Instrumentation instrumentation) { this.pendingClassesCache = pendingClassesCache; + this.instrumentation = instrumentation; } /** @@ -26,7 +32,8 @@ private InstrumentationManager(PendingClassesCache pendingClassesCache) { */ public static InstrumentationManager create() { PendingClassesCache pendingClassesCache = new PendingClassesCache(); - return new InstrumentationManager(pendingClassesCache); + Instrumentation instrumentation = InstrumentationHolder.getInstrumentation(); + return new InstrumentationManager(pendingClassesCache, instrumentation); } /** @@ -35,7 +42,8 @@ public static InstrumentationManager create() { */ public void startClassDiscovery() { InspectitScheduler scheduler = InspectitScheduler.getInstance(); - ClassDiscoveryService discoveryService = new ClassDiscoveryService(pendingClassesCache); + ClassDiscoveryService discoveryService = + new ClassDiscoveryService(pendingClassesCache, instrumentation); Duration discoveryInterval = Duration.ofSeconds(30); scheduler.startRunnable(discoveryService, discoveryInterval); } @@ -46,7 +54,8 @@ public void startClassDiscovery() { */ public void startBatchInstrumentation() { InspectitScheduler scheduler = InspectitScheduler.getInstance(); - BatchInstrumenter batchInstrumenter = new BatchInstrumenter(pendingClassesCache); + BatchInstrumenter batchInstrumenter = + new BatchInstrumenter(pendingClassesCache, instrumentation); Duration batchInterval = Duration.ofMillis(500); scheduler.startRunnable(batchInstrumenter, batchInterval); } @@ -54,7 +63,8 @@ public void startBatchInstrumentation() { /** Creates an observer, who listens to {@link ConfigurationReceivedEvent}s. */ public void createConfigurationReceiver() { log.info("Creating ConfigurationReceiver..."); - ConfigurationReceiver configurationReceiver = new ConfigurationReceiver(pendingClassesCache); + ConfigurationReceiver configurationReceiver = + new ConfigurationReceiver(pendingClassesCache, instrumentation); configurationReceiver.subscribeToConfigurationReceivedEvents(); } } diff --git a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryService.java b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryService.java index bd0a968..110cb0a 100644 --- a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryService.java +++ b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryService.java @@ -1,6 +1,5 @@ package rocks.inspectit.gepard.agent.instrumentation.filling; -import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; import java.lang.instrument.Instrumentation; import java.util.Collections; import java.util.HashSet; @@ -23,10 +22,11 @@ public class ClassDiscoveryService implements NamedRunnable { private final Instrumentation instrumentation; - public ClassDiscoveryService(PendingClassesCache pendingClassesCache) { + public ClassDiscoveryService( + PendingClassesCache pendingClassesCache, Instrumentation instrumentation) { this.discoveredClasses = Collections.newSetFromMap(new WeakHashMap<>()); this.pendingClassesCache = pendingClassesCache; - this.instrumentation = InstrumentationHolder.getInstrumentation(); + this.instrumentation = instrumentation; } @Override diff --git a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiver.java b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiver.java index 73b0522..18669eb 100644 --- a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiver.java +++ b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiver.java @@ -1,6 +1,5 @@ package rocks.inspectit.gepard.agent.instrumentation.filling; -import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; import java.lang.instrument.Instrumentation; import java.util.Set; import org.slf4j.Logger; @@ -20,9 +19,10 @@ public class ConfigurationReceiver implements ConfigurationReceivedObserver { private final Instrumentation instrumentation; - public ConfigurationReceiver(PendingClassesCache pendingClassesCache) { + public ConfigurationReceiver( + PendingClassesCache pendingClassesCache, Instrumentation instrumentation) { this.pendingClassesCache = pendingClassesCache; - this.instrumentation = InstrumentationHolder.getInstrumentation(); + this.instrumentation = instrumentation; } @Override diff --git a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenter.java b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenter.java index 5854f5e..5d9c2fe 100644 --- a/src/main/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenter.java +++ b/src/main/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenter.java @@ -1,7 +1,6 @@ package rocks.inspectit.gepard.agent.instrumentation.processing; import com.google.common.annotations.VisibleForTesting; -import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; import java.lang.instrument.Instrumentation; import java.util.*; import org.slf4j.Logger; @@ -16,17 +15,14 @@ public class BatchInstrumenter implements NamedRunnable { /** Hard coded batch size to transform classes */ private static final int BATCH_SIZE = 1000; - /** - * The set of classes which might need instrumentation updates. This service works through this - * set in batches. - */ - private final Instrumentation instrumentation; - private final PendingClassesCache pendingClassesCache; - public BatchInstrumenter(PendingClassesCache pendingClassesCache) { + private final Instrumentation instrumentation; + + public BatchInstrumenter( + PendingClassesCache pendingClassesCache, Instrumentation instrumentation) { this.pendingClassesCache = pendingClassesCache; - this.instrumentation = InstrumentationHolder.getInstrumentation(); + this.instrumentation = instrumentation; } @Override @@ -49,7 +45,7 @@ public void run() { */ @VisibleForTesting Set> getNextBatch(int batchSize) { - Set> batch = new HashSet<>(); + Set> classesToBeInstrumented = new HashSet<>(); int checkedClassesCount = 0; Iterator> queueIterator = pendingClassesCache.getKeyIterator(); @@ -58,7 +54,7 @@ Set> getNextBatch(int batchSize) { queueIterator.remove(); checkedClassesCount++; - if (ConfigurationResolver.shouldRetransform(clazz)) batch.add(clazz); + if (ConfigurationResolver.shouldRetransform(clazz)) classesToBeInstrumented.add(clazz); if (checkedClassesCount >= batchSize) break; } @@ -68,7 +64,7 @@ Set> getNextBatch(int batchSize) { checkedClassesCount, pendingClassesCache.getSize()); - return batch; + return classesToBeInstrumented; } /** diff --git a/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryServiceTest.java b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryServiceTest.java new file mode 100644 index 0000000..af01d07 --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ClassDiscoveryServiceTest.java @@ -0,0 +1,32 @@ +package rocks.inspectit.gepard.agent.instrumentation.filling; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import rocks.inspectit.gepard.agent.instrumentation.PendingClassesCache; + +import java.lang.instrument.Instrumentation; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class ClassDiscoveryServiceTest { + + @Mock + private Instrumentation instrumentation; + + @Test + void discoveryDoesFillCache() { + Class[] clazz = {getClass()}; + when(instrumentation.getAllLoadedClasses()).thenReturn(clazz); + PendingClassesCache cache = new PendingClassesCache(); + ClassDiscoveryService service = new ClassDiscoveryService(cache, instrumentation); + + service.discoverClasses(); + + assertEquals(1, cache.getSize()); + verify(instrumentation, times(1)).getAllLoadedClasses(); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiverTest.java b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiverTest.java new file mode 100644 index 0000000..c13ab3b --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/filling/ConfigurationReceiverTest.java @@ -0,0 +1,33 @@ +package rocks.inspectit.gepard.agent.instrumentation.filling; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; + +import java.lang.instrument.Instrumentation; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import rocks.inspectit.gepard.agent.instrumentation.PendingClassesCache; +import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; +import rocks.inspectit.gepard.agent.internal.configuration.observer.ConfigurationReceivedEvent; + +@ExtendWith(MockitoExtension.class) +class ConfigurationReceiverTest { + + @Mock private Instrumentation instrumentation; + + @Test + void receiverDoesFillCache() { + Class[] clazz = {getClass()}; + when(instrumentation.getAllLoadedClasses()).thenReturn(clazz); + PendingClassesCache cache = new PendingClassesCache(); + ConfigurationReceiver receiver = new ConfigurationReceiver(cache, instrumentation); + ConfigurationReceivedEvent event = new ConfigurationReceivedEvent(this, new InspectitConfiguration()); + + receiver.handleConfiguration(event); + + assertEquals(1, cache.getSize()); + verify(instrumentation, times(1)).getAllLoadedClasses(); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenterTest.java b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenterTest.java new file mode 100644 index 0000000..707a12f --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/instrumentation/processing/BatchInstrumenterTest.java @@ -0,0 +1,89 @@ +package rocks.inspectit.gepard.agent.instrumentation.processing; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import rocks.inspectit.gepard.agent.instrumentation.PendingClassesCache; +import rocks.inspectit.gepard.agent.internal.configuration.ConfigurationHolder; +import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; +import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.InstrumentationConfiguration; +import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.Scope; +import rocks.inspectit.gepard.agent.internal.configuration.observer.ConfigurationReceivedEvent; + +import java.lang.instrument.Instrumentation; +import java.lang.instrument.UnmodifiableClassException; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class BatchInstrumenterTest { + + private final static int BATCH_SIZE = 10; + + private final Class TEST_CLASS = getClass(); + + @Mock + private Instrumentation instrumentation; + + @Mock + private PendingClassesCache cache; + + @Test + void classIsRemovedFromCacheAndNotAddedToBatch() { + Set> classes = new HashSet<>(); + classes.add(TEST_CLASS); + when(cache.getKeyIterator()).thenReturn(classes.iterator()); + BatchInstrumenter instrumenter = new BatchInstrumenter(cache, instrumentation); + + Set> classesToBeInstrumented = instrumenter.getNextBatch(BATCH_SIZE); + + assertEquals(0, classesToBeInstrumented.size()); + assertEquals(0, classes.size()); + } + + @Test + void classIsRemovedFromCacheAndAddedToBatch() { + updateConfigurationHolder(); + Set> classes = new HashSet<>(); + classes.add(TEST_CLASS); + when(cache.getKeyIterator()).thenReturn(classes.iterator()); + BatchInstrumenter instrumenter = new BatchInstrumenter(cache, instrumentation); + + Set> classesToBeInstrumented = instrumenter.getNextBatch(BATCH_SIZE); + + assertEquals(1, classesToBeInstrumented.size()); + assertEquals(0, classes.size()); + } + + @Test + void classIsRetransformed() throws UnmodifiableClassException { + Set> classes = new HashSet<>(); + classes.add(TEST_CLASS); + BatchInstrumenter instrumenter = new BatchInstrumenter(cache, instrumentation); + + instrumenter.retransformBatch(classes.iterator()); + + verify(instrumentation).retransformClasses(TEST_CLASS); + } + + /** + * Updates the current {@link InspectitConfiguration} + */ + private void updateConfigurationHolder() { + Scope scope = new Scope(TEST_CLASS.getName(), true); + InstrumentationConfiguration instrumentationConfiguration = + new InstrumentationConfiguration(List.of(scope)); + InspectitConfiguration configuration = new InspectitConfiguration(instrumentationConfiguration); + + ConfigurationHolder holder = ConfigurationHolder.getInstance(); + ConfigurationReceivedEvent event = new ConfigurationReceivedEvent(this, configuration); + holder.handleConfiguration(event); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/ConfigurationHolderTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/ConfigurationHolderTest.java index 3bfb6cf..bc25819 100644 --- a/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/ConfigurationHolderTest.java +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/ConfigurationHolderTest.java @@ -3,15 +3,14 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import java.util.List; import org.junit.jupiter.api.Test; import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.InstrumentationConfiguration; import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.Scope; import rocks.inspectit.gepard.agent.internal.configuration.observer.ConfigurationReceivedEvent; -import java.util.List; - -public class ConfigurationHolderTest { +class ConfigurationHolderTest { private final ConfigurationHolder holder = ConfigurationHolder.getInstance(); @@ -27,7 +26,7 @@ void configurationIsUpdated() { InspectitConfiguration configuration = createConfiguration(); ConfigurationReceivedEvent event = new ConfigurationReceivedEvent(this, configuration); - holder.handleConfiguration(event); + holder.handleConfiguration(event); InspectitConfiguration updatedConfiguration = holder.getConfiguration(); assertEquals(configuration, updatedConfiguration); @@ -35,7 +34,8 @@ void configurationIsUpdated() { private InspectitConfiguration createConfiguration() { Scope scope = new Scope("com.example.Application", true); - InstrumentationConfiguration instrumentationConfiguration = new InstrumentationConfiguration(List.of(scope)); + InstrumentationConfiguration instrumentationConfiguration = + new InstrumentationConfiguration(List.of(scope)); return new InspectitConfiguration(instrumentationConfiguration); } } diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/observer/ConfigurationReceivedSubjectTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/observer/ConfigurationReceivedSubjectTest.java new file mode 100644 index 0000000..be98f20 --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/observer/ConfigurationReceivedSubjectTest.java @@ -0,0 +1,23 @@ +package rocks.inspectit.gepard.agent.internal.configuration.observer; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.concurrent.atomic.AtomicBoolean; +import org.junit.jupiter.api.Test; +import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; + +class ConfigurationReceivedSubjectTest { + + @Test + void listenersAreNotified() { + AtomicBoolean wasNotified = new AtomicBoolean(false); + + ConfigurationReceivedObserver observer = (event) -> wasNotified.set(true); + observer.subscribeToConfigurationReceivedEvents(); + + ConfigurationReceivedSubject subject = ConfigurationReceivedSubject.getInstance(); + subject.notifyListeners(new InspectitConfiguration()); + + assertTrue(wasNotified.get()); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationResolverTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationResolverTest.java new file mode 100644 index 0000000..e0b0f47 --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationResolverTest.java @@ -0,0 +1,87 @@ +package rocks.inspectit.gepard.agent.internal.configuration.util; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import net.bytebuddy.description.type.TypeDescription; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import rocks.inspectit.gepard.agent.internal.configuration.ConfigurationHolder; +import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; +import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.InstrumentationConfiguration; +import rocks.inspectit.gepard.agent.internal.configuration.model.instrumentation.Scope; +import rocks.inspectit.gepard.agent.internal.configuration.observer.ConfigurationReceivedEvent; + +class ConfigurationResolverTest { + + private final Class TEST_CLASS = getClass(); + + // In the future, we might use some library like powermock to mock the ConfigurationHolder + @AfterEach + void clearConfigurationHolder() { + InspectitConfiguration defaultConfiguration = new InspectitConfiguration(); + ConfigurationReceivedEvent event = new ConfigurationReceivedEvent(this, defaultConfiguration); + + ConfigurationHolder holder = ConfigurationHolder.getInstance(); + holder.handleConfiguration(event); + } + + @Test + void classShouldNotBeRetransformed() { + boolean shouldRetransform = ConfigurationResolver.shouldRetransform(TEST_CLASS); + + assertFalse(shouldRetransform); + } + + @Test + void classShouldBeRetransformed() { + updateConfigurationHolder(true); + + boolean shouldRetransform = ConfigurationResolver.shouldRetransform(TEST_CLASS); + + assertTrue(shouldRetransform); + } + + @Test + void typeShouldNotBeInstrumented() { + TypeDescription type = new TypeDescription.ForLoadedType(TEST_CLASS); + boolean shouldInstrument = ConfigurationResolver.shouldInstrument(type); + + assertFalse(shouldInstrument); + } + + @Test + void typeShouldBeInstrumented() { + updateConfigurationHolder(true); + TypeDescription type = new TypeDescription.ForLoadedType(TEST_CLASS); + boolean shouldInstrument = ConfigurationResolver.shouldInstrument(type); + + assertTrue(shouldInstrument); + } + + @Test + void typeShouldBeDeinstrumented() { + updateConfigurationHolder(false); + TypeDescription type = new TypeDescription.ForLoadedType(TEST_CLASS); + boolean shouldInstrument = ConfigurationResolver.shouldInstrument(type); + + assertFalse(shouldInstrument); + } + + /** + * Updates the current {@link InspectitConfiguration} + * + * @param enabled the status of the scope for this test class + */ + private void updateConfigurationHolder(boolean enabled) { + Scope scope = new Scope(TEST_CLASS.getName(), enabled); + InstrumentationConfiguration instrumentationConfiguration = + new InstrumentationConfiguration(List.of(scope)); + InspectitConfiguration configuration = new InspectitConfiguration(instrumentationConfiguration); + + ConfigurationHolder holder = ConfigurationHolder.getInstance(); + ConfigurationReceivedEvent event = new ConfigurationReceivedEvent(this, configuration); + holder.handleConfiguration(event); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationUtilTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationUtilTest.java new file mode 100644 index 0000000..f29e263 --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/configuration/util/ConfigurationUtilTest.java @@ -0,0 +1,39 @@ +package rocks.inspectit.gepard.agent.internal.configuration.util; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; +import rocks.inspectit.gepard.agent.internal.configuration.exception.CouldNotSerializeConfigurationException; +import rocks.inspectit.gepard.agent.internal.configuration.model.InspectitConfiguration; + +class ConfigurationUtilTest { + + @Test + void validStringIsDeserialized() { + String body = + """ + { + "instrumentationConfiguration": { + "scopes": [ + { + "fqn": "com.example.Application", + "enabled": true + } + ] + } + } + """; + + InspectitConfiguration result = ConfigurationUtil.deserializeConfiguration(body); + + assertNotNull(result); + } + + @Test + void invalidStringThrowsException() { + String body = "invalid"; + assertThrows( + CouldNotSerializeConfigurationException.class, + () -> ConfigurationUtil.deserializeConfiguration(body)); + } +} diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/http/HttpRequestSenderTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/http/HttpRequestSenderTest.java index 64389be..9b2c3d7 100644 --- a/src/test/java/rocks/inspectit/gepard/agent/internal/http/HttpRequestSenderTest.java +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/http/HttpRequestSenderTest.java @@ -21,7 +21,7 @@ import rocks.inspectit.gepard.agent.MockServerTestBase; @ExtendWith(MockitoExtension.class) -public class HttpRequestSenderTest extends MockServerTestBase { +class HttpRequestSenderTest extends MockServerTestBase { @Mock private FutureCallback callback; diff --git a/src/test/java/rocks/inspectit/gepard/agent/internal/schedule/InspectitSchedulerTest.java b/src/test/java/rocks/inspectit/gepard/agent/internal/schedule/InspectitSchedulerTest.java index 0b505ca..4bd784a 100644 --- a/src/test/java/rocks/inspectit/gepard/agent/internal/schedule/InspectitSchedulerTest.java +++ b/src/test/java/rocks/inspectit/gepard/agent/internal/schedule/InspectitSchedulerTest.java @@ -5,7 +5,7 @@ import java.time.Duration; import org.junit.jupiter.api.Test; -public class InspectitSchedulerTest { +class InspectitSchedulerTest { private final InspectitScheduler scheduler = InspectitScheduler.getInstance(); diff --git a/src/test/java/rocks/inspectit/gepard/agent/transformation/TransformationManagerTest.java b/src/test/java/rocks/inspectit/gepard/agent/transformation/TransformationManagerTest.java new file mode 100644 index 0000000..dc6ab1e --- /dev/null +++ b/src/test/java/rocks/inspectit/gepard/agent/transformation/TransformationManagerTest.java @@ -0,0 +1,38 @@ +package rocks.inspectit.gepard.agent.transformation; + +import static org.junit.jupiter.api.Assertions.assertNotEquals; + +import io.opentelemetry.javaagent.tooling.AgentInstaller; +import net.bytebuddy.ByteBuddy; +import net.bytebuddy.agent.builder.AgentBuilder; +import net.bytebuddy.dynamic.VisibilityBridgeStrategy; +import net.bytebuddy.dynamic.scaffold.InstrumentedType; +import net.bytebuddy.dynamic.scaffold.MethodGraph; +import org.junit.jupiter.api.Test; + +class TransformationManagerTest { + + @Test + void agentBuilderDoNotEqual() { + TransformationManager manager = TransformationManager.create(); + + AgentBuilder agent = createAgentBuilder(); + AgentBuilder modifiedAgent = manager.modify(agent); + + // There is no ordinary way to compare the properties of the agentBuilders + assertNotEquals(agent, modifiedAgent); + } + + /** Copied from {@link AgentInstaller} */ + private AgentBuilder createAgentBuilder() { + return new AgentBuilder.Default( + new ByteBuddy() + .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE) + .with(VisibilityBridgeStrategy.Default.NEVER) + .with(InstrumentedType.Factory.Default.FROZEN)) + .with(AgentBuilder.TypeStrategy.Default.DECORATE) + .disableClassFormatChanges() + .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION) + .with(AgentBuilder.DescriptionStrategy.Default.POOL_ONLY); + } +}