IntegrationTestBase.java

package dev.fitko.fitconnect.integrationtests;

import com.nimbusds.jose.jwk.JWK;
import dev.fitko.fitconnect.api.config.ApplicationConfig;
import dev.fitko.fitconnect.api.config.Environment;
import dev.fitko.fitconnect.api.config.EnvironmentName;
import dev.fitko.fitconnect.api.config.SenderConfig;
import dev.fitko.fitconnect.api.config.SubscriberConfig;
import dev.fitko.fitconnect.api.config.defaults.Environments;
import dev.fitko.fitconnect.api.domain.model.event.problems.Problem;
import dev.fitko.fitconnect.client.SubscriberClient;
import dev.fitko.fitconnect.client.bootstrap.ClientFactory;

import java.io.IOException;
import java.text.ParseException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import static dev.fitko.fitconnect.api.domain.model.event.problems.Problem.SCHEMA_URL;

public class IntegrationTestBase {

    public static void cleanupTestSubmissions() {

        final UUID destinationId = UUID.fromString(System.getenv("TEST_DESTINATION_ID"));
        final Problem problem = new Problem(SCHEMA_URL + "technical-error", "cleanup", "submission-cleanup", "other");
        final SubscriberClient subscriberClient = ClientFactory.createSubscriberClient(getConfigWithCredentialsFromEnvironment());

        subscriberClient.getAvailableSubmissionsForDestination(destinationId).forEach((s -> {
            try {
                subscriberClient.rejectSubmission(s, List.of(problem));
            } catch (final Exception e) {
                //continue
            }
        }));
    }

    public static ApplicationConfig getConfigWithCredentialsFromEnvironment() {
        return getConfigWithCredentialsFromEnvironment(true, Collections.emptyMap());
    }

    public static ApplicationConfig getConfigWithCredentialsFromEnvironment(final boolean allowInsecurePublicKey) {
        return getConfigWithCredentialsFromEnvironment(allowInsecurePublicKey, Collections.emptyMap());
    }

    public static ApplicationConfig getConfigWithCredentialsFromEnvironment(final boolean allowInsecurePublicKey, final Map<String, String> submissionDataSchemas) {

        final var sender = new SenderConfig(System.getenv("SENDER_CLIENT_ID"), System.getenv("SENDER_CLIENT_SECRET"));

        var signingKey = getKeyAsJWK("/private_test_signing_key.json");
        var decryptionKey = getKeyAsJWK("/private_decryption_test_key.json");

        final var subscriber = SubscriberConfig.builder()
                .clientId(System.getenv("SUBSCRIBER_CLIENT_ID"))
                .clientSecret(System.getenv("SUBSCRIBER_CLIENT_SECRET"))
                .privateDecryptionKeys(List.of(decryptionKey, decryptionKey))
                .privateSigningKey(signingKey)
                .build();

        final EnvironmentName envName = Environments.TEST.getEnvironmentName();
        final Environment env = Environments.TEST.getEnvironment();
        env.setAllowInsecurePublicKey(allowInsecurePublicKey);

        return ApplicationConfig.builder()
                .senderConfig(sender)
                .subscriberConfig(subscriber)
                .environments(Map.of(envName, env))
                .activeEnvironment(envName)
                .submissionDataSchemas(submissionDataSchemas)
                .build();
    }

    private static JWK getKeyAsJWK(String key) {
        try {
            return JWK.parse(getResourceAsString(key));
        } catch (ParseException | IOException e) {
            throw new RuntimeException(e);
        }
    }

    static String getResourceAsString(final String filename) throws IOException {
        return new String(IntegrationTestBase.class.getResourceAsStream(filename).readAllBytes());
    }
}