postburner 0.8.0 → 0.9.0.rc.1

data/lib/postburner/strategies/immediate_test_queue.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../time_helpers'
+
+module Postburner
+  # Test queue strategy with automatic time travel for scheduled jobs.
+  #
+  # This strategy executes jobs inline/synchronously like {TestQueue}, but
+  # automatically uses time travel for scheduled jobs instead of raising
+  # exceptions. When a job has a future run_at, it travels to that time,
+  # executes the job, then returns to the present.
+  #
+  # @note Requires ActiveSupport::Testing::TimeHelpers (Rails testing framework)
+  #
+  # ## When to Use ImmediateTestQueue
+  #
+  # Choose this strategy for test environments where you want:
+  # - **Automatic time management:** No need to manually call `travel_to`
+  # - **Simple scheduled job testing:** Test delayed/scheduled jobs without boilerplate
+  # - **Fast tests:** Jobs execute immediately regardless of schedule
+  # - **No Beanstalkd:** Tests run without external dependencies
+  # - **Convenience over control:** Less explicit but easier to use than {TestQueue}
+  #
+  # This is ideal for integration/feature tests where you want to verify that
+  # scheduled jobs execute correctly without managing time travel yourself. The
+  # tradeoff is less explicit control over timing compared to {TestQueue}.
+  #
+  # ## Strategy Behavior
+  #
+  # - **Execution:** Synchronous/inline (no Beanstalkd required)
+  # - **Testing mode:** Returns true
+  # - **Premature execution:** Automatically travels to run_at and executes
+  # - **Beanstalkd:** Not used (bkid remains nil)
+  # - **Time travel:** Automatic using ActiveSupport::Testing::TimeHelpers
+  # - **Execution order:** Jobs may execute out of intended chronological order
+  #
+  # ## How Time Travel Works
+  #
+  # When a job with future run_at is queued:
+  # 1. Detects job.run_at > Time.zone.now
+  # 2. Calls `travel_to(job.run_at)` to stub global time
+  # 3. Executes job at the scheduled time (Time.zone.now == job.run_at)
+  # 4. Returns to present time after execution
+  # 5. Job timestamps reflect the scheduled time, not actual time
+  #
+  # @note Time is stubbed globally during execution - side effects may occur
+  # @note Multiple scheduled jobs execute in queue order, not scheduled order
+  #
+  # ## Usage
+  #
+  # @example Explicitly activate ImmediateTestQueue
+  #   Postburner.inline_immediate_test_strategy!
+  #   job = MyJob.create!(args: { user_id: 123 })
+  #   job.queue!(delay: 1.hour)
+  #   # Job executes immediately at scheduled time
+  #   assert job.reload.processed_at
+  #
+  # @example Scheduled jobs execute automatically
+  #   Postburner.inline_immediate_test_strategy!
+  #   job = SendReminderEmail.create!(args: { user_id: 123 })
+  #
+  #   # Job executes immediately despite 2-day delay
+  #   job.queue!(delay: 2.days)
+  #
+  #   # Timestamps reflect the scheduled time
+  #   assert_equal 2.days.from_now.to_i, job.reload.run_at.to_i
+  #   assert_not_nil job.processed_at
+  #
+  # @example Multiple jobs execute in queue order, not schedule order
+  #   Postburner.inline_immediate_test_strategy!
+  #
+  #   job1 = MyJob.create!(args: { id: 1 })
+  #   job2 = MyJob.create!(args: { id: 2 })
+  #
+  #   job1.queue!(delay: 2.days)  # Executes first (queued first)
+  #   job2.queue!(delay: 1.hour)  # Executes second (queued second)
+  #
+  #   # Both are processed, but job1 executed before job2
+  #   # despite job2 having an earlier scheduled time
+  #
+  # @example Testing feature with scheduled job
+  #   test "sends reminder email after 24 hours" do
+  #     Postburner.inline_immediate_test_strategy!
+  #
+  #     user = users(:john)
+  #     reminder = ReminderJob.create!(args: { user_id: user.id })
+  #     reminder.queue!(delay: 24.hours)
+  #
+  #     # Job executes immediately at scheduled time
+  #     assert reminder.reload.processed_at
+  #     assert_emails 1
+  #   end
+  #
+  # @see TestQueue Test strategy requiring explicit time travel
+  # @see NiceQueue Default production strategy
+  # @see Postburner.inline_immediate_test_strategy!
+  #
+  class ImmediateTestQueue < TestQueue
+    class << self
+      include TimeHelpers
+
+      # Executes job inline with automatic time travel for scheduled jobs.
+      #
+      # Called automatically via after_save_commit hook when {Postburner::Job#queue!}
+      # is invoked. If the job has a future run_at, travels to that time before
+      # execution. Otherwise executes immediately.
+      #
+      # @param job [Postburner::Job] The job to execute
+      # @param options [Hash] Unused in test mode
+      #
+      # @return [Hash] Status hash with :status => 'INLINE', :id => nil
+      #
+      # @raise [RuntimeError] if ActiveSupport::Testing::TimeHelpers not available
+      #
+      # @api private
+      #
+      def insert(job, options = {})
+        # If job has a future run_at, travel to that time for execution
+        if job.run_at && job.run_at > Time.zone.now
+          travel_to(job.run_at) do
+            job.perform!(job.args)
+          end
+        else
+          # No future run_at, execute normally
+          job.perform!(job.args)
+        end
+
+        # Return format matching Backburner response (symbol keys)
+        { status: 'INLINE', id: nil }
+      end
+    end
+  end
+end

data/lib/postburner/strategies/nice_queue.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Postburner
+  # Default production queue strategy with graceful handling of premature execution.
+  #
+  # This is the recommended production strategy and the default for Postburner.
+  # Unlike the strict {Queue} strategy, NiceQueue automatically re-inserts jobs
+  # that are executed before their scheduled run_at time, ensuring they run at
+  # the correct time without raising exceptions.
+  #
+  # @note This is the DEFAULT strategy set on Postburner initialization
+  #
+  # ## When to Use NiceQueue
+  #
+  # Choose this strategy for production environments:
+  # - **Default choice:** This should be your go-to production strategy
+  # - **Graceful recovery:** Automatically handles scheduling edge cases
+  # - **Worker restarts:** Handles jobs picked up during worker restarts
+  # - **Clock drift:** Tolerates minor time synchronization issues
+  # - **Robust operation:** Prevents job failures due to timing issues
+  #
+  # This strategy provides the most forgiving and robust behavior for production
+  # systems where you want scheduled jobs to execute correctly even if workers
+  # pick them up slightly early.
+  #
+  # ## Strategy Behavior
+  #
+  # - **Execution:** Asynchronous via Beanstalkd workers
+  # - **Testing mode:** Returns false
+  # - **Premature execution:** Re-inserts job with calculated delay, logs the event
+  # - **Beanstalkd:** Required and used for all job queueing
+  #
+  # ## How Premature Execution Works
+  #
+  # When a job is executed before its run_at time:
+  # 1. Calculates remaining delay: `job.run_at - Time.zone.now`
+  # 2. Re-inserts job to Beanstalkd with calculated delay
+  # 3. Logs "PREMATURE; RE-INSERTED" message to job logs
+  # 4. Returns without executing the job
+  # 5. Job executes normally when picked up at the correct time
+  #
+  # ## Usage
+  #
+  # @example Default behavior (automatically set)
+  #   # No configuration needed - NiceQueue is the default
+  #   job = MyJob.create!(args: { user_id: 123 })
+  #   job.queue!(delay: 1.hour)
+  #
+  # @example Explicitly activate NiceQueue
+  #   Postburner.nice_async_strategy!
+  #   job = MyJob.create!(args: {})
+  #   job.queue!(at: Time.zone.now + 2.days)
+  #
+  # @example Premature execution is handled gracefully
+  #   job = MyJob.create!(args: {})
+  #   job.queue!(delay: 1.hour)
+  #   # Worker picks up job 5 minutes early...
+  #   # Job is automatically re-inserted with 55-minute delay
+  #   # "PREMATURE; RE-INSERTED" logged to job.logs
+  #
+  # @see Queue Strict production strategy that raises on premature execution
+  # @see TestQueue Test strategy with inline execution
+  # @see Postburner.nice_async_strategy!
+  #
+  class NiceQueue < Queue
+    class << self
+      # Handles jobs executed before their scheduled run_at time.
+      #
+      # Unlike the parent {Queue} strategy, NiceQueue gracefully handles premature
+      # execution by re-inserting the job with the appropriate delay instead of
+      # raising an exception.
+      #
+      # @param job [Postburner::Job] The job being executed prematurely
+      #
+      # @return [void]
+      #
+      # @note Logs "PREMATURE; RE-INSERTED" message to job's audit trail
+      #
+      def handle_premature_perform(job)
+        response = job.insert! delay: job.run_at - Time.zone.now
+        job.log! "PREMATURE; RE-INSERTED: #{response}"
+      end
+    end
+  end
+end

data/lib/postburner/strategies/null_queue.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../time_helpers'
+
+module Postburner
+  # Null queue strategy for creating jobs without queueing to Beanstalkd.
+  #
+  # This strategy creates job records in the database but does NOT queue them
+  # to Beanstalkd. Jobs can be manually executed later using {.handle_perform!},
+  # which includes automatic time travel for scheduled jobs.
+  #
+  # @note This is a test-mode strategy (returns true for testing)
+  #
+  # ## When to Use NullQueue
+  #
+  # Choose this strategy when you want:
+  # - **Deferred batch processing:** Create many jobs upfront, execute them manually later
+  # - **Conditional execution:** Queue jobs that may or may not execute based on runtime conditions
+  # - **Testing/debugging:** Inspect jobs before execution without auto-execution
+  # - **Manual control:** Explicitly control when jobs execute
+  # - **No Beanstalkd:** Create jobs without requiring Beanstalkd server
+  #
+  # ## Strategy Behavior
+  #
+  # - **Execution:** Manual via {.handle_perform!} call
+  # - **Testing mode:** Returns true
+  # - **Queueing:** Jobs created in database but NOT sent to Beanstalkd
+  # - **Beanstalkd:** Not used (bkid remains nil)
+  # - **Time travel:** Automatic for scheduled jobs during manual execution
+  #
+  # ## Usage
+  #
+  # @example Create jobs without queueing
+  #   Postburner.null_strategy!
+  #   job1 = MyJob.create!(args: { id: 1 })
+  #   job2 = MyJob.create!(args: { id: 2 })
+  #
+  #   job1.queue!
+  #   job2.queue!(delay: 1.hour)
+  #
+  #   # Jobs created but NOT queued to Beanstalkd
+  #   job1.bkid  # => nil
+  #   job2.bkid  # => nil
+  #
+  # @example Manually execute jobs later
+  #   # Later, execute manually
+  #   Postburner::Job.perform(job1.id)  # Executes immediately
+  #   Postburner::Job.perform(job2.id)  # Time travels to scheduled time
+  #
+  #   job1.reload.processed_at  # => present
+  #   job2.reload.processed_at  # => present
+  #
+  # @example Batch processing pattern
+  #   Postburner.null_strategy!
+  #
+  #   # Create 1000 jobs
+  #   jobs = 1000.times.map do |i|
+  #     job = ProcessRecord.create!(args: { record_id: i })
+  #     job.queue!
+  #     job
+  #   end
+  #
+  #   # Execute in batches
+  #   jobs.each_slice(100) do |batch|
+  #     batch.each { |job| Postburner::Job.perform(job.id) }
+  #     sleep 1  # Rate limiting
+  #   end
+  #
+  # @see TestQueue Parent strategy class
+  # @see Postburner.null_strategy!
+  # @see TimeHelpers
+  #
+  class NullQueue < TestQueue
+    class << self
+      include TimeHelpers
+
+      # Does NOT insert job into Beanstalkd queue.
+      #
+      # Called automatically via after_save_commit hook when {Postburner::Job#queue!}
+      # is invoked. Unlike other strategies, this does NOT queue to Beanstalkd - it
+      # only creates the job record in the database.
+      #
+      # @param job [Postburner::Job] The job (not queued)
+      # @param options [Hash] Unused in null mode
+      #
+      # @return [Hash] Status hash with :status => 'NULL', :id => nil
+      #
+      # @api private
+      #
+      def insert(job, options = {})
+        # Return format matching Backburner response (symbol keys)
+        { status: 'NULL', id: nil }
+      end
+
+      # Executes a job with automatic time travel for scheduled jobs.
+      #
+      # Called by {Postburner::Job.perform} when NullQueue strategy is active.
+      # If the job has a future run_at, it automatically travels to that time
+      # before execution. Otherwise executes immediately.
+      #
+      # Users should call {Postburner::Job.perform} instead of this method directly.
+      #
+      # @param job [Postburner::Job] The job to execute
+      #
+      # @return [void]
+      #
+      # @raise [RuntimeError] if ActiveSupport::Testing::TimeHelpers not available
+      #
+      # @example Execute via Job.perform (recommended)
+      #   Postburner.null_strategy!
+      #   job = MyJob.create!(args: {})
+      #   job.queue!(delay: 1.hour)
+      #   Postburner::Job.perform(job.id)  # Delegates to this method
+      #   job.reload.processed_at  # => present
+      #
+      # @see Postburner::Job.perform
+      # @see TimeHelpers#travel_to
+      # @api private
+      #
+      def handle_perform!(job)
+        if job.run_at && job.run_at > Time.zone.now
+          travel_to(job.run_at) do
+            job.perform!(job.args)
+          end
+        else
+          # No future run_at, execute normally
+          job.perform!(job.args)
+        end
+      end
+    end
+  end
+end

data/lib/postburner/strategies/queue.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Postburner
+  # Base production queue strategy that queues jobs to Beanstalkd asynchronously.
+  #
+  # This is the strict production strategy that raises an exception if a job
+  # is executed before its scheduled run_at time. Unlike {NiceQueue}, it does
+  # not automatically re-insert premature jobs.
+  #
+  # @note This is NOT the default strategy - use {NiceQueue} for production
+  #
+  # ## When to Use Queue
+  #
+  # Choose this strategy when you want strict enforcement of job scheduling:
+  # - You want jobs to fail loudly if executed prematurely
+  # - You're debugging scheduling issues
+  # - You want to catch configuration errors in production
+  #
+  # For most production use cases, use {NiceQueue} instead, which handles
+  # premature execution gracefully by re-inserting with appropriate delay.
+  #
+  # ## Strategy Behavior
+  #
+  # - **Execution:** Asynchronous via Beanstalkd workers
+  # - **Testing mode:** Returns false
+  # - **Premature execution:** Raises {Postburner::Job::PrematurePerform} exception
+  # - **Beanstalkd:** Required and used for all job queueing
+  #
+  # ## Usage
+  #
+  # @example Activate Queue strategy
+  #   Postburner.async_strategy!
+  #   job = MyJob.create!(args: { user_id: 123 })
+  #   job.queue!(delay: 1.hour)
+  #
+  # @example Premature execution raises exception
+  #   Postburner.async_strategy!
+  #   job = MyJob.create!(args: {})
+  #   job.queue!(delay: 1.hour)
+  #   # Worker picks up job too early...
+  #   # => raises PrematurePerform: "Job has future run_at: ..."
+  #
+  # @see NiceQueue Default production strategy with graceful premature handling
+  # @see TestQueue Test strategy with inline execution
+  # @see Postburner.async_strategy!
+  #
+  class Queue
+    class << self
+      # Returns whether this strategy is for testing.
+      #
+      # @return [Boolean] Always false for production strategies
+      #
+      def testing
+        false
+      end
+
+      # Inserts job into Beanstalkd queue asynchronously.
+      #
+      # Called automatically via after_save_commit hook when {Postburner::Job#queue!}
+      # is invoked. Enqueues the job to Beanstalkd and returns the response.
+      # The bkid is updated by {Postburner::Job#insert!} after this returns.
+      #
+      # @param job [Postburner::Job] The job to insert
+      # @param options [Hash] Beanstalkd options
+      # @option options [Integer] :delay Seconds to delay execution
+      # @option options [Integer] :pri Priority (lower = higher priority)
+      # @option options [Integer] :ttr Time-to-run before job times out
+      #
+      # @return [Hash] Backburner response with :id and :status
+      #
+      # @raise [Beaneater::NotConnected] if Beanstalkd connection fails
+      #
+      # @api private
+      #
+      def insert(job, options = {})
+        Postburner::Job.transaction do
+          Backburner::Worker.enqueue(
+            Postburner::Job,
+            job.id,
+            options
+          )
+        end
+      end
+
+      def handle_perform!(job)
+        job.perform!(job.args)
+      end
+
+      # Handles jobs executed before their scheduled run_at time.
+      #
+      # This strategy raises an exception to fail loudly on premature execution.
+      # Override in subclasses (like {NiceQueue}) to handle differently.
+      #
+      # @param job [Postburner::Job] The job being executed prematurely
+      #
+      # @return [void]
+      #
+      # @raise [Postburner::Job::PrematurePerform] Always raises for this strategy
+      #
+      def handle_premature_perform(job)
+        raise Postburner::Job::PrematurePerform, "Job has future run_at: #{job.run_at}"
+      end
+    end
+  end
+end

data/lib/postburner/strategies/test_queue.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Postburner
+  # Test queue strategy with strict scheduling enforcement.
+  #
+  # This strategy executes jobs inline/synchronously without Beanstalkd, making
+  # tests fast and predictable. It raises {Postburner::Job::PrematurePerform} if
+  # a job has a future run_at, forcing you to use explicit time travel in tests.
+  #
+  # @note Auto-detected when Rails.env.test? and ActiveJob adapter is :test
+  #
+  # ## When to Use TestQueue
+  #
+  # Choose this strategy for test environments where you want:
+  # - **Explicit time management:** Forces you to use `travel_to` for scheduled jobs
+  # - **Strict testing:** Catches scheduling bugs by failing loudly
+  # - **Synchronous execution:** Jobs run immediately on `queue!` call
+  # - **No Beanstalkd:** Tests run without external dependencies
+  # - **Predictable timing:** Full control over when jobs execute
+  #
+  # This is ideal for unit/integration tests where you want to verify job
+  # scheduling logic and maintain explicit control over time progression.
+  #
+  # ## Strategy Behavior
+  #
+  # - **Execution:** Synchronous/inline (no Beanstalkd required)
+  # - **Testing mode:** Returns true
+  # - **Premature execution:** Raises {Postburner::Job::PrematurePerform} exception
+  # - **Beanstalkd:** Not used (bkid remains nil)
+  # - **Time travel:** Requires explicit `travel_to` for scheduled jobs
+  #
+  # ## Usage
+  #
+  # @example Automatically activated in Rails test environment
+  #   # In test_helper.rb or rails_helper.rb
+  #   # TestQueue is automatically set if Rails.env.test?
+  #   # and ActiveJob.queue_adapter == :test
+  #
+  # @example Explicitly activate TestQueue
+  #   Postburner.inline_test_strategy!
+  #   job = MyJob.create!(args: { user_id: 123 })
+  #   job.queue!
+  #   # Job executes immediately and synchronously
+  #   assert job.reload.processed_at
+  #
+  # @example Scheduled jobs require explicit time travel
+  #   Postburner.inline_test_strategy!
+  #   job = MyJob.create!(args: {})
+  #
+  #   # This will raise PrematurePerform
+  #   # job.queue!(delay: 1.hour)
+  #
+  #   # Use time travel instead
+  #   job.queue!(delay: 1.hour)
+  #   travel_to(job.run_at) do
+  #     # Job executes within the time travel block
+  #   end
+  #
+  # @example Testing with scheduled jobs
+  #   test "processes payment after delay" do
+  #     Postburner.inline_test_strategy!
+  #     job = ProcessPayment.create!(args: { payment_id: 123 })
+  #
+  #     future_time = 2.hours.from_now
+  #     job.queue!(at: future_time)
+  #
+  #     travel_to(future_time) do
+  #       # Job executes here
+  #       assert job.reload.processed_at
+  #     end
+  #   end
+  #
+  # @see ImmediateTestQueue Test strategy with automatic time travel
+  # @see NiceQueue Default production strategy
+  # @see Postburner.inline_test_strategy!
+  #
+  class TestQueue < Queue
+    class << self
+      # Returns whether this strategy is for testing.
+      #
+      # @return [Boolean] Always true for test strategies
+      #
+      def testing
+        true
+      end
+
+      # Executes job inline/synchronously without Beanstalkd.
+      #
+      # Called automatically via after_save_commit hook when {Postburner::Job#queue!}
+      # is invoked. Executes the job immediately in the same process. If the job
+      # has a future run_at, raises {Postburner::Job::PrematurePerform} to force
+      # explicit time management with `travel_to`.
+      #
+      # @param job [Postburner::Job] The job to execute
+      # @param options [Hash] Unused in test mode
+      #
+      # @return [Hash] Status hash with :status => 'INLINE', :id => nil
+      #
+      # @raise [Postburner::Job::PrematurePerform] if job has future run_at
+      #
+      # @api private
+      #
+      def insert(job, options = {})
+        # Execute immediately in test mode
+        # Will raise PrematurePerform if run_at is in the future
+        job.perform!(job.args)
+
+        # Return format matching Backburner response (symbol keys)
+        { status: 'INLINE', id: nil }
+      end
+
+      # Handles jobs executed before their scheduled run_at time.
+      #
+      # This strategy raises an exception with a helpful error message,
+      # forcing developers to use explicit `travel_to` calls in tests.
+      #
+      # @param job [Postburner::Job] The job being executed prematurely
+      #
+      # @return [void]
+      #
+      # @raise [Postburner::Job::PrematurePerform] Always raises with helpful message
+      #
+      def handle_premature_perform(job)
+        raise Postburner::Job::PrematurePerform, "Job scheduled for #{job.run_at} (#{((job.run_at - Time.zone.now) / 60).round(1)} minutes from now). Use `travel_to(job.run_at)` in your test, or set `Postburner.inline_immediate_test_strategy!` to execute scheduled jobs immediately."
+      end
+    end
+  end
+end

data/lib/postburner/time_helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Postburner
+  # Provides time travel utilities for testing without requiring test context.
+  #
+  # This module wraps ActiveSupport::Testing::TimeHelpers to enable time travel
+  # from non-test contexts (like class methods or service objects). It creates
+  # a helper object extended with Rails' TimeHelpers and delegates time travel
+  # operations to it.
+  #
+  # @note Requires ActiveSupport::Testing::TimeHelpers (Rails testing framework)
+  # @note Time travel affects global time via Time.stub - use only in test environments
+  #
+  # ## Usage
+  #
+  # @example Basic time travel
+  #   include Postburner::TimeHelpers
+  #
+  #   travel_to(2.days.from_now) do
+  #     # Code here executes as if it's 2 days in the future
+  #     Time.zone.now  # => 2 days from now
+  #   end
+  #
+  # @example In a class method
+  #   class MyService
+  #     extend Postburner::TimeHelpers
+  #
+  #     def self.process_scheduled_task(time)
+  #       travel_to(time) do
+  #         # Execute task at specified time
+  #       end
+  #     end
+  #   end
+  #
+  # @see ActiveSupport::Testing::TimeHelpers
+  #
+  module TimeHelpers
+    # Travels to specified time for block execution using Rails time helpers.
+    #
+    # Creates a helper object extended with ActiveSupport::Testing::TimeHelpers
+    # and uses it to stub global time. This is necessary for time travel outside
+    # of test method contexts where TimeHelpers aren't available directly.
+    #
+    # The travel_to call stubs Time globally (using Time.stub), so all time-based
+    # operations within the block execute as if they're happening at the specified
+    # time. After the block completes, time returns to normal.
+    #
+    # @param time [Time, DateTime, ActiveSupport::TimeWithZone] The time to travel to
+    # @param block [Proc] Block to execute at the specified time
+    #
+    # @return [Object] The return value of the block
+    #
+    # @raise [RuntimeError] if ActiveSupport::Testing::TimeHelpers not available
+    #
+    # @example Travel to specific time
+    #   travel_to(Time.zone.parse('2025-12-25 00:00:00')) do
+    #     puts Time.zone.now  # => 2025-12-25 00:00:00
+    #   end
+    #
+    # @example Travel relative to now
+    #   travel_to(1.hour.from_now) do
+    #     # Execute code as if 1 hour has passed
+    #   end
+    #
+    def travel_to(time, &block)
+      unless defined?(ActiveSupport::Testing::TimeHelpers)
+        raise "ActiveSupport::Testing::TimeHelpers not available. " \
+              "Postburner::TimeHelpers requires Rails testing helpers for time travel."
+      end
+
+      helper = Object.new.extend(ActiveSupport::Testing::TimeHelpers)
+      helper.travel_to(time, &block)
+    end
+  end
+end

data/lib/postburner/version.rb

@@ -1,3 +1,3 @@
 module Postburner
-  VERSION = '0.8.0'
+  VERSION = '0.9.0.rc.1'
 end