chaotic_job 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7a3e97903b960aad5ff163a8ea80d3d1c94d8427e86d0d06cb6c44ceffd7ad4
-  data.tar.gz: b4c2200a5436d1575f0f66d8647834514bd6563ac3fbf62a74014557d198ed90
+  metadata.gz: 8241f1235f37ed46c1da18d53e18c6fce43fb5758273bb51dba8db332dddb5b6
+  data.tar.gz: fc86ee73cf18b16d6142f7111e5d1cfa446b46bfea2e1959eb7aa222a5bf42dd
 SHA512:
-  metadata.gz: fa8f9e58bf1fa3eab4e4b6441e91824322e02043daea6fccb7f4d21844c739b34d376880ef03924fed43a7f7d49cf72fa536400698216ca58247cb287c49abd6
-  data.tar.gz: f8e83e868e13ed287f1ae9ff3b2560257b5c6fe1e6ba715bf400a93d2148c5a36d9372ac70aaadb5a498db198b3a0f0d9cd4bb3c00d138aa0ac4a8961c1e463a
+  metadata.gz: 7d32f1ab9748ea544d13c15692934634a6c3bcc01d602903e5e554abd229b7623a6a9aff111357031f474ec701fcd96131994604a121f9e55672eaed2616107b
+  data.tar.gz: c8ef73d8d07a091f59ebd1347ecc3f11fbd6ba6abc3eee218e251600ff156f748ec2a911d8108834cad96f9ce7ef59d1b3989606a27a827f1bb7bd93bfd9b062

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.2.0] - 2024-11-06
+
+- Update the `perform_all` helper method to `perform_all_jobs`
+- Update the `perform_all_before` helper method to `perform_all_jobs_before`
+- Update the `perform_all_after` helper method to `perform_all_jobs_after`
+- Update the `perform_all_within` helper method to `perform_all_jobs_within`
+
+## [0.1.1] - 2024-11-06
+
+- Update `Journal` interface
+- Add top-level `ChaoticJob` methods to work with the journal
+- Fix bug with job sorting in the `Performer`
+- Fix bug with resolving time cutoffs in the `Performer`
+- Fix bug with using the `run_scenario` helper with a block
+
 ## [0.1.0] - 2024-11-06
 
 - Added `Journal` to log activity for tests

data/README.md

@@ -10,7 +10,7 @@
 > [!TIP]
 > This gem helps you test that your Active Jobs are reliable and resilient to failures. If you want to more easily *build* reliable and resilient Active Jobs, check out the companion [Acidic Job](https://github.com/fractaledmind/acidic_job/tree/alpha-1.0) gem.
 
-`ChaoticJob` provides a set of tools to help you test the reliability and resilience of your Active Jobs. It does this by allowing you to simulate various types of failures and glitches that can occur in a production environment.
+`ChaoticJob` provides a set of tools to help you test the reliability and resilience of your Active Jobs. It does this by allowing you to simulate various types of failures and glitches that can occur in a production environment, inspired by the principles of [chaos testing](https://principlesofchaos.org) and [deterministic simulation testing](https://blog.resonatehq.io/deterministic-simulation-testing)
 
 ## Installation
 
@@ -59,29 +59,29 @@ end
 
 But, this method does not behave as you would expect. Functionally, it overwrites the `enqueue` method to immediately perform the job, which means that instead of your job being performed in waves, the retry is performed _within_ the execution of the original job. This both confuses the logs and means the behavior in your tests are not representative of the behavior in production.
 
-In order to properly test job retries, you should use the `perform_all` method provided by `ChaoticJob::Helpers`:
+In order to properly test job retries, you should use the `perform_all_jobs` method provided by `ChaoticJob::Helpers`:
 
 ```ruby
 Job.perform_later
-perform_all
+perform_all_jobs
 ```
 
 This helper will perform the job and all of its retries in the proper way, in waves, just like it would in production.
 
-If you need more control over which batches of jobs are performed, you can use the `perform_all_before` and `perform_all_after` methods. These are particularly useful if you need to test the behavior of a job that schedules another job. You can use these methods to perform only the original job and its retries, assert the state of the system, and then perform the scheduled job and its retries.
+If you need more control over which batches of jobs are performed, you can use the `perform_all_jobs_before` and `perform_all_jobs_after` methods. These are particularly useful if you need to test the behavior of a job that schedules another job. You can use these methods to perform only the original job and its retries, assert the state of the system, and then perform the scheduled job and its retries.
 
 ```ruby
 JobThatSchedules.perform_later
-perform_all_before(4.seconds)
+perform_all_jobs_before(4.seconds)
 assert_equal 1, enqueued_jobs.size
 assert_equal 2, performed_jobs.size
 
-perform_all_after(1.day)
+perform_all_jobs_after(1.day)
 assert_equal 0, enqueued_jobs.size
 assert_equal 3, performed_jobs.size
 ```
 
-You can pass either a `Time` object or an `ActiveSupport::Duration` object to these methods. And, to make the code as readable as possible, the `perform_all_before` is also aliased as the `perform_all_within` method. This allows you to write the example above as `perform_all_within(4.seconds)`.
+You can pass either a `Time` object or an `ActiveSupport::Duration` object to these methods. And, to make the code as readable as possible, the `perform_all_jobs_before` is also aliased as the `perform_all_jobs_within` method. This allows you to write the example above as `perform_all_jobs_within(4.seconds)`.
 
 ### Simulating Failures
 
@@ -115,10 +115,10 @@ end
 > |---|---|
 > | `Journal.log` | log simply that something happened within the default scope |
 > | `Journal.log(thing, scope: :special)` | log a particular value within a particular scope |
-> | `Journal.total` | get the total number of logs under the default scope |
-> | `Journal.total(scope: :special)` | get the total number of logs under a particular scope |
-> | `Journal.all` | get all of the logged values under the default scope |
-> | `Journal.all(scope: :special)` | get all of the logged values under a particular scope |
+> | `Journal.size` | get the total number of logs under the default scope |
+> | `Journal.size(scope: :special)` | get the total number of logs under a particular scope |
+> | `Journal.entries` | get all of the logged values under the default scope |
+> | `Journal.entries(scope: :special)` | get all of the logged values under a particular scope |
 
 In this example, the job being tested is defined within the test case. You can, of course, also test jobs defined in your application. The key detail is the `glitch` keyword argument. A "glitch" is simply a tuple that describes precisely where you would like the failure to occur. The first element of the tuple is the location of the glitch, which can be either *before* or *after*. The second element is the location of the code that will be affected by the glitch, defined by its file path and line number. What this example scenario does is inject a glitch before the `step_3` method is called, here:
 

data/lib/chaotic_job/journal.rb

@@ -20,12 +20,16 @@ module ChaoticJob
       @logs[scope] << item
     end
 
-    def total(scope: :default)
+    def size(scope: :default)
       @logs[scope]&.size || 0
     end
 
-    def all(scope: :default)
+    def entries(scope: :default)
       @logs[scope]
     end
+
+    def top(scope: :default)
+      entries&.first
+    end
   end
 end

data/lib/chaotic_job/performer.rb

@@ -40,7 +40,17 @@ module ChaoticJob
 
     def enqueued_jobs_where(before: nil, after: nil)
       enqueued_jobs
-        .sort_by { |job| job["scheduled_at"] }
+        .sort do |ljob, rjob|
+          lat = ljob[:at]
+          rat = rjob[:at]
+
+          # sort by scheduled time, with nil values first
+          if lat && rat
+            lat <=> rat
+          else
+            lat ? 1 : -1
+          end
+        end
         .select do |job|
           scheduled_at = job[:at]
 
@@ -67,7 +77,7 @@ module ChaoticJob
       in Time
         cutoff
       end
-      delta = (Time.now - time).abs
+      delta = (Time.now - time).abs.floor
       changeset = case delta
       when 0..59                    # seconds
         {usec: 0}

data/lib/chaotic_job/scenario.rb

@@ -16,15 +16,15 @@ module ChaoticJob
       @events = []
     end
 
-    def run
+    def run(&block)
       @job.class.retry_on RetryableError, attempts: 10, wait: 1, jitter: 0
 
       ActiveSupport::Notifications.subscribed(->(event) { @events << event.dup }, @capture) do
         glitch.inject! do
-          if block_given?
-            yield
+          @job.enqueue
+          if block
+            block.call
           else
-            @job.enqueue
             Performer.perform_all
           end
         end

data/lib/chaotic_job/version.rb

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

data/lib/chaotic_job.rb

@@ -11,20 +11,45 @@ module ChaoticJob
   class RetryableError < StandardError
   end
 
-  module Helpers
-    def perform_all
-      Performer.perform_all
+  def self.log_to_journal!(item = nil, scope: nil)
+    if item && scope
+      Journal.log(item, scope: scope)
+    elsif item
+      Journal.log(item)
+    elsif scope
+      Journal.log(scope: scope)
+    else
+      Journal.log
+    end
+  end
+
+  def self.journal_size(scope: nil)
+    if scope
+      Journal.size(scope: scope)
+    else
+      Journal.size
     end
+  end
 
-    def perform_all_within(time)
-      Performer.perform_all_within(time)
+  def self.top_journal_entry(scope: nil)
+    if scope
+      Journal.top(scope: scope)
+    else
+      Journal.top
+    end
+  end
+
+  module Helpers
+    def perform_all_jobs
+      Performer.perform_all
     end
 
-    def perform_all_before(time)
+    def perform_all_jobs_before(time)
       Performer.perform_all_before(time)
     end
+    alias_method :perform_all_jobs_within, :perform_all_jobs_before
 
-    def perform_all_after(time)
+    def perform_all_jobs_after(time)
       Performer.perform_all_after(time)
     end
 
@@ -36,11 +61,15 @@ module ChaoticJob
       Simulation.new(job, **kwargs).run(&block)
     end
 
-    def run_scenario(job, glitch: nil, glitches: nil, raise: nil, capture: nil)
+    def run_scenario(job, glitch: nil, glitches: nil, raise: nil, capture: nil, &block)
       kwargs = {glitches: glitches || [glitch]}
       kwargs[:raise] = raise if raise
       kwargs[:capture] = capture if capture
-      Scenario.new(job, **kwargs).run
+      if block
+        Scenario.new(job, **kwargs).run(&block)
+      else
+        Scenario.new(job, **kwargs).run
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chaotic_job
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephen Margheim