混合使用@ResourceArg时的测试配置

提问者：小点点

混合使用@ResourceArg时的测试配置

TL： DR；当使用不同的@ResourceArg运行测试时，不同测试的配置会被抛出并覆盖其他测试，从而破坏了旨在使用特定配置运行的测试。

因此，我有一个服务，它具有在不同配置设置中运行的测试。目前的主要区别是该服务可以管理自己的身份验证或从外部源（KeyCloak）获取它。

我首先使用测试配置文件来控制它，这似乎工作得很好。不幸的是，为了支持这两种情况，我安装的ResourceLifeycleManager支持设置KeyCloak实例并返回破坏配置以进行自我身份验证的配置值（这主要是因为我还没有发现如何让生命周期管理器自行确定当前运行的配置文件或配置。如果我能做到这一点，我想我会比使用@ResourceArg好得多，所以很想知道我是否错过了一些东西）。

为了弥补这个缺点，我尝试使用@ResourceArg向生命周期管理器传达何时设置外部身份验证。然而，我注意到一些非常奇怪的执行时间，并且最终在我的测试/服务中的配置不是我根据测试类的注释所打算的，很明显生命周期管理器已经设置了外部身份验证。

此外，应该注意的是，我已经对测试进行了排序，这样配置文件和配置文件就不会无序运行；所有不关心的测试都首先运行，然后是使用self auth的“正常”测试，然后是使用外部auth配置文件的测试。当我在intellij中运行时，我可以看到这是正常的，而且我可以看出在测试配置文件之间启动新服务实例所花费的时间。

当我在某些地方抛出断点时，查看日志，一些奇怪的事情是显而易见的：

当错误测试断点时（在外部配置的测试运行之前）

我的TestResourceLifeycleManager的start（）方法被调用了两次

第一次运行以KeyCloak启动运行，将覆盖/破坏配置

虽然我希望需要采取的时间启动密钥斗篷没有发生，有点困惑这里

start（）方法现在已经被调用了4次；对于应用程序的新运行，事情似乎再次以与以前相同的顺序启动

Intellij/Gradle显示日志的方式可能有些奇怪，但我将其解释为：

QUKUS在启动应用程序时由于某种原因启动了LifeycleManager的两个实例，并且一个的配置覆盖了另一个，导致了我的麻烦。
生命周期管理器按预期工作；无论哪种方式配置，它都会适当地启动/不启动keyCloak

在这一点上，我不知道我是否做错了什么，或者是否有bug。

自我验证测试的测试类示例（此（test）配置文件中所有测试的注释相同）：

@Slf4j
@QuarkusTest
@QuarkusTestResource(TestResourceLifecycleManager.class)
@TestHTTPEndpoint(Auth.class)
class AuthTest extends RunningServerTest {

外部身份验证测试的测试类示例（此（externalAuth）配置文件中所有测试的注释相同）：

@Slf4j
@QuarkusTest
@TestProfile(ExternalAuthTestProfile.class)
@QuarkusTestResource(value = TestResourceLifecycleManager.class, initArgs = @ResourceArg(name=TestResourceLifecycleManager.EXTERNAL_AUTH_ARG, value="true"))
@TestHTTPEndpoint(Auth.class)
class AuthExternalTest extends RunningServerTest {

ExternalAuthTestProfile对此进行了扩展，提供了适当的配置文件名称：

public class NonDefaultTestProfile implements QuarkusTestProfile {

    private final String testProfile;
    private final Map<String, String> overrides = new HashMap<>();

    protected NonDefaultTestProfile(String testProfile) {
        this.testProfile = testProfile;
    }

    protected NonDefaultTestProfile(String testProfile, Map<String, String> configOverrides) {
        this(testProfile);
        this.overrides.putAll(configOverrides);
    }

    @Override
    public Map<String, String> getConfigOverrides() {
        return new HashMap<>(this.overrides);
    }

    @Override
    public String getConfigProfile() {
        return testProfile;
    }

    @Override
    public List<TestResourceEntry> testResources() {
        return QuarkusTestProfile.super.testResources();
    }
}

生命周期管理器：

@Slf4j
public class TestResourceLifecycleManager implements QuarkusTestResourceLifecycleManager {
    public static final String EXTERNAL_AUTH_ARG = "externalAuth";

    private static volatile MongodExecutable MONGO_EXE = null;
    private static volatile KeycloakContainer KEYCLOAK_CONTAINER = null;

    private boolean externalAuth = false;

    public synchronized Map<String, String> startKeycloakTestServer() {
        if(!this.externalAuth){
            log.info("No need for keycloak.");
            return Map.of();
        }
        if (KEYCLOAK_CONTAINER != null) {
            log.info("Keycloak already started.");
        } else {
            KEYCLOAK_CONTAINER = new KeycloakContainer()
//              .withEnv("hello","world")
                    .withRealmImportFile("keycloak-realm.json");
            KEYCLOAK_CONTAINER.start();
            log.info(
                    "Test keycloak started at endpoint: {}\tAdmin creds: {}:{}",
                    KEYCLOAK_CONTAINER.getAuthServerUrl(),
                    KEYCLOAK_CONTAINER.getAdminUsername(),
                    KEYCLOAK_CONTAINER.getAdminPassword()
            );

        }
        String clientId;
        String clientSecret;
        String publicKey = "";
        try (
                Keycloak keycloak = KeycloakBuilder.builder()
                        .serverUrl(KEYCLOAK_CONTAINER.getAuthServerUrl())
                        .realm("master")
                        .grantType(OAuth2Constants.PASSWORD)
                        .clientId("admin-cli")
                        .username(KEYCLOAK_CONTAINER.getAdminUsername())
                        .password(KEYCLOAK_CONTAINER.getAdminPassword())
                        .build();
        ) {
            RealmResource appsRealmResource = keycloak.realms().realm("apps");

            ClientRepresentation qmClientResource = appsRealmResource.clients().findByClientId("quartermaster").get(0);

            clientSecret = qmClientResource.getSecret();

            log.info("Got client id \"{}\" with secret: {}", "quartermaster", clientSecret);

            //get private key
            for (KeysMetadataRepresentation.KeyMetadataRepresentation curKey : appsRealmResource.keys().getKeyMetadata().getKeys()) {
                if (!SIG.equals(curKey.getUse())) {
                    continue;
                }
                if (!"RSA".equals(curKey.getType())) {
                    continue;
                }
                String publicKeyTemp = curKey.getPublicKey();
                if (publicKeyTemp == null || publicKeyTemp.isBlank()) {
                    continue;
                }
                publicKey = publicKeyTemp;
                log.info("Found a relevant key for public key use: {} / {}", curKey.getKid(), publicKey);
            }
        }
        // write public key
        // = new File(TestResourceLifecycleManager.class.getResource("/").toURI().toString() + "/security/testKeycloakPublicKey.pem");
        File publicKeyFile;
        try {
            publicKeyFile = File.createTempFile("oqmTestKeycloakPublicKey",".pem");
//            publicKeyFile = new File(TestResourceLifecycleManager.class.getResource("/").toURI().toString().replace("/classes/java/", "/resources/") + "/security/testKeycloakPublicKey.pem");
            log.info("path of public key: {}", publicKeyFile);
//            if(publicKeyFile.createNewFile()){
//                log.info("created new public key file");
//
//            } else {
//                log.info("Public file already exists");
//            }
            try (
                    FileOutputStream os = new FileOutputStream(
                            publicKeyFile
                    );
            ) {
                IOUtils.write(publicKey, os, UTF_8);
            } catch (IOException e) {
                log.error("Failed to write out public key of keycloak: ", e);
                throw new IllegalStateException("Failed to write out public key of keycloak.", e);
            }
        } catch (IOException  e) {
            log.error("Failed to create public key file: ", e);
            throw new IllegalStateException("Failed to create public key file", e);
        }

        String keycloakUrl = KEYCLOAK_CONTAINER.getAuthServerUrl().replace("/auth", "");

        return Map.of(
                "test.keycloak.url", keycloakUrl,
                "test.keycloak.authUrl", KEYCLOAK_CONTAINER.getAuthServerUrl(),
                "test.keycloak.adminName", KEYCLOAK_CONTAINER.getAdminUsername(),
                "test.keycloak.adminPass", KEYCLOAK_CONTAINER.getAdminPassword(),
                //TODO:: add config for server to talk to
                "service.externalAuth.url", keycloakUrl,
                "mp.jwt.verify.publickey.location", publicKeyFile.getAbsolutePath()


        );
    }

    public static synchronized void startMongoTestServer() throws IOException {
        if (MONGO_EXE != null) {
            log.info("Flapdoodle Mongo already started.");
            return;
        }
        Version.Main version = Version.Main.V4_0;
        int port = 27018;
        log.info("Starting Flapdoodle Test Mongo {} on port {}", version, port);
        IMongodConfig config = new MongodConfigBuilder()
                .version(version)
                .net(new Net(port, Network.localhostIsIPv6()))
                .build();
        try {
            MONGO_EXE = MongodStarter.getDefaultInstance().prepare(config);
            MongodProcess process = MONGO_EXE.start();
            if (!process.isProcessRunning()) {
                throw new IOException();
            }
        } catch (Throwable e) {
            log.error("FAILED to start test mongo server: ", e);
            MONGO_EXE = null;
            throw e;
        }
    }

    public static synchronized void stopMongoTestServer() {
        if (MONGO_EXE == null) {
            log.warn("Mongo was not started.");
            return;
        }
        MONGO_EXE.stop();
        MONGO_EXE = null;
    }

    public synchronized static void cleanMongo() throws IOException {
        if (MONGO_EXE == null) {
            log.warn("Mongo was not started.");
            return;
        }

        log.info("Cleaning Mongo of all entries.");
    }


    @Override
    public void init(Map<String, String> initArgs) {
        this.externalAuth = Boolean.parseBoolean(initArgs.getOrDefault(EXTERNAL_AUTH_ARG, Boolean.toString(this.externalAuth)));
    }

    @Override
    public Map<String, String> start() {
        log.info("STARTING test lifecycle resources.");
        Map<String, String> configOverride = new HashMap<>();
        try {
            startMongoTestServer();
        } catch (IOException e) {
            log.error("Unable to start Flapdoodle Mongo server");
        }

        configOverride.putAll(startKeycloakTestServer());

        return configOverride;
    }

    @Override
    public void stop() {
        log.info("STOPPING test lifecycle resources.");
        stopMongoTestServer();
    }
}

该应用程序可以在这里找到：https://github.com/Epic-Breakfast-Productions/OpenQuarterMaster/tree/main/software/open-qm-base-station

测试目前以我描述的方式失败了，所以请随意环顾四周。

请注意，要运行此操作，您需要在https://github.com/Epic-Breakfast-Productions/OpenQuarterMaster/tree/main/software/libs/open-qm-core中运行./gradlew build PublishToMavenLocal以在本地安装依赖项。

Github问题也跟踪这个：https://github.com/quarkusio/quarkus/issues/22025

共1个答案

匿名用户

任何使用@QuarkusTestResource（）而不将限制为true的情况下，都意味着无论注释放置在哪里，都将应用于所有测试。

希望限制ToAnnotatedClass能解决这个问题。


		      
                相关问题
                

																                
					
										   @BeforeClass在ktor测试类中不工作
										   Jest vanilla JavaScript JSDOM刷新失败，切换beforeAll到before每一个后的第二次测试中断
										   使用Junit重新运行失败的测试
										   如何在角单元测试退订功能
										   Maven故障安全测试没有打印任何系统或摘要
										   JUnit测试仅在重命名测试类名时有效
										   我从Maven那里得到一个错误，说“有测试失败”，但我没有写任何测试失败
										   “mvn验证”与“mvn测试”有什么区别？
										   mvn测试vs mvn surefire：测试
										   如何防止Spring Boot将危险控制器包含在生产配置文件中？
										   如何在gradle的测试源代码集中包含所有src/test/资源/**和src/main/java/**/*. html？
										   具有并行性的Circleci-每个容器执行所有测试
										   IntelliJ IDEA运行配置的命令行版本
										   Maven-为什么mvn安装启动编译或测试阶段？
										   JavaFX-测试GridPane单元格是否为空时的InvocationTargetException
										   我想使用HttpClient4来做并发发送请求的RESTfulAPI压力测试，我可以使用一个HttpClient实例吗？
										   如何使用Spring属性配置Spring查找方法
										   Spring JavaConfig-在@Bean注释的配置方法上禁用自动装配
										   在Spring Boot中使用Java配置在bean定义之外别名bean
										   如何热导出ActiveMQ Artemis的配置并热导入？

混合使用@ResourceArg时的测试配置

共1个答案

相关问题

热门标签

微信关注