chaotic_job 0.10.1 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 304867076ba4ade8191d2802075fadc2a2bfe83c35bdf3af8217b35b3097fc2d
-  data.tar.gz: 0a5ca5c1df4253011f0b9894f92424deb85262646eae89d40fd5c293ae6b8263
+  metadata.gz: 65b239108a3f3c45022378231bb6bd49c85f29fba2441e71a0fc49b06fb91413
+  data.tar.gz: bce5cb7e9beefbaed434d0f4a232341d8cb427eaa0f569b765dfc9da3b692840
 SHA512:
-  metadata.gz: 6877fdc030d30b9c53486a8d60f8be9d70dca9c3327e53f080e58a6dc73c6ca067f4ff91cb50f7de8e1b0812dddcbde5a5fafc37b8a5732d2e3119d614525044
-  data.tar.gz: 772b32d2e2d444cd0d9b1da623a3049071234b6548aab13eac409d15abccee8a49c476211e84d9e774ea6a6bf4a2675af1c4a991ce35e05e49cf6af658bc55ff
+  metadata.gz: bb13d55b1ad97aab48e9d9a87cefb2dd76134a5fd7aae46409b17107dad1aa4070b890e4224139db43b3c53a9f8410bf8befbe758579d06a9d69fffdac049e30
+  data.tar.gz: 93f0394e4138e749beeb1a26bf62f3e14b7345ffcaa9d2b9343db22849568e50108dc0cf9b45d920c3ad1989f2f94b0cd8c1bd8846449ffa310238f264e7d0ea

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.11.1] - 2025-06-18
+
+- Fix mistaken `job_id` assignment in `Simulation`
+
+## [0.11.0] - 2025-06-18
+
+- Allow a Simulation to control the ActiveSupport::Notifications captured, and capture all by default [#20](https://github.com/fractaledmind/chaotic_job/pull/20)
+- Instead of running a simulation within a test case, introduce a builder class method that dynamically defines each scenario as a test case method. [#21](https://github.com/fractaledmind/chaotic_job/pull/21)
+
 ## [0.10.1] - 2025-06-18
 
 - Add more switch methods [#19](https://github.com/fractaledmind/chaotic_job/pull/19)

data/README.md

@@ -167,10 +167,12 @@ Finally, if you need to inject a glitch right before a particular line of code i
 run_scenario(Job.new, glitch: ChaoticJob::Glitch.before_line("#{__FILE__}:6"))
 ```
 
-Scenario testing is useful to test the behavior of a job under a specific set of conditions. But, if you want to test the behavior of a job under a variety of conditions, you can use the `run_simulation` method. Instead of running a single scenario, a simulation will run the full set of possible error scenarios for your job.
+Scenario testing is useful to test the behavior of a job under a specific set of conditions. But, if you want to test the behavior of a job under a variety of conditions, you can use the `test_simulation` method. Instead of running a single scenario, a simulation will define a full set of possible error scenarios for your job as individual test cases.
 
 ```ruby
-test "simulation of a simple job" do
+class TestYourJob < ActiveJob::TestCase
+  include ChaoticJob::Helpers
+
   class Job < ActiveJob::Base
     def perform
       step_1
@@ -183,7 +185,8 @@ test "simulation of a simple job" do
     def step_3 = ChaoticJob::Journal.log
   end
 
-  run_simulation(Job.new) do |scenario|
+  # will dynamically generate a test method for each failure scenario
+  test_simulation(Job.new) do |scenario|
     assert_operator ChaoticJob::Journal.total, :>=, 3
   end
 end
@@ -206,9 +209,9 @@ More specifically, it will create a scenario injecting a glitch before every lin
   [:return, "Job#perform"]}>
 ```
 
-It generates all possible glitch scenarios by performing your job once with a [`TracePoint`](https://docs.ruby-lang.org/en/master/TracePoint.html) that captures every event executed as a part of your job running. The block that you pass to `run_simulation` will be called for each scenario, allowing you to make assertions about the behavior of your job under all scenarios.
+It generates all possible glitch scenarios by performing your job once with a [`TracePoint`](https://docs.ruby-lang.org/en/master/TracePoint.html) that captures every event executed as a part of your job running. The block that you pass to `test_simulation` will be called for each scenario, allowing you to make assertions about the behavior of your job under all scenarios.
 
-If you want to have the simulation run against a larger collection of scenarios, you can capture a custom callstack using the `ChaoticJob::Tracer` class and pass it to the `run_simulation` method as the `callstack` parameter. A `Tracer` is initialized with a block that determines which `TracePoint` events to collect. You then call `capture` with a block that defines the code to be traced. The default `Simulation` tracer collects all events for the passed job and then traces the job execution, essentially like this:
+If you want to have the simulation run against a larger collection of scenarios, you can capture a custom callstack using the `ChaoticJob::Tracer` class and pass it to the `test_simulation` method as the `callstack` parameter. A `Tracer` is initialized with a block that determines which `TracePoint` events to collect. You then call `capture` with a block that defines the code to be traced. The default `Simulation` tracer collects all events for the passed job and then traces the job execution, essentially like this:
 
 ```ruby
 job_file_path = YourJob.instance_method(:perform).source_location&.first

data/lib/chaotic_job/scenario.rb

@@ -7,7 +7,9 @@ module ChaoticJob
   class Scenario
     attr_reader :events, :glitch, :job
 
-    def initialize(job, glitch:, raise: RetryableError, capture: /active_job/)
+    Event = Struct.new(:name, :started, :finished, :unique_id, :payload)
+
+    def initialize(job, glitch:, raise: RetryableError, capture: nil)
       @job = job
       @glitch = (Glitch === glitch) ? glitch : (raise Error.new("glitch: must be a Glitch instance, but got #{glitch.inspect}"))
       @raise = binding.local_variable_get(:raise)
@@ -19,7 +21,7 @@ module ChaoticJob
       @job.class.retry_on RetryableError, attempts: 10, wait: 1, jitter: 0
       @glitch.set_action { raise @raise }
 
-      ActiveSupport::Notifications.subscribed(->(event) { @events << event.dup }, @capture) do
+      ActiveSupport::Notifications.subscribed(->(*args) { @events << Event.new(*args) }, @capture) do
         @glitch.inject! do
           @job.enqueue
           if block
@@ -73,6 +75,11 @@ module ChaoticJob
       glitch_lines.each do |line|
         buffer << "  #{line}\n"
       end
+      buffer << "  events: [\n"
+      @events.sort_by { |it| it.started }.each do |it|
+        buffer << "    #{it.started.utc.iso8601(6)}: #{it.name}\n"
+      end
+      buffer << "  ]\n"
       buffer << ")"
 
       buffer

data/lib/chaotic_job/simulation.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-# Simulation.new(job).run { |scenario| ... }
-# Simulation.new(job).variants
-# Simulation.new(job).scenarios
+# Simulation.new(job).define { |scenario| ... }
 module ChaoticJob
   class Simulation
-    def initialize(job, callstack: nil, variations: nil, test: nil, seed: nil, perform_only_jobs_within: nil)
+    def initialize(job, callstack: nil, variations: nil, test: nil, seed: nil, perform_only_jobs_within: nil, capture: nil)
       @template = job
       @callstack = callstack || capture_callstack
       @variations = variations
@@ -13,21 +11,37 @@ module ChaoticJob
       @seed = seed || Random.new_seed
       @random = Random.new(@seed)
       @perform_only_jobs_within = perform_only_jobs_within
+      @capture = capture
 
+      @template.class.retry_on RetryableError, attempts: 3, wait: 1, jitter: 0
       raise Error.new("callstack must be a generated via ChaoticJob::Tracer") unless @callstack.is_a?(Stack)
     end
 
-    def run(&assertions)
-      @template.class.retry_on RetryableError, attempts: 3, wait: 1, jitter: 0
-
-      debug "👾 Running #{@variations || "all"} simulations of the total #{variants.size} possibilities..."
-
-      scenarios.map do |scenario|
-        run_scenario(scenario, &assertions)
-        print "·"
+    def define(&assertions)
+      debug "👾 Defining #{@variations || "all"} simulated scenarios of the total #{variants.size} possibilities..."
+
+      scenarios.each do |scenario|
+        test_method_name = "test_simulation_scenario_before_#{scenario.glitch.event}_#{scenario.glitch.key}"
+        perform_only_jobs_within = @perform_only_jobs_within
+
+        @test.define_method(test_method_name) do
+          if perform_only_jobs_within
+            scenario.run do
+              Performer.perform_all_before(perform_only_jobs_within)
+              instance_exec(scenario, &assertions)
+            end
+          else
+            scenario.run
+            instance_exec(scenario, &assertions)
+          end
+
+          assert scenario.glitched?, "Scenario did not execute glitch: #{scenario.glitch}"
+        end
       end
     end
 
+    private
+
     def variants
       error_locations = @callstack.map do |event, key|
         ["before_#{event}", key]
@@ -43,12 +57,10 @@ module ChaoticJob
         job = clone_job_template
         glitch = Glitch.public_send(event, key)
         job.job_id = [job.job_id.split("-").first, glitch.event, glitch.key].join("-")
-        Scenario.new(job, glitch: glitch)
+        Scenario.new(job, glitch: glitch, capture: @capture)
       end
     end
 
-    private
-
     def capture_callstack
       tracer = Tracer.new { |tp| tp.defined_class == @template.class }
       callstack = tracer.capture do
@@ -61,27 +73,6 @@ module ChaoticJob
       callstack
     end
 
-    def run_scenario(scenario, &assertions)
-      debug "👾 Running simulation with scenario: #{scenario}"
-      @test.before_setup
-      @test.simulation_scenario = scenario
-
-      if @perform_only_jobs_within
-        scenario.run do
-          Performer.perform_all_before(@perform_only_jobs_within)
-          assertions.call(scenario)
-        end
-      else
-        scenario.run
-        assertions.call(scenario)
-      end
-
-      @test.after_teardown
-      @test.assert scenario.glitched?, "Scenario did not execute glitch: #{scenario.glitch}"
-    ensure
-      @test.simulation_scenario = nil
-    end
-
     def clone_job_template
       serialized_template = @template.serialize
       job = ActiveJob::Base.deserialize(serialized_template)

data/lib/chaotic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChaoticJob
-  VERSION = "0.10.1"
+  VERSION = "0.11.1"
 end

data/lib/chaotic_job.rb

@@ -80,7 +80,21 @@ module ChaoticJob
   end
 
   module Helpers
-    attr_accessor :simulation_scenario
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def test_simulation(job, variations: nil, callstack: nil, perform_only_jobs_within: nil, &block)
+        seed = defined?(RSpec) ? RSpec.configuration.seed : Minitest.seed
+        kwargs = {test: self, seed: seed}
+        kwargs[:variations] = variations if variations
+        kwargs[:callstack] = callstack if callstack
+        kwargs[:perform_only_jobs_within] = perform_only_jobs_within if perform_only_jobs_within
+
+        Simulation.new(job, **kwargs).define(&block)
+      end
+    end
 
     def perform_all_jobs
       Performer.perform_all
@@ -95,16 +109,6 @@ module ChaoticJob
       Performer.perform_all_after(time)
     end
 
-    def run_simulation(job, variations: nil, callstack: nil, perform_only_jobs_within: nil, &block)
-      seed = defined?(RSpec) ? RSpec.configuration.seed : Minitest.seed
-      kwargs = {test: self, seed: seed}
-      kwargs[:variations] = variations if variations
-      kwargs[:callstack] = callstack if callstack
-      kwargs[:perform_only_jobs_within] = perform_only_jobs_within if perform_only_jobs_within
-      self.simulation_scenario = nil
-      Simulation.new(job, **kwargs).run(&block)
-    end
-
     def run_scenario(job, glitch:, raise: nil, capture: nil, &block)
       kwargs = {}
 
@@ -130,20 +134,5 @@ module ChaoticJob
     def glitch_before_return(key, return_type = nil, &block)
       Glitch.before_return(key, return_type, &block)
     end
-
-    def assert(test, msg = nil)
-      return super unless @simulation_scenario
-
-      contextual_msg = lambda do
-        # copied from the original `assert` method in Minitest::Assertions
-        default_msg = "Expected #{mu_pp test} to be truthy."
-        custom_msg = msg.is_a?(Proc) ? msg.call : msg
-        full_msg = custom_msg || default_msg
-        indented_scenario = @simulation_scenario.to_s.split("\n").join("\n  ")
-        "  #{indented_scenario}\n#{full_msg}"
-      end
-
-      super(test, contextual_msg)
-    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: chaotic_job
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.1
 platform: ruby
 authors:
 - Stephen Margheim
 bindir: exe
 cert_chain: []
-date: 2025-06-17 00:00:00.000000000 Z
+date: 2025-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob