rename-datasafe-business-integration-test-files-for-clear-separation

datasafe-business/src/test/java/de/adorsys/datasafe/business/impl/e2e/SchemeDelegationIT.java

@@ -1,106 +1,151 @@
 package de.adorsys.datasafe.business.impl.e2e;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import de.adorsys.datasafe.business.impl.service.DaggerDefaultDatasafeServices;
 import de.adorsys.datasafe.business.impl.service.DefaultDatasafeServices;
 import de.adorsys.datasafe.directory.impl.profile.config.DefaultDFSConfig;
 import de.adorsys.datasafe.encrypiton.api.types.UserID;
 import de.adorsys.datasafe.encrypiton.api.types.UserIDAuth;
 import de.adorsys.datasafe.storage.api.SchemeDelegatingStorage;
 import de.adorsys.datasafe.storage.api.StorageService;
+import de.adorsys.datasafe.storage.impl.db.DatabaseConnectionRegistry;
+import de.adorsys.datasafe.storage.impl.db.DatabaseCredentials;
+import de.adorsys.datasafe.storage.impl.db.DatabaseStorageService;
 import de.adorsys.datasafe.storage.impl.fs.FileSystemStorageService;
 import de.adorsys.datasafe.teststorage.WithStorageProvider;
 import de.adorsys.datasafe.types.api.actions.WriteRequest;
 import de.adorsys.datasafe.types.api.resource.AbsoluteLocation;
 import de.adorsys.datasafe.types.api.resource.BasePrivateResource;
+import de.adorsys.datasafe.types.api.resource.ResolvedResource;
 import de.adorsys.datasafe.types.api.resource.Uri;
+import de.adorsys.datasafe.types.api.types.ReadStorePassword;
+import de.adorsys.datasafe.types.api.utils.ReadKeyPasswordTestFactory;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
-import org.testcontainers.shaded.com.google.common.collect.ImmutableMap;
 
 import java.io.OutputStream;
+import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import static de.adorsys.datasafe.types.api.global.PathEncryptionId.AES_SIV;
 import static org.assertj.core.api.Assertions.assertThat;
 
-class SchemeDelegationTest extends WithStorageProvider {
+class SchemeDelegationWithDbTest extends WithStorageProvider {
+
+ private static final Set<String> ALLOWED_TABLES = ImmutableSet.of("users", "private_profiles", "public_profiles");
 
  private Path fsPath;
- private Uri minioPath;
- private StorageService minio;
- private StorageService filesystem;
+ private StorageService db;
  private DefaultDatasafeServices datasafeServices;
 
  @BeforeEach
  void initialize(@TempDir Path tempDir) {
- WithStorageProvider.StorageDescriptor minioDescriptor = minio();
  this.fsPath = tempDir;
- this.minio = minioDescriptor.getStorageService().get();
- this.filesystem = new FileSystemStorageService(tempDir);
- this.minioPath = minioDescriptor.getLocation();
+ StorageService filesystem = new FileSystemStorageService(tempDir);
+ this.db = new DatabaseStorageService(ALLOWED_TABLES, new DatabaseConnectionRegistry(
+ uri -> uri.location().getWrapped().getScheme() + ":" + uri.location().getPath().split("/")[1],
+ ImmutableMap.of("jdbc://localhost:9999", new DatabaseCredentials("sa", "sa")))
+ );
+
  StorageService multiDfs = new SchemeDelegatingStorage(
  ImmutableMap.of(
- "s3", minio,
- "file", filesystem
+ "file", filesystem,
+ "jdbc", db
  )
  );
 
  this.datasafeServices = DaggerDefaultDatasafeServices
  .builder()
- .config(new ProfilesOnFsDataOnMinio(minioPath, tempDir))
+ .config(new ProfilesOnDbDataOnFs(tempDir.toUri(), URI.create("jdbc://localhost:9999/h2:mem:test/")))
  .storage(multiDfs)
  .build();
  }
 
  @Test
  @SneakyThrows
- void testProfileOnFsDataOnMinioWorks() {
- UserIDAuth userJohn = new UserIDAuth("john", "doe");
+ void testProfileOnDbDataOnFsWorks() {
+ UserIDAuth userJohn = new UserIDAuth("john", ReadKeyPasswordTestFactory.getForString("doe"));
 
- // John's profile will be saved to filesystem
+ // John's profile will be saved to Database
  datasafeServices.userProfile().registerUsingDefaults(userJohn);
 
- // But this data - it will be saved to minio
+ // But this data - it will be saved to FS
  try (OutputStream os =
  datasafeServices.privateService().write(WriteRequest.forDefaultPrivate(userJohn, "file.txt"))) {
  os.write("Hello".getBytes());
  }
 
- // Profiles are on FS
- assertThat(Files.walk(fsPath))
- .extracting(it -> fsPath.relativize(it))
- .extracting(Path::toString)
- .containsExactlyInAnyOrder("", "public-john", "private-john");
- // File and keystore/pub keys are on minio
- assertThat(minio.list(new AbsoluteLocation<>(BasePrivateResource.forPrivate(minioPath.resolve("")))))
- .extracting(it -> minioPath.relativize(it.location()))
- .extracting(it -> it.asURI().toString())
- .contains("users/john/private/keystore", "users/john/public/pubkeys")
- .anyMatch(it -> it.startsWith("users/john/private/files/"))
- .hasSize(3);
+ // Profiles are on DB
+ assertThat(listDb("jdbc://localhost:9999/h2:mem:test/private_profiles/"))
+ .containsExactly("jdbc://localhost:9999/h2:mem:test/private_profiles/john");
+ assertThat(listDb("jdbc://localhost:9999/h2:mem:test/public_profiles/"))
+ .containsExactly("jdbc://localhost:9999/h2:mem:test/public_profiles/john");
+
+ Path path = fsPath.resolve(new Uri("users/john/private/files/").resolve(AES_SIV.asUriRoot()).asString());
+ Path encryptedFile = walk(path).get(1);
+ // File and keystore/pub keys are on FS
+ assertThat(walk(fsPath))
+ .extracting(it -> fsPath.toUri().relativize(it.toUri()))
+ .extracting(URI::toString)
+ .containsExactlyInAnyOrder(
+ "",
+ "users/",
+ "users/john/",
+ "users/john/public/",
+ "users/john/public/pubkeys",
+ "users/john/private/",
+ "users/john/private/keystore",
+ "users/john/private/files/",
+ "users/john/private/files/SIV/",
+ fsPath.toUri().relativize(encryptedFile.toUri()).toString()
+ );
+ }
+
+ @SneakyThrows
+ private List<Path> walk(Path at) {
+ try (Stream<Path> ls = Files.walk(at)) {
+ return ls.collect(Collectors.toList());
+ }
+ }
+
+ private List<String> listDb(String path) {
+ try (Stream<AbsoluteLocation<ResolvedResource>> stream = db.list(BasePrivateResource.forAbsolutePrivate(URI.create(path)))){
+ return stream.map(it -> it.location().asURI().toString()).collect(Collectors.toList());
+ }
  }
 
- static class ProfilesOnFsDataOnMinio extends DefaultDFSConfig {
+ static class ProfilesOnDbDataOnFs extends DefaultDFSConfig {
 
- private final Path profilesPath;
+ private final Uri profilesPath;
 
- ProfilesOnFsDataOnMinio(Uri minioBucketPath, Path profilesPath) {
- super(minioBucketPath, "PAZZWORT");
- this.profilesPath = profilesPath;
+ ProfilesOnDbDataOnFs(URI fsPath, URI profilesPath) {
+ super(fsPath, new ReadStorePassword("PAZZWORT"));
+ this.profilesPath = new Uri(profilesPath);
  }
 
  @Override
  public AbsoluteLocation publicProfile(UserID forUser) {
  return new AbsoluteLocation<>(
- BasePrivateResource.forPrivate(profilesPath.resolve("public-" + forUser.getValue()).toUri())
+ BasePrivateResource.forPrivate(
+ profilesPath.resolve("public_profiles/").resolve(forUser.getValue())
+ )
  );
  }
 
  @Override
  public AbsoluteLocation privateProfile(UserID forUser) {
  return new AbsoluteLocation<>(
- BasePrivateResource.forPrivate(profilesPath.resolve("private-" + forUser.getValue()).toUri())
+ BasePrivateResource.forPrivate(
+ profilesPath.resolve("private_profiles/").resolve(forUser.getValue())
+ )
  );
  }
  }