Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudfront): echo OriginSslProtocols and round-trip legacy cache behavior fields (#3182)
Matan Baruch006f3c77c954
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontController.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontController.javaindex 1745d67a45..c3c9d0dfcf 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontController.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontController.java@@ -1934,6 +1934,7 @@ public class CloudFrontController {.elem("HTTPSPort", coc.getOrDefault("HTTPSPort", "443").toString()).elem("OriginProtocolPolicy",coc.getOrDefault("OriginProtocolPolicy", "https-only").toString())+ .raw(xmlOriginSslProtocols(coc.get("OriginSslProtocols"))).end("CustomOriginConfig");}@@ -1966,13 +1967,19 @@ public class CloudFrontController {.elem("CachePolicyId", dcb.getCachePolicyId()).elem("OriginRequestPolicyId", dcb.getOriginRequestPolicyId()).elem("ResponseHeadersPolicyId", dcb.getResponseHeadersPolicyId())- .elem("Compress", dcb.isCompress());+ .elem("FieldLevelEncryptionId",+ dcb.getFieldLevelEncryptionId() != null ? dcb.getFieldLevelEncryptionId() : "")+ .elem("Compress", dcb.isCompress())+ .elem("SmoothStreaming", dcb.isSmoothStreaming());++ xml.raw(xmlCacheBehaviorTtls(dcb.getMinTTL(), dcb.getDefaultTTL(), dcb.getMaxTTL()));xml.raw(xmlTrustedSigners());xml.raw(xmlTrustedKeyGroups(dcb.isTrustedKeyGroupsEnabled(), dcb.getTrustedKeyGroups()));xml.raw(xmlAllowedMethods(dcb.getAllowedMethods(), dcb.getCachedMethods()));+ xml.raw(xmlCacheBehaviorForwardedValues(dcb.getCachePolicyId(), dcb.getForwardedValues()));xml.raw(xmlFunctionAssociations(dcb.getFunctionAssociations()));xml.raw(xmlLambdaFunctionAssociations(dcb.getLambdaFunctionAssociations()));@@ -1991,13 +1998,19 @@ public class CloudFrontController {.elem("CachePolicyId", cb.getCachePolicyId()).elem("OriginRequestPolicyId", cb.getOriginRequestPolicyId()).elem("ResponseHeadersPolicyId", cb.getResponseHeadersPolicyId())- .elem("Compress", cb.isCompress());+ .elem("FieldLevelEncryptionId",+ cb.getFieldLevelEncryptionId() != null ? cb.getFieldLevelEncryptionId() : "")+ .elem("Compress", cb.isCompress())+ .elem("SmoothStreaming", cb.isSmoothStreaming());++ xml.raw(xmlCacheBehaviorTtls(cb.getMinTTL(), cb.getDefaultTTL(), cb.getMaxTTL()));xml.raw(xmlTrustedSigners());xml.raw(xmlTrustedKeyGroups(cb.isTrustedKeyGroupsEnabled(), cb.getTrustedKeyGroups()));xml.raw(xmlAllowedMethods(cb.getAllowedMethods(), cb.getCachedMethods()));+ xml.raw(xmlCacheBehaviorForwardedValues(cb.getCachePolicyId(), cb.getForwardedValues()));xml.raw(xmlFunctionAssociations(cb.getFunctionAssociations()));xml.raw(xmlLambdaFunctionAssociations(cb.getLambdaFunctionAssociations()));@@ -2072,6 +2085,85 @@ public class CloudFrontController {.build();}+ // A custom origin must carry OriginSslProtocols. Floci did not echo it, and the Terraform AWS+ // provider flattens CustomOriginConfig.OriginSslProtocols.Items with no nil guard, so an omitted+ // element segfaults it on distribution read-back. Round-trip the submitted protocols, defaulting+ // to the form AWS returns when the client sends none.+ private String xmlOriginSslProtocols(Object protocols) {+ List<String> list = stringList(protocols);+ if (list.isEmpty()) {+ list = List.of("TLSv1.2");+ }+ XmlBuilder xml = new XmlBuilder()+ .start("OriginSslProtocols")+ .elem("Quantity", list.size())+ .start("Items");+ for (String protocol : list) {+ xml.elem("SslProtocol", protocol);+ }+ return xml.end("Items").end("OriginSslProtocols").build();+ }++ // DefaultTTL and MaxTTL are optional, and 0 is a meaningful value (the usual "do not cache" with+ // forwarded_values), so presence has to be tracked separately from the value. Treating 0 as unset+ // drops an explicit default_ttl = 0 from the read-back and the provider then sees a permanent diff.+ private String xmlCacheBehaviorTtls(Long minTtl, Long defaultTtl, Long maxTtl) {+ XmlBuilder xml = new XmlBuilder().elem("MinTTL", minTtl != null ? minTtl : 0L);+ if (defaultTtl != null) {+ xml.elem("DefaultTTL", defaultTtl);+ }+ if (maxTtl != null) {+ xml.elem("MaxTTL", maxTtl);+ }+ return xml.build();+ }++ // When a cache behavior uses the legacy (non-cache-policy) form, AWS echoes a full ForwardedValues+ // object. Floci dropped it, so the provider's read either lost the config or, on newer provider+ // versions, dereferenced the missing object. Emit the submitted values in the shape AWS returns.+ private String xmlCacheBehaviorForwardedValues(String cachePolicyId, Map<String, Object> forwardedValues) {+ if (cachePolicyId != null && !cachePolicyId.isEmpty()) {+ return "";+ }+ boolean queryString = forwardedValues != null+ && Boolean.TRUE.equals(forwardedValues.get("QueryString"));+ Object forward = forwardedValues != null ? forwardedValues.get("CookiesForward") : null;+ XmlBuilder xml = new XmlBuilder()+ .start("ForwardedValues")+ .elem("QueryString", queryString)+ .start("Cookies")+ .elem("Forward", forward != null ? forward.toString() : "none");+ xml.raw(xmlForwardedNames("WhitelistedNames", "Name",+ forwardedValuesList(forwardedValues, "CookieNames")));+ xml.end("Cookies");+ xml.raw(xmlForwardedNames("Headers", "Name",+ forwardedValuesList(forwardedValues, "Headers")));+ xml.raw(xmlForwardedNames("QueryStringCacheKeys", "Name",+ forwardedValuesList(forwardedValues, "QueryStringCacheKeys")));+ return xml.end("ForwardedValues").build();+ }++ @SuppressWarnings("unchecked")+ private static List<String> forwardedValuesList(Map<String, Object> forwardedValues, String key) {+ Object value = forwardedValues != null ? forwardedValues.get(key) : null;+ return value instanceof List<?> list ? (List<String>) list : List.of();+ }++ // Whitelisted cookie names, forwarded headers and query-string cache keys are Quantity/Items pairs.+ // Echoing a bare Quantity 0 loses whatever the client whitelisted, so the provider reads the lists+ // back empty and diffs on every plan. AWS omits Items entirely when the quantity is zero.+ private String xmlForwardedNames(String wrapper, String itemName, List<String> names) {+ XmlBuilder xml = new XmlBuilder().start(wrapper).elem("Quantity", names.size());+ if (!names.isEmpty()) {+ xml.start("Items");+ for (String name : names) {+ xml.elem(itemName, name);+ }+ xml.end("Items");+ }+ return xml.end(wrapper).build();+ }+private String xmlActiveTrustedKeyGroups(DistributionConfig config) {List<KeyGroup> groups = service.activeTrustedKeyGroups(config);XmlBuilder xml = new XmlBuilder()@@ -2554,9 +2646,11 @@ public class CloudFrontController {boolean inOrigin = false;boolean inS3OriginConfig = false;boolean inCustomOriginConfig = false;+ boolean inOriginSslProtocols = false;Origin current = null;Map<String, String> s3Config = null;Map<String, Object> customConfig = null;+ List<String> sslProtocols = null;boolean inCustomHeaders = false;boolean inCustomHeaderItems = false;boolean customHeaderItemsSeen = false;@@ -2608,6 +2702,17 @@ public class CloudFrontController {customConfig = new LinkedHashMap<>();}}+ case "OriginSslProtocols" -> {+ if (inCustomOriginConfig) {+ inOriginSslProtocols = true;+ sslProtocols = new ArrayList<>();+ }+ }+ case "SslProtocol" -> {+ if (inOriginSslProtocols && sslProtocols != null) {+ sslProtocols.add(r.getElementText());+ }+ }case "Id" -> {if (inOrigin && !inS3OriginConfig && !inCustomOriginConfig && current != null) {current.setId(r.getElementText());@@ -2717,6 +2822,13 @@ public class CloudFrontController {inS3OriginConfig = false;s3Config = null;}+ case "OriginSslProtocols" -> {+ if (inCustomOriginConfig && customConfig != null && sslProtocols != null) {+ customConfig.put("OriginSslProtocols", sslProtocols);+ }+ inOriginSslProtocols = false;+ sslProtocols = null;+ }case "CustomOriginConfig" -> {if (inCustomOriginConfig && current != null) {current.setCustomOriginConfig(customConfig);@@ -2847,6 +2959,40 @@ public class CloudFrontController {}}+ private static long parseLongOrZero(String value) {+ if (value == null) {+ return 0L;+ }+ try {+ return Long.parseLong(value.trim());+ } catch (NumberFormatException e) {+ return 0L;+ }+ }++ private static Map<String, Object> forwardedValuesModel(+ Boolean queryString,+ String cookiesForward,+ List<String> cookieNames,+ List<String> headers,+ List<String> queryStringCacheKeys) {+ Map<String, Object> forwardedValues = new LinkedHashMap<>();+ forwardedValues.put("QueryString", queryString != null && queryString);+ if (cookiesForward != null) {+ forwardedValues.put("CookiesForward", cookiesForward);+ }+ if (cookieNames != null && !cookieNames.isEmpty()) {+ forwardedValues.put("CookieNames", List.copyOf(cookieNames));+ }+ if (headers != null && !headers.isEmpty()) {+ forwardedValues.put("Headers", List.copyOf(headers));+ }+ if (queryStringCacheKeys != null && !queryStringCacheKeys.isEmpty()) {+ forwardedValues.put("QueryStringCacheKeys", List.copyOf(queryStringCacheKeys));+ }+ return forwardedValues;+ }+private DefaultCacheBehavior parseDefaultCacheBehavior(String body) {DefaultCacheBehavior dcb = new DefaultCacheBehavior();if (body == null || body.isEmpty()) {@@ -2864,6 +3010,17 @@ public class CloudFrontController {List<String> allowedMethods = new ArrayList<>();List<String> cachedMethods = new ArrayList<>();List<String> trustedKeyGroups = new ArrayList<>();+ boolean inForwardedValues = false;+ boolean inForwardedCookies = false;+ boolean inForwardedCookieNames = false;+ boolean inForwardedHeaders = false;+ boolean inForwardedQueryStringCacheKeys = false;+ boolean sawForwardedValues = false;+ Boolean forwardedQueryString = null;+ String forwardedCookiesForward = null;+ List<String> forwardedCookieNames = new ArrayList<>();+ List<String> forwardedHeaders = new ArrayList<>();+ List<String> forwardedQueryStringCacheKeys = new ArrayList<>();boolean inLambdaAssociations = false;boolean inFunctionAssociations = false;Map<String, Object> currentLambdaAssociation = null;@@ -2957,6 +3114,41 @@ public class CloudFrontController {case "CachedMethods" -> {if (inAllowedMethods) inCachedMethods = true;}+ case "ForwardedValues" -> {+ if (inDcb) {+ inForwardedValues = true;+ sawForwardedValues = true;+ }+ }+ case "Cookies" -> {+ if (inForwardedValues) inForwardedCookies = true;+ }+ case "WhitelistedNames" -> {+ if (inForwardedCookies) inForwardedCookieNames = true;+ }+ case "Headers" -> {+ if (inForwardedValues) inForwardedHeaders = true;+ }+ case "QueryStringCacheKeys" -> {+ if (inForwardedValues) inForwardedQueryStringCacheKeys = true;+ }+ case "Name" -> {+ if (inForwardedCookieNames) {+ forwardedCookieNames.add(r.getElementText());+ } else if (inForwardedHeaders) {+ forwardedHeaders.add(r.getElementText());+ } else if (inForwardedQueryStringCacheKeys) {+ forwardedQueryStringCacheKeys.add(r.getElementText());+ }+ }+ case "QueryString" -> {+ if (inForwardedValues && !inForwardedCookies) {+ forwardedQueryString = "true".equalsIgnoreCase(r.getElementText());+ }+ }+ case "Forward" -> {+ if (inForwardedCookies) forwardedCookiesForward = r.getElementText();+ }case "TargetOriginId" -> {if (inDcb) dcb.setTargetOriginId(r.getElementText());}@@ -2981,6 +3173,18 @@ public class CloudFrontController {case "Compress" -> {if (inDcb) dcb.setCompress("true".equalsIgnoreCase(r.getElementText()));}+ case "SmoothStreaming" -> {+ if (inDcb) dcb.setSmoothStreaming("true".equalsIgnoreCase(r.getElementText()));+ }+ case "MinTTL" -> {+ if (inDcb) dcb.setMinTTL(parseLongOrZero(r.getElementText()));+ }+ case "DefaultTTL" -> {+ if (inDcb) dcb.setDefaultTTL(parseLongOrZero(r.getElementText()));+ }+ case "MaxTTL" -> {+ if (inDcb) dcb.setMaxTTL(parseLongOrZero(r.getElementText()));+ }case "Method" -> {if (inCachedMethods) {cachedMethods.add(r.getElementText());@@ -2995,6 +3199,11 @@ public class CloudFrontController {switch (r.getLocalName()) {case "CachedMethods" -> inCachedMethods = false;case "AllowedMethods" -> inAllowedMethods = false;+ case "WhitelistedNames" -> inForwardedCookieNames = false;+ case "Headers" -> inForwardedHeaders = false;+ case "QueryStringCacheKeys" -> inForwardedQueryStringCacheKeys = false;+ case "Cookies" -> inForwardedCookies = false;+ case "ForwardedValues" -> inForwardedValues = false;case "TrustedKeyGroups" -> inTrustedKeyGroups = false;case "DefaultCacheBehavior" -> inDcb = false;case "LambdaFunctionAssociations" -> inLambdaAssociations = false;@@ -3023,6 +3232,14 @@ public class CloudFrontController {if (!cachedMethods.isEmpty()) {dcb.setCachedMethods(cachedMethods);}+ if (sawForwardedValues) {+ dcb.setForwardedValues(forwardedValuesModel(+ forwardedQueryString,+ forwardedCookiesForward,+ forwardedCookieNames,+ forwardedHeaders,+ forwardedQueryStringCacheKeys));+ }if (!trustedKeyGroups.isEmpty()) {dcb.setTrustedKeyGroups(trustedKeyGroups);}@@ -3078,6 +3295,17 @@ public class CloudFrontController {List<String> allowedMethods = new ArrayList<>();List<String> cachedMethods = new ArrayList<>();List<String> trustedKeyGroups = new ArrayList<>();+ boolean inForwardedValues = false;+ boolean inForwardedCookies = false;+ boolean inForwardedCookieNames = false;+ boolean inForwardedHeaders = false;+ boolean inForwardedQueryStringCacheKeys = false;+ boolean sawForwardedValues = false;+ Boolean forwardedQueryString = null;+ String forwardedCookiesForward = null;+ List<String> forwardedCookieNames = new ArrayList<>();+ List<String> forwardedHeaders = new ArrayList<>();+ List<String> forwardedQueryStringCacheKeys = new ArrayList<>();boolean inLambdaAssociations = false;boolean inFunctionAssociations = false;Map<String, Object> currentLambdaAssociation = null;@@ -3103,6 +3331,12 @@ public class CloudFrontController {allowedMethods = new ArrayList<>();cachedMethods = new ArrayList<>();trustedKeyGroups = new ArrayList<>();+ sawForwardedValues = false;+ forwardedQueryString = null;+ forwardedCookiesForward = null;+ forwardedCookieNames = new ArrayList<>();+ forwardedHeaders = new ArrayList<>();+ forwardedQueryStringCacheKeys = new ArrayList<>();lambdaAssociations = new ArrayList<>();functionAssociations = new ArrayList<>();lambdaAssociationsQuantity = null;@@ -3187,6 +3421,41 @@ public class CloudFrontController {case "CachedMethods" -> {if (inAllowedMethods) inCachedMethods = true;}+ case "ForwardedValues" -> {+ if (inCacheBehavior) {+ inForwardedValues = true;+ sawForwardedValues = true;+ }+ }+ case "Cookies" -> {+ if (inForwardedValues) inForwardedCookies = true;+ }+ case "WhitelistedNames" -> {+ if (inForwardedCookies) inForwardedCookieNames = true;+ }+ case "Headers" -> {+ if (inForwardedValues) inForwardedHeaders = true;+ }+ case "QueryStringCacheKeys" -> {+ if (inForwardedValues) inForwardedQueryStringCacheKeys = true;+ }+ case "Name" -> {+ if (inForwardedCookieNames) {+ forwardedCookieNames.add(r.getElementText());+ } else if (inForwardedHeaders) {+ forwardedHeaders.add(r.getElementText());+ } else if (inForwardedQueryStringCacheKeys) {+ forwardedQueryStringCacheKeys.add(r.getElementText());+ }+ }+ case "QueryString" -> {+ if (inForwardedValues && !inForwardedCookies) {+ forwardedQueryString = "true".equalsIgnoreCase(r.getElementText());+ }+ }+ case "Forward" -> {+ if (inForwardedCookies) forwardedCookiesForward = r.getElementText();+ }case "PathPattern" -> {if (inCacheBehavior && current != null) current.setPathPattern(r.getElementText());}@@ -3207,11 +3476,35 @@ public class CloudFrontController {if (inCacheBehavior && current != null)current.setResponseHeadersPolicyId(r.getElementText());}+ case "FieldLevelEncryptionId" -> {+ if (inCacheBehavior && current != null)+ current.setFieldLevelEncryptionId(r.getElementText());+ }case "Compress" -> {if (inCacheBehavior && current != null) {current.setCompress("true".equalsIgnoreCase(r.getElementText()));}}+ case "SmoothStreaming" -> {+ if (inCacheBehavior && current != null) {+ current.setSmoothStreaming("true".equalsIgnoreCase(r.getElementText()));+ }+ }+ case "MinTTL" -> {+ if (inCacheBehavior && current != null) {+ current.setMinTTL(parseLongOrZero(r.getElementText()));+ }+ }+ case "DefaultTTL" -> {+ if (inCacheBehavior && current != null) {+ current.setDefaultTTL(parseLongOrZero(r.getElementText()));+ }+ }+ case "MaxTTL" -> {+ if (inCacheBehavior && current != null) {+ current.setMaxTTL(parseLongOrZero(r.getElementText()));+ }+ }case "Method" -> {if (inCachedMethods) {cachedMethods.add(r.getElementText());@@ -3226,6 +3519,11 @@ public class CloudFrontController {switch (r.getLocalName()) {case "CachedMethods" -> inCachedMethods = false;case "AllowedMethods" -> inAllowedMethods = false;+ case "WhitelistedNames" -> inForwardedCookieNames = false;+ case "Headers" -> inForwardedHeaders = false;+ case "QueryStringCacheKeys" -> inForwardedQueryStringCacheKeys = false;+ case "Cookies" -> inForwardedCookies = false;+ case "ForwardedValues" -> inForwardedValues = false;case "TrustedKeyGroups" -> inTrustedKeyGroups = false;case "LambdaFunctionAssociations" -> inLambdaAssociations = false;case "FunctionAssociations" -> inFunctionAssociations = false;@@ -3249,6 +3547,14 @@ public class CloudFrontController {if (!cachedMethods.isEmpty()) {current.setCachedMethods(cachedMethods);}+ if (sawForwardedValues) {+ current.setForwardedValues(forwardedValuesModel(+ forwardedQueryString,+ forwardedCookiesForward,+ forwardedCookieNames,+ forwardedHeaders,+ forwardedQueryStringCacheKeys));+ }if (!trustedKeyGroups.isEmpty()) {current.setTrustedKeyGroups(trustedKeyGroups);}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/CacheBehavior.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/CacheBehavior.javaindex 10f2a0989f..4834ab4ffc 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/CacheBehavior.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/CacheBehavior.java@@ -21,9 +21,11 @@ public class CacheBehavior {private List<Map<String, String>> functionAssociations;private List<Map<String, Object>> lambdaFunctionAssociations;private boolean compress;- private long defaultTTL;- private long minTTL;- private long maxTTL;+ private boolean smoothStreaming;+ private Long defaultTTL;+ private Long minTTL;+ private Long maxTTL;+ private Map<String, Object> forwardedValues;// Private-content key group IDs whose public keys may sign requests.// Explicit enablement controls signature enforcement.private Boolean trustedKeyGroupsEnabled;@@ -70,14 +72,20 @@ public class CacheBehavior {public boolean isCompress() { return compress; }public void setCompress(boolean compress) { this.compress = compress; }- public long getDefaultTTL() { return defaultTTL; }- public void setDefaultTTL(long defaultTTL) { this.defaultTTL = defaultTTL; }+ public boolean isSmoothStreaming() { return smoothStreaming; }+ public void setSmoothStreaming(boolean smoothStreaming) { this.smoothStreaming = smoothStreaming; }- public long getMinTTL() { return minTTL; }- public void setMinTTL(long minTTL) { this.minTTL = minTTL; }+ public Map<String, Object> getForwardedValues() { return forwardedValues; }+ public void setForwardedValues(Map<String, Object> forwardedValues) { this.forwardedValues = forwardedValues; }- public long getMaxTTL() { return maxTTL; }- public void setMaxTTL(long maxTTL) { this.maxTTL = maxTTL; }+ public Long getDefaultTTL() { return defaultTTL; }+ public void setDefaultTTL(Long defaultTTL) { this.defaultTTL = defaultTTL; }++ public Long getMinTTL() { return minTTL; }+ public void setMinTTL(Long minTTL) { this.minTTL = minTTL; }++ public Long getMaxTTL() { return maxTTL; }+ public void setMaxTTL(Long maxTTL) { this.maxTTL = maxTTL; }public boolean isTrustedKeyGroupsEnabled() {return trustedKeyGroupsEnabled != nulldiff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/DefaultCacheBehavior.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/DefaultCacheBehavior.javaindex 83f49df338..8885fcd351 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/DefaultCacheBehavior.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/model/DefaultCacheBehavior.java@@ -20,9 +20,11 @@ public class DefaultCacheBehavior {private List<Map<String, String>> functionAssociations;private List<Map<String, Object>> lambdaFunctionAssociations;private boolean compress;- private long defaultTTL;- private long minTTL;- private long maxTTL;+ private boolean smoothStreaming;+ private Long defaultTTL;+ private Long minTTL;+ private Long maxTTL;+ private Map<String, Object> forwardedValues;// Private-content key group IDs whose public keys may sign requests.// Explicit enablement controls signature enforcement.private Boolean trustedKeyGroupsEnabled;@@ -66,14 +68,20 @@ public class DefaultCacheBehavior {public boolean isCompress() { return compress; }public void setCompress(boolean compress) { this.compress = compress; }- public long getDefaultTTL() { return defaultTTL; }- public void setDefaultTTL(long defaultTTL) { this.defaultTTL = defaultTTL; }+ public boolean isSmoothStreaming() { return smoothStreaming; }+ public void setSmoothStreaming(boolean smoothStreaming) { this.smoothStreaming = smoothStreaming; }- public long getMinTTL() { return minTTL; }- public void setMinTTL(long minTTL) { this.minTTL = minTTL; }+ public Map<String, Object> getForwardedValues() { return forwardedValues; }+ public void setForwardedValues(Map<String, Object> forwardedValues) { this.forwardedValues = forwardedValues; }- public long getMaxTTL() { return maxTTL; }- public void setMaxTTL(long maxTTL) { this.maxTTL = maxTTL; }+ public Long getDefaultTTL() { return defaultTTL; }+ public void setDefaultTTL(Long defaultTTL) { this.defaultTTL = defaultTTL; }++ public Long getMinTTL() { return minTTL; }+ public void setMinTTL(Long minTTL) { this.minTTL = minTTL; }++ public Long getMaxTTL() { return maxTTL; }+ public void setMaxTTL(Long maxTTL) { this.maxTTL = maxTTL; }public boolean isTrustedKeyGroupsEnabled() {return trustedKeyGroupsEnabled != nulldiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontControllerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontControllerTest.javaindex d17619f326..f9bf4aec91 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontControllerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontControllerTest.java@@ -12,6 +12,7 @@ import java.util.List;import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.Mockito.mock;@@ -319,6 +320,218 @@ class CloudFrontControllerTest {assertTrue(((String) created.getEntity()).contains("InconsistentQuantities"));}}+ @Test+ void customOriginConfigEchoesOriginSslProtocolsSoTheAwsProviderDoesNotSegfault() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ // A custom origin whose request omits OriginSslProtocols, as the aws provider sends for a+ // minimal distribution. The provider flattens CustomOriginConfig.OriginSslProtocols.Items with+ // no nil guard, so an omitted object segfaults it on read-back. AWS always echoes the object.+ String body = distributionConfigBody("");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-ssl");+ d.setEtag("etag-ssl");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-ssl")).thenReturn(captor.getValue());++ try (Response dist = controller.getDistribution("dist-ssl")) {+ String xml = (String) dist.getEntity();+ int start = xml.indexOf("<OriginSslProtocols>");+ assertTrue(start >= 0, "CustomOriginConfig must echo an OriginSslProtocols object");+ String block = xml.substring(start, xml.indexOf("</OriginSslProtocols>", start));+ assertTrue(block.contains("<SslProtocol>"),+ "OriginSslProtocols must list at least one protocol");+ }+ }++ @Test+ void customOriginConfigRoundTripsSubmittedOriginSslProtocols() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ String body = distributionConfigBody("").replace(+ "<OriginProtocolPolicy>https-only</OriginProtocolPolicy></CustomOriginConfig>",+ "<OriginProtocolPolicy>https-only</OriginProtocolPolicy>"+ + "<OriginSslProtocols><Quantity>2</Quantity><Items>"+ + "<SslProtocol>TLSv1.1</SslProtocol><SslProtocol>TLSv1.2</SslProtocol>"+ + "</Items></OriginSslProtocols></CustomOriginConfig>");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-ssl2");+ d.setEtag("etag-ssl2");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-ssl2")).thenReturn(captor.getValue());++ try (Response cfg = controller.getDistributionConfig("dist-ssl2")) {+ String xml = (String) cfg.getEntity();+ int start = xml.indexOf("<OriginSslProtocols>");+ assertTrue(start >= 0);+ String block = xml.substring(start, xml.indexOf("</OriginSslProtocols>", start));+ assertTrue(block.contains("<SslProtocol>TLSv1.1</SslProtocol>"), "echoes TLSv1.1");+ assertTrue(block.contains("<SslProtocol>TLSv1.2</SslProtocol>"), "echoes TLSv1.2");+ }+ }++ @Test+ void defaultCacheBehaviorRoundTripsForwardedValues() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ String body = distributionConfigBody(+ "<ForwardedValues><QueryString>true</QueryString>"+ + "<Cookies><Forward>all</Forward></Cookies></ForwardedValues>");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-fv");+ d.setEtag("etag-fv");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-fv")).thenReturn(captor.getValue());++ try (Response dist = controller.getDistribution("dist-fv")) {+ String xml = (String) dist.getEntity();+ int start = xml.indexOf("<ForwardedValues>");+ assertTrue(start >= 0, "DefaultCacheBehavior must echo a ForwardedValues object");+ String block = xml.substring(start, xml.indexOf("</ForwardedValues>", start));+ assertTrue(block.contains("<QueryString>true</QueryString>"), "echoes QueryString");+ assertTrue(block.contains("<Forward>all</Forward>"), "echoes Cookies.Forward");+ }+ }++ @Test+ void defaultCacheBehaviorRoundTripsAnExplicitZeroDefaultTtl() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ // default_ttl = 0 with forwarded_values is the usual "do not cache". Treating 0 as "unset"+ // drops it from the read-back, so the provider sees the attribute disappear and diffs forever.+ String body = distributionConfigBody(+ "<MinTTL>0</MinTTL><DefaultTTL>0</DefaultTTL><MaxTTL>0</MaxTTL>"+ + "<ForwardedValues><QueryString>false</QueryString>"+ + "<Cookies><Forward>none</Forward></Cookies></ForwardedValues>");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-ttl0");+ d.setEtag("etag-ttl0");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-ttl0")).thenReturn(captor.getValue());++ try (Response dist = controller.getDistribution("dist-ttl0")) {+ String xml = (String) dist.getEntity();+ assertTrue(xml.contains("<MinTTL>0</MinTTL>"), "echoes an explicit MinTTL of 0");+ assertTrue(xml.contains("<DefaultTTL>0</DefaultTTL>"), "echoes an explicit DefaultTTL of 0");+ assertTrue(xml.contains("<MaxTTL>0</MaxTTL>"), "echoes an explicit MaxTTL of 0");+ }+ }++ @Test+ void defaultCacheBehaviorOmitsTtlsTheClientNeverSubmitted() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ String body = distributionConfigBody(+ "<ForwardedValues><QueryString>false</QueryString>"+ + "<Cookies><Forward>none</Forward></Cookies></ForwardedValues>");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-ttlabsent");+ d.setEtag("etag-ttlabsent");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-ttlabsent")).thenReturn(captor.getValue());++ try (Response dist = controller.getDistribution("dist-ttlabsent")) {+ String xml = (String) dist.getEntity();+ assertFalse(xml.contains("<DefaultTTL>"), "an unsubmitted DefaultTTL stays absent");+ assertFalse(xml.contains("<MaxTTL>"), "an unsubmitted MaxTTL stays absent");+ }+ }++ @Test+ void forwardedValuesRoundTripsHeadersQueryStringCacheKeysAndWhitelistedCookies() {+ CloudFrontService service = mock(CloudFrontService.class);+ CloudFrontController controller = new CloudFrontController(service);++ // Headers, QueryStringCacheKeys and Cookies.WhitelistedNames are Quantity/Items pairs. Echoing+ // a bare Quantity 0 loses them, so the provider reads the lists back empty and diffs each plan.+ String body = distributionConfigBody(+ "<ForwardedValues><QueryString>true</QueryString>"+ + "<Cookies><Forward>whitelist</Forward>"+ + "<WhitelistedNames><Quantity>2</Quantity><Items>"+ + "<Name>session</Name><Name>tracking</Name></Items></WhitelistedNames>"+ + "</Cookies>"+ + "<Headers><Quantity>2</Quantity><Items>"+ + "<Name>Origin</Name><Name>Accept</Name></Items></Headers>"+ + "<QueryStringCacheKeys><Quantity>1</Quantity><Items>"+ + "<Name>page</Name></Items></QueryStringCacheKeys>"+ + "</ForwardedValues>");++ ArgumentCaptor<Distribution> captor = ArgumentCaptor.forClass(Distribution.class);+ when(service.createDistribution(captor.capture(), any())).thenAnswer(inv -> {+ Distribution d = inv.getArgument(0);+ d.setId("dist-fvnames");+ d.setEtag("etag-fvnames");+ return d;+ });+ try (Response created = controller.createDistribution(null, body)) {+ assertEquals(201, created.getStatus());+ }+ when(service.getDistribution("dist-fvnames")).thenReturn(captor.getValue());++ try (Response dist = controller.getDistribution("dist-fvnames")) {+ String xml = (String) dist.getEntity();+ int start = xml.indexOf("<ForwardedValues>");+ assertTrue(start >= 0);+ String block = xml.substring(start, xml.indexOf("</ForwardedValues>", start));++ String cookies = block.substring(+ block.indexOf("<Cookies>"), block.indexOf("</Cookies>"));+ assertEquals(List.of("session", "tracking"), XmlParser.extractAll(cookies, "Name"),+ "whitelisted cookie names round-trip inside Cookies");++ String headers = block.substring(+ block.indexOf("<Headers>"), block.indexOf("</Headers>"));+ assertEquals(List.of("Origin", "Accept"), XmlParser.extractAll(headers, "Name"),+ "forwarded headers round-trip");+ assertTrue(headers.contains("<Quantity>2</Quantity>"), "Headers.Quantity matches");++ String keys = block.substring(+ block.indexOf("<QueryStringCacheKeys>"), block.indexOf("</QueryStringCacheKeys>"));+ assertEquals(List.of("page"), XmlParser.extractAll(keys, "Name"),+ "query string cache keys round-trip");+ }+ }+private static String distributionConfigBody(String defaultCacheBehaviorExtra) {return """