tests: add comprehensive edge case coverage

Add ~39 new tests covering edge cases across workflow features:

- branch: integer/boolean/nil conditions, exception handling
- foreach: non-list items, raising exceptions, nested items
- parallel: conflicting keys, 15+ steps, merge strategies
- wait: duplicate events, special chars, unicode event names
- compensation: single-step, error returns, parallel steps
- scheduler: empty/complex input, cron edge cases

New test files:
- context_test.exs: key handling, large context, serialization
- validation_test.exs: step returns, workflow input validation
- resume_edge_cases_test.exs: corrupted state, context restoration

Author: kasvith

test/durable/branch_test.exs

@@ -187,6 +187,74 @@ defmodule Durable.BranchTest do
     end
   end
 
+  describe "branch with string conditions" do
+    test "branch matches string condition correctly" do
+      {:ok, execution} =
+        create_and_execute_workflow(StringConditionBranchWorkflow, %{"category" => "electronics"})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "electronics"
+    end
+
+    test "branch uses default when string does not match" do
+      {:ok, execution} =
+        create_and_execute_workflow(StringConditionBranchWorkflow, %{"category" => "unknown"})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "other"
+    end
+  end
+
+  describe "branch execution - edge cases" do
+    test "branch with integer condition matches correctly" do
+      {:ok, execution} =
+        create_and_execute_workflow(IntegerConditionBranchWorkflow, %{"priority" => 1})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "high"
+    end
+
+    test "branch with integer condition falls to default when no match" do
+      {:ok, execution} =
+        create_and_execute_workflow(IntegerConditionBranchWorkflow, %{"priority" => 99})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "unknown"
+    end
+
+    test "branch with boolean false condition (not just falsy)" do
+      {:ok, execution} =
+        create_and_execute_workflow(BooleanConditionBranchWorkflow, %{"enabled" => false})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "disabled"
+    end
+
+    test "branch with boolean true condition" do
+      {:ok, execution} =
+        create_and_execute_workflow(BooleanConditionBranchWorkflow, %{"enabled" => true})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "enabled"
+    end
+
+    test "branch with nil condition value uses default if present" do
+      {:ok, execution} =
+        create_and_execute_workflow(NilConditionBranchWorkflow, %{"value" => nil})
+
+      assert execution.status == :completed
+      assert execution.context["processed_as"] == "nil_handled"
+    end
+
+    test "branch condition function raising exception fails workflow" do
+      {:ok, execution} =
+        create_and_execute_workflow(ExceptionConditionBranchWorkflow, %{})
+
+      assert execution.status == :failed
+      assert execution.error != nil
+    end
+  end
+
   # Helper functions
   defp create_and_execute_workflow(module, input) do
     config = Config.get(Durable)
@@ -342,3 +410,156 @@ defmodule ContextBranchWorkflow do
     end)
   end
 end
+
+defmodule StringConditionBranchWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "string_condition_branch" do
+    step(:setup, fn data ->
+      # Keep the string type, don't convert to atom
+      {:ok, assign(data, :category, data["category"])}
+    end)
+
+    branch on: fn data -> data.category end do
+      "electronics" ->
+        step(:process_electronics, fn data ->
+          {:ok, assign(data, :processed_as, "electronics")}
+        end)
+
+      "clothing" ->
+        step(:process_clothing, fn data ->
+          {:ok, assign(data, :processed_as, "clothing")}
+        end)
+
+      _ ->
+        step(:process_other, fn data ->
+          {:ok, assign(data, :processed_as, "other")}
+        end)
+    end
+
+    step(:done, fn data ->
+      {:ok, data}
+    end)
+  end
+end
+
+# Edge case test workflows
+
+defmodule IntegerConditionBranchWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "integer_condition_branch" do
+    step(:setup, fn data ->
+      {:ok, assign(data, :priority, data["priority"])}
+    end)
+
+    branch on: fn data -> data.priority end do
+      1 ->
+        step(:high_priority, fn data ->
+          {:ok, assign(data, :processed_as, "high")}
+        end)
+
+      2 ->
+        step(:medium_priority, fn data ->
+          {:ok, assign(data, :processed_as, "medium")}
+        end)
+
+      3 ->
+        step(:low_priority, fn data ->
+          {:ok, assign(data, :processed_as, "low")}
+        end)
+
+      _ ->
+        step(:unknown_priority, fn data ->
+          {:ok, assign(data, :processed_as, "unknown")}
+        end)
+    end
+
+    step(:done, fn data ->
+      {:ok, data}
+    end)
+  end
+end
+
+defmodule BooleanConditionBranchWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "boolean_condition_branch" do
+    step(:setup, fn data ->
+      {:ok, assign(data, :enabled, data["enabled"])}
+    end)
+
+    branch on: fn data -> data.enabled end do
+      true ->
+        step(:process_enabled, fn data ->
+          {:ok, assign(data, :processed_as, "enabled")}
+        end)
+
+      false ->
+        step(:process_disabled, fn data ->
+          {:ok, assign(data, :processed_as, "disabled")}
+        end)
+    end
+
+    step(:done, fn data ->
+      {:ok, data}
+    end)
+  end
+end
+
+defmodule NilConditionBranchWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "nil_condition_branch" do
+    step(:setup, fn data ->
+      {:ok, assign(data, :value, data["value"])}
+    end)
+
+    branch on: fn data -> data.value end do
+      nil ->
+        step(:handle_nil, fn data ->
+          {:ok, assign(data, :processed_as, "nil_handled")}
+        end)
+
+      _ ->
+        step(:handle_other, fn data ->
+          {:ok, assign(data, :processed_as, "other")}
+        end)
+    end
+
+    step(:done, fn data ->
+      {:ok, data}
+    end)
+  end
+end
+
+defmodule ExceptionConditionBranchWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "exception_condition_branch" do
+    step(:setup, fn data ->
+      {:ok, data}
+    end)
+
+    branch on: fn _data -> raise "Condition evaluation failed" end do
+      :a ->
+        step(:process_a, fn data ->
+          {:ok, assign(data, :processed_as, "a")}
+        end)
+
+      _ ->
+        step(:process_default, fn data ->
+          {:ok, assign(data, :processed_as, "default")}
+        end)
+    end
+
+    step(:done, fn data ->
+      {:ok, data}
+    end)
+  end
+end

test/durable/compensation_test.exs

@@ -246,6 +246,39 @@ defmodule Durable.CompensationTest do
     end
   end
 
+  describe "compensation execution - edge cases" do
+    test "single-step workflow with compensation where step raises" do
+      {:ok, execution} = create_and_execute_workflow(SingleStepRaisingCompensationWorkflow, %{})
+
+      # When a step raises and has a compensation, it should be compensated
+      # The step needs to actually complete first before the raise for compensation to apply
+      assert execution.status in [:failed, :compensated]
+    end
+
+    test "compensation with step that returns {:error, map}" do
+      {:ok, execution} = create_and_execute_workflow(ErrorMapCompensationWorkflow, %{})
+
+      # Workflow enters compensation when a step fails
+      # Compensation returning {:error, map} should mark as compensation_failed
+      assert execution.status in [:compensated, :compensation_failed]
+    end
+
+    test "parallel steps trigger compensations when step after parallel fails" do
+      {:ok, execution} = create_and_execute_workflow(ParallelWithCompensationWorkflow, %{})
+
+      # Workflow should be in compensated state
+      assert execution.status == :compensated
+
+      # Should have compensation results for each completed parallel step
+      results = execution.compensation_results
+      # At least 2 compensations should run (from the parallel steps that completed)
+      assert length(results) >= 2
+
+      # All compensations should be completed
+      assert Enum.all?(results, fn r -> r["result"]["status"] == "completed" end)
+    end
+  end
+
   # Helper function to create and execute workflow
   defp create_and_execute_workflow(module, input) do
     config = Config.get(Durable)
@@ -271,3 +304,72 @@ defmodule Durable.CompensationTest do
     {:ok, repo.get!(WorkflowExecution, execution.id)}
   end
 end
+
+# Edge case test workflows
+
+defmodule SingleStepRaisingCompensationWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "single_step_raising_compensation" do
+    step(:setup_step, [compensate: :undo_setup], fn data ->
+      {:ok, assign(data, :setup_done, true)}
+    end)
+
+    step(:failing_step, fn _data ->
+      raise "Intentional failure"
+    end)
+
+    compensate(:undo_setup, fn data ->
+      {:ok, assign(data, :undone, true)}
+    end)
+  end
+end
+
+defmodule ErrorMapCompensationWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "error_map_compensation" do
+    step(:do_work, [compensate: :undo_work], fn data ->
+      {:ok, assign(data, :work_done, true)}
+    end)
+
+    step(:fail_step, fn _data ->
+      raise "Step failed"
+    end)
+
+    compensate(:undo_work, fn _data ->
+      {:error, %{reason: "Compensation returned error"}}
+    end)
+  end
+end
+
+defmodule ParallelWithCompensationWorkflow do
+  use Durable
+  use Durable.Helpers
+
+  workflow "parallel_with_compensation" do
+    parallel do
+      step(:task_a, [compensate: :undo_task_a], fn data ->
+        {:ok, assign(data, :a_done, true)}
+      end)
+
+      step(:task_b, [compensate: :undo_task_b], fn data ->
+        {:ok, assign(data, :b_done, true)}
+      end)
+    end
+
+    step(:after_parallel, fn _data ->
+      raise "Failure after parallel"
+    end)
+
+    compensate(:undo_task_a, fn data ->
+      {:ok, assign(data, :a_undone, true)}
+    end)
+
+    compensate(:undo_task_b, fn data ->
+      {:ok, assign(data, :b_undone, true)}
+    end)
+  end
+end