From a914ef1ec40dc87b8d8ad94628e7181072aa318b Mon Sep 17 00:00:00 2001 From: Rasmus Neikes Date: Sun, 16 Aug 2026 14:24:03 +0200 Subject: [PATCH] spring update 4 --- server/pom.xml | 2 +- .../locqr/server/crypto/SigningService.java | 15 +- .../server/dto/DomainStatusResponse.java | 4 +- .../server/relay/RelayHttpRequestHandler.java | 8 +- .../server/relay/RelayWebSocketHandler.java | 5 +- .../store/RegistrationCertificateStore.java | 10 +- .../java/dev/locqr/server/util/Base64Url.java | 5 - .../locqr/server/RunFlowIntegrationTest.java | 152 +++++++++++------- .../relay/RelaySessionRegistryTest.java | 1 - .../store/InMemoryKeyBundleStoreTest.java | 27 ++-- .../RegistrationCertificateStoreTest.java | 18 +-- 11 files changed, 141 insertions(+), 106 deletions(-) diff --git a/server/pom.xml b/server/pom.xml index d2a4ca8..3e18b74 100644 --- a/server/pom.xml +++ b/server/pom.xml @@ -7,7 +7,7 @@ org.springframework.boot spring-boot-starter-parent - 3.3.4 + 4.1.0 diff --git a/server/src/main/java/dev/locqr/server/crypto/SigningService.java b/server/src/main/java/dev/locqr/server/crypto/SigningService.java index f852899..9301f93 100644 --- a/server/src/main/java/dev/locqr/server/crypto/SigningService.java +++ b/server/src/main/java/dev/locqr/server/crypto/SigningService.java @@ -1,10 +1,11 @@ package dev.locqr.server.crypto; -import com.fasterxml.jackson.databind.ObjectMapper; import dev.locqr.server.config.LocqrProperties; import dev.locqr.server.util.Base64Url; import org.erdtman.jcs.JsonCanonicalizer; import org.springframework.stereotype.Service; +import tools.jackson.databind.ObjectMapper; +import tools.jackson.databind.json.JsonMapper; import java.io.IOException; import java.io.UncheckedIOException; @@ -34,7 +35,7 @@ import java.util.Map; public class SigningService { private final PrivateKey ed25519SecretKey; - private final ObjectMapper objectMapper = new ObjectMapper(); + private final ObjectMapper objectMapper = new JsonMapper(); public SigningService(LocqrProperties properties) { this.ed25519SecretKey = loadEd25519SecretKey(properties.ed25519SecretKeyPath()); @@ -62,8 +63,10 @@ public class SigningService { /** RFC 8785 (JCS) canonicalization — mandatory, no bespoke implementation. */ public byte[] canonicalize(Map payload) { + // writeValueAsString throws the unchecked JacksonException (Jackson 3); only + // JsonCanonicalizer's own IOException (io.github.erdtman, unrelated library) needs catching. + String json = objectMapper.writeValueAsString(payload); try { - String json = objectMapper.writeValueAsString(payload); return new JsonCanonicalizer(json).getEncodedUTF8(); } catch (IOException e) { throw new UncheckedIOException("Failed to JCS-canonicalize signed payload", e); @@ -114,10 +117,6 @@ public class SigningService { } public String toBase64UrlJson(Map envelope) { - try { - return Base64Url.encode(objectMapper.writeValueAsBytes(envelope)); - } catch (IOException e) { - throw new UncheckedIOException(e); - } + return Base64Url.encode(objectMapper.writeValueAsBytes(envelope)); } } diff --git a/server/src/main/java/dev/locqr/server/dto/DomainStatusResponse.java b/server/src/main/java/dev/locqr/server/dto/DomainStatusResponse.java index ea350ca..297b35e 100644 --- a/server/src/main/java/dev/locqr/server/dto/DomainStatusResponse.java +++ b/server/src/main/java/dev/locqr/server/dto/DomainStatusResponse.java @@ -5,5 +5,7 @@ import com.fasterxml.jackson.annotation.JsonProperty; public record DomainStatusResponse(@JsonProperty("status") String status) { public static final String VALID = "valid"; public static final String REJECTED = "rejected"; - public static final String SUSPENDED = "suspended"; + // "suspended" (interfaces.md) is a valid wire value but nothing in the + // current (PoC) scope ever computes it — no account-suspension logic + // exists yet. Add the constant back when that logic is added. } diff --git a/server/src/main/java/dev/locqr/server/relay/RelayHttpRequestHandler.java b/server/src/main/java/dev/locqr/server/relay/RelayHttpRequestHandler.java index f524cb7..362af7b 100644 --- a/server/src/main/java/dev/locqr/server/relay/RelayHttpRequestHandler.java +++ b/server/src/main/java/dev/locqr/server/relay/RelayHttpRequestHandler.java @@ -1,13 +1,15 @@ package dev.locqr.server.relay; -import com.fasterxml.jackson.databind.ObjectMapper; import dev.locqr.server.dto.RelayMessage; import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; +import org.jspecify.annotations.NonNull; import org.springframework.stereotype.Component; import org.springframework.web.HttpRequestHandler; import org.springframework.web.socket.server.support.WebSocketHttpRequestHandler; +import tools.jackson.databind.ObjectMapper; +import tools.jackson.databind.json.JsonMapper; import java.io.IOException; @@ -26,7 +28,7 @@ public class RelayHttpRequestHandler implements HttpRequestHandler { private final WebSocketHttpRequestHandler webSocketHandler; private final RelaySessionRegistry registry; - private final ObjectMapper objectMapper = new ObjectMapper(); + private final ObjectMapper objectMapper = new JsonMapper(); public RelayHttpRequestHandler(RelayWebSocketHandler relayWebSocketHandler, RelaySessionRegistry registry) { this.webSocketHandler = new WebSocketHttpRequestHandler(relayWebSocketHandler); @@ -34,7 +36,7 @@ public class RelayHttpRequestHandler implements HttpRequestHandler { } @Override - public void handleRequest(HttpServletRequest request, HttpServletResponse response) + public void handleRequest(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response) throws ServletException, IOException { switch (request.getMethod()) { case "GET" -> webSocketHandler.handleRequest(request, response); diff --git a/server/src/main/java/dev/locqr/server/relay/RelayWebSocketHandler.java b/server/src/main/java/dev/locqr/server/relay/RelayWebSocketHandler.java index 0c34a99..4d99ee4 100644 --- a/server/src/main/java/dev/locqr/server/relay/RelayWebSocketHandler.java +++ b/server/src/main/java/dev/locqr/server/relay/RelayWebSocketHandler.java @@ -1,5 +1,6 @@ package dev.locqr.server.relay; +import org.jspecify.annotations.NonNull; import org.springframework.stereotype.Component; import org.springframework.web.socket.CloseStatus; import org.springframework.web.socket.WebSocketSession; @@ -24,14 +25,14 @@ public class RelayWebSocketHandler extends TextWebSocketHandler { } @Override - public void afterConnectionEstablished(WebSocketSession session) { + public void afterConnectionEstablished(@NonNull WebSocketSession session) { String runId = runIdFrom(session); session.getAttributes().put(RUN_ID_ATTR, runId); registry.register(runId, session); } @Override - public void afterConnectionClosed(WebSocketSession session, CloseStatus status) { + public void afterConnectionClosed(@NonNull WebSocketSession session, @NonNull CloseStatus status) { String runId = (String) session.getAttributes().get(RUN_ID_ATTR); if (runId != null) { registry.unregister(runId, session); diff --git a/server/src/main/java/dev/locqr/server/store/RegistrationCertificateStore.java b/server/src/main/java/dev/locqr/server/store/RegistrationCertificateStore.java index 6b3045d..212d126 100644 --- a/server/src/main/java/dev/locqr/server/store/RegistrationCertificateStore.java +++ b/server/src/main/java/dev/locqr/server/store/RegistrationCertificateStore.java @@ -24,20 +24,20 @@ public class RegistrationCertificateStore { private static final Logger log = LoggerFactory.getLogger(RegistrationCertificateStore.class); private final String testDomain; - private final Optional cert; + private final String cert; // null if no cert file was found at startup public RegistrationCertificateStore(LocqrProperties properties) { this.testDomain = properties.testDomain(); this.cert = load(properties.registrationCertPath()); } - private static Optional load(String path) { + private static String load(String path) { try { - return Optional.of(Files.readString(Path.of(path)).trim()); + return Files.readString(Path.of(path)).trim(); } catch (IOException e) { log.warn("No registration certificate at {} — GET /domain/registration will 404 " + "until the dev setup script (dev.md) generates it.", path); - return Optional.empty(); + return null; } } @@ -45,6 +45,6 @@ public class RegistrationCertificateStore { if (!testDomain.equals(domain)) { return Optional.empty(); } - return cert; + return Optional.ofNullable(cert); } } diff --git a/server/src/main/java/dev/locqr/server/util/Base64Url.java b/server/src/main/java/dev/locqr/server/util/Base64Url.java index f4f3259..365e091 100644 --- a/server/src/main/java/dev/locqr/server/util/Base64Url.java +++ b/server/src/main/java/dev/locqr/server/util/Base64Url.java @@ -1,6 +1,5 @@ package dev.locqr.server.util; -import java.nio.charset.StandardCharsets; import java.util.Base64; /** @@ -18,8 +17,4 @@ public final class Base64Url { public static byte[] decode(String s) { return Base64.getUrlDecoder().decode(s); } - - public static String encodeUtf8(String s) { - return encode(s.getBytes(StandardCharsets.UTF_8)); - } } diff --git a/server/src/test/java/dev/locqr/server/RunFlowIntegrationTest.java b/server/src/test/java/dev/locqr/server/RunFlowIntegrationTest.java index 8509cf7..7b34b8b 100644 --- a/server/src/test/java/dev/locqr/server/RunFlowIntegrationTest.java +++ b/server/src/test/java/dev/locqr/server/RunFlowIntegrationTest.java @@ -1,20 +1,22 @@ package dev.locqr.server; -import com.fasterxml.jackson.databind.ObjectMapper; import dev.locqr.server.dto.*; import dev.locqr.server.support.TestEd25519Keys; +import org.jspecify.annotations.NonNull; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.boot.test.web.client.TestRestTemplate; import org.springframework.boot.test.web.server.LocalServerPort; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; +import org.springframework.http.MediaType; import org.springframework.test.context.DynamicPropertyRegistry; import org.springframework.test.context.DynamicPropertySource; +import org.springframework.test.web.servlet.client.RestTestClient; import org.springframework.web.socket.TextMessage; import org.springframework.web.socket.WebSocketSession; import org.springframework.web.socket.client.standard.StandardWebSocketClient; import org.springframework.web.socket.handler.TextWebSocketHandler; +import tools.jackson.databind.ObjectMapper; +import tools.jackson.databind.json.JsonMapper; import java.nio.file.Files; import java.nio.file.Path; @@ -32,6 +34,10 @@ import static org.assertj.core.api.Assertions.assertThat; * WebSocket stack rather than by inspecting code. A hermetic, generated * Ed25519 key is used — these tests never depend on the committed * {@code dev/keys/} material, so they're unaffected by dev key rotation. + * + *

Uses {@link RestTestClient} (Spring Framework 7 / Boot 4), not the + * older {@code TestRestTemplate} — that class no longer ships in + * {@code spring-boot-starter-test} as of Boot 4. */ @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) class RunFlowIntegrationTest { @@ -39,10 +45,13 @@ class RunFlowIntegrationTest { @LocalServerPort int port; - @org.springframework.beans.factory.annotation.Autowired - TestRestTemplate restTemplate; + private RestTestClient client; + private final ObjectMapper objectMapper = new JsonMapper(); - private final ObjectMapper objectMapper = new ObjectMapper(); + @BeforeEach + void setUpClient() { + client = RestTestClient.bindToServer().baseUrl("http://localhost:" + port).build(); + } @DynamicPropertySource static void dynamicKeyAndCert(DynamicPropertyRegistry registry) throws Exception { @@ -65,62 +74,82 @@ class RunFlowIntegrationTest { var upload = new RunBundleUploadRequest( runId, "https://test.locqr.dev", randomBase64(32), randomBase64(1184)); - ResponseEntity uploadResponse = - restTemplate.postForEntity("/run/bundle", upload, RunBundleUploadResponse.class); + RunBundleUploadResponse body = client.post().uri("/run/bundle") + .contentType(MediaType.APPLICATION_JSON) + .body(upload) + .exchange() + .expectStatus().isOk() + .expectBody(RunBundleUploadResponse.class) + .returnResult() + .getResponseBody(); - assertThat(uploadResponse.getStatusCode()).isEqualTo(HttpStatus.OK); - RunBundleUploadResponse body = uploadResponse.getBody(); assertThat(body).isNotNull(); assertThat(body.qrTtl()).isEqualTo(90); assertThat(body.maxAutoRefresh()).isEqualTo(3); assertThat(body.pinTtl()).isEqualTo(120); assertThat(body.signedToken()).isNotBlank(); - ResponseEntity firstFetch = - restTemplate.getForEntity("/run/bundle/{runId}", RunBundleFetchResponse.class, runId); - assertThat(firstFetch.getStatusCode()).isEqualTo(HttpStatus.OK); - assertThat(firstFetch.getBody()).isNotNull(); - assertThat(firstFetch.getBody().x25519Pubkey()).isEqualTo(upload.x25519Pubkey()); - assertThat(firstFetch.getBody().kemPubkey()).isEqualTo(upload.kemPubkey()); + RunBundleFetchResponse firstFetch = client.get().uri("/run/bundle/{runId}", runId) + .exchange() + .expectStatus().isOk() + .expectBody(RunBundleFetchResponse.class) + .returnResult() + .getResponseBody(); - ResponseEntity secondFetch = - restTemplate.getForEntity("/run/bundle/{runId}", RunBundleFetchResponse.class, runId); - assertThat(secondFetch.getStatusCode()) - .as("at-most-once: the bundle must be gone after the first fetch") - .isEqualTo(HttpStatus.NOT_FOUND); + assertThat(firstFetch).isNotNull(); + assertThat(firstFetch.x25519Pubkey()).isEqualTo(upload.x25519Pubkey()); + assertThat(firstFetch.kemPubkey()).isEqualTo(upload.kemPubkey()); + + // at-most-once: the bundle must be gone after the first fetch + client.get().uri("/run/bundle/{runId}", runId) + .exchange() + .expectStatus().isNotFound(); } @Test void fetchingAnUnknownRunId_returnsNotFound() { - ResponseEntity response = restTemplate.getForEntity( - "/run/bundle/{runId}", RunBundleFetchResponse.class, "never-uploaded-" + UUID.randomUUID()); - - assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); + client.get().uri("/run/bundle/{runId}", "never-uploaded-" + UUID.randomUUID()) + .exchange() + .expectStatus().isNotFound(); } // --- Domain status / registration (interfaces.md) --- @Test void domainStatus_isValidForTheTestDomain_andRejectedForAnyOther() { - ResponseEntity valid = restTemplate.getForEntity( - "/domain/status?domain={d}", DomainStatusResponse.class, "test.locqr.dev"); - assertThat(valid.getBody().status()).isEqualTo(DomainStatusResponse.VALID); + DomainStatusResponse valid = client.get().uri("/domain/status?domain={d}", "test.locqr.dev") + .exchange() + .expectStatus().isOk() + .expectBody(DomainStatusResponse.class) + .returnResult() + .getResponseBody(); + assertThat(valid).isNotNull(); + assertThat(valid.status()).isEqualTo(DomainStatusResponse.VALID); - ResponseEntity rejected = restTemplate.getForEntity( - "/domain/status?domain={d}", DomainStatusResponse.class, "evil.example.com"); - assertThat(rejected.getBody().status()).isEqualTo(DomainStatusResponse.REJECTED); + DomainStatusResponse rejected = client.get().uri("/domain/status?domain={d}", "evil.example.com") + .exchange() + .expectStatus().isOk() + .expectBody(DomainStatusResponse.class) + .returnResult() + .getResponseBody(); + assertThat(rejected).isNotNull(); + assertThat(rejected.status()).isEqualTo(DomainStatusResponse.REJECTED); } @Test void registration_returnsTheCert_forTheTestDomain_andNotFoundForAnyOther() { - ResponseEntity found = restTemplate.getForEntity( - "/domain/registration?domain={d}", RegistrationResponse.class, "test.locqr.dev"); - assertThat(found.getStatusCode()).isEqualTo(HttpStatus.OK); - assertThat(found.getBody().cert()).isEqualTo("dummy-registration-envelope"); + RegistrationResponse found = client.get().uri("/domain/registration?domain={d}", "test.locqr.dev") + .exchange() + .expectStatus().isOk() + .expectBody(RegistrationResponse.class) + .returnResult() + .getResponseBody(); + assertThat(found).isNotNull(); + assertThat(found.cert()).isEqualTo("dummy-registration-envelope"); - ResponseEntity notFound = restTemplate.getForEntity( - "/domain/registration?domain={d}", RegistrationResponse.class, "evil.example.com"); - assertThat(notFound.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); + client.get().uri("/domain/registration?domain={d}", "evil.example.com") + .exchange() + .expectStatus().isNotFound(); } // --- Security report (interfaces.md) --- @@ -129,9 +158,11 @@ class RunFlowIntegrationTest { void securityReport_isAccepted_unauthenticated() { var report = new SecurityReportRequest(UUID.randomUUID().toString(), "pin_mismatch", 1748390461L); - ResponseEntity response = restTemplate.postForEntity("/security/report", report, Void.class); - - assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + client.post().uri("/security/report") + .contentType(MediaType.APPLICATION_JSON) + .body(report) + .exchange() + .expectStatus().isOk(); } // --- Relay: WebSocket + POST both live at /run/relay/:runId (server/claude.md) --- @@ -149,37 +180,39 @@ class RunFlowIntegrationTest { var buffered = new RelayMessage(RelayMessage.KEM_CIPHERTEXT, "QlVGRkVSRUQ"); // POSTed before any socket is open -> must be buffered, not dropped or rejected. - ResponseEntity bufferedPost = - restTemplate.postForEntity("/run/relay/{runId}", buffered, Void.class, runId); - assertThat(bufferedPost.getStatusCode()).isEqualTo(HttpStatus.OK); + client.post().uri("/run/relay/{runId}", runId) + .contentType(MediaType.APPLICATION_JSON) + .body(buffered) + .exchange() + .expectStatus().isOk(); BlockingQueue received = new LinkedBlockingQueue<>(); - StandardWebSocketClient client = new StandardWebSocketClient(); - WebSocketSession session = client.execute( + StandardWebSocketClient wsClient = new StandardWebSocketClient(); + + try (WebSocketSession session = wsClient.execute( new TextWebSocketHandler() { @Override - protected void handleTextMessage(WebSocketSession s, TextMessage message) { + protected void handleTextMessage(@NonNull WebSocketSession s, @NonNull TextMessage message) { received.add(message.getPayload()); } }, "ws://localhost:{port}/run/relay/{runId}", port, runId) - .get(5, TimeUnit.SECONDS); + .get(5, TimeUnit.SECONDS)) { - try { String flushedJson = received.poll(5, TimeUnit.SECONDS); assertThat(flushedJson).isNotNull(); assertThat(objectMapper.readValue(flushedJson, RelayMessage.class)).isEqualTo(buffered); var live = new RelayMessage(RelayMessage.CREDENTIAL, "TElWRQ"); - ResponseEntity livePost = - restTemplate.postForEntity("/run/relay/{runId}", live, Void.class, runId); - assertThat(livePost.getStatusCode()).isEqualTo(HttpStatus.OK); + client.post().uri("/run/relay/{runId}", runId) + .contentType(MediaType.APPLICATION_JSON) + .body(live) + .exchange() + .expectStatus().isOk(); String liveJson = received.poll(5, TimeUnit.SECONDS); assertThat(liveJson).isNotNull(); assertThat(objectMapper.readValue(liveJson, RelayMessage.class)).isEqualTo(live); - } finally { - session.close(); } } @@ -188,10 +221,11 @@ class RunFlowIntegrationTest { String runId = "ws-it-invalid-" + UUID.randomUUID(); var invalid = new RelayMessage("not_a_real_type", "AAAA"); - ResponseEntity response = - restTemplate.postForEntity("/run/relay/{runId}", invalid, Void.class, runId); - - assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); + client.post().uri("/run/relay/{runId}", runId) + .contentType(MediaType.APPLICATION_JSON) + .body(invalid) + .exchange() + .expectStatus().isBadRequest(); } private static String randomBase64(int numBytes) { diff --git a/server/src/test/java/dev/locqr/server/relay/RelaySessionRegistryTest.java b/server/src/test/java/dev/locqr/server/relay/RelaySessionRegistryTest.java index 7376964..1f72018 100644 --- a/server/src/test/java/dev/locqr/server/relay/RelaySessionRegistryTest.java +++ b/server/src/test/java/dev/locqr/server/relay/RelaySessionRegistryTest.java @@ -9,7 +9,6 @@ import org.springframework.web.socket.WebSocketSession; import java.util.ArrayList; import java.util.List; -import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; diff --git a/server/src/test/java/dev/locqr/server/store/InMemoryKeyBundleStoreTest.java b/server/src/test/java/dev/locqr/server/store/InMemoryKeyBundleStoreTest.java index 58e94ed..f572352 100644 --- a/server/src/test/java/dev/locqr/server/store/InMemoryKeyBundleStoreTest.java +++ b/server/src/test/java/dev/locqr/server/store/InMemoryKeyBundleStoreTest.java @@ -41,29 +41,32 @@ class InMemoryKeyBundleStoreTest { store.put(bundle); int attempts = 50; - var pool = java.util.concurrent.Executors.newFixedThreadPool(attempts); var successes = new java.util.concurrent.atomic.AtomicInteger(); var latch = new java.util.concurrent.CountDownLatch(attempts); - for (int i = 0; i < attempts; i++) { - pool.submit(() -> { - try { - if (store.takeIfPresent(bundle.runId()).isPresent()) { - successes.incrementAndGet(); + try (var pool = java.util.concurrent.Executors.newFixedThreadPool(attempts)) { + for (int i = 0; i < attempts; i++) { + pool.submit(() -> { + try { + if (store.takeIfPresent(bundle.runId()).isPresent()) { + successes.incrementAndGet(); + } + } finally { + latch.countDown(); } - } finally { - latch.countDown(); - } - }); + }); + } + latch.await(); } - latch.await(); - pool.shutdown(); assertThat(successes.get()) .as("ConcurrentHashMap.remove() must be atomic: exactly one concurrent fetch wins") .isEqualTo(1); } + // Only ever called with 60s in this file, so IntelliJ flags the parameter — + // kept anyway, since "an unexpired bundle" is the meaningful concept a + // reader needs, not the literal 60. private static KeyBundle bundleExpiringIn(long seconds) { return new KeyBundle( "run-1", "https://test.locqr.dev", "x25519pub", "kempub", Instant.now().plusSeconds(seconds)); diff --git a/server/src/test/java/dev/locqr/server/store/RegistrationCertificateStoreTest.java b/server/src/test/java/dev/locqr/server/store/RegistrationCertificateStoreTest.java index 6a7a02e..ed6bbe0 100644 --- a/server/src/test/java/dev/locqr/server/store/RegistrationCertificateStoreTest.java +++ b/server/src/test/java/dev/locqr/server/store/RegistrationCertificateStoreTest.java @@ -11,15 +11,16 @@ import static org.assertj.core.api.Assertions.assertThat; class RegistrationCertificateStoreTest { + private static final String TEST_DOMAIN = "test.locqr.dev"; + @Test void certFor_returnsTheFileContents_forTheConfiguredTestDomain(@TempDir Path dir) throws Exception { Path certFile = dir.resolve("test-registration.b64"); Files.writeString(certFile, "dummy-envelope\n"); - RegistrationCertificateStore store = - new RegistrationCertificateStore(properties("test.locqr.dev", certFile.toString())); + RegistrationCertificateStore store = new RegistrationCertificateStore(properties(certFile.toString())); - assertThat(store.certFor("test.locqr.dev")).contains("dummy-envelope"); + assertThat(store.certFor(TEST_DOMAIN)).contains("dummy-envelope"); } @Test @@ -27,8 +28,7 @@ class RegistrationCertificateStoreTest { Path certFile = dir.resolve("test-registration.b64"); Files.writeString(certFile, "dummy-envelope"); - RegistrationCertificateStore store = - new RegistrationCertificateStore(properties("test.locqr.dev", certFile.toString())); + RegistrationCertificateStore store = new RegistrationCertificateStore(properties(certFile.toString())); assertThat(store.certFor("evil.example.com")).isEmpty(); } @@ -36,14 +36,14 @@ class RegistrationCertificateStoreTest { @Test void certFor_isEmpty_whenTheCertFileDoesNotExist_ratherThanThrowingAtStartup() { RegistrationCertificateStore store = - new RegistrationCertificateStore(properties("test.locqr.dev", "/definitely/does/not/exist.b64")); + new RegistrationCertificateStore(properties("/definitely/does/not/exist.b64")); - assertThat(store.certFor("test.locqr.dev")).isEmpty(); + assertThat(store.certFor(TEST_DOMAIN)).isEmpty(); } - private static LocqrProperties properties(String testDomain, String certPath) { + private static LocqrProperties properties(String certPath) { return new LocqrProperties( - testDomain, + TEST_DOMAIN, "unused", certPath, new LocqrProperties.Run(90, 3, 120),