From 7690928127a82790e947cd1b4c49790fefa0ed07 Mon Sep 17 00:00:00 2001 From: Sarah Bedn Date: Sat, 5 Oct 2024 17:58:55 +0100 Subject: [PATCH] 10 tests --- .../common/CatchingExecutorsTest.java | 72 ++++++++++ .../cryptomator/common/CommonsModuleTest.java | 125 ++++++++++++++++++ .../cryptomator/common/LicenseHolderTest.java | 85 ++++++++++++ .../common/ObservableUtilTest.java | 98 ++++++++++++++ .../cryptomator/common/mount/MounterTest.java | 86 ++++++++++++ .../java/org/cryptomator/ipc/ServerTest.java | 95 +++++++++++++ .../org/cryptomator/launcher/Cryptomator.java | 92 +++++++++++++ .../logging/LogbackConfiguratorTest.java | 66 +++++++++ .../org/cryptomator/ui/common/TasksTest.java | 95 +++++++++++++ .../ui/common/VaultServiceTest.java | 93 +++++++++++++ 10 files changed, 907 insertions(+) create mode 100644 src/test/java/org/cryptomator/common/CatchingExecutorsTest.java create mode 100644 src/test/java/org/cryptomator/common/CommonsModuleTest.java create mode 100644 src/test/java/org/cryptomator/common/LicenseHolderTest.java create mode 100644 src/test/java/org/cryptomator/common/ObservableUtilTest.java create mode 100644 src/test/java/org/cryptomator/common/mount/MounterTest.java create mode 100644 src/test/java/org/cryptomator/ipc/ServerTest.java create mode 100644 src/test/java/org/cryptomator/launcher/Cryptomator.java create mode 100644 src/test/java/org/cryptomator/logging/LogbackConfiguratorTest.java create mode 100644 src/test/java/org/cryptomator/ui/common/TasksTest.java create mode 100644 src/test/java/org/cryptomator/ui/common/VaultServiceTest.java diff --git a/src/test/java/org/cryptomator/common/CatchingExecutorsTest.java b/src/test/java/org/cryptomator/common/CatchingExecutorsTest.java new file mode 100644 index 0000000000..435f46b83f --- /dev/null +++ b/src/test/java/org/cryptomator/common/CatchingExecutorsTest.java @@ -0,0 +1,72 @@ +package org.cryptomator.common; + +import javafx.concurrent.Task; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.concurrent.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class CatchingExecutorsTest { + + private CatchingExecutors.CatchingScheduledThreadPoolExecutor scheduledExecutor; + private CatchingExecutors.CatchingThreadPoolExecutor threadPoolExecutor; + + @BeforeEach + public void setUp() { + scheduledExecutor = new CatchingExecutors.CatchingScheduledThreadPoolExecutor(1, Executors.defaultThreadFactory()); + threadPoolExecutor = new CatchingExecutors.CatchingThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), Executors.defaultThreadFactory()); + } + + @Test + public void testScheduledExecutor_ScheduleAtFixedRate() throws InterruptedException { + // Arrange + Runnable command = mock(Runnable.class); + + // Act + ScheduledFuture future = scheduledExecutor.scheduleAtFixedRate(command, 0, 1, TimeUnit.SECONDS); + Thread.sleep(1500); // Wait for at least one execution + + // Assert + verify(command, atLeastOnce()).run(); + future.cancel(true); + } + + @Test + public void testScheduledExecutor_ScheduleWithFixedDelay() throws InterruptedException { + // Arrange + Runnable command = mock(Runnable.class); + + // Act + ScheduledFuture future = scheduledExecutor.scheduleWithFixedDelay(command, 0, 1, TimeUnit.SECONDS); + Thread.sleep(1500); // Wait for at least one execution + + // Assert + verify(command, atLeastOnce()).run(); + future.cancel(true); + } + + @Test + public void testThreadPoolExecutor_AfterExecute() { + // Arrange + Runnable command = mock(Runnable.class); + + // Act + threadPoolExecutor.execute(command); + + // Assert + verify(command, timeout(1000)).run(); + } + + @Test + public void testAfterExecuteInternal_WithException() { + // Arrange + Runnable command = () -> { throw new RuntimeException("Test Exception"); }; + + // Act & Assert + assertThrows(RuntimeException.class, () -> threadPoolExecutor.execute(command)); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/common/CommonsModuleTest.java b/src/test/java/org/cryptomator/common/CommonsModuleTest.java new file mode 100644 index 0000000000..e12a0a0a6a --- /dev/null +++ b/src/test/java/org/cryptomator/common/CommonsModuleTest.java @@ -0,0 +1,125 @@ +package org.cryptomator.common; + +import org.cryptomator.common.keychain.KeychainModule; +import org.cryptomator.common.mount.MountModule; +import org.cryptomator.common.settings.Settings; +import org.cryptomator.common.settings.SettingsProvider; +import org.cryptomator.common.vaults.VaultComponent; +import org.cryptomator.common.vaults.VaultListModule; +import org.cryptomator.cryptolib.common.MasterkeyFileAccess; +import org.cryptomator.integrations.revealpath.RevealPathService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import javax.inject.Named; +import javax.inject.Singleton; +import java.security.SecureRandom; +import java.util.Comparator; +import java.util.Optional; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.ScheduledExecutorService; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class CommonsModuleTest { + + private SettingsProvider settingsProvider; + private ShutdownHook shutdownHook; + + @BeforeEach + public void setUp() { + settingsProvider = mock(SettingsProvider.class); + shutdownHook = mock(ShutdownHook.class); + } + + @Test + public void testProvideEnvironment() { + // Act + Environment environment = CommonsModule.provideEnvironment(); + + // Assert + assertNotNull(environment); + } + + @Test + public void testProvideLicensePublicKey() { + // Act + String publicKey = CommonsModule.provideLicensePublicKey(); + + // Assert + assertNotNull(publicKey); + assertFalse(publicKey.isEmpty()); + } + + @Test + public void testProvideCSPRNG() { + // Act + SecureRandom csprng = CommonsModule.provideCSPRNG(); + + // Assert + assertNotNull(csprng); + } + + @Test + public void testProvideMasterkeyFileAccess() { + // Arrange + SecureRandom csprng = mock(SecureRandom.class); + + // Act + MasterkeyFileAccess masterkeyFileAccess = CommonsModule.provideMasterkeyFileAccess(csprng); + + // Assert + assertNotNull(masterkeyFileAccess); + } + + @Test + public void testProvidesSemVerComparator() { + // Act + Comparator comparator = CommonsModule.providesSemVerComparator(); + + // Assert + assertNotNull(comparator); + } + + @Test + public void testProvideRevealPathService() { + // Act + Optional revealPathService = CommonsModule.provideRevealPathService(); + + // Assert + assertNotNull(revealPathService); + } + + @Test + public void testProvideSettings() { + // Arrange + Settings settings = mock(Settings.class); + when(settingsProvider.get()).thenReturn(settings); + + // Act + Settings providedSettings = CommonsModule.provideSettings(settingsProvider); + + // Assert + assertEquals(settings, providedSettings); + } + + @Test + public void testProvideScheduledExecutorService() { + // Act + ScheduledExecutorService executorService = CommonsModule.provideScheduledExecutorService(shutdownHook); + + // Assert + assertNotNull(executorService); + } + + @Test + public void testProvideExecutorService() { + // Act + ExecutorService executorService = CommonsModule.provideExecutorService(shutdownHook); + + // Assert + assertNotNull(executorService); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/common/LicenseHolderTest.java b/src/test/java/org/cryptomator/common/LicenseHolderTest.java new file mode 100644 index 0000000000..577886a78f --- /dev/null +++ b/src/test/java/org/cryptomator/common/LicenseHolderTest.java @@ -0,0 +1,85 @@ +package org.cryptomator.common; + +import com.auth0.jwt.interfaces.DecodedJWT; +import javafx.beans.property.SimpleStringProperty; +import org.cryptomator.common.settings.Settings; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class LicenseHolderTest { + + private LicenseChecker licenseChecker; + private Settings settings; + private LicenseHolder licenseHolder; + + @BeforeEach + public void setUp() { + licenseChecker = mock(LicenseChecker.class); + settings = mock(Settings.class); + settings.licenseKey = new SimpleStringProperty(); + licenseHolder = new LicenseHolder(licenseChecker, settings); + } + + @Test + public void testValidateAndStoreLicense_ValidLicense() { + // Arrange + String validLicenseKey = "validKey"; + DecodedJWT decodedJWT = mock(DecodedJWT.class); + when(licenseChecker.check(validLicenseKey)).thenReturn(Optional.of(decodedJWT)); + + // Act + boolean result = licenseHolder.validateAndStoreLicense(validLicenseKey); + + // Assert + assertTrue(result); + assertEquals(validLicenseKey, settings.licenseKey.get()); + assertEquals(Optional.of(decodedJWT.getToken()), licenseHolder.getLicenseKey()); + } + + @Test + public void testValidateAndStoreLicense_InvalidLicense() { + // Arrange + String invalidLicenseKey = "invalidKey"; + when(licenseChecker.check(invalidLicenseKey)).thenReturn(Optional.empty()); + + // Act + boolean result = licenseHolder.validateAndStoreLicense(invalidLicenseKey); + + // Assert + assertFalse(result); + assertNull(settings.licenseKey.get()); + assertEquals(Optional.empty(), licenseHolder.getLicenseKey()); + } + + @Test + public void testLicenseSubjectProperty() { + // Arrange + DecodedJWT decodedJWT = mock(DecodedJWT.class); + when(decodedJWT.getSubject()).thenReturn("subject"); + when(licenseChecker.check(anyString())).thenReturn(Optional.of(decodedJWT)); + licenseHolder.validateAndStoreLicense("validKey"); + + // Act + String subject = licenseHolder.getLicenseSubject(); + + // Assert + assertEquals("subject", subject); + } + + @Test + public void testValidLicenseProperty() { + // Arrange + DecodedJWT decodedJWT = mock(DecodedJWT.class); + when(licenseChecker.check(anyString())).thenReturn(Optional.of(decodedJWT)); + licenseHolder.validateAndStoreLicense("validKey"); + + // Act & Assert + assertTrue(licenseHolder.isValidLicense()); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/common/ObservableUtilTest.java b/src/test/java/org/cryptomator/common/ObservableUtilTest.java new file mode 100644 index 0000000000..b90f22ca8e --- /dev/null +++ b/src/test/java/org/cryptomator/common/ObservableUtilTest.java @@ -0,0 +1,98 @@ +package org.cryptomator.common; + +import javafx.beans.property.SimpleObjectProperty; +import javafx.beans.value.ObservableValue; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.function.Supplier; + +public class ObservableUtilTest { + + @Test + public void testMapWithDefault_NullValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>(null); + Function mapper = String::length; + Integer defaultValue = 0; + + // Act + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValue); + + // Assert + Assertions.assertEquals(defaultValue, result.getValue()); + } + + @Test + public void testMapWithDefault_NonNullValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>("test"); + Function mapper = String::length; + Integer defaultValue = 0; + + // Act + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValue); + + // Assert + Assertions.assertEquals(4, result.getValue()); + } + + @Test + public void testMapWithDefault_Supplier_NullValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>(null); + Function mapper = String::length; + Supplier defaultValueSupplier = () -> 0; + + // Act + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValueSupplier); + + // Assert + Assertions.assertEquals(defaultValueSupplier.get(), result.getValue()); + } + + @Test + public void testMapWithDefault_Supplier_NonNullValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>("test"); + Function mapper = String::length; + Supplier defaultValueSupplier = () -> 0; + + // Act + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValueSupplier); + + // Assert + Assertions.assertEquals(4, result.getValue()); + } + + @Test + public void testMapWithDefault_ChangeObservableValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>("test"); + Function mapper = String::length; + Integer defaultValue = 0; + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValue); + + // Act + observable.set("changed"); + + // Assert + Assertions.assertEquals(7, result.getValue()); + } + + @Test + public void testMapWithDefault_Supplier_ChangeObservableValue() { + // Arrange + SimpleObjectProperty observable = new SimpleObjectProperty<>("test"); + Function mapper = String::length; + Supplier defaultValueSupplier = () -> 0; + ObservableValue result = ObservableUtil.mapWithDefault(observable, mapper, defaultValueSupplier); + + // Act + observable.set("changed"); + + // Assert + Assertions.assertEquals(7, result.getValue()); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/common/mount/MounterTest.java b/src/test/java/org/cryptomator/common/mount/MounterTest.java new file mode 100644 index 0000000000..10b1f49af1 --- /dev/null +++ b/src/test/java/org/cryptomator/common/mount/MounterTest.java @@ -0,0 +1,86 @@ +package org.cryptomator.common.mount; + +import javafx.beans.property.SimpleObjectProperty; +import javafx.beans.value.ObservableValue; +import org.cryptomator.common.Environment; +import org.cryptomator.common.settings.Settings; +import org.cryptomator.common.settings.VaultSettings; +import org.cryptomator.integrations.mount.Mount; +import org.cryptomator.integrations.mount.MountFailedException; +import org.cryptomator.integrations.mount.MountService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class MounterTest { + + private Environment env; + private Settings settings; + private WindowsDriveLetters driveLetters; + private List mountProviders; + private Set usedMountServices; + private ObservableValue defaultMountService; + private Mounter mounter; + + @BeforeEach + public void setUp() { + env = mock(Environment.class); + settings = mock(Settings.class); + driveLetters = mock(WindowsDriveLetters.class); + mountProviders = List.of(mock(MountService.class)); + usedMountServices = Set.of(); + defaultMountService = new SimpleObjectProperty<>(mountProviders.get(0)); + mounter = new Mounter(env, settings, driveLetters, mountProviders, usedMountServices, defaultMountService); + } + + @Test + public void testMountSuccess() throws IOException, MountFailedException { + // Arrange + VaultSettings vaultSettings = mock(VaultSettings.class); + Path cryptoFsRoot = mock(Path.class); + MountService mountService = mountProviders.get(0); + when(mountService.forFileSystem(cryptoFsRoot)).thenReturn(mock(Mount.class)); + + // Act + Mounter.MountHandle handle = mounter.mount(vaultSettings, cryptoFsRoot); + + // Assert + assertNotNull(handle); + } + + @Test + public void testMountConflictingService() { + // Arrange + VaultSettings vaultSettings = mock(VaultSettings.class); + Path cryptoFsRoot = mock(Path.class); + MountService mountService = mountProviders.get(0); + when(mountService.getClass().getName()).thenReturn("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider"); + usedMountServices.add(mountService); + + // Act & Assert + assertThrows(ConflictingMountServiceException.class, () -> mounter.mount(vaultSettings, cryptoFsRoot)); + } + + @Test + public void testIsConflictingMountService() { + // Arrange + MountService mountService = mountProviders.get(0); + when(mountService.getClass().getName()).thenReturn("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider"); + usedMountServices.add(mountService); + + // Act + boolean isConflicting = mounter.isConflictingMountService(mountService); + + // Assert + assertTrue(isConflicting); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/ipc/ServerTest.java b/src/test/java/org/cryptomator/ipc/ServerTest.java new file mode 100644 index 0000000000..2cf76139ba --- /dev/null +++ b/src/test/java/org/cryptomator/ipc/ServerTest.java @@ -0,0 +1,95 @@ +package org.cryptomator.ipc; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.io.IOException; +import java.net.UnixDomainSocketAddress; +import java.nio.channels.ServerSocketChannel; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.concurrent.Executor; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class ServerTest { + + private Path socketPath; + private ServerSocketChannel serverSocketChannel; + private IpcMessageListener listener; + private Executor executor; + + @BeforeEach + public void setUp() throws IOException { + socketPath = Files.createTempFile("test-socket", ".sock"); + serverSocketChannel = mock(ServerSocketChannel.class); + listener = mock(IpcMessageListener.class); + executor = Runnable::run; // Direct executor for testing + } + + @Test + public void testCreateServer() throws IOException { + // Arrange + when(serverSocketChannel.isOpen()).thenReturn(true); + + // Act + Server server = Server.create(socketPath); + + // Assert + assertNotNull(server); + assertTrue(Files.exists(socketPath)); + server.close(); + } + + @Test + public void testIsClient() throws IOException { + // Arrange + Server server = new Server(serverSocketChannel, socketPath); + + // Act & Assert + assertFalse(server.isClient()); + } + + @Test + public void testListen() throws IOException { + // Arrange + Server server = new Server(serverSocketChannel, socketPath); + when(serverSocketChannel.isOpen()).thenReturn(true); + + // Act + server.listen(listener, executor); + + // Assert + verify(listener, never()).handleMessage(any()); + server.close(); + } + + @Test + public void testSend() throws IOException { + // Arrange + Server server = new Server(serverSocketChannel, socketPath); + IpcMessage message = mock(IpcMessage.class); + + // Act + server.send(message, executor); + + // Assert + verify(message, never()).send(any()); + server.close(); + } + + @Test + public void testClose() throws IOException { + // Arrange + Server server = new Server(serverSocketChannel, socketPath); + + // Act + server.close(); + + // Assert + assertFalse(Files.exists(socketPath)); + verify(serverSocketChannel).close(); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/launcher/Cryptomator.java b/src/test/java/org/cryptomator/launcher/Cryptomator.java new file mode 100644 index 0000000000..ccb3799415 --- /dev/null +++ b/src/test/java/org/cryptomator/launcher/Cryptomator.java @@ -0,0 +1,92 @@ +package org.cryptomator.launcher; + +import org.cryptomator.common.Environment; +import org.cryptomator.common.ShutdownHook; +import org.cryptomator.ipc.IpcCommunicator; +import org.cryptomator.logging.DebugMode; +import org.cryptomator.ui.fxapp.FxApplicationComponent; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class CryptomatorTest { + + private DebugMode debugMode; + private SupportedLanguages supportedLanguages; + private Environment env; + private IpcCommunicator ipcCommunicator; + private ShutdownHook shutdownHook; + private Cryptomator cryptomator; + + @BeforeEach + public void setUp() { + debugMode = mock(DebugMode.class); + supportedLanguages = mock(SupportedLanguages.class); + env = mock(Environment.class); + ipcCommunicator = mock(IpcCommunicator.class); + shutdownHook = mock(ShutdownHook.class); + cryptomator = new Cryptomator(debugMode, supportedLanguages, env, () -> ipcCommunicator, shutdownHook); + } + + @Test + public void testRunWithValidArgs() { + // Arrange + String[] args = {"--version"}; + when(env.getAppVersion()).thenReturn("1.0.0"); + + // Act + int exitCode = cryptomator.run(args); + + // Assert + assertEquals(0, exitCode); + verify(ipcCommunicator, never()).sendHandleLaunchargs(any()); + } + + @Test + public void testRunWithInvalidArgs() { + // Arrange + String[] args = {"--invalid"}; + when(ipcCommunicator.isClient()).thenReturn(false); + + // Act + int exitCode = cryptomator.run(args); + + // Assert + assertNotEquals(0, exitCode); + verify(ipcCommunicator).listen(any(), any()); + } + + @Test + public void testRunGuiApplication() { + // Act + int exitCode = cryptomator.runGuiApplication(); + + // Assert + assertEquals(0, exitCode); + } + + @Test + public void testMainAppStart() { + // Arrange + Cryptomator.MainApp mainApp = new Cryptomator.MainApp(); + FxApplicationComponent component = mock(FxApplicationComponent.class); + when(component.application()).thenReturn(mock(FxApplicationComponent.Application.class)); + + // Act & Assert + assertDoesNotThrow(() -> mainApp.start(mock(javafx.stage.Stage.class))); + } + + @Test + public void testMainAppStop() { + // Arrange + Cryptomator.MainApp mainApp = new Cryptomator.MainApp(); + + // Act & Assert + assertDoesNotThrow(mainApp::stop); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/logging/LogbackConfiguratorTest.java b/src/test/java/org/cryptomator/logging/LogbackConfiguratorTest.java new file mode 100644 index 0000000000..dad9dc743c --- /dev/null +++ b/src/test/java/org/cryptomator/logging/LogbackConfiguratorTest.java @@ -0,0 +1,66 @@ +package org.cryptomator.logging; + +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.spi.Configurator.ExecutionStatus; +import org.cryptomator.common.Environment; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.nio.file.Path; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class LogbackConfiguratorTest { + + private LoggerContext context; + private Environment environment; + private LogbackConfigurator configurator; + + @BeforeEach + public void setUp() { + context = new LoggerContext(); + environment = mock(Environment.class); + configurator = new LogbackConfigurator(); + } + + @Test + public void testConfigureWithCustomConfig() { + // Arrange + when(environment.useCustomLogbackConfig()).thenReturn(true); + + // Act + ExecutionStatus status = configurator.configure(context); + + // Assert + assertEquals(ExecutionStatus.DO_NOT_INVOKE_NEXT_IF_ANY, status); + } + + @Test + public void testConfigureWithoutCustomConfig() { + // Arrange + when(environment.useCustomLogbackConfig()).thenReturn(false); + when(environment.getLogDir()).thenReturn(Optional.of(Path.of("logs"))); + + // Act + ExecutionStatus status = configurator.configure(context); + + // Assert + assertEquals(ExecutionStatus.DO_NOT_INVOKE_NEXT_IF_ANY, status); + assertNotNull(context.getLogger("org.cryptomator")); + } + + @Test + public void testSetLogLevels() { + // Arrange + var logLevels = Map.of("org.cryptomator", Level.DEBUG); + + // Act + configurator.setLogLevels(logLevels); + + // Assert + assertEquals(Level.DEBUG, context.getLogger("org.cryptomator").getLevel()); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/ui/common/TasksTest.java b/src/test/java/org/cryptomator/ui/common/TasksTest.java new file mode 100644 index 0000000000..0632b90cdc --- /dev/null +++ b/src/test/java/org/cryptomator/ui/common/TasksTest.java @@ -0,0 +1,95 @@ +package org.cryptomator.ui.common; + +import javafx.concurrent.Task; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.*; + +public class TasksTest { + + private ExecutorService executor; + private ScheduledExecutorService scheduler; + + @BeforeEach + public void setUp() { + executor = Executors.newSingleThreadExecutor(); + scheduler = Executors.newSingleThreadScheduledExecutor(); + } + + @Test + public void testCreateTask_Success() throws Exception { + // Arrange + Tasks.TaskBuilder taskBuilder = Tasks.create(() -> "Success"); + + // Act + Task task = taskBuilder.runOnce(executor); + task.get(); + + // Assert + assertEquals("Success", task.getValue()); + } + + @Test + public void testCreateTask_Failure() { + // Arrange + Tasks.TaskBuilder taskBuilder = Tasks.create(() -> { + throw new RuntimeException("Failure"); + }); + + // Act + Task task = taskBuilder.runOnce(executor); + + // Assert + assertThrows(Exception.class, task::get); + } + + @Test + public void testScheduleTask() throws Exception { + // Arrange + Tasks.TaskBuilder taskBuilder = Tasks.create(() -> "Scheduled"); + + // Act + Task task = taskBuilder.scheduleOnce(scheduler, 1, TimeUnit.SECONDS); + task.get(2, TimeUnit.SECONDS); + + // Assert + assertEquals("Scheduled", task.getValue()); + } + + @Test + public void testOnSuccessHandler() throws Exception { + // Arrange + StringBuilder result = new StringBuilder(); + Tasks.TaskBuilder taskBuilder = Tasks.create(() -> "Success") + .onSuccess(result::append); + + // Act + Task task = taskBuilder.runOnce(executor); + task.get(); + + // Assert + assertEquals("Success", result.toString()); + } + + @Test + public void testOnErrorHandler() { + // Arrange + StringBuilder result = new StringBuilder(); + Tasks.TaskBuilder taskBuilder = Tasks.create(() -> { + throw new RuntimeException("Failure"); + }).onError(RuntimeException.class, e -> result.append(e.getMessage())); + + // Act + Task task = taskBuilder.runOnce(executor); + + // Assert + assertThrows(Exception.class, task::get); + assertEquals("Failure", result.toString()); + } +} \ No newline at end of file diff --git a/src/test/java/org/cryptomator/ui/common/VaultServiceTest.java b/src/test/java/org/cryptomator/ui/common/VaultServiceTest.java new file mode 100644 index 0000000000..065493b5b4 --- /dev/null +++ b/src/test/java/org/cryptomator/ui/common/VaultServiceTest.java @@ -0,0 +1,93 @@ +package org.cryptomator.ui.common; + +import javafx.application.Application; +import javafx.concurrent.Task; +import org.cryptomator.common.vaults.Vault; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Collection; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class VaultServiceTest { + + private VaultService vaultService; + private ExecutorService executorService; + private Application application; + + @BeforeEach + public void setUp() { + executorService = Executors.newSingleThreadExecutor(); + application = mock(Application.class); + vaultService = new VaultService(() -> application, executorService); + } + + @Test + public void testReveal() { + // Arrange + Vault vault = mock(Vault.class); + + // Act + vaultService.reveal(vault); + + // Assert + verify(vault, never()).lock(anyBoolean()); + } + + @Test + public void testLock() { + // Arrange + Vault vault = mock(Vault.class); + + // Act + vaultService.lock(vault, false); + + // Assert + verify(vault, never()).lock(anyBoolean()); + } + + @Test + public void testLockAll() { + // Arrange + Vault vault1 = mock(Vault.class); + Vault vault2 = mock(Vault.class); + Collection vaults = List.of(vault1, vault2); + + // Act + vaultService.lockAll(vaults, false); + + // Assert + verify(vault1, never()).lock(anyBoolean()); + verify(vault2, never()).lock(anyBoolean()); + } + + @Test + public void testCreateRevealTask() { + // Arrange + Vault vault = mock(Vault.class); + + // Act + Task task = vaultService.createRevealTask(vault); + + // Assert + assertNotNull(task); + } + + @Test + public void testCreateLockTask() { + // Arrange + Vault vault = mock(Vault.class); + + // Act + Task task = vaultService.createLockTask(vault, false); + + // Assert + assertNotNull(task); + } +} \ No newline at end of file