idempotency_check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbbc8f01fa1d5065ce9b934f19f2906617273c926a1094bb70b801cadb534a12
+  data.tar.gz: 65e82375d324b949971364189c89895554502de934b7ba0ce35e0cdbd33ed2dc
+SHA512:
+  metadata.gz: 5ee41662951a3af3fa1f7c83a4217c2b624017d4fd3eed6b60f740ce224f3f055bbf6ca4796bed4f2a3f413a4761ab6d9ffeb5fab814349fc96f3c3e0b8d3969
+  data.tar.gz: bb28dc2ce5e986ae2f78bcf383614dff955086973cdeee8be5d86198f21f99c72a14100880a564cd4845122cc523103ff9a31c4076b8bf590c8bf9d62b09fbc8

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agustin Fornio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,134 @@
+# idempotency_check
+
+Detects whether a job — or any block of Ruby code — is idempotent, by running it multiple times and comparing the side effects it produces.
+
+It works by running your block 3 times and comparing, between runs:
+
+- database row counts and content (via ActiveRecord)
+- ActionMailer deliveries
+- ActiveJob activity (`perform_later` and `perform_now`), broken down by job class and arguments
+- optionally, Sidekiq activity (`perform_async`), if you opt in
+- outbound HTTP calls, which can't be verified, so they're flagged instead of assumed safe
+
+It has **no runtime dependencies**.
+It works on any block of code, not only jobs — `IdempotencyCheck.idempotent? { user.update!(...) }` works the same way as it does for a job's `perform`.
+
+## Installation
+
+```ruby
+gem "idempotency_check"
+```
+
+## Usage
+
+```ruby
+require "idempotency_check"
+
+IdempotencyCheck.idempotent? { MyJob.perform_now(user_id) }
+# => true, false
+```
+
+Returns `true` only when running the block again produces no additional effect.
+Any unconfirmed situation (see "HTTP calls" below) is treated as `false` by default — the safe assumption is "not confirmed idempotent", never a false positive.
+
+### Ignoring timestamp-only changes
+
+A job that calls `.touch`/`.save` on every run bumps `updated_at` even if nothing else changed.
+By default that counts as non-idempotent (strict); opt out with:
+
+```ruby
+IdempotencyCheck.idempotent?(ignore_timestamps: true) { MyJob.perform_now }
+# or, to ignore other specific columns:
+IdempotencyCheck.idempotent?(ignore_columns: ["last_checked_at"]) { MyJob.perform_now }
+```
+
+### HTTP calls
+
+Outbound HTTP calls can't be verified — the gem doesn't know whether the external service is itself idempotent.
+By default, any HTTP call during the run makes the result `false` (unconfirmed = not safe to assume).
+If you've independently verified a particular source is safe (e.g. it calls your own idempotent internal API), exclude it from the check:
+
+```ruby
+IdempotencyCheck.idempotent?(trust: [:http]) { MyJob.perform_now }
+```
+
+`trust:` accepts any of the sources the checker tracks: `:table`, `:row`, `:mailer`, `:active_job`, `:http`, and (if loaded) `:sidekiq`.
+
+### Getting a reason, not just true/false
+
+```ruby
+IdempotencyCheck.idempotent?(verbose: true) { MyJob.perform_now }
+# => { result: true, reason: :ok }
+# => { result: false, reason: [:row] }              # which source(s) changed
+# => { result: false, reason: :suspicious_http }     # DB looked fine, but there was an unverified HTTP call
+```
+
+## Optional integrations
+
+Neither of these are gemspec dependencies — they're only loaded (and only need their gem installed) if you explicitly require them.
+
+### RSpec
+
+```ruby
+require "idempotency_check/rspec"
+
+expect { MyJob.perform_now(user_id) }.to be_idempotent
+expect { MyJob.perform_now(user_id) }.to be_idempotent(trust: [:http])
+```
+
+### Sidekiq (native `include Sidekiq::Job` / `perform_async`)
+
+ActiveJob is supported out of the box, even when Sidekiq is its queue adapter.
+This is only needed for jobs that use Sidekiq's own API directly (`include Sidekiq::Job`, `perform_async`), which doesn't go through ActiveJob at all.
+
+```ruby
+require "idempotency_check/sidekiq"
+
+IdempotencyCheck.idempotent? { MyWorker.perform_async(user_id) }
+```
+
+## The check does not undo anything
+
+Running a check executes your block **3 times, for real**.
+Nothing is rolled back.
+A block that creates a row leaves 3 rows behind; one that sends a mail sends 3 mails.
+
+Run checks inside a transactional test, which is what they're designed for:
+
+```ruby
+# RSpec, with use_transactional_fixtures = true (the default)
+it "is safe to retry" do
+  expect { MyJob.perform_now(user.id) }.to be_idempotent
+end
+```
+
+The surrounding transaction wraps all 3 runs and rolls the database back when the example ends.
+Mailer deliveries and enqueued jobs aren't covered by the transaction, but the checker resets those itself at the start of every check, so they don't leak between examples.
+
+Not undone by a transaction, in a test or anywhere else:
+
+- **HTTP requests** — they really go out, 3 times.
+  This is also why an unverified HTTP call makes the result `false` by default.
+- **Sidekiq's native `perform_async`** — pushes to Redis for real.
+- **Redis and `Rails.cache`** — no rollback.
+- **`after_commit`** — inside a test transaction the real commit never happens, so a job that depends on it may not behave the way it does in production.
+
+Running a check against a development console is a bad idea for the same reason: it will triple whatever the block does.
+
+## What it doesn't cover (yet)
+
+- Automatic retries (`retry_on`/`discard_on`) — the checker runs the block cleanly 3 times, it doesn't simulate a mid-run failure and retry.
+- Cache/Redis side effects (e.g. `Rails.cache.increment`).
+- External storage (S3, ActiveStorage).
+- Real concurrency — every run is sequential, not parallel.
+- Writes that don't go through the Rails adapter: database triggers and `ON DELETE CASCADE`.
+  Those tables never show up in `sql.active_record`, so they're not snapshotted.
+- HTTP clients that bypass `Net::HTTP` (`httpx`, `excon`, `typhoeus`, `curb`).
+  Anything built on `Net::HTTP` — Faraday's default adapter, HTTParty, RestClient — is seen.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```

data/lib/idempotency_check/active_job_perform_tracker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+
+module IdempotencyCheck
+  # Accumulates every job actually performed (synchronously, e.g. via
+  # perform_now) since the last reset!, by subscribing to ActiveJob's core
+  # "perform.active_job" notification. This fires regardless of queue
+  # adapter, but with queue_adapter = :test it's the only way to see
+  # synchronous performs, since perform_later jobs just sit in the queue
+  # and never actually run.
+  module ActiveJobPerformTracker
+    @performed = []
+
+    class << self
+      attr_reader :performed
+    end
+
+    def self.reset!
+      @performed = []
+    end
+
+    ActiveSupport::Notifications.subscribe('perform.active_job') do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      job = event.payload[:job]
+      @performed << [job.class.name, job.arguments]
+    end
+  end
+end

data/lib/idempotency_check/active_job_snapshot.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  # Snapshots job activity so far (cumulative since the last reset!), broken
+  # down by job class and arguments so that swapping which job/args ran
+  # between runs is caught, not just a raw count. Covers both:
+  #   - enqueued jobs (perform_later), via ActiveJob's :test queue adapter
+  #   - performed jobs (perform_now), via ActiveJobPerformTracker
+  # Requires ActiveJob::Base.queue_adapter = :test in the host app.
+  class ActiveJobSnapshot
+    def self.take
+      {
+        enqueued: ActiveJob::Base.queue_adapter.enqueued_jobs.map { |job| [job[:job].name, job[:args]] },
+        performed: ActiveJobPerformTracker.performed.dup
+      }
+    end
+
+    def self.reset!
+      ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+      ActiveJobPerformTracker.reset!
+    end
+  end
+end

data/lib/idempotency_check/checker.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  class Checker
+    RUNS = 3
+    TIMESTAMP_COLUMNS = %w[created_at updated_at].freeze
+
+    @extra_snapshot_sources = {}
+
+    class << self
+      attr_reader :extra_snapshot_sources
+    end
+
+    # Lets optional integrations (e.g. idempotency_check/sidekiq) plug in
+    # their own snapshot source without the core Checker knowing about them.
+    # `name` is the symbol callers use to refer to this source via `trust:`.
+    # If the source responds to reset!, it's called before each check so
+    # cumulative trackers don't grow unbounded across an entire test suite.
+    def self.register_snapshot_source(name, source)
+      @extra_snapshot_sources[name] = source
+    end
+
+    def self.idempotent?(ignore_columns: [], ignore_timestamps: false, trust: [], verbose: false, &block)
+      effective_ignore_columns = ignore_columns + (ignore_timestamps ? TIMESTAMP_COLUMNS : [])
+      trusted = Array(trust)
+
+      MailerSnapshot.reset!
+      ActiveJobSnapshot.reset!
+      extra_snapshot_sources.each_value { |source| source.reset! if source.respond_to?(:reset!) }
+
+      snapshots = {
+        table: [],
+        row: [],
+        mailer: [],
+        active_job: []
+      }
+      extra_snapshot_sources.each_key { |name| snapshots[name] = [] }
+      http_calls = 0
+      # Accumulated across runs: a run that writes a table no earlier run
+      # touched is itself a sign the block isn't settling down, and the
+      # snapshots will differ on that table anyway.
+      written_tables = []
+
+      RUNS.times do
+        http_calls += HttpTracker.track do
+          written_tables |= SqlTracker.track(&block)
+        end
+        snapshots[:table] << TableSnapshot.take(tables: written_tables)
+        snapshots[:row] << RowSnapshot.take(tables: written_tables, ignore_columns: effective_ignore_columns)
+        snapshots[:mailer] << MailerSnapshot.take
+        snapshots[:active_job] << ActiveJobSnapshot.take
+        extra_snapshot_sources.each { |name, source| snapshots[name] << source.take }
+      end
+
+      changed_sources = snapshots
+                        .reject { |name, _| trusted.include?(name) }
+                        .select { |_, list| list.uniq.size > 1 }
+                        .keys
+
+      suspicious_http = http_calls.positive? && !trusted.include?(:http)
+
+      result = changed_sources.empty? && !suspicious_http
+
+      return result unless verbose
+
+      reason =
+        if changed_sources.any?
+          changed_sources
+        elsif suspicious_http
+          :suspicious_http
+        else
+          :ok
+        end
+
+      { result: result, reason: reason }
+    end
+  end
+end

data/lib/idempotency_check/http_tracker.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module IdempotencyCheck
+  # Counts how many outbound HTTP requests happen inside a block, by
+  # wrapping Net::HTTP#request. We can't verify idempotency of external
+  # side effects, so this is only used to flag results as suspicious.
+  class HttpTracker
+    def self.track
+      count = 0
+      original = Net::HTTP.instance_method(:request)
+
+      Net::HTTP.send(:define_method, :request) do |*args, &blk|
+        count += 1
+        original.bind(self).call(*args, &blk)
+      end
+
+      yield
+
+      count
+    ensure
+      Net::HTTP.send(:define_method, :request, original) if original
+    end
+  end
+end

data/lib/idempotency_check/mailer_snapshot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  # Snapshots how many mails have been delivered so far (cumulative since the
+  # last reset!), using ActionMailer's :test delivery method. Requires the
+  # host app to set config.action_mailer.delivery_method = :test.
+  class MailerSnapshot
+    def self.take
+      ActionMailer::Base.deliveries.size
+    end
+
+    def self.reset!
+      ActionMailer::Base.deliveries.clear
+    end
+  end
+end

data/lib/idempotency_check/row_snapshot.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  # Snapshots full row content per table, so two snapshots can be compared to
+  # catch changes that don't alter row counts (e.g. a counter being incremented).
+  #
+  # Only the tables the checked block wrote to are read — see SqlTracker.
+  class RowSnapshot
+    class << self
+      def take(tables:, ignore_columns: [])
+        connection = ActiveRecord::Base.connection
+
+        tables.each_with_object({}) do |table, rows|
+          rows[table] = fetch_rows(connection, table, ignore_columns)
+        end
+      end
+
+      private
+
+      def fetch_rows(connection, table, ignore_columns)
+        order_columns = Array(connection.primary_key(table))
+        sql = +"SELECT * FROM #{connection.quote_table_name(table)}"
+        sql << " ORDER BY #{order_columns.map { |c| connection.quote_column_name(c) }.join(', ')}" if order_columns.any?
+
+        rows = connection.select_all(sql).map { |row| row.except(*ignore_columns) }
+        # Tables without a usable primary key (e.g. composite/no-PK join
+        # tables) have no natural row order from the DB — sort the result
+        # ourselves so two snapshots taken back-to-back compare reliably.
+        order_columns.any? ? rows : rows.sort_by(&:to_s)
+      end
+    end
+  end
+end

data/lib/idempotency_check/rspec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'idempotency_check'
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_idempotent do |**opts|
+  supports_block_expectations
+
+  match do |block|
+    @result = IdempotencyCheck.idempotent?(**opts, &block)
+    @result == true
+  end
+
+  failure_message do
+    if @result == :suspicious
+      "expected the block to be idempotent, but it made external HTTP calls we can't verify"
+    else
+      'expected the block to be idempotent, but running it again produced different effects'
+    end
+  end
+end

data/lib/idempotency_check/sidekiq.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../idempotency_check'
+require 'sidekiq'
+require 'sidekiq/test_api' # for Sidekiq::Testing.server_middleware, used under Sidekiq::Testing.inline!
+
+module IdempotencyCheck
+  # Accumulates every job actually performed (via Sidekiq::Testing.inline! or
+  # a real worker process) for the lifetime of the process, by adding a
+  # server middleware. Sidekiq has no ActiveSupport::Notifications-style hook
+  # of its own, so we install our own.
+  module SidekiqPerformTracker
+    @performed = []
+
+    class << self
+      attr_reader :performed
+    end
+
+    def self.record(job_class, args)
+      @performed << [job_class, args]
+    end
+
+    def self.reset!
+      @performed = []
+    end
+  end
+
+  class SidekiqServerTracker
+    def call(_job_instance, msg, _queue)
+      SidekiqPerformTracker.record(msg['class'], msg['args'])
+      yield
+    end
+  end
+
+  # Snapshots Sidekiq job activity so far (cumulative), broken down by job
+  # class and arguments, covering both:
+  #   - enqueued jobs (perform_async), via Sidekiq::Testing.fake!'s global
+  #     Sidekiq::Queues registry (no middleware needed, Sidekiq tracks this
+  #     itself)
+  #   - performed jobs (perform_async under Sidekiq::Testing.inline!, or a
+  #     real worker), via SidekiqServerTracker
+  class SidekiqSnapshot
+    def self.take
+      {
+        enqueued: Sidekiq::Queues.jobs_by_class.flat_map do |klass, jobs|
+          jobs.map { |job| [klass, job['args']] }
+        end,
+        performed: SidekiqPerformTracker.performed.dup
+      }
+    end
+
+    def self.reset!
+      Sidekiq::Queues.clear_all
+      SidekiqPerformTracker.reset!
+    end
+  end
+
+  # Real worker process (production).
+  Sidekiq.default_configuration.server_middleware do |chain|
+    chain.add SidekiqServerTracker
+  end
+
+  # Sidekiq::Testing.inline! uses its own separate middleware chain.
+  Sidekiq::Testing.server_middleware do |chain|
+    chain.add SidekiqServerTracker
+  end
+
+  register_snapshot_source(:sidekiq, SidekiqSnapshot)
+end

data/lib/idempotency_check/sql_tracker.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  # Collects which tables received a write (INSERT/UPDATE/DELETE) inside a
+  # block, by subscribing to ActiveSupport::Notifications "sql.active_record".
+  #
+  # This only narrows down which tables are worth snapshotting — it never
+  # decides idempotency on its own. That matters: if the SQL parsing below
+  # reports a table that wasn't really written to, the cost is one extra
+  # table snapshotted, not a wrong answer.
+  class SqlTracker
+    IGNORED_TABLES = %w[schema_migrations ar_internal_metadata].freeze
+
+    class << self
+      def track(&block)
+        new.track(&block)
+      end
+    end
+
+    def track
+      tables = []
+
+      subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        table = written_table(event.payload[:sql].to_s)
+        tables << table if table
+      end
+
+      yield
+
+      tables.uniq
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    private
+
+    def written_table(sql)
+      operation = sql[/\A\s*(INSERT|UPDATE|DELETE)/i, 1]
+      return unless operation
+
+      table = sql[/\A\s*#{operation}\s+(?:INTO\s+|FROM\s+)?["`\[]?(\w+)/i, 1]
+      return if table.nil? || IGNORED_TABLES.include?(table)
+
+      table
+    end
+  end
+end

data/lib/idempotency_check/table_snapshot.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  # Snapshots row counts per table, so two snapshots can be compared to see
+  # whether running something again changed the resulting state.
+  #
+  # `tables` is the set of tables the checked block actually wrote to — see
+  # SqlTracker. Snapshotting only those keeps a check proportional to what
+  # the job touches instead of to the size of the whole schema.
+  class TableSnapshot
+    class << self
+      def take(tables:)
+        connection = ActiveRecord::Base.connection
+
+        tables.each_with_object({}) do |table, counts|
+          counts[table] = connection.select_value(
+            "SELECT COUNT(*) FROM #{connection.quote_table_name(table)}"
+          ).to_i
+        end
+      end
+    end
+  end
+end

data/lib/idempotency_check/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module IdempotencyCheck
+  VERSION = '0.1.0'
+end

data/lib/idempotency_check.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'idempotency_check/version'
+require_relative 'idempotency_check/sql_tracker'
+require_relative 'idempotency_check/table_snapshot'
+require_relative 'idempotency_check/row_snapshot'
+require_relative 'idempotency_check/http_tracker'
+require_relative 'idempotency_check/mailer_snapshot'
+require_relative 'idempotency_check/active_job_perform_tracker'
+require_relative 'idempotency_check/active_job_snapshot'
+require_relative 'idempotency_check/checker'
+
+module IdempotencyCheck
+  def self.idempotent?(**opts, &block)
+    Checker.idempotent?(**opts, &block)
+  end
+
+  def self.register_snapshot_source(name, source)
+    Checker.register_snapshot_source(name, source)
+  end
+
+  private_constant :Checker
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: idempotency_check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Agustin Fornio
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  idempotency_check runs a block of code multiple times and compares the
+  side effects it produces (database rows, ActionMailer deliveries,
+  ActiveJob enqueue/perform activity, and optionally Sidekiq) to detect
+  jobs that aren't safe to retry or re-run. It works on any block of Ruby
+  code, not just jobs, and has no runtime dependencies of its own.
+email:
+- agustinfornio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/idempotency_check.rb
+- lib/idempotency_check/active_job_perform_tracker.rb
+- lib/idempotency_check/active_job_snapshot.rb
+- lib/idempotency_check/checker.rb
+- lib/idempotency_check/http_tracker.rb
+- lib/idempotency_check/mailer_snapshot.rb
+- lib/idempotency_check/row_snapshot.rb
+- lib/idempotency_check/rspec.rb
+- lib/idempotency_check/sidekiq.rb
+- lib/idempotency_check/sql_tracker.rb
+- lib/idempotency_check/table_snapshot.rb
+- lib/idempotency_check/version.rb
+homepage: https://github.com/AFornio/idempotency_check
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/AFornio/idempotency_check
+  bug_tracker_uri: https://github.com/AFornio/idempotency_check/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Detects whether a job (and eventually other units of work) is idempotent
+  by running it twice and comparing effects
+test_files: []