acidic_job 1.0.0.pre7 → 1.0.0.pre10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf6aac5040961c40dafe3650663ae883ce7f8a101bea9eaaf3e82c23df75938d
-  data.tar.gz: 5ddef7d9b955f06306c9a7f338c3b2dca01e85a7716f24c2865d94f294ac26dc
+  metadata.gz: 95b8fbdebe38a639f9b905df6ac1f5b853b09383d0810696c89c6c9e001efffe
+  data.tar.gz: b7e92f9b98461e2f39122405b6e3278fb7ed8a0edec65963026f7e2665bb5042
 SHA512:
-  metadata.gz: a224fb33d1c86ac07c4a0d6bd5d4f8853a7ddbb477fef6c3a1584c62002f7e1c7741c89b751874b8405d99132bfa17fefae6aa0364373709f9cd5725b64cb02f
-  data.tar.gz: '090ca69264e42984c3dd2331e073d90cd9f3d464c602b854f81d745a9dedd33586f155cfbd885d832b30b8e4c0956b0eda192978e3aa5165b623ce503a651b01'
+  metadata.gz: 13b5ea59163e833f5b698625d841fdcdc0a630b46880526df3274926e696b227b41946fd6622e121b9afd90ad3cc94589f6e864188e871d70f03c77168e3ad5e
+  data.tar.gz: 27e5b74147706f227875f4f4a61f084298c42e615149cb0a74670af841df8fcce9eb4f95d11935561912af61d6d8759c21c9ca9862e897f765b49c78b1e42ebd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre7)
+    acidic_job (1.0.0.pre10)
       activerecord (>= 6.1.0)
       activesupport
 

data/README.md

@@ -78,7 +78,7 @@ class RideCreateJob < ActiveJob::Base
   def perform(user_id, ride_params)
     user = User.find(user_id)
 
-    with_acidity given: { user: user, params: ride_params, ride: nil } do
+    with_acidity providing: { user: user, params: ride_params, ride: nil } do
       step :create_ride_and_audit_record
       step :create_stripe_charge
       step :send_receipt
@@ -99,20 +99,20 @@ class RideCreateJob < ActiveJob::Base
 end
 ```
 
-`with_acidity` takes only the `given:` named parameter and a block where you define the steps of this operation. `step` simply takes the name of a method available in the job. That's all!
+`with_acidity` takes only the `providing:` named parameter and a block where you define the steps of this operation. `step` simply takes the name of a method available in the job. That's all!
 
 Now, each execution of this job will find or create an `AcidicJob::Run` record, which we leverage to wrap every step in a database transaction. Moreover, this database record allows `acidic_job` to ensure that if your job fails on step 3, when it retries, it will simply jump right back to trying to execute the method defined for the 3rd step, and won't even execute the first two step methods. This means your step methods only need to be idempotent on failure, not on success, since they will never be run again if they succeed.
 
 ### Persisted Attributes
 
-Any objects passed to the `given` option on the `with_acidity` method are not just made available to each of your step methods, they are made available across retries. This means that you can set an attribute in step 1, access it in step 2, have step 2 fail, have the job retry, jump directly back to step 2 on retry, and have that object still accessible. This is done by serializing all objects to a field on the `AcidicJob::Run` and manually providing getters and setters that sync with the database record.
+Any objects passed to the `providing` option on the `with_acidity` method are not just made available to each of your step methods, they are made available across retries. This means that you can set an attribute in step 1, access it in step 2, have step 2 fail, have the job retry, jump directly back to step 2 on retry, and have that object still accessible. This is done by serializing all objects to a field on the `AcidicJob::Run` and manually providing getters and setters that sync with the database record.
 
 ```ruby
 class RideCreateJob < ActiveJob::Base
   include AcidicJob
 
   def perform(ride_params)
-    with_acidity given: { ride: nil } do
+    with_acidity providing: { ride: nil } do
       step :create_ride_and_audit_record
       step :create_stripe_charge
       step :send_receipt
@@ -148,7 +148,7 @@ class RideCreateJob < ActiveJob::Base
   def perform(user_id, ride_params)
     user = User.find(user_id)
     
-    with_acidity given: { user: user, params: ride_params, ride: nil } do
+    with_acidity providing: { user: user, params: ride_params, ride: nil } do
       step :create_ride_and_audit_record
       step :create_stripe_charge
       step :send_receipt
@@ -182,7 +182,7 @@ class RideCreateJob < ActiveJob::Base
   def perform(user_id, ride_params)
     user = User.find(user_id)
 
-    with_acidity given: { user: user, params: ride_params, ride: nil } do
+    with_acidity providing: { user: user, params: ride_params, ride: nil } do
       step :create_ride_and_audit_record, awaits: [SomeJob]
       step :create_stripe_charge, args: [1, 2, 3], kwargs: { some: 'thing' }
       step :send_receipt
@@ -203,25 +203,7 @@ This error is thrown because by default RSpec and most MiniTest test suites use
 
 In order to avoid this error, you need to ensure firstly that your tests that run your acidic jobs are not using a database transaction and secondly that they use some different strategy to keep your test database clean. The [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) gem is a commonly used tool to manage different strategies for keeping your test database clean. As for which strategy to use, `truncation` and `deletion` are both safe, but their speed varies based on our app's table structure (see https://github.com/DatabaseCleaner/database_cleaner#what-strategy-is-fastest). Either is fine; use whichever is faster for your app.
 
-In order to make this test setup simpler, `AcidicJob` provides a `TestCase` class that your MiniTest jobs tests can inherit from. It is simple; it inherits from `ActiveJob::TestCase`, sets `use_transactional_tests` to `false`, and ensures `DatabaseCleaner` is run for each of your tests:
-
-```ruby
-class AcidicJob::TestCase < ActiveJob::TestCase
-  self.use_transactional_tests = false
-
-  def before_setup
-    super
-    DatabaseCleaner.start
-  end
-
-  def after_teardown
-    DatabaseCleaner.clean
-    super
-  end
-
-  # ...
-end
-```
+In order to make this test setup simpler, `AcidicJob` provides a `TestCase` class that your MiniTest jobs tests can inherit from. It is simple; it inherits from `ActiveJob::TestCase`, sets `use_transactional_tests` to `false`, and ensures `DatabaseCleaner` is run for each of your tests. Moreover, it ensures that the system's original DatabaseCleaner configuration is maintained, options included, except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy. It does so by storing whatever the system DatabaseCleaner configuration is at the start of `before_setup` phase in an instance variable and then restores that configuration at the end of `after_teardown` phase. In between, it runs the configuration thru a pipeline that selectively replaces any `transaction` strategies with a corresponding `deletion` strategy, leaving any other configured strategies untouched.
 
 For those of you using RSpec, you can require the `acidic_job/rspec_configuration` file, which will configure RSpec in the exact same way I have used in my RSpec projects to allow me to test acidic jobs with either the `deletion` strategy but still have all of my other tests use the fast `transaction` strategy:
 

data/lib/acidic_job/extensions/action_mailer.rb

@@ -7,18 +7,27 @@ module AcidicJob
     module ActionMailer
       extend ActiveSupport::Concern
 
-      def deliver_acidicly(_options = {})
-        job = ::ActionMailer::MailDeliveryJob
+      def deliver_acidicly(_options = {}, idempotency_key: nil, unique_by: nil)
+        job_class = ::ActionMailer::MailDeliveryJob
 
         job_args = [@mailer_class.name, @action.to_s, "deliver_now", @params, *@args]
         # for Sidekiq, this depends on the Sidekiq::Serialization extension
-        serialized_job = job.new(job_args).serialize
+        serialized_job = job_class.new(job_args).serialize
+        acidic_identifier = job_class.respond_to?(:acidic_identifier) ? job_class.acidic_identifier : :job_id
+        # use either [1] provided key, [2] provided uniqueness constraint, or [3] computed key
+        key = if idempotency_key
+                idempotency_key
+              elsif unique_by
+                IdempotencyKey.generate(unique_by: unique_by, job_class: job_class.name)
+              else
+                IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
+              end
 
         AcidicJob::Run.create!(
           staged: true,
-          job_class: job.name,
+          job_class: job_class.name,
           serialized_job: serialized_job,
-          idempotency_key: IdempotencyKey.value_for(serialized_job)
+          idempotency_key: key
         )
       end
       alias deliver_transactionally deliver_acidicly

data/lib/acidic_job/extensions/active_job.rb

@@ -24,12 +24,21 @@ module AcidicJob
           raise UnsupportedExtension unless defined?(::ActiveJob) && self < ::ActiveJob::Base
 
           serialized_job = serialize_with_arguments(*args, **kwargs)
+          # use either [1] provided key, [2] provided uniqueness constraint, or [3] computed key
+          key = if kwargs.key?(:idempotency_key) || kwargs.key?("idempotency_key")
+                  kwargs[:idempotency_key] || kwargs["idempotency_key"]
+                elsif kwargs.key?(:unique_by) || kwargs.key?("unique_by")
+                  unique_by = [kwargs[:unique_by], kwargs["unique_by"]].compact.first
+                  IdempotencyKey.generate(unique_by: unique_by, job_class: name)
+                else
+                  IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
+                end
 
           AcidicJob::Run.create!(
             staged: true,
             job_class: name,
             serialized_job: serialized_job,
-            idempotency_key: IdempotencyKey.value_for(serialized_job)
+            idempotency_key: key
           )
         end
         alias_method :perform_transactionally, :perform_acidicly

data/lib/acidic_job/extensions/noticed.rb

@@ -6,12 +6,12 @@ module AcidicJob
       extend ActiveSupport::Concern
 
       class_methods do
-        def deliver_acidicly(recipients)
-          new.deliver_acidicly(recipients)
+        def deliver_acidicly(recipients, idempotency_key: nil, unique_by: nil)
+          new.deliver_acidicly(recipients, idempotency_key: idempotency_key, unique_by: unique_by)
         end
       end
 
-      def deliver_acidicly(recipients)
+      def deliver_acidicly(recipients, idempotency_key: nil, unique_by: nil)
         # THIS IS A HACK THAT COPIES AND PASTES KEY PARTS OF THE `Noticed::Base` CODE
         # IN ORDER TO ALLOW US TO TRANSACTIONALLY DELIVER NOTIFICATIONS
         # THIS IS THUS LIABLE TO BREAK WHENEVER THAT GEM IS UPDATED
@@ -36,12 +36,21 @@ module AcidicJob
               record: record
             }
             serialized_job = job_class.send(:job_or_instantiate, args).serialize
+            acidic_identifier = job_class.respond_to?(:acidic_identifier) ? job_class.acidic_identifier : :job_id
+            # use either [1] provided key, [2] provided uniqueness constraint, or [3] computed key
+            key = if idempotency_key
+                    idempotency_key
+                  elsif unique_by
+                    IdempotencyKey.generate(unique_by: unique_by, job_class: job_class.name)
+                  else
+                    IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
+                  end
 
             AcidicJob::Run.create!(
               staged: true,
               job_class: job_class.name,
               serialized_job: serialized_job,
-              idempotency_key: IdempotencyKey.value_for(serialized_job)
+              idempotency_key: key
             )
           end
         end

data/lib/acidic_job/extensions/sidekiq.rb

@@ -58,12 +58,21 @@ module AcidicJob
         class_methods do
           def perform_acidicly(*args, **kwargs)
             serialized_job = serialize_with_arguments(*args, **kwargs)
+            # use either [1] provided key, [2] provided uniqueness constraint, or [3] computed key
+            key = if kwargs.key?(:idempotency_key) || kwargs.key?("idempotency_key")
+                    kwargs[:idempotency_key] || kwargs["idempotency_key"]
+                  elsif kwargs.key?(:unique_by) || kwargs.key?("unique_by")
+                    unique_by = [kwargs[:unique_by], kwargs["unique_by"]].compact.first
+                    IdempotencyKey.generate(unique_by: unique_by, job_class: name)
+                  else
+                    IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
+                  end
 
             AcidicJob::Run.create!(
               staged: true,
               job_class: name,
               serialized_job: serialized_job,
-              idempotency_key: IdempotencyKey.value_for(serialized_job)
+              idempotency_key: key
             )
           end
           alias_method :perform_transactionally, :perform_acidicly

data/lib/acidic_job/idempotency_key.rb

@@ -2,15 +2,57 @@
 
 module AcidicJob
   class IdempotencyKey
-    def self.value_for(hash_or_job, *args, **kwargs)
-      return hash_or_job.job_id if hash_or_job.respond_to?(:job_id) && !hash_or_job.job_id.nil?
-      return hash_or_job.jid if hash_or_job.respond_to?(:jid) && !hash_or_job.jid.nil?
+    def self.generate(unique_by:, job_class:)
+      new(:job_args).value_for({ "job_class" => job_class }, Marshal.dump(unique_by))
+    end
+
+    def initialize(identifier = :job_id)
+      @identifier = identifier
+    end
+
+    def value_for(hash_or_job, *args, **kwargs)
+      return value_from_job_args(hash_or_job, *args, **kwargs) if @identifier == :job_args
+
+      value = if hash_or_job.is_a?(Hash)
+                value_from_job_id_for_hash(hash_or_job)
+              else
+                value_from_job_id_for_obj(hash_or_job)
+              end
+
+      value || value_from_job_args(hash_or_job, *args, **kwargs)
+    end
+
+    private
 
-      if hash_or_job.is_a?(Hash) && hash_or_job.key?("job_id") && !hash_or_job["job_id"].nil?
-        return hash_or_job["job_id"]
+    def value_from_job_id_for_hash(hash)
+      if hash.key?("job_id")
+        return if hash["job_id"].nil?
+        return if hash["job_id"].empty?
+
+        hash["job_id"]
+      elsif hash.key?("jid")
+        return if hash["jid"].nil?
+        return if hash["jid"].empty?
+
+        hash["jid"]
+      end
+    end
+
+    def value_from_job_id_for_obj(obj)
+      if obj.respond_to?(:job_id)
+        return if obj.job_id.nil?
+        return if obj.job_id.empty?
+
+        obj.job_id
+      elsif obj.respond_to?(:jid)
+        return if obj.jid.nil?
+        return if obj.jid.empty?
+
+        obj.jid
       end
-      return hash_or_job["jid"] if hash_or_job.is_a?(Hash) && hash_or_job.key?("jid") && !hash_or_job["jid"].nil?
+    end
 
+    def value_from_job_args(hash_or_job, *args, **kwargs)
       worker_class = case hash_or_job
                      when Hash
                        hash_or_job["worker"] || hash_or_job["job_class"]

data/lib/acidic_job/staging.rb

@@ -26,5 +26,15 @@ module AcidicJob
 
       GlobalID::Locator.locate(staged_job_gid)
     end
+
+    def identifier
+      return jid if defined?(jid) && !jid.nil?
+      return job_id if defined?(job_id) && !job_id.nil?
+
+      # might be defined already in `with_acidity` method
+      @__acidic_job_idempotency_key ||= IdempotencyKey.value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
+
+      @__acidic_job_idempotency_key
+    end
   end
 end

data/lib/acidic_job/test_case.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require "active_job/test_case"
-require "database_cleaner/active_record"
+require "database_cleaner"
 
 module AcidicJob
   class TestCase < ActiveJob::TestCase
-    self.use_transactional_tests = false
+    self.use_transactional_tests = false if respond_to?(:use_transactional_tests)
 
     def before_setup
+      @original_cleaners = DatabaseCleaner.cleaners
+      DatabaseCleaner.cleaners = transaction_free_cleaners_for(@original_cleaners)
       super
       DatabaseCleaner.start
     end
@@ -15,6 +17,55 @@ module AcidicJob
     def after_teardown
       DatabaseCleaner.clean
       super
+      DatabaseCleaner.cleaners = @original_cleaners
+    end
+
+    private
+
+    # Ensure that the system's original DatabaseCleaner configuration is maintained, options included,
+    # except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy.
+    def transaction_free_cleaners_for(original_cleaners)
+      non_transaction_cleaners = original_cleaners.dup.map do |(orm, opts), cleaner|
+        [[orm, opts], ensure_no_transaction_strategies_for(cleaner)]
+      end.to_h
+      DatabaseCleaner::Cleaners.new(non_transaction_cleaners)
+    end
+
+    def ensure_no_transaction_strategies_for(cleaner)
+      return cleaner unless strategy_name_for(cleaner) == "transaction"
+
+      cleaner.strategy = deletion_strategy_for(cleaner)
+      cleaner
+    end
+
+    def strategy_name_for(cleaner)
+      cleaner               # <DatabaseCleaner::Cleaner>
+        .strategy           # <DatabaseCleaner::ActiveRecord::Truncation>
+        .class              # DatabaseCleaner::ActiveRecord::Truncation
+        .name               # "DatabaseCleaner::ActiveRecord::Truncation"
+        .rpartition("::")   # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
+        .last               # "Truncation"
+        .downcase           # "truncation"
+    end
+
+    def deletion_strategy_for(cleaner)
+      strategy = cleaner.strategy
+      strategy_namespace = strategy # <DatabaseCleaner::ActiveRecord::Truncation>
+                           .class                      # DatabaseCleaner::ActiveRecord::Truncation
+                           .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
+                           .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
+                           .first                      # "DatabaseCleaner::ActiveRecord"
+      deletion_strategy_class_name = [strategy_namespace, "::", "Deletion"].join
+      deletion_strategy_class = deletion_strategy_class_name.constantize
+      instance_variable_hash = strategy.instance_variables.map do |var|
+        [
+          var.to_s.remove("@"),
+          strategy.instance_variable_get(var)
+        ]
+      end.to_h
+      options = instance_variable_hash.except("db", "connection_class")
+
+      deletion_strategy_class.new(**options)
     end
   end
 end

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "1.0.0.pre7"
+  VERSION = "1.0.0.pre10"
 end

data/lib/acidic_job.rb

@@ -46,6 +46,10 @@ module AcidicJob
     end
 
     klass.set_callback :perform, :after, :delete_staged_job_record, if: :was_staged_job?
+
+    klass.instance_variable_set(:@acidic_identifier, :job_id)
+    klass.define_singleton_method(:acidic_by_job_id) { @acidic_identifier = :job_id }
+    klass.define_singleton_method(:acidic_by_job_args) { @acidic_identifier = :job_args }
   end
 
   included do
@@ -57,34 +61,35 @@ module AcidicJob
       AcidicJob.wire_everything_up(subclass)
       super
     end
+
+    def acidic_identifier
+      @acidic_identifier
+    end
   end
 
-  def with_acidity(given: {})
-    # execute the block to gather the info on what steps are defined for this job workflow
+  def with_acidity(providing: {})
+    # ensure this instance variable is always defined
     @__acidic_job_steps = []
-    steps = yield || []
+    # execute the block to gather the info on what steps are defined for this job workflow
+    yield
 
     # check that the block actually defined at least one step
     # TODO: WRITE TESTS FOR FAULTY BLOCK VALUES
     raise NoDefinedSteps if @__acidic_job_steps.nil? || @__acidic_job_steps.empty?
 
     # convert the array of steps into a hash of recovery_points and next steps
-    workflow = define_workflow(steps)
-
-    # determine the idempotency key value for this job run (`job_id` or `jid`)
-    # might be defined already in `identifier` method
-    # TODO: allow idempotency to be defined by args OR job id
-    @__acidic_job_idempotency_key ||= IdempotencyKey.value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
+    workflow = define_workflow(@__acidic_job_steps)
 
-    @run = ensure_run_record(@__acidic_job_idempotency_key, workflow, given)
+    @run = ensure_run_record(workflow, providing)
 
     # begin the workflow
     process_run(@run)
   end
 
   # DEPRECATED
-  def idempotently(with:, &blk)
-    with_acidity(given: with, &blk)
+  def idempotently(with: {}, &blk)
+    ActiveSupport::Deprecation.new("1.0", "AcidicJob").deprecation_warning(:idempotently)
+    with_acidity(providing: with, &blk)
   end
 
   def safely_finish_acidic_job
@@ -93,11 +98,16 @@ module AcidicJob
     FinishedPoint.new
   end
 
+  # TODO: allow idempotency to be defined by args OR job id
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def idempotency_key
-    return @__acidic_job_idempotency_key if defined? @__acidic_job_idempotency_key
+    if defined?(@__acidic_job_idempotency_key) && !@__acidic_job_idempotency_key.nil?
+      return @__acidic_job_idempotency_key
+    end
 
-    @__acidic_job_idempotency_key ||= IdempotencyKey.value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
+    acidic_identifier = self.class.acidic_identifier
+    @__acidic_job_idempotency_key ||= IdempotencyKey.new(acidic_identifier)
+                                                    .value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 
@@ -171,7 +181,7 @@ module AcidicJob
     # { "step 1": { does: "step 1", awaits: [], then: "step 2" }, ...  }
   end
 
-  def ensure_run_record(key_val, workflow, accessors)
+  def ensure_run_record(workflow, accessors)
     isolation_level = case ActiveRecord::Base.connection.adapter_name.downcase.to_sym
                       when :sqlite
                         :read_uncommitted
@@ -180,7 +190,7 @@ module AcidicJob
                       end
 
     ActiveRecord::Base.transaction(isolation: isolation_level) do
-      run = Run.find_by(idempotency_key: key_val)
+      run = Run.find_by(idempotency_key: idempotency_key)
       serialized_job = serialize_job(@__acidic_job_args, @__acidic_job_kwargs)
 
       if run.present?
@@ -201,7 +211,7 @@ module AcidicJob
       else
         run = Run.create!(
           staged: false,
-          idempotency_key: key_val,
+          idempotency_key: idempotency_key,
           job_class: self.class.name,
           locked_at: Time.current,
           last_run_at: Time.current,
@@ -246,14 +256,4 @@ module AcidicJob
 
     true
   end
-
-  def identifier
-    return jid if defined?(jid) && !jid.nil?
-    return job_id if defined?(job_id) && !job_id.nil?
-
-    # might be defined already in `with_acidity` method
-    @__acidic_job_idempotency_key ||= IdempotencyKey.value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
-
-    @__acidic_job_idempotency_key
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre7
+  version: 1.0.0.pre10
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-11 00:00:00.000000000 Z
+date: 2022-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord