From 5c6fc2e23af0922b0fbd070663c942ee44f207fa Mon Sep 17 00:00:00 2001 From: Atif Ali Date: Thu, 13 Jul 2023 15:51:41 -0400 Subject: [PATCH] not sure why im getting 'always' instead of 'never' --- .vscode/settings.json | 3 + .../api/v1/TargetRecordingsPostHandler.java | 15 ++-- .../graph/StartRecordingOnTargetMutator.java | 11 +-- .../recordings/RecordingTargetHelper.java | 39 ++++++-- .../java/io/cryostat/rules/RuleProcessor.java | 6 +- .../v1/TargetRecordingsPostHandlerTest.java | 89 +++++++++++++------ .../recordings/RecordingTargetHelperTest.java | 29 +++--- .../io/cryostat/rules/RuleProcessorTest.java | 54 ++++++----- 8 files changed, 162 insertions(+), 84 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000000..7b016a89fb --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "java.compile.nullAnalysis.mode": "automatic" +} \ No newline at end of file diff --git a/src/main/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandler.java b/src/main/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandler.java index dfc54c655f..c172555f42 100644 --- a/src/main/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandler.java +++ b/src/main/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandler.java @@ -48,10 +48,16 @@ import javax.inject.Inject; import javax.inject.Provider; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.Pair; import org.openjdk.jmc.common.unit.QuantityConversionException; import org.openjdk.jmc.flightrecorder.configuration.recording.RecordingOptionsBuilder; import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor; +import com.google.gson.Gson; +import com.google.gson.JsonSyntaxException; +import com.google.gson.reflect.TypeToken; + import io.cryostat.configuration.CredentialsManager; import io.cryostat.core.log.Logger; import io.cryostat.core.net.JFRConnection; @@ -69,17 +75,11 @@ import io.cryostat.recordings.RecordingMetadataManager.Metadata; import io.cryostat.recordings.RecordingOptionsBuilderFactory; import io.cryostat.recordings.RecordingTargetHelper; - -import com.google.gson.Gson; -import com.google.gson.JsonSyntaxException; -import com.google.gson.reflect.TypeToken; import io.vertx.core.MultiMap; import io.vertx.core.http.HttpHeaders; import io.vertx.core.http.HttpMethod; import io.vertx.ext.web.RoutingContext; import io.vertx.ext.web.handler.HttpException; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.Pair; public class TargetRecordingsPostHandler extends AbstractAuthenticatedRequestHandler { @@ -221,7 +221,8 @@ public void handleAuthenticated(RoutingContext ctx) throws Exception { eventSpecifier); IRecordingDescriptor descriptor = recordingTargetHelper.startRecording( - restart, + null, + "always", connectionDescriptor, builder.build(), template.getLeft(), diff --git a/src/main/java/io/cryostat/net/web/http/api/v2/graph/StartRecordingOnTargetMutator.java b/src/main/java/io/cryostat/net/web/http/api/v2/graph/StartRecordingOnTargetMutator.java index 4d5bf87e6c..0758e9dd18 100644 --- a/src/main/java/io/cryostat/net/web/http/api/v2/graph/StartRecordingOnTargetMutator.java +++ b/src/main/java/io/cryostat/net/web/http/api/v2/graph/StartRecordingOnTargetMutator.java @@ -50,6 +50,10 @@ import org.openjdk.jmc.flightrecorder.configuration.recording.RecordingOptionsBuilder; import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor; +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; + +import graphql.schema.DataFetchingEnvironment; import io.cryostat.configuration.CredentialsManager; import io.cryostat.core.templates.TemplateType; import io.cryostat.jmc.serialization.HyperlinkedSerializableRecordingDescriptor; @@ -65,10 +69,6 @@ import io.cryostat.recordings.RecordingOptionsBuilderFactory; import io.cryostat.recordings.RecordingTargetHelper; -import com.google.gson.Gson; -import com.google.gson.reflect.TypeToken; -import graphql.schema.DataFetchingEnvironment; - class StartRecordingOnTargetMutator extends AbstractPermissionedDataFetcher { @@ -179,7 +179,8 @@ public HyperlinkedSerializableRecordingDescriptor getAuthenticated( } IRecordingDescriptor desc = recordingTargetHelper.startRecording( - restart, + null, + "always", cd, builder.build(), (String) settings.get("template"), diff --git a/src/main/java/io/cryostat/recordings/RecordingTargetHelper.java b/src/main/java/io/cryostat/recordings/RecordingTargetHelper.java index e90536d004..6754ff52ca 100644 --- a/src/main/java/io/cryostat/recordings/RecordingTargetHelper.java +++ b/src/main/java/io/cryostat/recordings/RecordingTargetHelper.java @@ -51,6 +51,8 @@ import java.util.regex.Pattern; import java.util.stream.Collectors; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.Pair; import org.openjdk.jmc.common.unit.IConstrainedMap; import org.openjdk.jmc.flightrecorder.configuration.events.EventOptionID; import org.openjdk.jmc.flightrecorder.configuration.recording.RecordingOptionsBuilder; @@ -58,6 +60,7 @@ import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor; import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor.RecordingState; +import dagger.Lazy; import io.cryostat.core.log.Logger; import io.cryostat.core.net.JFRConnection; import io.cryostat.core.templates.Template; @@ -70,13 +73,9 @@ import io.cryostat.net.web.WebServer; import io.cryostat.net.web.http.HttpMimeType; import io.cryostat.recordings.RecordingMetadataManager.Metadata; - -import dagger.Lazy; import io.vertx.core.Handler; import io.vertx.core.Promise; import io.vertx.core.Vertx; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.Pair; public class RecordingTargetHelper { @@ -221,6 +220,8 @@ public IRecordingDescriptor startRecording( throws Exception { String recordingName = (String) recordingOptions.get(RecordingOptionsBuilder.KEY_NAME); boolean restartRecording = shouldRestartRecording(replace, restart); + System.out.println("++==Restart value: " + restart); // Log the value of restart + System.out.println("++==Replace value: " + replace); return targetConnectionManager.executeConnectedTask( connectionDescriptor, @@ -282,18 +283,40 @@ public IRecordingDescriptor startRecording( } private boolean shouldRestartRecording(String replace, String restart) { - if (replace != null) { + System.out.println("++replace: " + replace); + System.out.println("++restart: " + restart); + + if (replace != null && !replace.isEmpty()) { switch (replace) { case "always": + System.out.println("++replace is 'always'"); return true; case "stopped": - return restart == null || restart.equals("true"); + System.out.println("replace is 'stopped'"); + // Check if the recording is stopped + boolean isStopped = isRecordingStopped(replace); + System.out.println("++isStopped: " + isStopped); + return isStopped; case "never": - default: + System.out.println("++replace is 'never'"); return false; } } - // Default behavior if 'replace' is not specified + + // Handle restart parameter (deprecated) + if (restart != null && !restart.isEmpty()) { // Check 'restart' parameter here + System.out.println("++Handling restart parameter"); + boolean isStopped = isRecordingStopped(restart); + System.out.println("++isStopped: " + isStopped); + return isStopped; + } + // if neither restart nor replace is specified, default to never + System.out.println("++Defaulting to 'never'"); + return false; + } + + private boolean isRecordingStopped(String restart) { + // If restart is null or "true", consider the recording as stopped return restart != null && restart.equals("true"); } diff --git a/src/main/java/io/cryostat/rules/RuleProcessor.java b/src/main/java/io/cryostat/rules/RuleProcessor.java index dbfc66392c..c837b1e120 100644 --- a/src/main/java/io/cryostat/rules/RuleProcessor.java +++ b/src/main/java/io/cryostat/rules/RuleProcessor.java @@ -52,6 +52,7 @@ import javax.script.ScriptException; +import org.apache.commons.lang3.tuple.Pair; import org.openjdk.jmc.flightrecorder.configuration.recording.RecordingOptionsBuilder; import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor; @@ -73,10 +74,8 @@ import io.cryostat.rules.RuleRegistry.RuleEvent; import io.cryostat.util.events.Event; import io.cryostat.util.events.EventListener; - import io.vertx.core.AbstractVerticle; import io.vertx.core.Vertx; -import org.apache.commons.lang3.tuple.Pair; public class RuleProcessor extends AbstractVerticle implements Consumer { @@ -405,7 +404,8 @@ private void startRuleRecording(ConnectionDescriptor connectionDescriptor, Rule RecordingTargetHelper.parseEventSpecifierToTemplate( rule.getEventSpecifier()); return recordingTargetHelper.startRecording( - true, + "true", + "always", connectionDescriptor, builder.build(), template.getLeft(), diff --git a/src/test/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandlerTest.java b/src/test/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandlerTest.java index 89cc3326d5..2196d4b3cd 100644 --- a/src/test/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandlerTest.java +++ b/src/test/java/io/cryostat/net/web/http/api/v1/TargetRecordingsPostHandlerTest.java @@ -43,6 +43,18 @@ import java.util.concurrent.TimeUnit; import java.util.stream.Stream; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; import org.openjdk.jmc.common.unit.IConstrainedMap; import org.openjdk.jmc.common.unit.IQuantity; import org.openjdk.jmc.common.unit.QuantityConversionException; @@ -50,6 +62,8 @@ import org.openjdk.jmc.rjmx.services.jfr.IFlightRecorderService; import org.openjdk.jmc.rjmx.services.jfr.IRecordingDescriptor; +import com.google.gson.Gson; + import io.cryostat.MainModule; import io.cryostat.configuration.CredentialsManager; import io.cryostat.core.log.Logger; @@ -65,8 +79,6 @@ import io.cryostat.recordings.RecordingMetadataManager.Metadata; import io.cryostat.recordings.RecordingOptionsBuilderFactory; import io.cryostat.recordings.RecordingTargetHelper; - -import com.google.gson.Gson; import io.vertx.core.MultiMap; import io.vertx.core.http.HttpHeaders; import io.vertx.core.http.HttpMethod; @@ -74,18 +86,6 @@ import io.vertx.core.http.HttpServerResponse; import io.vertx.ext.web.RoutingContext; import io.vertx.ext.web.handler.HttpException; -import org.hamcrest.MatcherAssert; -import org.hamcrest.Matchers; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class TargetRecordingsPostHandlerTest { @@ -194,6 +194,7 @@ void shouldStartRecording() throws Exception { attrs.add("maxAge", "50"); attrs.add("maxSize", "64"); attrs.add("archiveOnStop", "false"); + Mockito.when(ctx.response()).thenReturn(resp); Mockito.when( resp.putHeader( @@ -203,7 +204,8 @@ void shouldStartRecording() throws Exception { IRecordingDescriptor descriptor = createDescriptor("someRecording"); Mockito.when( recordingTargetHelper.startRecording( - Mockito.anyBoolean(), + Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), @@ -223,13 +225,18 @@ void shouldStartRecording() throws Exception { Mockito.verify(recordingOptionsBuilder).maxAge(50L); Mockito.verify(recordingOptionsBuilder).maxSize(64L); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); ArgumentCaptor> recordingOptionsCaptor = ArgumentCaptor.forClass(IConstrainedMap.class); + ArgumentCaptor templateNameCaptor = ArgumentCaptor.forClass(String.class); @@ -243,6 +250,7 @@ void shouldStartRecording() throws Exception { Mockito.verify(recordingTargetHelper) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), @@ -250,7 +258,9 @@ void shouldStartRecording() throws Exception { metadataCaptor.capture(), archiveOnStopCaptor.capture()); - MatcherAssert.assertThat(restartCaptor.getValue(), Matchers.equalTo(false)); +System.out.println("++ 260 replace value: "+replaceCaptor.getValue()); + + MatcherAssert.assertThat(restartCaptor.getValue(), Matchers.equalTo("false")); ConnectionDescriptor connectionDescriptor = connectionDescriptorCaptor.getValue(); MatcherAssert.assertThat( @@ -307,7 +317,8 @@ void shouldRestartRecording() throws Exception { IRecordingDescriptor descriptor = createDescriptor("someRecording"); Mockito.when( recordingTargetHelper.startRecording( - Mockito.anyBoolean(), + Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), @@ -315,6 +326,7 @@ void shouldRestartRecording() throws Exception { Mockito.any(), Mockito.anyBoolean())) .thenReturn(descriptor); + Mockito.when(recordingMetadataManager.getMetadata(Mockito.any(), Mockito.anyString())) .thenReturn(new Metadata()); @@ -329,15 +341,27 @@ void shouldRestartRecording() throws Exception { resp.putHeader( Mockito.any(CharSequence.class), Mockito.any(CharSequence.class))) .thenReturn(resp); - attrs.add("restart", "true"); + attrs.add("replace", "always"); attrs.add("recordingName", "someRecording"); attrs.add("events", "template=Foo"); + // getting restart value + System.out.println("++Restart value: " + attrs.get("restart")); // Verify restart value before invoking handler + + handler.handle(ctx); + System.out.println("+++Restart value: " + attrs.get("restart")); // Verify restart value after invoking handler + + Mockito.verify(recordingOptionsBuilder).name("someRecording"); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + + + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); @@ -357,14 +381,20 @@ void shouldRestartRecording() throws Exception { Mockito.verify(recordingTargetHelper) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), templateTypeCaptor.capture(), metadataCaptor.capture(), archiveOnStopCaptor.capture()); + + ; + + +System.out.println("+++"+restartCaptor.getValue()); +MatcherAssert.assertThat(replaceCaptor.getValue(), Matchers.equalTo("always")); - MatcherAssert.assertThat(restartCaptor.getValue(), Matchers.equalTo(true)); ConnectionDescriptor connectionDescriptor = connectionDescriptorCaptor.getValue(); MatcherAssert.assertThat( @@ -411,7 +441,8 @@ void shouldHandleNameCollision() throws Exception { Mockito.when(recordingOptionsBuilder.build()).thenReturn(recordingOptions); Mockito.when( recordingTargetHelper.startRecording( - Mockito.anyBoolean(), + Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), @@ -574,7 +605,8 @@ void shouldStartRecordingAndArchiveOnStop() throws Exception { IRecordingDescriptor descriptor = createDescriptor("someRecording"); Mockito.when( recordingTargetHelper.startRecording( - Mockito.anyBoolean(), + Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), @@ -594,7 +626,10 @@ void shouldStartRecordingAndArchiveOnStop() throws Exception { Mockito.verify(recordingOptionsBuilder).maxAge(50L); Mockito.verify(recordingOptionsBuilder).maxSize(64L); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); @@ -614,6 +649,7 @@ void shouldStartRecordingAndArchiveOnStop() throws Exception { Mockito.verify(recordingTargetHelper) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), @@ -621,7 +657,9 @@ void shouldStartRecordingAndArchiveOnStop() throws Exception { metadataCaptor.capture(), archiveOnStopCaptor.capture()); - MatcherAssert.assertThat(restartCaptor.getValue(), Matchers.equalTo(false)); + System.out.println("++658 replace value: "+replaceCaptor.getValue()); + + MatcherAssert.assertThat(restartCaptor.getValue(), Matchers.equalTo("false")); ConnectionDescriptor connectionDescriptor = connectionDescriptorCaptor.getValue(); MatcherAssert.assertThat( @@ -647,3 +685,4 @@ void shouldStartRecordingAndArchiveOnStop() throws Exception { "{\"downloadUrl\":\"example-download-url\",\"reportUrl\":\"example-report-url\",\"metadata\":{\"labels\":{}},\"archiveOnStop\":true,\"id\":1,\"name\":\"someRecording\",\"state\":\"STOPPED\",\"startTime\":0,\"duration\":0,\"continuous\":false,\"toDisk\":false,\"maxSize\":0,\"maxAge\":0}"); } } +// first save \ No newline at end of file diff --git a/src/test/java/io/cryostat/recordings/RecordingTargetHelperTest.java b/src/test/java/io/cryostat/recordings/RecordingTargetHelperTest.java index ce341ea6d6..4f3a0c2979 100644 --- a/src/test/java/io/cryostat/recordings/RecordingTargetHelperTest.java +++ b/src/test/java/io/cryostat/recordings/RecordingTargetHelperTest.java @@ -52,6 +52,20 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.stubbing.Answer; import org.openjdk.jmc.common.unit.IConstrainedMap; import org.openjdk.jmc.common.unit.IQuantity; import org.openjdk.jmc.common.unit.QuantityConversionException; @@ -76,22 +90,7 @@ import io.cryostat.net.web.http.HttpMimeType; import io.cryostat.recordings.RecordingMetadataManager.Metadata; import io.cryostat.recordings.RecordingTargetHelper.SnapshotCreationException; - import io.vertx.core.Vertx; -import org.hamcrest.MatcherAssert; -import org.hamcrest.Matchers; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.stubbing.Answer; @ExtendWith(MockitoExtension.class) public class RecordingTargetHelperTest { diff --git a/src/test/java/io/cryostat/rules/RuleProcessorTest.java b/src/test/java/io/cryostat/rules/RuleProcessorTest.java index 4b148a8dde..29e4623e63 100644 --- a/src/test/java/io/cryostat/rules/RuleProcessorTest.java +++ b/src/test/java/io/cryostat/rules/RuleProcessorTest.java @@ -37,13 +37,27 @@ */ package io.cryostat.rules; -import static org.mockito.Mockito.never; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; import java.net.URI; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.function.Function; +import org.apache.commons.lang3.tuple.Pair; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.stubbing.Answer; import org.openjdk.jmc.common.unit.IConstrainedMap; import org.openjdk.jmc.flightrecorder.configuration.recording.RecordingOptionsBuilder; import org.openjdk.jmc.rjmx.services.jfr.IFlightRecorderService; @@ -69,23 +83,8 @@ import io.cryostat.recordings.RecordingTargetHelper; import io.cryostat.util.events.Event; import io.cryostat.util.events.EventListener; - import io.vertx.core.Handler; import io.vertx.core.Vertx; -import org.apache.commons.lang3.tuple.Pair; -import org.hamcrest.MatcherAssert; -import org.hamcrest.Matchers; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.InOrder; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.stubbing.Answer; @ExtendWith(MockitoExtension.class) class RuleProcessorTest { @@ -209,7 +208,10 @@ void testSuccessfulRuleActivationWithCredentials() throws Exception { Mockito.verify(recordingOptionsBuilder).maxAge(30); Mockito.verify(recordingOptionsBuilder).maxSize(1234); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); @@ -229,6 +231,7 @@ void testSuccessfulRuleActivationWithCredentials() throws Exception { Mockito.verify(recordingTargetHelper) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), @@ -236,7 +239,7 @@ void testSuccessfulRuleActivationWithCredentials() throws Exception { metadataCaptor.capture(), archiveOnStopCaptor.capture()); - Assertions.assertTrue(restartCaptor.getValue()); +assertEquals("true", restartCaptor.getValue()); ConnectionDescriptor connectionDescriptor = connectionDescriptorCaptor.getValue(); MatcherAssert.assertThat( @@ -462,7 +465,10 @@ public Void answer(InvocationOnMock invocation) throws Throwable { Mockito.verify(recordingOptionsBuilder).maxAge(30); Mockito.verify(recordingOptionsBuilder).maxSize(1234); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); @@ -482,6 +488,7 @@ public Void answer(InvocationOnMock invocation) throws Throwable { Mockito.verify(recordingTargetHelper) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), @@ -489,7 +496,7 @@ public Void answer(InvocationOnMock invocation) throws Throwable { metadataCaptor.capture(), archiveOnStopCaptor.capture()); - Assertions.assertTrue(restartCaptor.getValue()); + assertEquals("true", restartCaptor.getValue()); IConstrainedMap actualRecordingOptions = recordingOptionsCaptor.getValue(); MatcherAssert.assertThat(actualRecordingOptions, Matchers.sameInstance(recordingOptions)); @@ -530,7 +537,10 @@ void testSuccessfulRuleNonActivationWithCredentials() throws Exception { Mockito.verify(recordingOptionsBuilder, never()).name("auto_Test_Rule"); - ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(Boolean.class); + ArgumentCaptor restartCaptor = ArgumentCaptor.forClass(String.class); + + ArgumentCaptor replaceCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor connectionDescriptorCaptor = ArgumentCaptor.forClass(ConnectionDescriptor.class); @@ -550,6 +560,7 @@ void testSuccessfulRuleNonActivationWithCredentials() throws Exception { Mockito.verify(recordingTargetHelper, never()) .startRecording( restartCaptor.capture(), + replaceCaptor.capture(), connectionDescriptorCaptor.capture(), recordingOptionsCaptor.capture(), templateNameCaptor.capture(), @@ -558,3 +569,4 @@ void testSuccessfulRuleNonActivationWithCredentials() throws Exception { archiveOnStopCaptor.capture()); } } +// first save \ No newline at end of file