quarkus-random-generator/src/main/java/ch/phoenixtechnologies/quarkus/commons/random/UUIDGenerator.java

@@ -5,6 +5,11 @@ import java.util.UUID;
 
 public interface UUIDGenerator {
 
+    UUID NAMESPACE_DNS = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8");
+    UUID NAMESPACE_URL = UUID.fromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8");
+    UUID NAMESPACE_OID = UUID.fromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8");
+    UUID NAMESPACE_X500 = UUID.fromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8");
+
     UUID generateV4();
 
     UUID generateV4(Random random);
@@ -13,4 +18,20 @@ public interface UUIDGenerator {
 
     UUID generateV5(UUID namespace, String name);
 
+    default UUID generateV5WithDNSNamespace(String name) {
+        return generateV5(NAMESPACE_DNS, name);
+    }
+
+    default UUID generateV5WithURLNamespace(String name) {
+        return generateV5(NAMESPACE_URL, name);
+    }
+
+    default UUID generateV5WithOIDNamespace(String name) {
+        return generateV5(NAMESPACE_OID, name);
+    }
+
+    default UUID generateV5WithX500Namespace(String name) {
+        return generateV5(NAMESPACE_X500, name);
+    }
+
 }

quarkus-random-generator/src/test/java/ch/phoenixtechnologies/quarkus/commons/random/RandomProviderImplTest.java

@@ -4,11 +4,19 @@ import io.quarkus.test.junit.QuarkusTest;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.Security;
+
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 @QuarkusTest
+@SuppressWarnings("removal")
 class RandomProviderImplTest {
 
+    public static final String SECURE_RANDOM_STRONG_ALGORITHMS = "securerandom.strongAlgorithms";
+
     @Inject
     RandomProviderImpl provider;
 
@@ -18,4 +26,35 @@ class RandomProviderImplTest {
                 .as("Random instance should not be null")
                 .isNotNull();
     }
+
+    @Test
+    void getWhenNoSuchAlgorithm() {
+        var algo = getSecurityProperty();
+
+        setSecurityProperty("non-existent-algorithm");
+
+        try {
+            assertThatThrownBy(() -> provider.get())
+                    .as("Should throw IllegalStateException when algorithm is not found")
+                    .isInstanceOf(IllegalStateException.class)
+                    .hasMessageContaining("Unable to obtain strong SecureRandom instance");
+        } finally {
+            setSecurityProperty(algo);
+        }
+    }
+
+    private static String getSecurityProperty() {
+        return AccessController.doPrivileged(
+                (PrivilegedAction<String>) () -> Security.getProperty(
+                        SECURE_RANDOM_STRONG_ALGORITHMS));
+    }
+
+    private static void setSecurityProperty(String datum) {
+        AccessController.doPrivileged(
+                (PrivilegedAction<Void>) () -> {
+                    Security.setProperty(
+                            SECURE_RANDOM_STRONG_ALGORITHMS, datum);
+                    return (Void) null;
+                });
+    }
 }

quarkus-random-generator/src/test/java/ch/phoenixtechnologies/quarkus/commons/random/UUIDGeneratorImplTest.java

@@ -3,15 +3,30 @@ package ch.phoenixtechnologies.quarkus.commons.random;
 import io.quarkus.test.junit.QuarkusTest;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.Random;
 import java.util.UUID;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 
 @QuarkusTest
 class UUIDGeneratorImplTest {
 
+    private static final UUID NAMESPACE_DNS = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8");
+    private static final UUID NAMESPACE_URL = UUID.fromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8");
+    private static final UUID NAMESPACE_OID = UUID.fromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8");
+    private static final UUID NAMESPACE_X500 = UUID.fromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8");
+
+    private static final String V5_NAME = "test";
+    private static final UUID EXPECTED_V5_DNS = UUID.fromString("4be0643f-1d98-573b-97cd-ca98a65347dd");
+    private static final UUID EXPECTED_V5_URL = UUID.fromString("da5b8893-d6ca-5c1c-9a9c-91f40a2a3649");
+    private static final UUID EXPECTED_V5_OID = UUID.fromString("b428b5d9-df19-5bb9-a1dc-115e071b836c");
+    private static final UUID EXPECTED_V5_X500 = UUID.fromString("63a3ab2b-61b8-5b04-ae2f-70d3875c6e97");
+
     @Inject
     UUIDGeneratorImpl generator;
 
@@ -35,10 +50,64 @@ class UUIDGeneratorImplTest {
 
     @Test
     void generateV5() {
+        var expected = UUID.fromString("a94a8fe5-ccb1-5ba6-9c4c-0873d391e987");
+
+        var actual = generator.generateV5("test");
+
+        assertThat(actual)
+                .as("Generated UUID should match expected value")
+                .isEqualTo(expected);
+    }
+
+    public static Stream<Arguments> generateV5WithNamespace() {
+        return Stream.of(
+                Arguments.of(NAMESPACE_DNS, V5_NAME, EXPECTED_V5_DNS),
+                Arguments.of(NAMESPACE_URL, V5_NAME, EXPECTED_V5_URL),
+                Arguments.of(NAMESPACE_OID, V5_NAME, EXPECTED_V5_OID),
+                Arguments.of(NAMESPACE_X500, V5_NAME, EXPECTED_V5_X500)
+        );
+    }
+
+    @MethodSource
+    @ParameterizedTest
+    void generateV5WithNamespace(UUID namespace, String name, UUID expected) {
+        var actual = generator.generateV5(namespace, name);
+
+        assertThat(actual)
+                .as("Generated UUID should match expected value")
+                .isEqualTo(expected);
     }
 
     @Test
-    void generateV5WithNamespace() {
+    void generateV5WithDNSNamespace() {
+        var actual = generator.generateV5WithDNSNamespace(V5_NAME);
+
+        assertThat(actual)
+                .as("Generated UUID should match expected value")
+                .isEqualTo(EXPECTED_V5_DNS);
+    }
+
+    @Test
+    void generateV5WithURLNamespace() {
+        var actual = generator.generateV5WithURLNamespace(V5_NAME);
+
+        assertThat(actual)
+                .as("Generated UUID should match expected value")
+                .isEqualTo(EXPECTED_V5_URL);
+    }
+
+    @Test
+    void generateV5WithOIDNamespace() {
+        assertThat(generator.generateV5WithOIDNamespace(V5_NAME))
+                .as("Generated UUID should match expected value")
+                .isEqualTo(EXPECTED_V5_OID);
+    }
+
+    @Test
+    void generateV5WithX500Namespace() {
+        assertThat(generator.generateV5WithX500Namespace(V5_NAME))
+                .as("Generated UUID should match expected value")
+                .isEqualTo(EXPECTED_V5_X500);
     }
 
     private static Random getRandom() {