Merge pull request #91 from shift7-ch/86-katta-integration-tests-refactoring-part-2

chenkins · web-flow · commit 72918aecbd96 · 2025-03-25T18:05:37.000+01:00
86 katta integration tests refactoring part 2
diff --git a/hub/src/main/java/cloud/katta/protocols/hub/HubSession.java b/hub/src/main/java/cloud/katta/protocols/hub/HubSession.java
@@ -12,6 +12,7 @@
 import ch.cyberduck.core.ListService;
 import ch.cyberduck.core.LocaleFactory;
 import ch.cyberduck.core.LoginCallback;
+import ch.cyberduck.core.OAuthTokens;
 import ch.cyberduck.core.PasswordStoreFactory;
 import ch.cyberduck.core.Profile;
 import ch.cyberduck.core.ProtocolFactory;
@@ -70,8 +71,7 @@ public class HubSession extends HttpSession<HubApiClient> {
 
     private final HubVaultRegistry registry = new HubVaultRegistry();
 
-    private final HubVaultListService vaults = new HubVaultListService(protocols,
-            this, trust, key, registry, keychain);
+    private HubVaultListService vaults;
 
     /**
      * Interceptor for OpenID connect flow
@@ -150,6 +150,9 @@ public void login(final LoginCallback prompt, final CancelCallback cancel) throw
                     new DeviceKeysServiceImpl(keychain).getOrCreateDeviceKeys(host, setup), setup);
             log.debug("Retrieved user keys {}", userKeys);
             // Ensure vaults are registered
+            final OAuthTokens tokens = new OAuthTokens(credentials.getOauth().getAccessToken(), credentials.getOauth().getRefreshToken(), credentials.getOauth().getExpiryInMilliseconds(),
+                    credentials.getOauth().getIdToken());
+            vaults = new HubVaultListService(protocols, this, trust, key, registry, tokens);
             vaults.list(Home.ROOT, new DisabledListProgressListener());
         }
         catch(SecurityFailure e) {
diff --git a/hub/src/main/java/cloud/katta/protocols/hub/HubVaultListService.java b/hub/src/main/java/cloud/katta/protocols/hub/HubVaultListService.java
@@ -6,7 +6,6 @@
 
 import ch.cyberduck.core.AttributedList;
 import ch.cyberduck.core.Host;
-import ch.cyberduck.core.HostPasswordStore;
 import ch.cyberduck.core.ListProgressListener;
 import ch.cyberduck.core.ListService;
 import ch.cyberduck.core.OAuthTokens;
@@ -56,16 +55,16 @@ public class HubVaultListService implements ListService {
     private final X509TrustManager trust;
     private final X509KeyManager key;
     private final VaultRegistry registry;
-    private final HostPasswordStore keychain;
+    private final OAuthTokens tokens;
 
     public HubVaultListService(final ProtocolFactory protocols, final HubSession session,
-                               final X509TrustManager trust, final X509KeyManager key, final VaultRegistry registry, final HostPasswordStore keychain) {
+                               final X509TrustManager trust, final X509KeyManager key, final VaultRegistry registry, final OAuthTokens tokens) {
         this.protocols = protocols;
         this.session = session;
         this.trust = trust;
         this.key = key;
         this.registry = registry;
-        this.keychain = keychain;
+        this.tokens = tokens;
     }
 
     @Override
@@ -86,10 +85,8 @@ public AttributedList<Path> list(final Path directory, final ListProgressListene
                     // Find storage configuration in vault metadata
                     final VaultServiceImpl vaultService = new VaultServiceImpl(session);
                     final UvfMetadataPayload vaultMetadata = vaultService.getVaultMetadataJWE(vaultDto.getId(), userKeys);
-                    final Host bookmark = vaultService.getStorageBackend(protocols, configDto, vaultDto.getId(), vaultMetadata.storage());
-                    final OAuthTokens tokens = keychain.findOAuthTokens(session.getHost());
-                    log.debug("Use OAuth tokens {} from {}", tokens, session.getHost());
-                    bookmark.getCredentials().withOauth(tokens);
+                    final Host bookmark = vaultService.getStorageBackend(protocols, configDto, vaultDto.getId(),
+                            vaultMetadata.storage(), tokens);
                     log.debug("Configured {} for vault {}", bookmark, vaultDto);
                     final Session<?> storage = SessionFactory.create(bookmark, trust, key);
                     final HubUVFVault vault = new HubUVFVault(storage, new DefaultPathHomeFeature(bookmark).find());
diff --git a/hub/src/main/java/cloud/katta/workflows/CreateVaultService.java b/hub/src/main/java/cloud/katta/workflows/CreateVaultService.java
@@ -10,6 +10,7 @@
 import ch.cyberduck.core.Host;
 import ch.cyberduck.core.HostPasswordStore;
 import ch.cyberduck.core.HostUrlProvider;
+import ch.cyberduck.core.OAuthTokens;
 import ch.cyberduck.core.PasswordStoreFactory;
 import ch.cyberduck.core.Path;
 import ch.cyberduck.core.ProtocolFactory;
@@ -125,18 +126,19 @@ public void createVault(final UserKeys userKeys, final StorageProfileDtoWrapper
                     .region(metadataPayload.storage().getRegion());
             log.debug("Created storage dto {}", storageDto);
 
+            final HostPasswordStore keychain = PasswordStoreFactory.get();
+
+            final OAuthTokens tokens = keychain.findOAuthTokens(hubSession.getHost());
             final Host bookmark = new VaultServiceImpl(vaultResource, storageProfileResource).getStorageBackend(ProtocolFactory.get(),
-                    configResource.apiConfigGet(), vaultDto.getId(), metadataPayload.storage());
+                    configResource.apiConfigGet(), vaultDto.getId(), metadataPayload.storage(), tokens);
             if(storageProfileWrapper.getStsEndpoint() == null) {
                 // permanent: template upload into existing bucket from client (not backend)
-
                 templateUploadService.uploadTemplate(bookmark, metadataPayload, storageDto, hashedRootDirId);
             }
             else {
-                final HostPasswordStore keychain = PasswordStoreFactory.get();
                 // non-permanent: pass STS tokens (restricted by inline policy) to hub backend and have bucket created from there
                 final TemporaryAccessTokens stsTokens = stsInlinePolicyService.getSTSTokensFromAccessTokenWithCreateBucketInlinePolicy(
-                        keychain.findOAuthTokens(hubSession.getHost()).getAccessToken(),
+                        tokens.getAccessToken(),
                         storageProfileWrapper.getStsRoleArnClient(),
                         vaultDto.getId().toString(),
                         storageProfileWrapper.getStsEndpoint(),
diff --git a/hub/src/main/java/cloud/katta/workflows/VaultService.java b/hub/src/main/java/cloud/katta/workflows/VaultService.java
@@ -8,6 +8,7 @@
 
 import java.util.UUID;
 
+import ch.cyberduck.core.OAuthTokens;
 import ch.cyberduck.core.ProtocolFactory;
 
 import cloud.katta.client.ApiException;
@@ -54,5 +55,5 @@ public interface VaultService {
      * @throws AccessException Unsupported backend storage protocol
      * @throws ApiException Server error accessing storage profile
      */
-    Host getStorageBackend(final ProtocolFactory protocols, final ConfigDto configDto, UUID vaultId, VaultMetadataJWEBackendDto metadata) throws AccessException, ApiException;
+    Host getStorageBackend(final ProtocolFactory protocols, final ConfigDto configDto, UUID vaultId, VaultMetadataJWEBackendDto metadata, final OAuthTokens tokens) throws AccessException, ApiException;
 }
diff --git a/hub/src/main/java/cloud/katta/workflows/VaultServiceImpl.java b/hub/src/main/java/cloud/katta/workflows/VaultServiceImpl.java
@@ -4,7 +4,9 @@
 
 package cloud.katta.workflows;
 
+import ch.cyberduck.core.Credentials;
 import ch.cyberduck.core.Host;
+import ch.cyberduck.core.OAuthTokens;
 import ch.cyberduck.core.Profile;
 import ch.cyberduck.core.Protocol;
 import ch.cyberduck.core.ProtocolFactory;
@@ -83,7 +85,7 @@ public UvfAccessTokenPayload getVaultAccessTokenJWE(final UUID vaultId, final Us
     }
 
     @Override
-    public Host getStorageBackend(final ProtocolFactory protocols, final ConfigDto configDto, final UUID vaultId, final VaultMetadataJWEBackendDto vaultMetadata) throws ApiException, AccessException {
+    public Host getStorageBackend(final ProtocolFactory protocols, final ConfigDto configDto, final UUID vaultId, final VaultMetadataJWEBackendDto vaultMetadata, final OAuthTokens tokens) throws ApiException, AccessException {
         if(null == protocols.forName(vaultMetadata.getProvider())) {
             log.debug("Load missing profile {}", vaultMetadata.getProvider());
             final StorageProfileDtoWrapper storageProfile = StorageProfileDtoWrapper.coerce(storageProfileResourceApi
@@ -108,11 +110,13 @@ public Host getStorageBackend(final ProtocolFactory protocols, final ConfigDto c
         log.debug("Configure bookmark for vault {}", vaultMetadata);
         bookmark.setNickname(vaultMetadata.getNickname());
         bookmark.setDefaultPath(vaultMetadata.getDefaultPath());
+        final Credentials credentials = bookmark.getCredentials();
+        credentials.setOauth(tokens);
         if(vaultMetadata.getUsername() != null) {
-            bookmark.getCredentials().setUsername(vaultMetadata.getUsername());
+            credentials.setUsername(vaultMetadata.getUsername());
         }
         if(vaultMetadata.getPassword() != null) {
-            bookmark.getCredentials().setPassword(vaultMetadata.getPassword());
+            credentials.setPassword(vaultMetadata.getPassword());
         }
         if(protocol.getProperties().get(S3_ASSUMEROLE_ROLEARN) != null) {
             bookmark.setProperty(OAUTH_TOKENEXCHANGE_ADDITIONAL_SCOPES, vaultId.toString());
diff --git a/hub/src/test/java/cloud/katta/core/AbstractHubSynchronizeTest.java b/hub/src/test/java/cloud/katta/core/AbstractHubSynchronizeTest.java
@@ -9,6 +9,7 @@
 import ch.cyberduck.core.DisabledConnectionCallback;
 import ch.cyberduck.core.DisabledListProgressListener;
 import ch.cyberduck.core.ListService;
+import ch.cyberduck.core.OAuthTokens;
 import ch.cyberduck.core.Path;
 import ch.cyberduck.core.Session;
 import ch.cyberduck.core.SimplePathPredicate;
@@ -30,12 +31,18 @@
 import ch.cyberduck.core.transfer.TransferItem;
 import ch.cyberduck.core.transfer.TransferStatus;
 
+import cloud.katta.client.api.UsersResourceApi;
+
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.RandomUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.openapitools.jackson.nullable.JsonNullableModule;
 
 import java.io.ByteArrayInputStream;
@@ -71,6 +78,7 @@
 import static cloud.katta.testsetup.HubTestUtilities.getAdminApiClient;
 import static org.junit.jupiter.api.Assertions.*;
 
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public abstract class AbstractHubSynchronizeTest extends AbstractHubTest {
     private static final Logger log = LogManager.getLogger(AbstractHubSynchronizeTest.class.getName());
 
@@ -310,6 +318,22 @@ public void test03AddVault(final HubTestConfig config) throws Exception {
         }
     }
 
+    @ParameterizedTest
+    @MethodSource("arguments")
+    public void test04SetupCode(final HubTestConfig config) throws Exception {
+        final HubSession hubSession = setupConnection(config.setup);
+        assertEquals(OAuthTokens.EMPTY, hubSession.getHost().getCredentials().getOauth());
+        assertEquals(StringUtils.EMPTY, hubSession.getHost().getCredentials().getPassword());
+        final ListService feature = hubSession.getFeature(ListService.class);
+        final AttributedList<Path> vaults = feature.list(Home.ROOT, new DisabledListProgressListener());
+        assertEquals(2, vaults.size());
+        assertEquals(vaults, feature.list(Home.ROOT, new DisabledListProgressListener()));
+        for(Path vault : vaults) {
+            assertTrue(hubSession.getFeature(Find.class).find(vault));
+        }
+        new UsersResourceApi(hubSession.getClient()).apiUsersMeGet(true);
+    }
+
     private static byte @NotNull [] writeRandomFile(final Session<?> session, final Path file, int size) throws BackgroundException, IOException {
         final byte[] content = RandomUtils.nextBytes(size);
         final TransferStatus transferStatus = new TransferStatus().withLength(content.length);
diff --git a/hub/src/test/java/cloud/katta/testsetup/AbstractHubTest.java b/hub/src/test/java/cloud/katta/testsetup/AbstractHubTest.java
@@ -14,7 +14,9 @@
 import ch.cyberduck.core.vault.VaultRegistryFactory;
 import ch.cyberduck.test.VaultTest;
 
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Named;
 import org.junit.jupiter.params.provider.Arguments;
 
@@ -115,8 +117,8 @@ public abstract class AbstractHubTest extends VaultTest {
                 .withDockerConfig(HYBRID_DOCKER_CONFIG);
     }
 
-    @BeforeAll
-    public static void preferences() throws IOException {
+    @BeforeEach
+    public void preferences() throws IOException {
         final Preferences preferences;
         PreferencesFactory.set(preferences = new MemoryPreferences() {
             @Override
@@ -161,6 +163,23 @@ protected static HubSession setupConnection(final HubTestConfig.Setup setup) thr
         assertTrue(factory.forName("s3").isEnabled());
         assertTrue(factory.forType(Protocol.Type.s3).isEnabled());
 
+        final DeviceSetupCallback proxy = deviceSetupCallback(setup);
+        MockableDeviceSetupCallback.setProxy(proxy);
+
+        final Host hub = new HostParser(factory).get(setup.hubURL).withCredentials(new Credentials(setup.userConfig.username, setup.userConfig.password));
+        final HubSession session = (HubSession) SessionFactory.create(hub, new DefaultX509TrustManager(), new DefaultX509KeyManager())
+                .withRegistry(VaultRegistryFactory.get(new DisabledPasswordCallback()));
+        final LoginConnectionService login = new LoginConnectionService(new DisabledLoginCallback(), new DisabledHostKeyCallback(),
+                PasswordStoreFactory.get(), new DisabledProgressListener());
+        login.check(session, new DisabledCancelCallback());
+
+        final BookmarkCollection bookmarks = BookmarkCollection.defaultCollection();
+        bookmarks.add(hub);
+
+        return session;
+    }
+
+    protected static @NotNull DeviceSetupCallback deviceSetupCallback(HubTestConfig.Setup setup) {
         final DeviceSetupCallback proxy = new DeviceSetupCallback() {
             @Override
             public String displayAccountKeyAndAskDeviceName(final Host bookmark, final AccountKeyAndDeviceName accountKeyAndDeviceName) {
@@ -178,19 +197,7 @@ public String generateAccountKey() {
                 return staticSetupCode();
             }
         };
-        MockableDeviceSetupCallback.setProxy(proxy);
-
-        final Host hub = new HostParser(factory).get(setup.hubURL).withCredentials(new Credentials(setup.userConfig.username, setup.userConfig.password));
-        final HubSession session = (HubSession) SessionFactory.create(hub, new DefaultX509TrustManager(), new DefaultX509KeyManager())
-                .withRegistry(VaultRegistryFactory.get(new DisabledPasswordCallback()));
-        final LoginConnectionService login = new LoginConnectionService(new DisabledLoginCallback(), new DisabledHostKeyCallback(),
-                PasswordStoreFactory.get(), new DisabledProgressListener());
-        login.check(session, new DisabledCancelCallback());
-
-        final BookmarkCollection bookmarks = BookmarkCollection.defaultCollection();
-        bookmarks.add(hub);
-
-        return session;
+        return proxy;
     }
 }
 
diff --git a/hub/src/test/java/cloud/katta/workflows/UserKeysServiceImplIT.java b/hub/src/test/java/cloud/katta/workflows/UserKeysServiceImplIT.java
