Update datasafe-simple-adapter-spring test files to distinguish unit …

…and integration test

datasafe-simple-adapter/datasafe-simple-adapter-spring/src/test/java/de/adorsys/datasafe/simple/adapter/spring/InjectionForMinioIT.java

@@ -0,0 +1,48 @@
+package de.adorsys.datasafe.simple.adapter.spring;
+
+import de.adorsys.datasafe.simple.adapter.api.SimpleDatasafeService;
+import de.adorsys.datasafe.simple.adapter.spring.annotations.UseDatasafeSpringConfiguration;
+import de.adorsys.datasafe.simple.adapter.spring.factory.SpringSimpleDatasafeServiceFactory;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDFSCredentialProperties;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDatasafeEncryptionProperties;
+import de.adorsys.datasafe.teststorage.WithStorageProvider;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.stream.Stream;
+
+
+@Slf4j
+@ActiveProfiles("minio")
+@UseDatasafeSpringConfiguration
+public class InjectionForMinioIT extends InjectionIT {
+
+    @Autowired
+    private SpringDFSCredentialProperties dfsCredentialProperties;
+
+    @Autowired
+    private SpringDatasafeEncryptionProperties encryptionProperties;
+
+    @BeforeAll
+    static void startMinio() {
+        minio().getStorageService().get();
+        System.setProperty("MINIO_URL",  minio().getMappedUrl());
+    }
+
+    private static Stream<StorageDescriptor> minioonly() {
+        return Stream.of(minio());
+    }
+
+    @ParameterizedTest
+    @MethodSource("minioonly")
+    public void plainService(WithStorageProvider.StorageDescriptor descriptor) {
+        log.info("descriptor is " + descriptor.getName());
+        SpringSimpleDatasafeServiceFactory springSimpleDatasafeServiceFactory = new SpringSimpleDatasafeServiceFactory(SpringPropertiesToDFSCredentialsUtil.dfsCredentials(dfsCredentialProperties), encryptionProperties);
+        SimpleDatasafeService service = springSimpleDatasafeServiceFactory.getSimpleDataSafeServiceWithSubdir("subdir");
+        testCreateUser(service);
+    }
+}

datasafe-simple-adapter/datasafe-simple-adapter-spring/src/test/java/de/adorsys/datasafe/simple/adapter/spring/InjectionIT.java

@@ -0,0 +1,116 @@
+package de.adorsys.datasafe.simple.adapter.spring;
+
+import de.adorsys.datasafe.encrypiton.api.types.UserID;
+import de.adorsys.datasafe.encrypiton.api.types.UserIDAuth;
+import de.adorsys.datasafe.simple.adapter.api.SimpleDatasafeService;
+import de.adorsys.datasafe.simple.adapter.api.types.AmazonS3DFSCredentials;
+import de.adorsys.datasafe.simple.adapter.api.types.DFSCredentials;
+import de.adorsys.datasafe.simple.adapter.api.types.DSDocument;
+import de.adorsys.datasafe.simple.adapter.api.types.DocumentContent;
+import de.adorsys.datasafe.simple.adapter.api.types.DocumentFQN;
+import de.adorsys.datasafe.simple.adapter.api.types.FilesystemDFSCredentials;
+import de.adorsys.datasafe.simple.adapter.impl.SimpleDatasafeServiceImpl;
+import de.adorsys.datasafe.simple.adapter.spring.annotations.UseDatasafeSpringConfiguration;
+import de.adorsys.datasafe.teststorage.WithStorageProvider;
+import de.adorsys.datasafe.types.api.resource.AbsoluteLocation;
+import de.adorsys.datasafe.types.api.resource.BasePrivateResource;
+import de.adorsys.datasafe.types.api.resource.PrivateResource;
+import de.adorsys.datasafe.types.api.resource.ResolvedResource;
+import de.adorsys.datasafe.types.api.types.ReadKeyPassword;
+import de.adorsys.datasafe.types.api.utils.ReadKeyPasswordTestFactory;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.Nullable;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.boot.SpringBootConfiguration;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.shaded.org.apache.commons.io.IOUtils;
+
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.net.URI;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@Slf4j
+@SpringBootTest
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration
+@SpringBootConfiguration
+@UseDatasafeSpringConfiguration
+public class InjectionIT extends WithStorageProvider {
+
+    public void testCreateUser(SimpleDatasafeService datasafeService) {
+        assertThat(datasafeService).isNotNull();
+        UserID userid = new UserID("peter");
+        ReadKeyPassword password = ReadKeyPasswordTestFactory.getForString("password");
+        UserIDAuth userIDAuth = new UserIDAuth(userid, password);
+        assertThat(datasafeService.userExists(userid)).isFalse();
+        datasafeService.createUser(userIDAuth);
+        assertThat(datasafeService.userExists(userid)).isTrue();
+        datasafeService.destroyUser(userIDAuth);
+    }
+
+    @SneakyThrows
+    void testWithoutPathEncryption(SimpleDatasafeService simpleDatasafeServiceApi, DFSCredentials dfsCredentials) {
+        if (!(simpleDatasafeServiceApi instanceof SimpleDatasafeServiceImpl)) {
+            throw new TestException("Did expect instance of SimpleDatasafeServiceImpl");
+        }
+        AbsoluteLocation<PrivateResource> rootLocation = getPrivateResourceAbsoluteLocation(dfsCredentials);
+        SimpleDatasafeServiceImpl simpleDatasafeService = (SimpleDatasafeServiceImpl) simpleDatasafeServiceApi;
+
+        UserIDAuth userIDAuth = new UserIDAuth(new UserID("peter"), ReadKeyPasswordTestFactory.getForString("password"));
+        String content = "content of document";
+        String path = "a/b/c.txt";
+        DSDocument document = new DSDocument(new DocumentFQN(path), new DocumentContent(content.getBytes()));
+        simpleDatasafeService.createUser(userIDAuth);
+        simpleDatasafeService.storeDocument(userIDAuth, document);
+
+        try (Stream<AbsoluteLocation<ResolvedResource>> absoluteLocationStream = simpleDatasafeService.getStorageService().list(rootLocation)) {
+            assertEquals(1, absoluteLocationStream.filter(el -> el.location().toASCIIString().contains(path)).count());
+        }
+        try (Stream<AbsoluteLocation<ResolvedResource>> absoluteLocationStream = simpleDatasafeService.getStorageService().list(rootLocation)) {
+            Optional<AbsoluteLocation<ResolvedResource>> first = absoluteLocationStream.filter(el -> el.location().toASCIIString().contains(path)).findFirst();
+            if (!first.isPresent()) {
+                throw new TestException("expeceted absoluteLocatinn stream to have at least one element");
+            }
+
+            try (InputStream read = simpleDatasafeService.getStorageService().read(first.get())) {
+                StringWriter writer = new StringWriter();
+                IOUtils.copy(read, writer, UTF_8);
+                assertFalse(writer.toString().equals(content));
+            }
+        }
+        simpleDatasafeService.destroyUser(userIDAuth);
+    }
+
+    @Nullable
+    @SneakyThrows
+    private AbsoluteLocation<PrivateResource> getPrivateResourceAbsoluteLocation(DFSCredentials dfsCredentials) {
+        if (dfsCredentials instanceof FilesystemDFSCredentials) {
+            String root = ((FilesystemDFSCredentials) dfsCredentials).getRoot();
+            Path listpath = FileSystems.getDefault().getPath(root);
+            return new AbsoluteLocation<>(BasePrivateResource.forPrivate(listpath.toUri()));
+        }
+        if (dfsCredentials instanceof AmazonS3DFSCredentials) {
+            AmazonS3DFSCredentials a = (AmazonS3DFSCredentials) dfsCredentials;
+            return new AbsoluteLocation<>(BasePrivateResource.forPrivate(new URI(a.getUrl() + "/" + a.getRootBucket())));
+        }
+        throw new TestException("NYI");
+    }
+
+    static class TestException extends RuntimeException {
+        public TestException(String message) {
+            super(message);
+        }
+    }
+}

datasafe-simple-adapter/datasafe-simple-adapter-spring/src/test/java/de/adorsys/datasafe/simple/adapter/spring/InjectionWithoutPathEncryptionForFilesystemIT.java

@@ -0,0 +1,42 @@
+package de.adorsys.datasafe.simple.adapter.spring;
+
+import de.adorsys.datasafe.simple.adapter.api.SimpleDatasafeService;
+import de.adorsys.datasafe.simple.adapter.api.types.DFSCredentials;
+import de.adorsys.datasafe.simple.adapter.spring.annotations.UseDatasafeSpringConfiguration;
+import de.adorsys.datasafe.simple.adapter.spring.factory.SpringSimpleDatasafeServiceFactory;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDFSCredentialProperties;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDatasafeEncryptionProperties;
+import de.adorsys.datasafe.teststorage.WithStorageProvider;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.stream.Stream;
+
+@Slf4j
+@ActiveProfiles("fs-withoutPathEncryption")
+@UseDatasafeSpringConfiguration
+public class InjectionWithoutPathEncryptionForFilesystemIT extends InjectionIT {
+    @Autowired
+    private SpringDFSCredentialProperties dfsCredentialProperties;
+
+    @Autowired
+    private SpringDatasafeEncryptionProperties encryptionProperties;
+
+    private static Stream<StorageDescriptor> fsonly() {
+        return Stream.of(fs());
+    }
+
+    @ParameterizedTest
+    @MethodSource("fsonly")
+    public void plainService(WithStorageProvider.StorageDescriptor descriptor) {
+        log.info("descriptor is {}", descriptor.getName());
+        DFSCredentials dfsCredentials = SpringPropertiesToDFSCredentialsUtil.dfsCredentials(dfsCredentialProperties);
+        SpringSimpleDatasafeServiceFactory springSimpleDatasafeServiceFactory = new SpringSimpleDatasafeServiceFactory(dfsCredentials, encryptionProperties);
+        SimpleDatasafeService service = springSimpleDatasafeServiceFactory.getSimpleDataSafeServiceWithSubdir("subdir");
+        testWithoutPathEncryption(service, dfsCredentials);
+    }
+
+}

datasafe-simple-adapter/datasafe-simple-adapter-spring/src/test/java/de/adorsys/datasafe/simple/adapter/spring/InjectionWithoutPathEncryptionForMinioIT.java

@@ -0,0 +1,49 @@
+package de.adorsys.datasafe.simple.adapter.spring;
+
+import de.adorsys.datasafe.simple.adapter.api.SimpleDatasafeService;
+import de.adorsys.datasafe.simple.adapter.api.types.DFSCredentials;
+import de.adorsys.datasafe.simple.adapter.spring.annotations.UseDatasafeSpringConfiguration;
+import de.adorsys.datasafe.simple.adapter.spring.factory.SpringSimpleDatasafeServiceFactory;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDFSCredentialProperties;
+import de.adorsys.datasafe.simple.adapter.spring.properties.SpringDatasafeEncryptionProperties;
+import de.adorsys.datasafe.teststorage.WithStorageProvider;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.stream.Stream;
+
+@Slf4j
+@ActiveProfiles("minio-withoutPathEncryption")
+@UseDatasafeSpringConfiguration
+public class InjectionWithoutPathEncryptionForMinioIT extends InjectionIT {
+    @Autowired
+    private SpringDFSCredentialProperties dfsCredentialProperties;
+
+    @Autowired
+    private SpringDatasafeEncryptionProperties encryptionProperties;
+
+    @BeforeAll
+    static void startMinio() {
+        minio().getStorageService().get();
+        System.setProperty("MINIO_URL", minio().getMappedUrl());
+    }
+
+    private static Stream<WithStorageProvider.StorageDescriptor> minioonly() {
+        return Stream.of(minio());
+    }
+
+    @ParameterizedTest
+    @MethodSource("minioonly")
+    public void plainService(WithStorageProvider.StorageDescriptor descriptor) {
+        log.info("descriptor is {}", descriptor.getName());
+        DFSCredentials dfsCredentials = SpringPropertiesToDFSCredentialsUtil.dfsCredentials(dfsCredentialProperties);
+        SpringSimpleDatasafeServiceFactory springSimpleDatasafeServiceFactory = new SpringSimpleDatasafeServiceFactory(dfsCredentials, encryptionProperties);
+        SimpleDatasafeService service = springSimpleDatasafeServiceFactory.getSimpleDataSafeServiceWithSubdir("subdir");
+        testWithoutPathEncryption(service, dfsCredentials);
+    }
+
+}