From a9536a428f88613810859d4ff1cd28580cb7b692 Mon Sep 17 00:00:00 2001 From: 0xb00bface <0xboobface@gmail.com> Date: Sun, 6 Jun 2021 13:26:59 +0200 Subject: [PATCH] Add tests for RecordingPreconditions --- client/.classpath | 6 +- client/.settings/org.eclipse.jdt.core.prefs | 2 +- common/.classpath | 11 +- .../org.eclipse.core.resources.prefs | 1 + common/pom.xml | 10 - common/src/main/java/ctbrec/Config.java | 3 +- .../ctbrec/recorder/NextGenLocalRecorder.java | 2 +- .../recorder/RecordingPreconditions.java | 9 +- .../sites/xlovecam/XloveCamHttpClient.java | 2 +- common/src/test/java/ctbrec/VersionTest.java | 10 +- .../recorder/RecordingPreconditionsTest.java | 331 ++++++++++++++++++ ...ractPlaceholderAwarePostProcessorTest.java | 34 +- .../postprocessing/AbstractPpTest.java | 11 +- .../recorder/postprocessing/CopyTest.java | 12 +- .../postprocessing/DeleteOriginalTest.java | 12 +- .../postprocessing/DeleteTooShortTest.java | 16 +- .../postprocessing/MoveDirectoryTest.java | 12 +- .../postprocessing/MoveSingleFileTest.java | 14 +- .../postprocessing/RemoveKeepFileTest.java | 10 +- .../postprocessing/RenameDirectoryTest.java | 10 +- .../postprocessing/RenameSingleFileTest.java | 14 +- .../sites/mfc/MyFreeCamsClientTest.java | 5 +- master/pom.xml | 50 ++- server/.classpath | 19 +- server/pom.xml | 15 +- 25 files changed, 485 insertions(+), 136 deletions(-) create mode 100644 common/src/test/java/ctbrec/recorder/RecordingPreconditionsTest.java diff --git a/client/.classpath b/client/.classpath index d8ababe6..34bb78b4 100644 --- a/client/.classpath +++ b/client/.classpath @@ -11,7 +11,11 @@ - + + + + + diff --git a/client/.settings/org.eclipse.jdt.core.prefs b/client/.settings/org.eclipse.jdt.core.prefs index 9729e145..3b784bcd 100644 --- a/client/.settings/org.eclipse.jdt.core.prefs +++ b/client/.settings/org.eclipse.jdt.core.prefs @@ -12,5 +12,5 @@ org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled org.eclipse.jdt.core.compiler.problem.enumIdentifier=error org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning -org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.release=disabled org.eclipse.jdt.core.compiler.source=15 diff --git a/common/.classpath b/common/.classpath index 13fa9dd6..9cdc4d5e 100644 --- a/common/.classpath +++ b/common/.classpath @@ -6,7 +6,11 @@ - + + + + + @@ -19,5 +23,10 @@ + + + + + diff --git a/common/.settings/org.eclipse.core.resources.prefs b/common/.settings/org.eclipse.core.resources.prefs index f9fe3459..839d647e 100644 --- a/common/.settings/org.eclipse.core.resources.prefs +++ b/common/.settings/org.eclipse.core.resources.prefs @@ -1,4 +1,5 @@ eclipse.preferences.version=1 encoding//src/main/java=UTF-8 +encoding//src/main/resources=UTF-8 encoding//src/test/java=UTF-8 encoding/=UTF-8 diff --git a/common/pom.xml b/common/pom.xml index bbbddbbd..ba8d0228 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -70,16 +70,6 @@ 3.1.0 provided - - junit - junit - test - - - org.mockito - mockito-inline - test - javax.xml.bind jaxb-api diff --git a/common/src/main/java/ctbrec/Config.java b/common/src/main/java/ctbrec/Config.java index eb80fa40..fa0f6ebe 100644 --- a/common/src/main/java/ctbrec/Config.java +++ b/common/src/main/java/ctbrec/Config.java @@ -40,6 +40,7 @@ import ctbrec.recorder.postprocessing.Script; import ctbrec.sites.Site; import ctbrec.sites.cam4.Cam4Model; +// TODO don't use singleton pattern public class Config { private static final Logger LOG = LoggerFactory.getLogger(Config.class); @@ -56,7 +57,7 @@ public class Config { private boolean savingDisabled = false; public static final String RECORDING_DATE_FORMAT = "yyyy-MM-dd_HH-mm-ss_SSS"; - private Config(List sites) { + public Config(List sites) { this.sites = sites; if(System.getProperty("ctbrec.config.dir") != null) { configDir = new File(System.getProperty("ctbrec.config.dir")); diff --git a/common/src/main/java/ctbrec/recorder/NextGenLocalRecorder.java b/common/src/main/java/ctbrec/recorder/NextGenLocalRecorder.java index 30f2c79b..b6f2dc4c 100644 --- a/common/src/main/java/ctbrec/recorder/NextGenLocalRecorder.java +++ b/common/src/main/java/ctbrec/recorder/NextGenLocalRecorder.java @@ -287,7 +287,7 @@ public class NextGenLocalRecorder implements Recorder { return CompletableFuture.runAsync(() -> { recorderLock.lock(); try { - preconditions.check(model); + preconditions.check(model, config); LOG.info("Starting recording for model {}", model.getName()); Download download = createDownload(model); Recording rec = createRecording(download); diff --git a/common/src/main/java/ctbrec/recorder/RecordingPreconditions.java b/common/src/main/java/ctbrec/recorder/RecordingPreconditions.java index 94755245..932947e6 100644 --- a/common/src/main/java/ctbrec/recorder/RecordingPreconditions.java +++ b/common/src/main/java/ctbrec/recorder/RecordingPreconditions.java @@ -23,14 +23,17 @@ public class RecordingPreconditions { private static final Logger LOG = LoggerFactory.getLogger(RecordingPreconditions.class); + private Config config; private NextGenLocalRecorder recorder; private long lastPreconditionMessage = 0; + RecordingPreconditions(NextGenLocalRecorder recorder) { this.recorder = recorder; } - void check(Model model) throws IOException, InvalidKeyException, NoSuchAlgorithmException { + void check(Model model, Config config) throws IOException, InvalidKeyException, NoSuchAlgorithmException { + this.config = config; LOG.debug("Checking preconditions for model {}", model); ensureRecorderIsActive(); ensureModelIsNotSuspended(model); @@ -133,7 +136,7 @@ public class RecordingPreconditions { } private boolean downloadSlotAvailable() { - int concurrentRecordings = Config.getInstance().getSettings().concurrentRecordings; + int concurrentRecordings = config.getSettings().concurrentRecordings; return concurrentRecordings == 0 || concurrentRecordings > 0 && recorder.getRecordingProcesses().size() < concurrentRecordings; } @@ -168,7 +171,7 @@ public class RecordingPreconditions { } private Optional getModelForUrl(String modelUrl) { - return Config.getInstance().getSettings().models.stream() + return config.getSettings().models.stream() .filter(m -> Objects.equals(m.getUrl(), modelUrl)) .findFirst(); } diff --git a/common/src/main/java/ctbrec/sites/xlovecam/XloveCamHttpClient.java b/common/src/main/java/ctbrec/sites/xlovecam/XloveCamHttpClient.java index 0485c323..314b6506 100644 --- a/common/src/main/java/ctbrec/sites/xlovecam/XloveCamHttpClient.java +++ b/common/src/main/java/ctbrec/sites/xlovecam/XloveCamHttpClient.java @@ -26,7 +26,7 @@ import okhttp3.Response; public class XloveCamHttpClient extends HttpClient { private static final Logger LOG = LoggerFactory.getLogger(XloveCamHttpClient.class); - private static final Pattern CSRF_PATTERN = Pattern.compile("CSRFToken\s*=\s*\"(.*?)\";"); + private static final Pattern CSRF_PATTERN = Pattern.compile("CSRFToken\\s*=\\s*\"(.*?)\";"); private final Random rng = new Random(); public XloveCamHttpClient() { diff --git a/common/src/test/java/ctbrec/VersionTest.java b/common/src/test/java/ctbrec/VersionTest.java index 340f6978..957c1d91 100644 --- a/common/src/test/java/ctbrec/VersionTest.java +++ b/common/src/test/java/ctbrec/VersionTest.java @@ -1,12 +1,12 @@ package ctbrec; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; -public class VersionTest { +class VersionTest { @Test - public void testOf() { + void testOf() { Version v = Version.of("1.0.0"); assertEquals(1, v.major); assertEquals(0, v.minor); @@ -25,7 +25,7 @@ public class VersionTest { } @Test - public void testCompareTo() { + void testCompareTo() { Version a = Version.of("1.0.0"); Version b = Version.of("1.0.0"); assertEquals(0, a.compareTo(b)); diff --git a/common/src/test/java/ctbrec/recorder/RecordingPreconditionsTest.java b/common/src/test/java/ctbrec/recorder/RecordingPreconditionsTest.java new file mode 100644 index 00000000..021b2a5b --- /dev/null +++ b/common/src/test/java/ctbrec/recorder/RecordingPreconditionsTest.java @@ -0,0 +1,331 @@ +package ctbrec.recorder; + +import static java.time.temporal.ChronoUnit.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +import java.io.IOException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.time.Instant; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; + +import ctbrec.Config; +import ctbrec.Model; +import ctbrec.ModelGroup; +import ctbrec.Recording; +import ctbrec.Settings; +import ctbrec.recorder.download.Download; + +class RecordingPreconditionsTest { + + private Config config; + private Settings settings = new Settings(); + + @BeforeEach + void setup() { + config = mock(Config.class); + when(config.getSettings()).thenReturn(settings); + try (MockedStatic staticConfigMock = mockStatic(Config.class)) { + staticConfigMock.when(Config::getInstance).thenReturn(config); + } + } + + @Test + void testRecorderNotInRecordingMode() throws InvalidKeyException, NoSuchAlgorithmException, IOException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("Recorder is not in recording mode", ex.getMessage()); + } + + @Test + void testModelIsSuspended() throws InvalidKeyException, NoSuchAlgorithmException, IOException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + when(recorder.isRecording()).thenReturn(true); + when(model.isSuspended()).thenReturn(true); + when(model.toString()).thenReturn("Mockita Boobilicious"); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("Recording for model Mockita Boobilicious is suspended", ex.getMessage()); + } + + @Test + void testModelMarkedForLaterRecording() throws InvalidKeyException, NoSuchAlgorithmException, IOException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + when(recorder.isRecording()).thenReturn(true); + when(model.isMarkedForLaterRecording()).thenReturn(true); + when(model.toString()).thenReturn("Mockita Boobilicious"); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("Model Mockita Boobilicious is marked for later recording", ex.getMessage()); + } + + @Test + void testRecordUntil() throws InvalidKeyException, NoSuchAlgorithmException, IOException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + when(recorder.isRecording()).thenReturn(true); + when(model.getRecordUntil()).thenReturn(Instant.now().minus(1, HOURS)); + when(model.toString()).thenReturn("Mockita Boobilicious"); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertTrue(ex.getMessage().contains("Recording expired at ")); + } + + @Test + void testRecordingAlreadyRunning() throws InvalidKeyException, NoSuchAlgorithmException, IOException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + when(recorder.isRecording()).thenReturn(true); + Map recordingProcesses = new HashMap<>(); + recordingProcesses.put(model, new Recording()); + when(recorder.getRecordingProcesses()).thenReturn(recordingProcesses); + when(model.getRecordUntil()).thenReturn(Instant.MAX); + when(model.toString()).thenReturn("Mockita Boobilicious"); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("A recording for model Mockita Boobilicious is already running", ex.getMessage()); + } + + @Test + void testModelShouldBeRecorded() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + Model model = mock(Model.class); + + when(recorder.isRecording()).thenReturn(true); + List modelsToRecord = new LinkedList<>(); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(model.getRecordUntil()).thenReturn(Instant.MAX); + when(model.toString()).thenReturn("Mockita Boobilicious"); + when(model.isOnline(true)).thenReturn(true); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("Model Mockita Boobilicious has been removed. Restarting of recording cancelled.", ex.getMessage()); + + modelsToRecord.add(model); + reset(recorder); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + assertDoesNotThrow(() -> preconditions.check(model, config)); + } + + @Test + void testEnoughSpace() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + Model model = mock(Model.class); + when(model.getRecordUntil()).thenReturn(Instant.MAX); + when(model.toString()).thenReturn("Mockita Boobilicious"); + when(model.isOnline(true)).thenReturn(true); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + modelsToRecord.add(model); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(false); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(model, config)); + assertEquals("Not enough disk space for recording", ex.getMessage()); + } + + @Test + void testNoOtherFromGroupIsRecording() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + Model mockita = mock(Model.class); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.toString()).thenReturn("Mockita Boobilicious"); + when(mockita.isOnline(true)).thenReturn(true); + when(mockita.getUrl()).thenReturn("http://localhost/mockita"); + + Model theOtherOne = mock(Model.class); + when(theOtherOne.getRecordUntil()).thenReturn(Instant.MAX); + when(theOtherOne.toString()).thenReturn("The Other One"); + when(theOtherOne.isOnline(true)).thenReturn(true); + when(theOtherOne.getUrl()).thenReturn("http://localhost/theOtherOne"); + + ModelGroup group = new ModelGroup(); + group.add(theOtherOne); + group.add(mockita); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + settings.models = modelsToRecord; + modelsToRecord.add(theOtherOne); + modelsToRecord.add(mockita); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + when(recorder.getModelGroup(theOtherOne)).thenReturn(Optional.of(group)); + when(recorder.getModelGroup(mockita)).thenReturn(Optional.of(group)); + Map recordingProcesses = new HashMap<>(); + recordingProcesses.put(theOtherOne, new Recording()); + when(recorder.getRecordingProcesses()).thenReturn(recordingProcesses); + + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("The Other One from the same group is already recorded", ex.getMessage()); + } + + @Test + void testModelIsOffline() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + Model mockita = mock(Model.class); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.getName()).thenReturn("Mockita Boobilicious"); + when(mockita.toString()).thenReturn("Mockita Boobilicious"); + when(mockita.isOnline(true)).thenReturn(false); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + settings.models = modelsToRecord; + modelsToRecord.add(mockita); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("Mockita Boobilicious's room is not public", ex.getMessage()); + } + + @Test + void testModelIsOnlineWithExpection() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + Model mockita = mock(Model.class); + when(mockita.isOnline(true)).thenThrow(new IOException("Service unavailable")); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.getName()).thenReturn("Mockita Boobilicious"); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + settings.models = modelsToRecord; + modelsToRecord.add(mockita); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("Mockita Boobilicious's room is not public", ex.getMessage()); + + reset(mockita); + when(mockita.isOnline(true)).thenThrow(new InterruptedException()); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.getName()).thenReturn("Mockita Boobilicious"); + ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("Mockita Boobilicious's room is not public", ex.getMessage()); + } + + @Test + void testDownloadSlotsExhausted() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + settings.concurrentRecordings = 1; + + Model mockita = mock(Model.class); + when(mockita.isOnline(true)).thenReturn(true); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.getName()).thenReturn("Mockita Boobilicious"); + + Model theOtherOne = mock(Model.class); + when(theOtherOne.getRecordUntil()).thenReturn(Instant.MAX); + when(theOtherOne.toString()).thenReturn("The Other One"); + when(theOtherOne.isOnline(true)).thenReturn(true); + when(theOtherOne.getUrl()).thenReturn("http://localhost/theOtherOne"); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + settings.models = modelsToRecord; + modelsToRecord.add(mockita); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + Map recordingProcesses = new HashMap<>(); + recordingProcesses.put(theOtherOne, new Recording()); + when(recorder.getRecordingProcesses()).thenReturn(recordingProcesses); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + PreconditionNotMetException ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("Other models have higher prio, not starting recording for Mockita Boobilicious", ex.getMessage()); + + settings.concurrentRecordings = -1; + ex = assertThrows(PreconditionNotMetException.class, () -> preconditions.check(mockita, config)); + assertEquals("Other models have higher prio, not starting recording for Mockita Boobilicious", ex.getMessage()); + + settings.concurrentRecordings = 0; + assertDoesNotThrow(() -> preconditions.check(mockita, config)); + + settings.concurrentRecordings = 1; + recordingProcesses.clear(); + assertDoesNotThrow(() -> preconditions.check(mockita, config)); + } + + @Test + void testDownloadSlotFreedUp() throws InvalidKeyException, NoSuchAlgorithmException, IOException, ExecutionException, InterruptedException { + settings.concurrentRecordings = 1; + + Model mockita = mock(Model.class); + when(mockita.isOnline(true)).thenReturn(true); + when(mockita.getRecordUntil()).thenReturn(Instant.MAX); + when(mockita.getName()).thenReturn("Mockita Boobilicious"); + when(mockita.getPriority()).thenReturn(100); + + NextGenLocalRecorder recorder = mock(NextGenLocalRecorder.class); + List modelsToRecord = new LinkedList<>(); + settings.models = modelsToRecord; + modelsToRecord.add(mockita); + when(recorder.isRecording()).thenReturn(true); + when(recorder.getModels()).thenReturn(modelsToRecord); + when(recorder.enoughSpaceForRecording()).thenReturn(true); + Map recordingProcesses = new HashMap<>(); + when(recorder.getRecordingProcesses()).thenReturn(recordingProcesses); + + Model theOtherOne = mock(Model.class); + when(theOtherOne.getRecordUntil()).thenReturn(Instant.MAX); + when(theOtherOne.toString()).thenReturn("The Other One"); + when(theOtherOne.isOnline(true)).thenReturn(true); + when(theOtherOne.getUrl()).thenReturn("http://localhost/theOtherOne"); + when(theOtherOne.getPriority()).thenReturn(50); + recordingProcesses.put(theOtherOne, mockRecordingProcess(theOtherOne)); + + Model lowestPrio = mock(Model.class); + when(lowestPrio.getRecordUntil()).thenReturn(Instant.MAX); + when(lowestPrio.toString()).thenReturn("Lowest"); + when(lowestPrio.isOnline(true)).thenReturn(true); + when(lowestPrio.getUrl()).thenReturn("http://localhost/lowest"); + when(lowestPrio.getPriority()).thenReturn(1); + recordingProcesses.put(theOtherOne, mockRecordingProcess(lowestPrio)); + + RecordingPreconditions preconditions = new RecordingPreconditions(recorder); + assertDoesNotThrow(() -> preconditions.check(mockita, config)); + verify(recorder).stopRecordingProcess(lowestPrio); + } + + private Recording mockRecordingProcess(Model model) { + Download download = mock(Download.class); + when(download.getModel()).thenReturn(model); + Recording runningRecording = mock(Recording.class); + when(runningRecording.getDownload()).thenReturn(download); + return runningRecording; + } +} diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPlaceholderAwarePostProcessorTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPlaceholderAwarePostProcessorTest.java index 776f9121..99db4653 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPlaceholderAwarePostProcessorTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPlaceholderAwarePostProcessorTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -10,20 +10,20 @@ import java.time.ZoneOffset; import java.time.format.DateTimeFormatter; import java.util.Locale; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Recording; -public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { +class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { Recording rec; Config config; Move placeHolderAwarePp; @Override - @Before + @BeforeEach public void setup() throws IOException { super.setup(); rec = new Recording(); @@ -37,7 +37,7 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testModelNameReplacement() { + void testModelNameReplacement() { String input = "asdf_${modelName}_asdf"; assertEquals("asdf_Mockita Boobilicious_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); input = "asdf_${modelDisplayName}_asdf"; @@ -47,7 +47,7 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testSiteNameReplacement() { + void testSiteNameReplacement() { String input = "asdf_${siteName}_asdf"; assertEquals("asdf_Chaturbate_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); input = "asdf_${siteSanitizedName}_asdf"; @@ -55,7 +55,7 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testUtcTimeReplacement() { + void testUtcTimeReplacement() { // without user defined pattern String date = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss") .withLocale(Locale.US) @@ -82,7 +82,7 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testLocalTimeReplacement() { + void testLocalTimeReplacement() { String date = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss") .withLocale(Locale.US) .withZone(ZoneId.systemDefault()) @@ -99,44 +99,44 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testEpochReplacement() { + void testEpochReplacement() { long epoch = now.toEpochMilli() / 1000; String input = "asdf_${epochSecond}_asdf"; assertEquals("asdf_" + epoch + "_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testFileSuffixReplacement() { + void testFileSuffixReplacement() { String input = "asdf_${fileSuffix}_asdf"; assertEquals("asdf_ts_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testRecordingsDirReplacement() { + void testRecordingsDirReplacement() { String input = "asdf_${recordingsDir}_asdf"; assertEquals("asdf_" + recDir.toString() + "_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testAbsolutePathReplacement() { + void testAbsolutePathReplacement() { String input = "asdf_${absolutePath}_asdf"; assertEquals("asdf_" + postProcessed.getAbsolutePath().toString() + "_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testAbsoluteParentPathReplacement() { + void testAbsoluteParentPathReplacement() { String input = "asdf_${absoluteParentPath}_asdf"; assertEquals("asdf_" + postProcessed.getParentFile().toString() + "_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testModelNotesReplacement() { + void testModelNotesReplacement() { String input = "asdf_${modelNotes}_asdf"; assertEquals("asdf_tag,_foo,_bar_asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); } @Test - public void testPlaceholderDefaultValues() throws IOException { + void testPlaceholderDefaultValues() throws IOException { String input = "asdf_${modelGroupName?${modelSanitizedName?anonymous}}_asdf"; PostProcessingContext ctx = createPostProcessingContext(rec, null, config); ctx.getRecording().getModel().setName(null); @@ -154,7 +154,7 @@ public class AbstractPlaceholderAwarePostProcessorTest extends AbstractPpTest { } @Test - public void testMissingValueForPlaceholder() throws IOException { + void testMissingValueForPlaceholder() throws IOException { String input = "asdf_${modelNotes}_asdf"; when(config.getModelNotes(any())).thenReturn(null); assertEquals("asdf__asdf", placeHolderAwarePp.fillInPlaceHolders(input, createPostProcessingContext(rec, null, config))); diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPpTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPpTest.java index 3e8c2744..9f29abfc 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPpTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/AbstractPpTest.java @@ -12,8 +12,8 @@ import java.nio.file.Path; import java.time.Instant; import org.apache.commons.io.FileUtils; -import org.junit.After; -import org.junit.Before; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; import org.mockito.MockedStatic; import ctbrec.Config; @@ -37,7 +37,7 @@ public abstract class AbstractPpTest { MockedStatic configStatic; - @Before + @BeforeEach public void setup() throws IOException { baseDir = Files.createTempDirectory("ctbrec_test_"); recDir = baseDir.resolve("recordings"); @@ -52,7 +52,7 @@ public abstract class AbstractPpTest { FileUtils.touch(new File(originalDir, "playlist.m3u8")); } - @After + @AfterEach public void teardown() throws IOException { FileUtils.deleteDirectory(baseDir.toFile()); if (configStatic != null) { @@ -63,7 +63,8 @@ public abstract class AbstractPpTest { Config mockConfig() { Config config = mock(Config.class); - when(config.getSettings()).thenReturn(mockSettings()); + Settings settings = mockSettings(); + when(config.getSettings()).thenReturn(settings); when(config.getModelNotes(any())).thenReturn("tag, foo, bar"); when(config.getConfigDir()).thenReturn(new File(baseDir.toFile(), "config")); configStatic = mockStatic(Config.class); diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/CopyTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/CopyTest.java index 27624a12..6518f64b 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/CopyTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/CopyTest.java @@ -1,18 +1,18 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.io.IOException; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Recording; -public class CopyTest extends AbstractPpTest { +class CopyTest extends AbstractPpTest { @Test - public void testCopySingleFile() throws IOException, InterruptedException { + void testCopySingleFile() throws IOException, InterruptedException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -28,7 +28,7 @@ public class CopyTest extends AbstractPpTest { } @Test - public void testCopyDirectory() throws IOException, InterruptedException { + void testCopyDirectory() throws IOException, InterruptedException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -44,7 +44,7 @@ public class CopyTest extends AbstractPpTest { } @Test - public void testGetName() { + void testGetName() { assertEquals("create a copy", new Copy().getName()); } } diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/DeleteOriginalTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/DeleteOriginalTest.java index 7616c2c9..7a591d64 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/DeleteOriginalTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/DeleteOriginalTest.java @@ -1,19 +1,19 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.io.IOException; import java.nio.file.Files; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Recording; -public class DeleteOriginalTest extends AbstractPpTest { +class DeleteOriginalTest extends AbstractPpTest { @Test - public void testPostProcessWithSingleFile() throws IOException, InterruptedException { + void testPostProcessWithSingleFile() throws IOException, InterruptedException { Recording rec = new Recording(); rec.setModel(mockModel()); rec.setAbsoluteFile(original); @@ -31,7 +31,7 @@ public class DeleteOriginalTest extends AbstractPpTest { } @Test - public void testPostProcessWithDirectory() throws IOException, InterruptedException { + void testPostProcessWithDirectory() throws IOException, InterruptedException { Recording rec = new Recording(); rec.setModel(mockModel()); rec.setAbsoluteFile(originalDir); @@ -50,7 +50,7 @@ public class DeleteOriginalTest extends AbstractPpTest { } @Test - public void testGetName() { + void testGetName() { assertEquals("delete original", new DeleteOriginal().getName()); } diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/DeleteTooShortTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/DeleteTooShortTest.java index 0b11176b..9df0d833 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/DeleteTooShortTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/DeleteTooShortTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -9,7 +9,7 @@ import java.io.IOException; import java.time.Duration; import java.util.Collections; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.MockedStatic; import ctbrec.Config; @@ -18,15 +18,15 @@ import ctbrec.recorder.RecordingManager; import ctbrec.recorder.download.Download; import ctbrec.recorder.download.VideoLengthDetector; -public class DeleteTooShortTest extends AbstractPpTest { +class DeleteTooShortTest extends AbstractPpTest { @Test - public void tooShortSingleFileRecShouldBeDeleted() throws IOException, InterruptedException { + void tooShortSingleFileRecShouldBeDeleted() throws IOException, InterruptedException { testProcess(original); } @Test - public void tooShortDirectoryRecShouldBeDeleted() throws IOException, InterruptedException { + void tooShortDirectoryRecShouldBeDeleted() throws IOException, InterruptedException { testProcess(originalDir); } @@ -52,12 +52,12 @@ public class DeleteTooShortTest extends AbstractPpTest { } @Test - public void testGetName() { + void testGetName() { assertEquals("delete too short", new DeleteTooShort().getName()); } @Test - public void testDisabledWithSingleFile() throws IOException, InterruptedException { + void testDisabledWithSingleFile() throws IOException, InterruptedException { Recording rec = createRec(original); Config config = mockConfig(); RecordingManager recordingManager = new RecordingManager(config, Collections.emptyList()); @@ -74,7 +74,7 @@ public class DeleteTooShortTest extends AbstractPpTest { } @Test - public void longEnoughVideoShouldStay() throws IOException, InterruptedException { + void longEnoughVideoShouldStay() throws IOException, InterruptedException { Recording rec = createRec(original); Config config = mockConfig(); RecordingManager recordingManager = new RecordingManager(config, Collections.emptyList()); diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/MoveDirectoryTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/MoveDirectoryTest.java index 882664ac..3ea2c1d2 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/MoveDirectoryTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/MoveDirectoryTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -10,16 +10,16 @@ import java.nio.file.Files; import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Model; import ctbrec.Recording; -public class MoveDirectoryTest extends AbstractPpTest { +class MoveDirectoryTest extends AbstractPpTest { @Test - public void testOriginalFileReplacement() throws IOException { + void testOriginalFileReplacement() throws IOException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -37,7 +37,7 @@ public class MoveDirectoryTest extends AbstractPpTest { } @Test - public void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { + void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { Model model = mockModel(); Recording rec = mock(Recording.class); when(rec.getModel()).thenReturn(model); @@ -50,6 +50,6 @@ public class MoveDirectoryTest extends AbstractPpTest { Move pp = new Move(); Config config = mockConfig(); pp.getConfig().put(Move.PATH_TEMPLATE, new File(baseDir.toFile(), Move.DEFAULT).getAbsolutePath()); - pp.postprocess(createPostProcessingContext(rec, recordingManager, config)); + assertDoesNotThrow(() -> pp.postprocess(createPostProcessingContext(rec, recordingManager, config))); } } diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/MoveSingleFileTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/MoveSingleFileTest.java index 4758288a..e6cea17b 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/MoveSingleFileTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/MoveSingleFileTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -9,16 +9,16 @@ import java.io.IOException; import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Model; import ctbrec.Recording; -public class MoveSingleFileTest extends AbstractPpTest { +class MoveSingleFileTest extends AbstractPpTest { @Test - public void testOriginalFileReplacement() throws IOException { + void testOriginalFileReplacement() throws IOException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -37,7 +37,7 @@ public class MoveSingleFileTest extends AbstractPpTest { } @Test - public void testEarlyExit() throws IOException { + void testEarlyExit() throws IOException { Model model = mockModel(); Recording rec = mock(Recording.class); when(rec.getModel()).thenReturn(model); @@ -52,7 +52,7 @@ public class MoveSingleFileTest extends AbstractPpTest { } @Test - public void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { + void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { Model model = mockModel(); Recording rec = mock(Recording.class); when(rec.getModel()).thenReturn(model); @@ -67,7 +67,7 @@ public class MoveSingleFileTest extends AbstractPpTest { } @Test - public void testToString() { + void testToString() { Move pp = new Move(); assertEquals("move", pp.toString()); diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/RemoveKeepFileTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/RemoveKeepFileTest.java index a4b342fd..6463f22d 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/RemoveKeepFileTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/RemoveKeepFileTest.java @@ -1,20 +1,20 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.io.IOException; import java.util.Collections; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Recording; import ctbrec.recorder.RecordingManager; -public class RemoveKeepFileTest extends AbstractPpTest { +class RemoveKeepFileTest extends AbstractPpTest { @Test - public void testPostProcessWithSingleFile() throws IOException, InterruptedException { + void testPostProcessWithSingleFile() throws IOException, InterruptedException { Recording rec = new Recording(); rec.setModel(mockModel()); rec.setAbsoluteFile(original); @@ -35,7 +35,7 @@ public class RemoveKeepFileTest extends AbstractPpTest { } @Test - public void testGetName() { + void testGetName() { assertEquals("remove recording, but keep the files", new RemoveKeepFile().getName()); } diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/RenameDirectoryTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/RenameDirectoryTest.java index a8213d81..18f2e760 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/RenameDirectoryTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/RenameDirectoryTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -9,16 +9,16 @@ import java.nio.file.Files; import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Model; import ctbrec.Recording; -public class RenameDirectoryTest extends AbstractPpTest { +class RenameDirectoryTest extends AbstractPpTest { @Test - public void testOriginalFileReplacement() throws IOException { + void testOriginalFileReplacement() throws IOException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -35,7 +35,7 @@ public class RenameDirectoryTest extends AbstractPpTest { } @Test - public void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { + void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { Config config = mockConfig(); Model model = mockModel(); Recording rec = mock(Recording.class); diff --git a/common/src/test/java/ctbrec/recorder/postprocessing/RenameSingleFileTest.java b/common/src/test/java/ctbrec/recorder/postprocessing/RenameSingleFileTest.java index a0f59ff9..b2bc4708 100644 --- a/common/src/test/java/ctbrec/recorder/postprocessing/RenameSingleFileTest.java +++ b/common/src/test/java/ctbrec/recorder/postprocessing/RenameSingleFileTest.java @@ -1,6 +1,6 @@ package ctbrec.recorder.postprocessing; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -8,16 +8,16 @@ import java.io.IOException; import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.Config; import ctbrec.Model; import ctbrec.Recording; -public class RenameSingleFileTest extends AbstractPpTest { +class RenameSingleFileTest extends AbstractPpTest { @Test - public void testOriginalFileReplacement() throws IOException { + void testOriginalFileReplacement() throws IOException { Config config = mockConfig(); Recording rec = new Recording(); rec.setModel(mockModel()); @@ -34,7 +34,7 @@ public class RenameSingleFileTest extends AbstractPpTest { } @Test - public void testEarlyExit() throws IOException { + void testEarlyExit() throws IOException { Config config = mockConfig(); Model model = mockModel(); Recording rec = mock(Recording.class); @@ -49,7 +49,7 @@ public class RenameSingleFileTest extends AbstractPpTest { } @Test - public void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { + void absoluteFileShouldKeepBeingOriginalIfFilesDiffer() throws IOException { Config config = mockConfig(); Model model = mockModel(); Recording rec = mock(Recording.class); @@ -63,7 +63,7 @@ public class RenameSingleFileTest extends AbstractPpTest { } @Test - public void testToString() { + void testToString() { Rename pp = new Rename(); assertEquals("rename", pp.toString()); diff --git a/common/src/test/java/ctbrec/sites/mfc/MyFreeCamsClientTest.java b/common/src/test/java/ctbrec/sites/mfc/MyFreeCamsClientTest.java index 76633e43..37a1b056 100644 --- a/common/src/test/java/ctbrec/sites/mfc/MyFreeCamsClientTest.java +++ b/common/src/test/java/ctbrec/sites/mfc/MyFreeCamsClientTest.java @@ -1,11 +1,12 @@ package ctbrec.sites.mfc; -import static org.junit.Assert.*; + +import static org.junit.jupiter.api.Assertions.*; import java.lang.reflect.InvocationTargetException; import org.json.JSONObject; -import org.junit.Test; +import org.junit.jupiter.api.Test; import ctbrec.ReflectionUtil; import ctbrec.StringUtil; diff --git a/master/pom.xml b/master/pom.xml index 1eb115b0..d1e2d248 100644 --- a/master/pom.xml +++ b/master/pom.xml @@ -1,6 +1,6 @@ + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 ctbrec @@ -17,6 +17,7 @@ UTF-8 17-ea+9 + 5.7.2 @@ -27,12 +28,12 @@ 3.1.0 - org.apache.maven.plugins - maven-surefire-plugin - 2.22.2 - - true - + org.apache.maven.plugins + maven-surefire-plugin + 2.22.2 + + true + @@ -117,15 +118,21 @@ 2.8.0 - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter-api + ${version.junit} + test + + + org.junit.jupiter + junit-jupiter-engine + ${version.junit} test org.mockito mockito-inline - 3.5.11 + 3.11.0 test @@ -145,8 +152,23 @@ - - + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.mockito + mockito-inline + test + + diff --git a/server/.classpath b/server/.classpath index 32579c38..cbb4c58f 100644 --- a/server/.classpath +++ b/server/.classpath @@ -1,28 +1,19 @@ - - - - - - - - - - - - - - + + + + + diff --git a/server/pom.xml b/server/pom.xml index 7ffc3a4d..d0c4d5b0 100644 --- a/server/pom.xml +++ b/server/pom.xml @@ -6,11 +6,11 @@ server - ctbrec - master - 4.3.1 - ../master - + ctbrec + master + 4.3.1 + ../master + 1.8 @@ -96,10 +96,5 @@ 1.2.0 runtime - - junit - junit - test -