Light, fluffy, and always free - The AWS Local Emulator alternative
fix(elasticache): store the user Engine instead of hardcoding redis (#2331)
soreavis7a4fc45fdf70
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElastiCacheTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElastiCacheTest.javaindex 15c853351f..8b0635c6f7 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElastiCacheTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElastiCacheTest.java@@ -155,6 +155,7 @@ class ElastiCacheTest {assertThat(response.userId()).isEqualTo(userId);assertThat(response.userName()).isEqualTo(userName);+ assertThat(response.engine()).isEqualTo("redis");assertThat(response.authentication().typeAsString()).isEqualTo("password");assertThat(response.authentication().passwordCount()).isEqualTo(1);userCreated = true;@@ -168,7 +169,8 @@ class ElastiCacheTest {var response = elasticache.describeUsers(DescribeUsersRequest.builder().build());assertThat(response.users())- .anyMatch(user -> user.userId().equals(userId) && user.userName().equals(userName));+ .anyMatch(user -> user.userId().equals(userId) && user.userName().equals(userName)+ && "redis".equals(user.engine()));}@Test@@ -271,6 +273,27 @@ class ElastiCacheTest {@Test@Order(11)+ void valkeyUserRoundTripEchoesEngine() {+ String valkeyUserId = TestFixtures.uniqueName("ec-valkey-user");+ var created = elasticache.createUser(CreateUserRequest.builder()+ .userId(valkeyUserId)+ .userName(TestFixtures.uniqueName("ec-valkey-name"))+ .engine("valkey")+ .accessString("on ~* +@all")+ .authenticationMode(AuthenticationMode.builder()+ .type(InputAuthenticationType.NO_PASSWORD_REQUIRED)+ .build())+ .build());+ assertThat(created.engine()).isEqualTo("valkey");++ var deleted = elasticache.deleteUser(DeleteUserRequest.builder()+ .userId(valkeyUserId)+ .build());+ assertThat(deleted.engine()).isEqualTo("valkey");+ }++ @Test+ @Order(12)void deleteReplicationGroupReleasesPortForReuse() {requireGroup();diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.javaindex a06a283ed5..f8d394f007 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java@@ -158,6 +158,7 @@ public class ElastiCacheQueryHandler {String userName = params.getFirst("UserName");String accessString = params.getFirst("AccessString");String authModeType = params.getFirst("AuthenticationMode.Type");+ String engine = params.getFirst("Engine");if (userId == null || userId.isBlank()) {return AwsQueryResponse.error("InvalidParameterValue", "UserId is required.", AwsNamespaces.EC, 400);@@ -178,7 +179,7 @@ public class ElastiCacheQueryHandler {}try {- ElastiCacheUser user = service.createUser(userId, userName, authMode, passwords, accessString);+ ElastiCacheUser user = service.createUser(userId, userName, authMode, passwords, accessString, engine);return Response.ok(AwsQueryResponse.envelope("CreateUser", AwsNamespaces.EC, userXml(user))).build();} catch (AwsException e) {return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.EC, e.getHttpStatus());@@ -187,8 +188,9 @@ public class ElastiCacheQueryHandler {private Response handleDescribeUsers(MultivaluedMap<String, String> params) {String filterId = params.getFirst("UserId");+ String filterEngine = params.getFirst("Engine");try {- Collection<ElastiCacheUser> users = service.listUsers(filterId);+ Collection<ElastiCacheUser> users = service.listUsers(filterId, filterEngine);var xml = new XmlBuilder().start("Users");for (ElastiCacheUser u : users) {xml.start("member").raw(userXml(u)).end("member");@@ -202,12 +204,13 @@ public class ElastiCacheQueryHandler {private Response handleModifyUser(MultivaluedMap<String, String> params) {String userId = params.getFirst("UserId");+ String engine = params.getFirst("Engine");if (userId == null || userId.isBlank()) {return AwsQueryResponse.error("InvalidParameterValue", "UserId is required.", AwsNamespaces.EC, 400);}List<String> passwords = extractMemberList(params, "AuthenticationMode.Passwords.member.");try {- ElastiCacheUser user = service.modifyUser(userId, passwords.isEmpty() ? null : passwords);+ ElastiCacheUser user = service.modifyUser(userId, passwords.isEmpty() ? null : passwords, engine);return Response.ok(AwsQueryResponse.envelope("ModifyUser", AwsNamespaces.EC, userXml(user))).build();} catch (AwsException e) {return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.EC, e.getHttpStatus());@@ -384,7 +387,8 @@ public class ElastiCacheQueryHandler {.elem("Type", authType).elem("PasswordCount", (long) pwCount).end("Authentication")- .elem("Engine", "redis")+ .elem("Engine", u.getEngine())+ // MinimumEngineVersion: the only value AWS documents; no valkey-specific one is published..elem("MinimumEngineVersion", "6.0").start("UserGroupIds").end("UserGroupIds").elem("ARN", AwsArnUtils.Arn.of("elasticache", regionResolver.getDefaultRegion(), regionResolver.getAccountId(), "user:" + u.getUserId()).toString())diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.javaindex 62a16e76d1..0f32d2d7a5 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java@@ -20,6 +20,7 @@ import org.jboss.logging.Logger;import java.time.Instant;import java.util.Collection;import java.util.List;+import java.util.Locale;import java.util.Map;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;@@ -183,17 +184,20 @@ public class ElastiCacheService {}public ElastiCacheUser createUser(String userId, String userName, AuthMode authMode,- List<String> passwords, String accessString) {+ List<String> passwords, String accessString, String engine) {if (users.get(userId).isPresent()) {throw new AwsException("UserAlreadyExistsFault","User " + userId + " already exists.", 400);}+ // Engine is required on AWS, but Floci's CreateUser accepted requests without+ // it, so a missing value keeps the previous implicit redis.+ String normalizedEngine = (engine == null || engine.isBlank()) ? "redis" : normalizeEngine(engine);ElastiCacheUser user = new ElastiCacheUser(userId, userName, authMode,passwords != null ? passwords : List.of(),accessString != null ? accessString : "on ~* +@all",- "active", Instant.now());+ normalizedEngine, "active", Instant.now());users.put(userId, user);LOG.infov("ElastiCache user {0} created with authMode={1}", userId, authMode);@@ -205,21 +209,33 @@ public class ElastiCacheService {new AwsException("UserNotFoundFault", "User " + userId + " not found.", 404));}- public Collection<ElastiCacheUser> listUsers(String filterUserId) {+ public Collection<ElastiCacheUser> listUsers(String filterUserId, String filterEngine) {+ // UserId wins when both filters are sent; AWS documents no interaction between them.if (filterUserId != null && !filterUserId.isBlank()) {return users.get(filterUserId).map(List::of).orElseThrow(() -> new AwsException("UserNotFoundFault","User " + filterUserId + " not found.", 404));}+ if (filterEngine != null && !filterEngine.isBlank()) {+ return users.scan(k -> true).stream()+ .filter(u -> filterEngine.equalsIgnoreCase(u.getEngine()))+ .toList();+ }return users.scan(k -> true);}- public ElastiCacheUser modifyUser(String userId, List<String> passwords) {+ public ElastiCacheUser modifyUser(String userId, List<String> passwords, String engine) {ElastiCacheUser user = getUser(userId);+ // Storage backends hand back the live stored object, so validate everything+ // before the first setter — a rejected request must not leave changes behind.+ String normalizedEngine = (engine == null || engine.isBlank()) ? null : normalizeEngine(engine);if (passwords != null) {user.setPasswords(passwords);}+ if (normalizedEngine != null) {+ user.setEngine(normalizedEngine);+ }users.put(userId, user);return user;}@@ -267,6 +283,16 @@ public class ElastiCacheService {.anyMatch(u -> u.getPasswords() != null && u.getPasswords().contains(password));}+ // AWS allows only redis and valkey.+ private static String normalizeEngine(String engine) {+ String normalized = engine.toLowerCase(Locale.ROOT);+ if (!"redis".equals(normalized) && !"valkey".equals(normalized)) {+ throw new AwsException("InvalidParameterValue",+ "Engine must be 'redis' or 'valkey'.", 400);+ }+ return normalized;+ }+private String resolveEndpointHost() {return config.hostname().orElse("localhost");}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUser.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUser.javaindex 8978af9f8f..9949f06d7b 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUser.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUser.java@@ -13,19 +13,22 @@ public class ElastiCacheUser {private AuthMode authMode;private List<String> passwords;private String accessString;+ // "redis" or "valkey"; the initializer keeps users persisted before this field existed on redis.+ private String engine = "redis";private String status;private Instant createdAt;public ElastiCacheUser() {}public ElastiCacheUser(String userId, String userName, AuthMode authMode,- List<String> passwords, String accessString,+ List<String> passwords, String accessString, String engine,String status, Instant createdAt) {this.userId = userId;this.userName = userName;this.authMode = authMode;this.passwords = passwords;this.accessString = accessString;+ this.engine = engine;this.status = status;this.createdAt = createdAt;}@@ -45,6 +48,9 @@ public class ElastiCacheUser {public String getAccessString() { return accessString; }public void setAccessString(String accessString) { this.accessString = accessString; }+ public String getEngine() { return engine; }+ public void setEngine(String engine) { this.engine = engine; }+public String getStatus() { return status; }public void setStatus(String status) { this.status = status; }diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.javaindex e4d599ca54..35525201fc 100644--- a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java@@ -66,9 +66,9 @@ class ElastiCacheServiceTest {service.createReplicationGroup("grp", "test", AuthMode.PASSWORD, null);service.createUser("default-user-id", "default", AuthMode.PASSWORD,- List.of("default-pass"), "on ~* +@all");+ List.of("default-pass"), "on ~* +@all", null);service.createUser("other-user-id", "other", AuthMode.PASSWORD,- List.of("other-pass"), "on ~* +@all");+ List.of("other-pass"), "on ~* +@all", null);service.modifyReplicationGroup("grp",List.of("default-user-id", "other-user-id"), null);@@ -86,7 +86,7 @@ class ElastiCacheServiceTest {service.createReplicationGroup("grp", "test", AuthMode.PASSWORD, null);service.createUser("other-user-id", "other", AuthMode.PASSWORD,- List.of("other-pass"), "on ~* +@all");+ List.of("other-pass"), "on ~* +@all", null);service.modifyReplicationGroup("grp", List.of("other-user-id"), null);diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserEngineIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserEngineIntegrationTest.javanew file mode 100644index 0000000000..81794535e8--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserEngineIntegrationTest.java@@ -0,0 +1,322 @@+package io.github.hectorvent.floci.services.elasticache;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++/**+ * Control-plane coverage for the user Engine attribute; unlike the Docker-backed+ * lifecycle tests these never touch a container.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class ElastiCacheUserEngineIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260412/us-east-1/elasticache/aws4_request";+ private static final String VALKEY_USER = "engine-it-valkey-user";+ private static final String DEFAULT_USER = "engine-it-default-user";++ @Test+ @Order(1)+ void createUserWithValkeyEngineEchoesValkey() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", VALKEY_USER)+ .formParam("UserName", "engine-it-valkey")+ .formParam("Engine", "valkey")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Engine", equalTo("valkey"))+ // AWS documents no valkey-specific MinimumEngineVersion, so it stays at the published 6.0.+ .body("CreateUserResponse.CreateUserResult.MinimumEngineVersion", equalTo("6.0"));+ }++ @Test+ @Order(2)+ void createUserWithoutEngineDefaultsToRedis() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", DEFAULT_USER)+ .formParam("UserName", "engine-it-default")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Engine", equalTo("redis"))+ .body("CreateUserResponse.CreateUserResult.MinimumEngineVersion", equalTo("6.0"));+ }++ @Test+ @Order(3)+ void describeUsersReportsTheStoredEngine() {+ given()+ .formParam("Action", "DescribeUsers")+ .formParam("UserId", VALKEY_USER)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeUsersResponse.DescribeUsersResult.Users.member.Engine", equalTo("valkey"));+ }++ /** Floci's own tolerance, mirroring the handler's memcached check — AWS documents no case handling for Engine. */+ @Test+ @Order(4)+ void engineValueIsCaseInsensitiveAndStoredLowercase() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", "engine-it-case-user")+ .formParam("UserName", "engine-it-case")+ .formParam("Engine", "Valkey")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Engine", equalTo("valkey"));+ }++ @Test+ @Order(5)+ void createUserRejectsAnUnknownEngine() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", "engine-it-bad-user")+ .formParam("UserName", "engine-it-bad")+ .formParam("Engine", "memcached")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("InvalidParameterValue"));+ }++ @Test+ @Order(6)+ void modifyUserChangesTheEngine() {+ given()+ .formParam("Action", "ModifyUser")+ .formParam("UserId", DEFAULT_USER)+ .formParam("Engine", "valkey")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyUserResponse.ModifyUserResult.Engine", equalTo("valkey"));+ }++ @Test+ @Order(7)+ void modifyUserWithoutEngineLeavesItUnchanged() {+ given()+ .formParam("Action", "ModifyUser")+ .formParam("UserId", VALKEY_USER)+ .formParam("AuthenticationMode.Passwords.member.1", "some-password-1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyUserResponse.ModifyUserResult.Engine", equalTo("valkey"));+ }++ /** A sent-but-empty Engine is treated like an absent one on both actions. */+ @Test+ @Order(8)+ void blankEngineBehavesLikeAnAbsentOne() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", "engine-it-blank-user")+ .formParam("UserName", "engine-it-blank")+ .formParam("Engine", "")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Engine", equalTo("redis"));+ given()+ .formParam("Action", "ModifyUser")+ .formParam("UserId", VALKEY_USER)+ .formParam("Engine", "")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyUserResponse.ModifyUserResult.Engine", equalTo("valkey"));+ }++ @Test+ @Order(9)+ void createUserWithExplicitRedisEngineEchoesRedis() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", "engine-it-redis-user")+ .formParam("UserName", "engine-it-redis")+ .formParam("Engine", "redis")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Engine", equalTo("redis"));+ }++ /** DescribeUsers documents an Engine filter, which means something now that users differ by engine. */+ @Test+ @Order(10)+ void describeUsersFiltersByEngine() {+ given()+ .formParam("Action", "DescribeUsers")+ .formParam("Engine", "redis")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("engine-it-redis-user"))+ .body(not(containsString("engine-it-valkey-user")));+ given()+ .formParam("Action", "DescribeUsers")+ .formParam("Engine", "REDIS")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("engine-it-redis-user"))+ .body(not(containsString("engine-it-valkey-user")));+ // UserId wins when both filters are sent; the engine filter is ignored.+ given()+ .formParam("Action", "DescribeUsers")+ .formParam("UserId", VALKEY_USER)+ .formParam("Engine", "redis")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(VALKEY_USER));+ }++ /**+ * A ModifyUser rejected for a bad Engine must leave the user untouched — the storage+ * backends hand back the live stored object, so a password change applied before+ * validation would survive the 400.+ */+ @Test+ @Order(11)+ void rejectedModifyUserLeavesThePasswordsUnchanged() {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserId", "engine-it-atomic-user")+ .formParam("UserName", "engine-it-atomic")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "password")+ .formParam("AuthenticationMode.Passwords.member.1", "atomic-password-1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.Authentication.PasswordCount", equalTo("1"));+ given()+ .formParam("Action", "ModifyUser")+ .formParam("UserId", "engine-it-atomic-user")+ .formParam("AuthenticationMode.Passwords.member.1", "atomic-password-1")+ .formParam("AuthenticationMode.Passwords.member.2", "atomic-password-2")+ .formParam("Engine", "memcached")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("InvalidParameterValue"));+ given()+ .formParam("Action", "DescribeUsers")+ .formParam("UserId", "engine-it-atomic-user")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeUsersResponse.DescribeUsersResult.Users.member.Authentication.PasswordCount", equalTo("1"));+ // The same call with a valid engine applies both changes.+ given()+ .formParam("Action", "ModifyUser")+ .formParam("UserId", "engine-it-atomic-user")+ .formParam("AuthenticationMode.Passwords.member.1", "atomic-password-1")+ .formParam("AuthenticationMode.Passwords.member.2", "atomic-password-2")+ .formParam("Engine", "valkey")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyUserResponse.ModifyUserResult.Engine", equalTo("valkey"))+ .body("ModifyUserResponse.ModifyUserResult.Authentication.PasswordCount", equalTo("2"));+ }++ @Test+ @Order(12)+ void deleteUserEchoesTheStoredEngine() {+ given()+ .formParam("Action", "DeleteUser")+ .formParam("UserId", VALKEY_USER)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeleteUserResponse.DeleteUserResult.Engine", equalTo("valkey"));+ }++ /**+ * The user store is shared across test classes, so this class removes what it created —+ * as an ordered test rather than an {@code @AfterAll}, which would run after Quarkus has+ * already reset the RestAssured port, and asserting each delete so a silent no-op turns red.+ */+ @Test+ @Order(13)+ void deleteRemainingUsersSoTheSharedStoreStaysClean() {+ for (String userId : new String[] {DEFAULT_USER, "engine-it-case-user",+ "engine-it-blank-user", "engine-it-redis-user", "engine-it-atomic-user"}) {+ given()+ .formParam("Action", "DeleteUser")+ .formParam("UserId", userId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserModelTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserModelTest.javanew file mode 100644index 0000000000..414f8bd015--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheUserModelTest.java@@ -0,0 +1,29 @@+package io.github.hectorvent.floci.services.elasticache;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;+import io.github.hectorvent.floci.services.elasticache.model.ElastiCacheUser;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * Users persisted before the engine field existed must deserialize with the redis+ * default; the field initializer is what guarantees it, through the same+ * deserialization configuration the persistent storage backends use (ObjectMapper+ * plus JavaTimeModule).+ */+class ElastiCacheUserModelTest {++ @Test+ void legacyJsonWithoutEngineDeserializesAsRedis() throws Exception {+ ElastiCacheUser user = new ObjectMapper().registerModule(new JavaTimeModule()).readValue(+ """+ {"userId":"legacy","userName":"legacy","authMode":"PASSWORD",\+ "passwords":["legacy-password-1"],"accessString":"on ~* +@all",\+ "status":"active","createdAt":"2026-08-15T10:00:00Z"}+ """,+ ElastiCacheUser.class);+ assertEquals("redis", user.getEngine());+ }+}