Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codepipeline): evaluate V2 stage conditions and rules (#4617)
Sam Fakhreddine4c22aaad2e6e
diff --git a/docs/services/codepipeline.md b/docs/services/codepipeline.mdindex 9fcee353ec..c7bd07de4a 100644--- a/docs/services/codepipeline.md+++ b/docs/services/codepipeline.md@@ -72,6 +72,12 @@ as `Approved` or `Rejected`, limits `result.summary` to 512 characters, returns`InvalidApprovalTokenException` for unknown tokens, and returns`ApprovalAlreadyCompletedException` if the same approval token is reused after completion.+## V2 stage conditions++V2 stage condition blocks (`beforeEntry` and `onSuccess`) are evaluated during execution. Two rule providers evaluate for real: **LambdaInvoke** (invokes the configured local Lambda function; the rule passes when the invocation succeeds) and **VariableCheck** (compares a `#{variables.name}` reference with `EQ`, `NE`, `CONTAINS`, or `MATCHES`; `MATCHES` rejects a pattern or value longer than 256 characters). `Commands`, `DeploymentWindow` and `CloudWatchAlarm` rules are accepted but pass permissively. A `VariableCheck` reference resolves against the start request's variables and the pipeline's declared defaults; a reference that cannot be resolved (including action output variables) fails the rule. Every rule run is recorded on the execution and returned by `ListRuleExecutions`; `ListRuleTypes` returns the AWS rule catalog.++A failed `beforeEntry` or `onSuccess` condition applies its declared `result`: `FAIL` (the default) stops the execution, and `SKIP` skips the stage when it is on a `beforeEntry` condition. A failed `onSuccess` condition always fails the stage, because the stage has already run. `OverrideStageCondition` marks the condition overridden and, when the execution failed on exactly that condition, resumes it from the overridden stage. `onFailure` conditions and the `ROLLBACK` result are not acted on; a stage failure is recorded as a plain failure.+## Events and notificationsExecutions publish the real `aws.codepipeline` state-change events to the **defaultdiff --git a/src/main/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineService.java b/src/main/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineService.javaindex 09484faea2..55d8ed631a 100644--- a/src/main/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineService.java+++ b/src/main/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineService.java@@ -66,6 +66,7 @@ import java.util.concurrent.Executors;import java.util.concurrent.RejectedExecutionException;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;+import java.util.regex.Pattern;import java.util.zip.CRC32;import java.util.zip.Inflater;import java.util.zip.InflaterInputStream;@@ -121,8 +122,14 @@ public class CodePipelineService {private final Map<String, byte[]> runtimeArtifacts = new ConcurrentHashMap<>();// An execution's status turns Failed as soon as one action fails, while its runner is still waiting// on sibling actions. Retries check this set so they never overlap a runner that has not finished.- private final Set<String> activeRuns = ConcurrentHashMap.newKeySet();+ final Set<String> activeRuns = ConcurrentHashMap.newKeySet();private final long sourcePollIntervalMs;+ // Test hooks, set only through the package-private constructor: a shortened wait, and a probe+ // for the gap before the override timeout cleanup.+ private final long runFinishWaitNanos;+ private final Runnable beforeOverrideTimeoutCleanup;++ private static final long DEFAULT_RUN_FINISH_WAIT_NANOS = TimeUnit.SECONDS.toNanos(5);/** Matches the {@code source-poll-interval-ms} default in application.yml. */private static final long DEFAULT_SOURCE_POLL_INTERVAL_MS = 500L;@@ -135,7 +142,8 @@ public class CodePipelineService {CodeBuildService codeBuildService, CodeDeployService codeDeployService,LambdaService lambdaService, S3Service s3Service) {this(storageFactory, mapper, codeBuildService, codeDeployService, lambdaService, s3Service,- detachedEventPublisher(mapper), DEFAULT_SOURCE_POLL_INTERVAL_MS);+ detachedEventPublisher(mapper), DEFAULT_SOURCE_POLL_INTERVAL_MS,+ DEFAULT_RUN_FINISH_WAIT_NANOS, () -> { });}public CodePipelineService(StorageFactory storageFactory, ObjectMapper mapper,@@ -153,7 +161,8 @@ public class CodePipelineService {EmulatorConfig config, CodePipelineEventPublisher eventPublisher) {this(storageFactory, mapper, codeBuildService, codeDeployService, lambdaService, s3Service,eventPublisher,- resolveSourcePollInterval(config.services().codepipeline().sourcePollIntervalMs()));+ resolveSourcePollInterval(config.services().codepipeline().sourcePollIntervalMs()),+ DEFAULT_RUN_FINISH_WAIT_NANOS, () -> { });}/**@@ -179,10 +188,11 @@ public class CodePipelineService {}@SuppressWarnings("unchecked")- private CodePipelineService(StorageFactory storageFactory, ObjectMapper mapper,- CodeBuildService codeBuildService, CodeDeployService codeDeployService,- LambdaService lambdaService, S3Service s3Service,- CodePipelineEventPublisher eventPublisher, long sourcePollIntervalMs) {+ CodePipelineService(StorageFactory storageFactory, ObjectMapper mapper,+ CodeBuildService codeBuildService, CodeDeployService codeDeployService,+ LambdaService lambdaService, S3Service s3Service,+ CodePipelineEventPublisher eventPublisher, long sourcePollIntervalMs,+ long runFinishWaitNanos, Runnable beforeOverrideTimeoutCleanup) {this.pipelineStore = storageFactory.create("codepipeline", "codepipeline-pipelines.json", new TypeReference<Map<String, CodePipelinePipeline>>() {});this.executionStore = storageFactory.create(@@ -196,6 +206,8 @@ public class CodePipelineService {this.s3Service = s3Service;this.eventPublisher = eventPublisher;this.sourcePollIntervalMs = sourcePollIntervalMs;+ this.runFinishWaitNanos = runFinishWaitNanos;+ this.beforeOverrideTimeoutCleanup = beforeOverrideTimeoutCleanup;}public JsonNode handle(String action, JsonNode request, String region, String account) {@@ -224,7 +236,7 @@ public class CodePipelineService {case "GetActionType" -> getActionType(request, region, account);case "DeleteCustomActionType" -> deleteCustomActionType(request, region, account);case "ListActionTypes" -> listActionTypes(request, region, account);- case "ListRuleTypes" -> emptyPage("ruleTypes");+ case "ListRuleTypes" -> listRuleTypes();case "PollForJobs" -> pollForJobs(request, region, account, false);case "PollForThirdPartyJobs" -> pollForJobs(request, region, account, true);case "AcknowledgeJob", "AcknowledgeThirdPartyJob" -> acknowledgeJob(request, region, account);@@ -568,7 +580,7 @@ public class CodePipelineService {execution.setLastUpdateTime(execution.getStartTime());execution.setSourceRevisions(new ArrayList<>());execution.setSourceRevisionOverrides(sourceRevisionOverrides(request, pipeline));- execution.setVariables(variableList(request.path("variables")));+ execution.setVariables(variableList(request.path("variables"), pipeline.getDeclaration().path("variables")));Map<String, String> trigger = new LinkedHashMap<>();trigger.put("triggerType", triggerType);trigger.put("triggerDetail", triggerDetail);@@ -590,9 +602,7 @@ public class CodePipelineService {execution.setLastUpdateTime(now());putExecution(execution);eventPublisher.pipelineStateChange(execution, "FAILED");- throw new AwsException("ConflictException",- "Your request cannot be handled because the pipeline is busy handling ongoing activities. "- + "Try again later.", 400);+ throw pipelineBusy();}return mapper.createObjectNode().put("pipelineExecutionId", execution.getPipelineExecutionId());}@@ -875,13 +885,17 @@ public class CodePipelineService {execution.setStatusSummary("Stage retry could not be scheduled.");execution.setLastUpdateTime(now());putExecution(execution);- throw new AwsException("ConflictException",- "Your request cannot be handled because the pipeline is busy handling ongoing activities. "- + "Try again later.", 400);+ throw pipelineBusy();}return mapper.createObjectNode().put("pipelineExecutionId", executionId);}+ private static AwsException pipelineBusy() {+ return new AwsException("ConflictException",+ "Your request cannot be handled because the pipeline is busy handling ongoing activities. "+ + "Try again later.", 400);+ }+// Runs under startLocks so two concurrent retries cannot both pass the status checks,// and so a retry counts against the same active-execution cap StartPipelineExecution enforces.private Map<String, String> admitRetry(CodePipelinePipeline pipeline, CodePipelineExecution execution,@@ -959,13 +973,195 @@ public class CodePipelineService {}private ObjectNode overrideStageCondition(JsonNode request, String region, String account) {- requireExecution(account, region, text(request, "pipelineName"), text(request, "pipelineExecutionId"));+ String pipelineName = text(request, "pipelineName");+ String stageName = text(request, "stageName");+ String conditionType = text(request, "conditionType");+ if (!"BEFORE_ENTRY".equals(conditionType) && !"ON_SUCCESS".equals(conditionType)) {+ throw new AwsException("ValidationException",+ "conditionType must be BEFORE_ENTRY or ON_SUCCESS", 400);+ }+ CodePipelinePipeline pipeline = requirePipeline(account, region, pipelineName);+ JsonNode stage = stageByName(pipeline, stageName);+ CodePipelineExecution execution = requireExecution(+ account, region, pipelineName, text(request, "pipelineExecutionId"));+ if (!Objects.equals(execution.getPipelineVersion(), pipeline.getVersion())) {+ throw new AwsException("ConditionNotOverridableException",+ "The pipeline structure changed after this execution started", 400);+ }+ // A run that failed on this very condition resumes from the overridden stage, skipping the+ // stage's already-succeeded actions; admission shares the retry path's lock and run tracking.+ // The run marks itself Failed slightly before it leaves activeRuns; an override landing in that+ // window waits (outside the lock, which finishExecutionRun needs) for the run to finish, so it+ // resumes instead of storing a flag nothing will read.+ String conditionFailedSummary = "Condition " + conditionType + " failed in stage " + stageName + ".";+ boolean[] runStillFinishing = new boolean[1];+ Map<String, String> resumed = null;+ long finishDeadline = System.nanoTime() + runFinishWaitNanos;+ do {+ runStillFinishing[0] = false;+ resumed = startLocks.withLock(lockKey(execution), () -> {+ synchronized (execution) {+ execution.getConditionOverrides().put(stageName + "/" + conditionType, true);+ }+ boolean failedOnThisCondition = "Failed".equals(execution.getStatus())+ && conditionFailedSummary.equals(execution.getStatusSummary());+ if (failedOnThisCondition && activeRuns.contains(runKey(execution))) {+ runStillFinishing[0] = true;+ return null;+ }+ if (!failedOnThisCondition) {+ putExecution(execution);+ return null;+ }+ execution.setStatus("InProgress");+ execution.setStatusSummary("Condition " + conditionType + " overridden in stage "+ + stageName + ".");+ execution.setStopRequested(false);+ execution.setAbandon(false);+ execution.setLastUpdateTime(now());+ putExecution(execution);+ activeRuns.add(runKey(execution));+ return latestActionStatuses(execution, stageName);+ });+ if (runStillFinishing[0]) {+ try {+ TimeUnit.MILLISECONDS.sleep(10);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ break;+ }+ }+ } while (runStillFinishing[0] && System.nanoTime() - finishDeadline < 0);+ if (runStillFinishing[0]) {+ beforeOverrideTimeoutCleanup.run();+ // Another override may have resumed the run since this waiter's last check; clear the flag+ // only under the resume lock and only while the run is still failed on this condition.+ startLocks.withLock(lockKey(execution), () -> {+ synchronized (execution) {+ if ("Failed".equals(execution.getStatus())+ && conditionFailedSummary.equals(execution.getStatusSummary())) {+ execution.getConditionOverrides().remove(stageName + "/" + conditionType);+ putExecution(execution);+ }+ }+ return null;+ });+ throw pipelineBusy();+ }+ Map<String, String> resumeStatuses = resumed;+ if (resumeStatuses != null) {+ try {+ executor.submit(() -> runRetriedStage(pipeline, execution, stage, "FAILED_ACTIONS",+ resumeStatuses));+ } catch (RejectedExecutionException exception) {+ activeRuns.remove(runKey(execution));+ execution.setStatus("Failed");+ execution.setStatusSummary("Stage resume could not be scheduled.");+ execution.setLastUpdateTime(now());+ putExecution(execution);+ throw pipelineBusy();+ }+ }return mapper.createObjectNode();}private ObjectNode listRuleExecutions(JsonNode request, String region, String account) {- requirePipeline(account, region, text(request, "pipelineName"));- return emptyPage("ruleExecutionDetails");+ String pipelineName = text(request, "pipelineName");+ requirePipeline(account, region, pipelineName);+ String executionFilter = request.path("filter").path("pipelineExecutionId").asText(null);+ List<ObjectNode> details = new ArrayList<>();+ for (CodePipelineExecution execution : executions(account, region, pipelineName)) {+ if (executionFilter != null+ && !executionFilter.equals(execution.getPipelineExecutionId())) {+ continue;+ }+ List<Map<String, Object>> ruleSnapshot = new ArrayList<>();+ synchronized (execution) {+ for (Map<String, Object> rule : execution.getRuleExecutions()) {+ ruleSnapshot.add(new LinkedHashMap<>(rule));+ }+ }+ for (Map<String, Object> rule : ruleSnapshot) {+ ObjectNode detail = mapper.createObjectNode();+ detail.put("pipelineExecutionId", execution.getPipelineExecutionId());+ detail.put("ruleExecutionId", Objects.toString(rule.get("ruleExecutionId"), null));+ if (execution.getPipelineVersion() != null) {+ detail.put("pipelineVersion", execution.getPipelineVersion());+ }+ detail.put("stageName", Objects.toString(rule.get("stageName"), null));+ detail.put("ruleName", Objects.toString(rule.get("ruleName"), null));+ detail.put("status", Objects.toString(rule.get("status"), null));+ if (rule.get("startTime") instanceof Number start) {+ detail.put("startTime", start.doubleValue());+ }+ if (rule.get("lastUpdateTime") instanceof Number updated) {+ detail.put("lastUpdateTime", updated.doubleValue());+ }+ ObjectNode input = detail.putObject("input");+ input.putObject("ruleTypeId")+ .put("category", "Rule")+ .put("owner", "AWS")+ .put("provider", Objects.toString(rule.get("ruleProvider"), ""))+ .put("version", "1");+ detail.putObject("output").putObject("executionResult")+ .put("externalExecutionSummary", Objects.toString(rule.get("summary"), ""));+ details.add(detail);+ }+ }+ Page page = page(request, details.size(), 100);+ ObjectNode response = mapper.createObjectNode();+ ArrayNode array = response.putArray("ruleExecutionDetails");+ for (int i = page.start(); i < page.end(); i++) {+ array.add(details.get(i));+ }+ addNextToken(response, page, details.size());+ return response;+ }++ /** The AWS-owned rule types available for V2 stage conditions. */+ private ObjectNode listRuleTypes() {+ ObjectNode response = mapper.createObjectNode();+ ArrayNode ruleTypes = response.putArray("ruleTypes");+ ruleTypes.add(ruleTypeNode("LambdaInvoke",+ "Invokes a Lambda function and passes when the invocation succeeds",+ List.of("FunctionName")));+ ruleTypes.add(ruleTypeNode("VariableCheck",+ "Compares a pipeline variable against a value with EQ, NE, CONTAINS or MATCHES",+ List.of("Variable", "Value", "Operator")));+ ruleTypes.add(ruleTypeNode("Commands",+ "Runs shell commands (accepted but not evaluated by the emulator)",+ List.of("Commands")));+ ruleTypes.add(ruleTypeNode("DeploymentWindow",+ "Restricts deployments to a time window (accepted but not evaluated by the emulator)",+ List.of("Cron", "TimeZone")));+ ruleTypes.add(ruleTypeNode("CloudWatchAlarm",+ "Passes when a CloudWatch alarm is in the expected state (accepted but not evaluated by the emulator)",+ List.of("AlarmName", "AlarmStates")));+ return response;+ }++ private ObjectNode ruleTypeNode(String provider, String description, List<String> properties) {+ ObjectNode node = mapper.createObjectNode();+ node.putObject("id")+ .put("category", "Rule")+ .put("owner", "AWS")+ .put("provider", provider)+ .put("version", "1");+ ObjectNode settings = node.putObject("settings");+ settings.put("thirdPartyConfigurationUrl", "");+ ArrayNode props = node.putArray("ruleConfigurationProperties");+ for (String property : properties) {+ props.addObject()+ .put("name", property)+ .put("required", true)+ .put("key", true)+ .put("secret", false)+ .put("description", description);+ }+ node.putObject("inputArtifactDetails")+ .put("minimumCount", 0)+ .put("maximumCount", 1);+ return node;}private ObjectNode createCustomActionType(JsonNode request, String region, String account) {@@ -1200,22 +1396,9 @@ public class CodePipelineService {String stageName = stage.path("name").asText();try {int stageIndex = stageIndex(pipeline, stageName);- execution.setCurrentStage(stageName);- execution.getStageExecutionStatuses().put(stageName, "InProgress");- execution.setLastUpdateTime(now());- putExecution(execution);- runStage(pipeline, execution, stage, retryMode, previousStatuses);- if ("Failed".equals(execution.getStatus())) {- execution.getStageExecutionStatuses().put(stageName, "Failed");- return;- }- if (finishIfStopped(execution)) {+ if (!runStageInRun(pipeline, execution, stage, retryMode, previousStatuses)) {return;}- execution.getStageExecutionStatuses().put(stageName, "Succeeded");- execution.setCurrentStage(null);- execution.setLastUpdateTime(now());- putExecution(execution);runStagesFrom(pipeline, execution, stageIndex + 1);} catch (Exception e) {if (execution.getCurrentStage() != null) {@@ -1239,29 +1422,259 @@ public class CodePipelineService {if (finishIfStopped(execution)) {return;}- execution.setCurrentStage(stageName);- execution.getStageExecutionStatuses().put(stageName, "InProgress");- execution.setLastUpdateTime(now());- putExecution(execution);- eventPublisher.stageStateChange(execution, stageName, "STARTED");- runStage(pipeline, execution, stage);- if ("Failed".equals(execution.getStatus())) {- execution.getStageExecutionStatuses().put(stageName, "Failed");- eventPublisher.stageStateChange(execution, stageName, "FAILED");- return;- }- if (finishIfStopped(execution)) {- eventPublisher.stageStateChange(execution, stageName, "STOPPED");+ if (!runStageInRun(pipeline, execution, stage, "ALL_ACTIONS", Map.of())) {return;}- execution.getStageExecutionStatuses().put(stageName, "Succeeded");+ }+ execution.setStatus("Succeeded");+ execution.setStatusSummary("Pipeline execution succeeded.");+ }++ /**+ * Runs one stage of an execution, between its V2 {@code beforeEntry} and {@code onSuccess}+ * conditions.+ *+ * @return {@code false} when the execution must not continue to the next stage+ */+ private boolean runStageInRun(CodePipelinePipeline pipeline, CodePipelineExecution execution, JsonNode stage,+ String retryMode, Map<String, String> previousStatuses) {+ String stageName = stage.path("name").asText();+ execution.setCurrentStage(stageName);+ execution.getStageExecutionStatuses().put(stageName, "InProgress");+ execution.setLastUpdateTime(now());+ putExecution(execution);++ // Evaluated before STARTED is published: AWS documents no skipped-stage event, so a stage+ // skipped by its beforeEntry condition emits no stage events at all.+ ConditionOutcome entry = evaluateConditions(execution, stage, "BEFORE_ENTRY");+ if (entry == ConditionOutcome.SKIP_STAGE) {+ execution.getStageExecutionStatuses().put(stageName, "Skipped");execution.setCurrentStage(null);execution.setLastUpdateTime(now());putExecution(execution);- eventPublisher.stageStateChange(execution, stageName, "SUCCEEDED");+ return true;}- execution.setStatus("Succeeded");- execution.setStatusSummary("Pipeline execution succeeded.");+ eventPublisher.stageStateChange(execution, stageName, "STARTED");+ if (entry == ConditionOutcome.FAIL) {+ failForCondition(execution, stageName, "BEFORE_ENTRY");+ execution.getStageExecutionStatuses().put(stageName, "Failed");+ eventPublisher.stageStateChange(execution, stageName, "FAILED");+ return false;+ }++ runStage(pipeline, execution, stage, retryMode, previousStatuses);+ if ("Failed".equals(execution.getStatus())) {+ execution.getStageExecutionStatuses().put(stageName, "Failed");+ eventPublisher.stageStateChange(execution, stageName, "FAILED");+ return false;+ }+ if (finishIfStopped(execution)) {+ eventPublisher.stageStateChange(execution, stageName, "STOPPED");+ return false;+ }++ // A SKIP result only makes sense before entry; after the stage ran it cannot be skipped, so a+ // failed onSuccess condition fails the stage whatever its declared result.+ if (evaluateConditions(execution, stage, "ON_SUCCESS") != ConditionOutcome.PASS) {+ failForCondition(execution, stageName, "ON_SUCCESS");+ execution.getStageExecutionStatuses().put(stageName, "Failed");+ eventPublisher.stageStateChange(execution, stageName, "FAILED");+ return false;+ }+ execution.getStageExecutionStatuses().put(stageName, "Succeeded");+ execution.setCurrentStage(null);+ execution.setLastUpdateTime(now());+ putExecution(execution);+ eventPublisher.stageStateChange(execution, stageName, "SUCCEEDED");+ return true;+ }++ // ---------------------------------------------------------------- V2 stage conditions++ private enum ConditionOutcome { PASS, FAIL, SKIP_STAGE }++ /**+ * Evaluates the stage's {@code beforeEntry}/{@code onSuccess} condition block. Rules run+ * through the AWS rule providers we emulate: {@code LambdaInvoke} (real invocation via the+ * Lambda service) and {@code VariableCheck} (pipeline-variable comparison); other providers+ * pass permissively. A condition overridden via OverrideStageCondition always passes.+ */+ private ConditionOutcome evaluateConditions(CodePipelineExecution execution, JsonNode stage,+ String conditionType) {+ JsonNode block = stage.path(conditionBlockField(conditionType));+ if (block.isMissingNode() || !block.has("conditions")) {+ return ConditionOutcome.PASS;+ }+ if (Boolean.TRUE.equals(execution.getConditionOverrides()+ .get(stage.path("name").asText() + "/" + conditionType))) {+ return ConditionOutcome.PASS;+ }+ for (JsonNode condition : block.path("conditions")) {+ boolean passed = true;+ for (JsonNode rule : condition.path("rules")) {+ if (!evaluateRule(execution, stage.path("name").asText(), conditionType, rule)) {+ passed = false;+ }+ }+ if (!passed) {+ return "SKIP".equals(condition.path("result").asText("FAIL")) && "BEFORE_ENTRY".equals(conditionType)+ ? ConditionOutcome.SKIP_STAGE : ConditionOutcome.FAIL;+ }+ }+ return ConditionOutcome.PASS;+ }++ private static String conditionBlockField(String conditionType) {+ return switch (conditionType) {+ case "BEFORE_ENTRY" -> "beforeEntry";+ case "ON_SUCCESS" -> "onSuccess";+ case "ON_FAILURE" -> "onFailure";+ default -> throw new AwsException("ValidationException",+ "Unknown condition type " + conditionType, 400);+ };+ }++ private boolean evaluateRule(CodePipelineExecution execution, String stageName,+ String conditionType, JsonNode rule) {+ Map<String, Object> record = new LinkedHashMap<>();+ record.put("ruleExecutionId", UUID.randomUUID().toString());+ record.put("ruleName", rule.path("name").asText());+ record.put("stageName", stageName);+ record.put("conditionType", conditionType);+ record.put("ruleProvider", rule.path("ruleTypeId").path("provider").asText());+ record.put("startTime", now());+ record.put("status", "InProgress");+ synchronized (execution) {+ execution.getRuleExecutions().add(record);+ putExecution(execution);+ }+ boolean passed;+ String summary;+ try {+ String provider = rule.path("ruleTypeId").path("provider").asText();+ passed = switch (provider) {+ case "LambdaInvoke" -> lambdaRulePasses(execution, rule);+ case "VariableCheck" -> variableCheckPasses(execution, rule);+ // Commands / DeploymentWindow / CloudWatchAlarm and unknown providers pass permissively.+ default -> true;+ };+ summary = passed ? "Rule passed." : "Rule condition was not met.";+ } catch (Exception e) {+ passed = false;+ summary = Objects.toString(e.getMessage(), "Rule evaluation failed");+ }+ synchronized (execution) {+ record.put("status", passed ? "Succeeded" : "Failed");+ record.put("summary", summary);+ record.put("lastUpdateTime", now());+ putExecution(execution);+ }+ return passed;+ }++ private boolean lambdaRulePasses(CodePipelineExecution execution, JsonNode rule) {+ String functionName = rule.path("configuration").path("FunctionName").asText(null);+ if (functionName == null) {+ throw new AwsException("ValidationException",+ "LambdaInvoke rules require configuration.FunctionName", 400);+ }+ ObjectNode event = mapper.createObjectNode();+ event.put("ruleName", rule.path("name").asText());+ event.put("pipelineName", execution.getPipelineName());+ event.put("pipelineExecutionId", execution.getPipelineExecutionId());+ InvokeResult result = lambdaService.invoke(execution.getRegion(), functionName,+ event.toString().getBytes(StandardCharsets.UTF_8), InvocationType.RequestResponse);+ return result.getFunctionError() == null && result.getStatusCode() < 400;+ }++ /** Above this length, a MATCHES pattern or subject is rejected rather than risking+ * catastrophic regex backtracking on pipeline-declared input. */+ private static final int MAX_VARIABLE_CHECK_MATCH_LENGTH = 256;++ private static final long MATCHES_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(1);++ /** A regex subject whose {@code charAt} throws once the deadline passes, so a catastrophically+ * backtracking pattern aborts instead of holding the run forever. */+ private static final class DeadlineCharSequence implements CharSequence {+ private final CharSequence delegate;+ private final long deadlineNanos;++ DeadlineCharSequence(CharSequence delegate, long deadlineNanos) {+ this.delegate = delegate;+ this.deadlineNanos = deadlineNanos;+ }++ @Override+ public char charAt(int index) {+ if (System.nanoTime() - deadlineNanos > 0) {+ throw new IllegalStateException("MATCHES pattern evaluation timed out");+ }+ return delegate.charAt(index);+ }++ @Override+ public int length() {+ return delegate.length();+ }++ @Override+ public CharSequence subSequence(int start, int end) {+ return new DeadlineCharSequence(delegate.subSequence(start, end), deadlineNanos);+ }++ @Override+ public String toString() {+ return delegate.toString();+ }+ }++ private boolean variableCheckPasses(CodePipelineExecution execution, JsonNode rule) {+ JsonNode config = rule.path("configuration");+ String variable = resolveVariableReference(execution, config.path("Variable").asText(""));+ String value = config.path("Value").asText("");+ return switch (config.path("Operator").asText("EQ")) {+ case "EQ" -> variable.equals(value);+ case "NE" -> !variable.equals(value);+ case "CONTAINS" -> variable.contains(value);+ case "MATCHES" -> {+ if (value.length() > MAX_VARIABLE_CHECK_MATCH_LENGTH+ || variable.length() > MAX_VARIABLE_CHECK_MATCH_LENGTH) {+ throw new AwsException("ValidationException",+ "VariableCheck MATCHES pattern or value exceeds "+ + MAX_VARIABLE_CHECK_MATCH_LENGTH + " characters", 400);+ }+ yield Pattern.compile(value).matcher(new DeadlineCharSequence(variable,+ System.nanoTime() + MATCHES_TIMEOUT_NANOS)).matches();+ }+ default -> throw new AwsException("ValidationException",+ "Unknown VariableCheck operator", 400);+ };+ }++ /** Resolves {@code #{variables.name}} references against the execution's variables. */+ private String resolveVariableReference(CodePipelineExecution execution, String reference) {+ String name = reference;+ if (reference.startsWith("#{") && reference.endsWith("}")) {+ name = reference.substring(2, reference.length() - 1);+ if (name.startsWith("variables.")) {+ name = name.substring("variables.".length());+ }+ }+ for (Map<String, String> variable : execution.getVariables()) {+ if (variable.get("name").equals(name)) {+ return variable.getOrDefault("resolvedValue", "");+ }+ }+ // An unresolved reference must fail the rule, not compare as its own placeholder text.+ throw new AwsException("ValidationException",+ "VariableCheck variable " + reference + " could not be resolved", 400);+ }++ private void failForCondition(CodePipelineExecution execution, String stageName, String conditionType) {+ execution.setStatus("Failed");+ execution.setStatusSummary(+ "Condition " + conditionType + " failed in stage " + stageName + ".");+ putExecution(execution);}private void finishExecutionRun(CodePipelineExecution execution) {@@ -2038,9 +2451,12 @@ public class CodePipelineService {}private void putExecution(CodePipelineExecution execution) {- executionStore.putForAccount(execution.getAccountId(),- executionKey(execution.getRegion(), execution.getPipelineName(),- execution.getPipelineExecutionId()), execution);+ // Serializing the execution walks its rule records, which evaluateRule mutates under this lock.+ synchronized (execution) {+ executionStore.putForAccount(execution.getAccountId(),+ executionKey(execution.getRegion(), execution.getPipelineName(),+ execution.getPipelineExecutionId()), execution);+ }}private void storeItem(String account, String region, String type, String id,@@ -2207,7 +2623,7 @@ public class CodePipelineService {node.remove(List.of("accountId", "region", "startTime", "lastUpdateTime","sourceRevisions", "sourceRevisionOverrides", "actionExecutions", "currentStage","stopRequested", "abandon", "rollbackTargetPipelineExecutionId", "stageExecutionStatuses",- "artifactsReleased"));+ "artifactsReleased", "ruleExecutions", "conditionOverrides"));if (execution.getRollbackTargetPipelineExecutionId() != null) {node.putObject("rollbackMetadata").put("rollbackTargetPipelineExecutionId", execution.getRollbackTargetPipelineExecutionId());@@ -2422,15 +2838,26 @@ public class CodePipelineService {execution.getSourceRevisions().add(sourceRevision);}- private List<Map<String, String>> variableList(JsonNode node) {+ /** The request's variables, plus the declared default of every pipeline variable it omits. */+ private List<Map<String, String>> variableList(JsonNode node, JsonNode declared) {List<Map<String, String>> result = new ArrayList<>();+ Set<String> supplied = new HashSet<>();if (node != null && node.isArray()) {for (JsonNode variable : node) {+ supplied.add(variable.path("name").asText());result.add(Map.of("name", variable.path("name").asText(),"resolvedValue", variable.path("value").asText()));}}+ if (declared != null && declared.isArray()) {+ for (JsonNode variable : declared) {+ String name = variable.path("name").asText();+ if (!supplied.contains(name) && variable.hasNonNull("defaultValue")) {+ result.add(Map.of("name", name, "resolvedValue", variable.path("defaultValue").asText()));+ }+ }+ }return result;}diff --git a/src/main/java/io/github/hectorvent/floci/services/codepipeline/model/CodePipelineExecution.java b/src/main/java/io/github/hectorvent/floci/services/codepipeline/model/CodePipelineExecution.javaindex 2978731eaa..5ea450a7e8 100644--- a/src/main/java/io/github/hectorvent/floci/services/codepipeline/model/CodePipelineExecution.java+++ b/src/main/java/io/github/hectorvent/floci/services/codepipeline/model/CodePipelineExecution.java@@ -37,6 +37,9 @@ public class CodePipelineExecution {private volatile boolean abandon;private volatile boolean artifactsReleased;private String rollbackTargetPipelineExecutionId;+ private List<Map<String, Object>> ruleExecutions = new ArrayList<>();+ /** Overridden stage conditions, keyed {@code <stageName>/<conditionType>}. */+ private Map<String, Boolean> conditionOverrides = new LinkedHashMap<>();public String getAccountId() {return accountId;@@ -223,6 +226,22 @@ public class CodePipelineExecution {this.rollbackTargetPipelineExecutionId = rollbackTargetPipelineExecutionId;}+ public List<Map<String, Object>> getRuleExecutions() {+ return ruleExecutions;+ }++ public void setRuleExecutions(List<Map<String, Object>> ruleExecutions) {+ this.ruleExecutions = ruleExecutions;+ }++ public Map<String, Boolean> getConditionOverrides() {+ return conditionOverrides;+ }++ public void setConditionOverrides(Map<String, Boolean> conditionOverrides) {+ this.conditionOverrides = conditionOverrides;+ }+@RegisterForReflection@JsonInclude(JsonInclude.Include.NON_NULL)public static class ActionExecution {diff --git a/src/test/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineV2ConditionsTest.java b/src/test/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineV2ConditionsTest.javanew file mode 100644index 0000000000..0ca8a30c48--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codepipeline/CodePipelineV2ConditionsTest.java@@ -0,0 +1,493 @@+package io.github.hectorvent.floci.services.codepipeline;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.codebuild.CodeBuildService;+import io.github.hectorvent.floci.services.codepipeline.model.CodePipelineExecution;+import io.github.hectorvent.floci.services.codedeploy.CodeDeployService;+import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;+import io.github.hectorvent.floci.services.lambda.LambdaService;+import io.github.hectorvent.floci.services.lambda.model.InvocationType;+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.services.s3.model.S3Object;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.time.Duration;+import java.io.IOException;+import java.time.Instant;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicBoolean;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;+import static org.junit.jupiter.api.Assertions.fail;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.atLeastOnce;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * V2 stage condition evaluation: beforeEntry/onSuccess rules (VariableCheck, LambdaInvoke),+ * the FAIL and SKIP results, rule-execution records, and OverrideStageCondition resume.+ */+class CodePipelineV2ConditionsTest {++ private static final String ACCOUNT = "000000000000";+ private static final String REGION = "us-east-1";++ private final ObjectMapper mapper = new ObjectMapper();+ private LambdaService lambdaService;+ private S3Service s3Service;+ private CodePipelineService service;+ private InMemoryStorageFactory storageFactory;++ @BeforeEach+ void setUp() {+ lambdaService = mock(LambdaService.class);+ s3Service = mock(S3Service.class);+ S3Object object = mock(S3Object.class);+ when(object.getData()).thenReturn("artifact".getBytes());+ when(object.getETag()).thenReturn("etag-1");+ when(object.getVersionId()).thenReturn("v1");+ when(object.getLastModified()).thenReturn(Instant.now());+ when(s3Service.getObject(anyString(), anyString())).thenReturn(object);+ // The S3 source action reads a pinned version, and CreatePipeline baselines source polling.+ when(s3Service.getObject(anyString(), anyString(), any())).thenReturn(object);+ when(s3Service.headObject(anyString(), anyString())).thenReturn(object);+ lambdaReturns(null);++ storageFactory = new InMemoryStorageFactory();+ service = new CodePipelineService(storageFactory, mapper, mock(CodeBuildService.class),+ mock(CodeDeployService.class), lambdaService, s3Service);+ }++ private void lambdaReturns(String functionError) {+ InvokeResult result = mock(InvokeResult.class);+ when(result.getStatusCode()).thenReturn(200);+ when(result.getFunctionError()).thenReturn(functionError);+ when(result.getRequestId()).thenReturn("req-1");+ when(lambdaService.invoke(anyString(), anyString(), any(byte[].class), any(InvocationType.class)))+ .thenReturn(result);+ }++ // ---------------------------------------------------------------- helpers++ private ObjectNode sourceStage() {+ ObjectNode stage = mapper.createObjectNode();+ stage.put("name", "Fetch");+ ObjectNode action = stage.putArray("actions").addObject();+ action.put("name", "S3Source");+ action.putObject("actionTypeId")+ .put("category", "Source").put("owner", "AWS").put("provider", "S3").put("version", "1");+ action.putObject("configuration").put("S3Bucket", "bucket").put("S3ObjectKey", "app.zip");+ action.putArray("outputArtifacts").addObject().put("name", "SourceOut");+ action.put("runOrder", 1);+ return stage;+ }++ private ObjectNode lambdaStage(String stageName) {+ ObjectNode stage = mapper.createObjectNode();+ stage.put("name", stageName);+ ObjectNode action = stage.putArray("actions").addObject();+ action.put("name", stageName + "Fn");+ action.putObject("actionTypeId")+ .put("category", "Invoke").put("owner", "AWS").put("provider", "Lambda").put("version", "1");+ action.putObject("configuration").put("FunctionName", "fn-" + stageName);+ action.put("runOrder", 1);+ return stage;+ }++ /** Adds a one-rule condition to the stage's {@code block} (beforeEntry or onSuccess). */+ private ObjectNode addRule(ObjectNode stage, String block, String result, String provider) {+ ObjectNode condition = stage.putObject(block).putArray("conditions").addObject();+ condition.put("result", result);+ ObjectNode rule = condition.putArray("rules").addObject();+ rule.put("name", "rule-" + provider);+ rule.putObject("ruleTypeId")+ .put("category", "Rule").put("owner", "AWS").put("provider", provider).put("version", "1");+ return rule.putObject("configuration");+ }++ private ObjectNode pipelineDeclaration(String name, ObjectNode... stages) {+ ObjectNode declaration = mapper.createObjectNode();+ declaration.put("name", name);+ declaration.put("roleArn", "arn:aws:iam::000000000000:role/cp");+ declaration.putObject("artifactStore").put("type", "S3").put("location", "bucket");+ ArrayNode stageArray = declaration.putArray("stages");+ for (ObjectNode stage : stages) {+ stageArray.add(stage);+ }+ return declaration;+ }++ private void createPipeline(String name, ObjectNode... stages) {+ service.handle("CreatePipeline", mapper.createObjectNode().set("pipeline", pipelineDeclaration(name, stages)),+ REGION, ACCOUNT);+ }++ private String startExecution(String pipelineName) {+ JsonNode result = service.handle("StartPipelineExecution",+ mapper.createObjectNode().put("name", pipelineName), REGION, ACCOUNT);+ return result.path("pipelineExecutionId").asText();+ }++ private JsonNode awaitStatus(String pipelineName, String executionId, String expected) {+ long deadline = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(10);+ while (System.currentTimeMillis() < deadline) {+ JsonNode execution = service.handle("GetPipelineExecution", mapper.createObjectNode()+ .put("pipelineName", pipelineName).put("pipelineExecutionId", executionId),+ REGION, ACCOUNT).path("pipelineExecution");+ if (expected.equals(execution.path("status").asText())) {+ return execution;+ }+ try {+ TimeUnit.MILLISECONDS.sleep(50);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ }+ return fail("Execution " + executionId + " did not reach " + expected + " in time");+ }++ private JsonNode ruleExecutions(String pipelineName) {+ return service.handle("ListRuleExecutions",+ mapper.createObjectNode().put("pipelineName", pipelineName), REGION, ACCOUNT)+ .path("ruleExecutionDetails");+ }++ // ---------------------------------------------------------------- tests++ @Test+ void onSuccessVariableCheckFailureFailsExecutionAndOverrideResumes() {+ // Catches: a failed onSuccess VariableCheck not failing the run, or OverrideStageCondition+ // not resuming an execution that failed on exactly that condition.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "prod").put("Operator", "EQ");+ createPipeline("conditional", sourceStage(), deploy);++ // Start without the expected variable: the ON_SUCCESS condition fails the run.+ String executionId = startExecution("conditional");+ JsonNode failed = awaitStatus("conditional", executionId, "Failed");+ assertEquals("Condition ON_SUCCESS failed in stage Deploy.", failed.path("statusSummary").asText());+ assertEquals(1, ruleExecutions("conditional").size());+ assertEquals("Failed", ruleExecutions("conditional").get(0).path("status").asText());++ // Overriding the failed condition resumes the execution to success.+ service.handle("OverrideStageCondition", mapper.createObjectNode()+ .put("pipelineName", "conditional")+ .put("pipelineExecutionId", executionId)+ .put("stageName", "Deploy")+ .put("conditionType", "ON_SUCCESS"), REGION, ACCOUNT);+ awaitStatus("conditional", executionId, "Succeeded");+ }++ @Test+ void variableCheckMatchesRejectsAnOverlongPatternInsteadOfRunningIt() {+ // Catches: an unbounded MATCHES regex being evaluated against pipeline-declared input.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "a".repeat(257)).put("Operator", "MATCHES");+ createPipeline("matches-overlong", sourceStage(), deploy);++ ObjectNode start = mapper.createObjectNode().put("name", "matches-overlong");+ start.putArray("variables").addObject().put("name", "env").put("value", "prod");+ String executionId = service.handle("StartPipelineExecution", start, REGION, ACCOUNT)+ .path("pipelineExecutionId").asText();+ awaitStatus("matches-overlong", executionId, "Failed");+ JsonNode rules = ruleExecutions("matches-overlong");+ assertEquals(1, rules.size());+ assertEquals("Failed", rules.get(0).path("status").asText());+ assertEquals("VariableCheck MATCHES pattern or value exceeds 256 characters",+ rules.get(0).path("output").path("executionResult").path("externalExecutionSummary").asText());+ }++ @Test+ void variableCheckMatchesFailsARuleWhosePatternBacktracksCatastrophically() {+ // Catches: a short but pathological MATCHES pattern spinning forever inside the run.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "(a+)+\\1").put("Operator", "MATCHES");+ createPipeline("matches-redos", sourceStage(), deploy);++ ObjectNode start = mapper.createObjectNode().put("name", "matches-redos");+ start.putArray("variables").addObject().put("name", "env").put("value", "a".repeat(30) + "!");+ String executionId = service.handle("StartPipelineExecution", start, REGION, ACCOUNT)+ .path("pipelineExecutionId").asText();+ assertTimeoutPreemptively(Duration.ofSeconds(10), () -> {+ awaitStatus("matches-redos", executionId, "Failed");+ });+ JsonNode rules = ruleExecutions("matches-redos");+ assertEquals("Failed", rules.get(0).path("status").asText());+ assertEquals("MATCHES pattern evaluation timed out",+ rules.get(0).path("output").path("executionResult").path("externalExecutionSummary").asText());+ }++ @Test+ void variableCheckMatchesPassesWhenTheVariableMatchesThePattern() {+ // Catches: MATCHES comparing literally instead of as a full-string regex.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "pr.*").put("Operator", "MATCHES");+ createPipeline("matches-ok", sourceStage(), deploy);++ ObjectNode start = mapper.createObjectNode().put("name", "matches-ok");+ start.putArray("variables").addObject().put("name", "env").put("value", "prod");+ String executionId = service.handle("StartPipelineExecution", start, REGION, ACCOUNT)+ .path("pipelineExecutionId").asText();+ awaitStatus("matches-ok", executionId, "Succeeded");+ assertEquals("Succeeded", ruleExecutions("matches-ok").get(0).path("status").asText());+ }++ @Test+ void beforeEntrySkipConditionSkipsStage() {+ // Catches: a failed beforeEntry condition with result SKIP running or failing the stage.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "SKIP", "VariableCheck")+ .put("Variable", "#{variables.go}").put("Value", "yes").put("Operator", "EQ");+ createPipeline("skipper", sourceStage(), deploy);++ String executionId = startExecution("skipper");+ awaitStatus("skipper", executionId, "Succeeded");+ JsonNode actions = service.handle("ListActionExecutions",+ mapper.createObjectNode().put("pipelineName", "skipper"), REGION, ACCOUNT)+ .path("actionExecutionDetails");+ assertFalse(actions.findValuesAsText("stageName").contains("Deploy"));+ }++ @Test+ @SuppressWarnings("unchecked")+ void beforeEntrySkipEmitsNoStageEventsForTheSkippedStage() {+ // Catches: a stage skipped by beforeEntry publishing a STARTED stage event with no terminal event.+ EventBridgeService eventBridge = mock(EventBridgeService.class);+ service = new CodePipelineService(storageFactory, mapper, mock(CodeBuildService.class),+ mock(CodeDeployService.class), lambdaService, s3Service,+ new CodePipelineEventPublisher(eventBridge, null, mapper), 500L,+ TimeUnit.SECONDS.toNanos(5), () -> { });+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "SKIP", "VariableCheck")+ .put("Variable", "#{variables.go}").put("Value", "yes").put("Operator", "EQ");+ createPipeline("skip-events", sourceStage(), deploy);++ String executionId = startExecution("skip-events");+ awaitStatus("skip-events", executionId, "Succeeded");++ ArgumentCaptor<List<Map<String, Object>>> events = ArgumentCaptor.forClass(List.class);+ verify(eventBridge, atLeastOnce()).putEvents(events.capture(), anyString(), anyString());+ List<String> deployStageStates = new ArrayList<>();+ for (List<Map<String, Object>> batch : events.getAllValues()) {+ for (Map<String, Object> entry : batch) {+ if ("CodePipeline Stage Execution State Change".equals(entry.get("DetailType"))) {+ JsonNode detail = parseDetail((String) entry.get("Detail"));+ if ("Deploy".equals(detail.path("stage").asText())) {+ deployStageStates.add(detail.path("state").asText());+ }+ }+ }+ }+ assertEquals(List.of(), deployStageStates);+ }++ private JsonNode parseDetail(String detail) {+ try {+ return mapper.readTree(detail);+ } catch (IOException e) {+ return fail("Unparseable event detail: " + detail);+ }+ }++ @Test+ void failedLambdaInvokeRuleFailsTheCondition() {+ // Catches: a LambdaInvoke rule passing although the function returned a function error.+ lambdaReturns("Unhandled");+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "FAIL", "LambdaInvoke").put("FunctionName", "gate-fn");+ createPipeline("lambda-gated", sourceStage(), deploy);++ String executionId = startExecution("lambda-gated");+ JsonNode failed = awaitStatus("lambda-gated", executionId, "Failed");+ assertEquals("Condition BEFORE_ENTRY failed in stage Deploy.", failed.path("statusSummary").asText());+ }++ @Test+ void listRuleTypesReturnsTheAwsRuleCatalog() {+ // Catches: ListRuleTypes returning an empty page instead of the AWS rule providers.+ JsonNode result = service.handle("ListRuleTypes", mapper.createObjectNode(), REGION, ACCOUNT);+ List<String> providers = result.path("ruleTypes").findValuesAsText("provider");+ assertEquals(List.of("LambdaInvoke", "VariableCheck", "Commands", "DeploymentWindow", "CloudWatchAlarm"), providers);+ }++ @Test+ void listRuleExecutionsSurfacesRecordedRules() {+ // Catches: ListRuleExecutions dropping the recorded rule runs or their provider.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "LambdaInvoke").put("FunctionName", "gate-fn");+ createPipeline("ruled", sourceStage(), deploy);++ String executionId = startExecution("ruled");+ awaitStatus("ruled", executionId, "Succeeded");++ JsonNode details = ruleExecutions("ruled");+ assertEquals(1, details.size());+ JsonNode detail = details.get(0);+ assertEquals("rule-LambdaInvoke", detail.path("ruleName").asText());+ assertEquals("Deploy", detail.path("stageName").asText());+ assertEquals("Succeeded", detail.path("status").asText());+ assertEquals("LambdaInvoke", detail.path("input").path("ruleTypeId").path("provider").asText());+ assertEquals(executionId, detail.path("pipelineExecutionId").asText());+ }++ @Test+ void onSuccessSkipConditionFailsTheStageBecauseTheStageAlreadyRan() {+ // Catches: a failed onSuccess condition with result SKIP being recorded as a Succeeded stage.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "SKIP", "VariableCheck")+ .put("Variable", "#{variables.go}").put("Value", "yes").put("Operator", "EQ");+ createPipeline("on-success-skip", sourceStage(), deploy);++ String executionId = startExecution("on-success-skip");+ JsonNode failed = awaitStatus("on-success-skip", executionId, "Failed");+ assertEquals("Condition ON_SUCCESS failed in stage Deploy.", failed.path("statusSummary").asText());+ }++ @Test+ void variableCheckUsesTheDeclaredDefaultWhenTheStartRequestOmitsTheVariable() {+ // Catches: a pipeline variable's declared default being ignored by VariableCheck.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "prod").put("Operator", "EQ");+ ObjectNode declaration = pipelineDeclaration("defaulted", sourceStage(), deploy);+ declaration.putArray("variables").addObject().put("name", "env").put("defaultValue", "prod");+ service.handle("CreatePipeline", mapper.createObjectNode().set("pipeline", declaration), REGION, ACCOUNT);++ String executionId = startExecution("defaulted");+ awaitStatus("defaulted", executionId, "Succeeded");+ }++ @Test+ void variableCheckNotEqualsDoesNotPassOnAnUnresolvedReference() {+ // Catches: an unresolved variable reference comparing as its placeholder text, so NE passes.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "beforeEntry", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.missing}").put("Value", "x").put("Operator", "NE");+ createPipeline("unresolved", sourceStage(), deploy);++ String executionId = startExecution("unresolved");+ awaitStatus("unresolved", executionId, "Failed");+ assertEquals("Failed", ruleExecutions("unresolved").get(0).path("status").asText());+ }++ @Test+ void overrideIsRejectedWhenThePipelineChangedAfterTheExecutionFailed() {+ // Catches: an override resuming an older execution against a newer pipeline declaration.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "prod").put("Operator", "EQ");+ createPipeline("versioned", sourceStage(), deploy);+ String executionId = startExecution("versioned");+ awaitStatus("versioned", executionId, "Failed");++ ObjectNode changed = pipelineDeclaration("versioned", sourceStage(), lambdaStage("Deploy"));+ service.handle("UpdatePipeline", mapper.createObjectNode().set("pipeline", changed), REGION, ACCOUNT);++ AwsException thrown = assertThrows(AwsException.class, () -> service.handle("OverrideStageCondition",+ mapper.createObjectNode().put("pipelineName", "versioned")+ .put("pipelineExecutionId", executionId).put("stageName", "Deploy")+ .put("conditionType", "ON_SUCCESS"), REGION, ACCOUNT));+ assertEquals("ConditionNotOverridableException", thrown.getErrorCode());+ }++ @Test+ void getPipelineExecutionDoesNotExposeInternalConditionState() {+ // Catches: ruleExecutions and conditionOverrides leaking into the GetPipelineExecution response.+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "LambdaInvoke").put("FunctionName", "gate-fn");+ createPipeline("clean-response", sourceStage(), deploy);+ String executionId = startExecution("clean-response");+ JsonNode execution = awaitStatus("clean-response", executionId, "Succeeded");+ assertFalse(execution.has("ruleExecutions"));+ assertFalse(execution.has("conditionOverrides"));+ }++ @Test+ void overrideWaiterTimingOutDoesNotEraseAnOverrideAnotherRequestAccepted() {+ // Catches: a timed-out override waiter removing the flag of a concurrent override that already+ // resumed the run.+ // Shorten the finish wait; just before the waiter cleans up, the run finishes and a second+ // override resumes it.+ AtomicBoolean cleanupProbed = new AtomicBoolean();+ AtomicReference<ObjectNode> pendingOverride = new AtomicReference<>();+ service = new CodePipelineService(storageFactory, mapper, mock(CodeBuildService.class),+ mock(CodeDeployService.class), lambdaService, s3Service,+ new CodePipelineEventPublisher(null, null, mapper), 500L,+ TimeUnit.MILLISECONDS.toNanos(200), () -> {+ if (cleanupProbed.compareAndSet(false, true)) {+ ObjectNode request = pendingOverride.get();+ service.activeRuns.remove(ACCOUNT + ":" + request.path("pipelineExecutionId").asText());+ service.handle("OverrideStageCondition", request, REGION, ACCOUNT);+ }+ });+ ObjectNode deploy = lambdaStage("Deploy");+ addRule(deploy, "onSuccess", "FAIL", "VariableCheck")+ .put("Variable", "#{variables.env}").put("Value", "prod").put("Operator", "EQ");+ createPipeline("override-race", sourceStage(), deploy);+ String executionId = startExecution("override-race");+ awaitStatus("override-race", executionId, "Failed");++ ObjectNode override = mapper.createObjectNode().put("pipelineName", "override-race")+ .put("pipelineExecutionId", executionId).put("stageName", "Deploy")+ .put("conditionType", "ON_SUCCESS");+ pendingOverride.set(override);+ // The run looks like it is still finishing, so the first override waits and then times out.+ String runKey = ACCOUNT + ":" + executionId;+ service.activeRuns.add(runKey);++ AwsException thrown = assertThrows(AwsException.class,+ () -> service.handle("OverrideStageCondition", override, REGION, ACCOUNT));+ assertEquals("ConflictException", thrown.getErrorCode());++ CodePipelineExecution stored = storageFactory.executionBackend().scanAllAccounts().get(0);+ assertEquals(Boolean.TRUE, stored.getConditionOverrides().get("Deploy/ON_SUCCESS"));+ }++ private static final class InMemoryStorageFactory extends StorageFactory {+ private final List<AccountAwareStorageBackend<?>> created = new ArrayList<>();++ private InMemoryStorageFactory() {+ super(null, null);+ }++ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<CodePipelineExecution> executionBackend() {+ return (AccountAwareStorageBackend<CodePipelineExecution>) created.stream()+ .filter(backend -> backend.scanAllAccounts().stream()+ .anyMatch(CodePipelineExecution.class::isInstance))+ .findFirst().orElseThrow();+ }++ @Override+ public <V> AccountAwareStorageBackend<V> create(String serviceName, String fileName,+ TypeReference<Map<String, V>> typeReference) {+ AccountAwareStorageBackend<V> backend = AccountAwareStorageBackend.inMemory(ACCOUNT);+ created.add(backend);+ return backend;+ }+ }+}