rspec-rewind 0.1.0 → 1.0.0

data/lib/rspec/rewind/retry_transition.rb

@@ -2,38 +2,219 @@
 
 module RSpec
   module Rewind
+    SleepMeasurement = Struct.new(:scheduled, :actual, keyword_init: true)
+
     class RetryTransition
-      def initialize(configuration:, retry_delay_resolver:, event_builder:, notifier:, state_resetter:, sleep:)
+      def initialize(
+        configuration:,
+        retry_delay_resolver:,
+        event_builder:,
+        notifier:,
+        state_resetter:,
+        sleep:,
+        clock: nil
+      )
         @configuration = configuration
         @retry_delay_resolver = retry_delay_resolver
         @event_builder = event_builder
         @notifier = notifier
         @state_resetter = state_resetter
         @sleep = sleep
+        @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       end
 
-      def perform(retry_number:, resolved_retries:, duration:, exception:, backoff:, wait:, example_source:)
+      def perform(
+        retry_number:,
+        resolved_retries:,
+        duration:,
+        exception:,
+        backoff:,
+        wait:,
+        example_source:,
+        total_duration: nil,
+        attempt_durations: nil,
+        sleep_total: 0.0,
+        failure_fingerprint: nil,
+        budget_decision: nil,
+        policy_decision: nil
+      )
         sleep_seconds = @retry_delay_resolver.resolve(
           retry_number: retry_number,
           backoff: backoff,
           wait: wait,
-          exception: exception
+          exception: exception,
+          resolved_retries: resolved_retries,
+          previous_sleep_seconds: sleep_total,
+          failure_fingerprint: failure_fingerprint
+        )
+        sleep_seconds = clamp_sleep_to_budget(sleep_seconds, sleep_total)
+
+        event_context = {
+          retry_number: retry_number,
+          resolved_retries: resolved_retries,
+          duration: duration,
+          sleep_seconds: sleep_seconds,
+          total_duration: total_duration,
+          attempt_durations: attempt_durations,
+          sleep_total: sleep_total,
+          budget_decision: budget_decision,
+          policy_decision: policy_decision
+        }
+
+        scheduled_event = build_event(
+          exception: exception,
+          scheduled_sleep_seconds: sleep_seconds,
+          actual_sleep_seconds: nil,
+          **event_context
+        )
+        @notifier.notify_before_retry(scheduled_event)
+        @notifier.show_failure_message(exception) if @configuration.display_retry_failure_messages
+        reset_example_state(
+          example_source: example_source,
+          retry_exception: exception,
+          **event_context
+        )
+        actual_sleep_seconds = sleep_if_needed(sleep_seconds)
+
+        event = build_event(
+          exception: exception,
+          scheduled_sleep_seconds: sleep_seconds,
+          actual_sleep_seconds: actual_sleep_seconds,
+          **event_context.merge(sleep_total: sleep_total + actual_sleep_seconds)
         )
 
+        @notifier.notify_retry(event)
+        @notifier.notify_after_retry(event)
+
+        SleepMeasurement.new(scheduled: sleep_seconds, actual: actual_sleep_seconds)
+      end
+
+      def publish_not_retried(
+        retry_number:,
+        resolved_retries:,
+        duration:,
+        exception:,
+        decision:,
+        total_duration: nil,
+        attempt_durations: nil,
+        sleep_total: 0.0
+      )
+        policy_decision = decision.policy_decision
         event = @event_builder.build(
-          status: :retrying,
+          status: :not_retried,
           retry_reason: :exception,
+          decision_reason: decision.reason,
           attempt: retry_number,
           retries: resolved_retries,
           duration: duration,
+          total_duration: total_duration,
+          attempt_durations: attempt_durations,
+          sleep_seconds: 0.0,
+          scheduled_sleep_seconds: 0.0,
+          actual_sleep_seconds: 0.0,
+          sleep_total: sleep_total,
+          budget_decision: decision.budget_decision,
+          matched_retry_on: policy_decision&.matched_retry_on,
+          matched_skip_retry_on: policy_decision&.matched_skip_retry_on,
+          matcher_error: policy_decision&.matcher_error,
+          exception: exception
+        )
+
+        @notifier.publish_not_retried(event)
+      end
+
+      private
+
+      def reset_example_state(example_source:, retry_exception:, **event_context)
+        reset_result = @state_resetter.reset(example_source)
+        return unless reset_result == false
+
+        publish_reset_failed(
+          reset_exception: state_reset_exception || retry_exception,
+          **event_context
+        )
+      rescue StandardError => e
+        publish_reset_failed(
+          reset_exception: e,
+          **event_context
+        )
+        raise
+      end
+
+      def publish_reset_failed(reset_exception:, **event_context)
+        policy_decision = event_context[:policy_decision]
+        sleep_seconds = event_context[:sleep_seconds]
+        event = @event_builder.build(
+          status: :reset_failed,
+          retry_reason: :state_reset,
+          decision_reason: :state_reset_failed,
+          attempt: event_context[:retry_number],
+          retries: event_context[:resolved_retries],
+          duration: event_context[:duration],
+          total_duration: event_context[:total_duration],
+          attempt_durations: event_context[:attempt_durations],
           sleep_seconds: sleep_seconds,
+          scheduled_sleep_seconds: sleep_seconds,
+          actual_sleep_seconds: 0.0,
+          sleep_total: event_context[:sleep_total],
+          budget_decision: event_context[:budget_decision],
+          matched_retry_on: policy_decision&.matched_retry_on,
+          matched_skip_retry_on: policy_decision&.matched_skip_retry_on,
+          matcher_error: policy_decision&.matcher_error,
+          exception: reset_exception
+        )
+
+        @notifier.publish_reset_failed(event)
+      end
+
+      def state_reset_exception
+        return nil unless @state_resetter.respond_to?(:last_exception)
+
+        @state_resetter.last_exception
+      end
+
+      def build_event(exception:, scheduled_sleep_seconds:, actual_sleep_seconds:, **event_context)
+        policy_decision = event_context[:policy_decision]
+        @event_builder.build(
+          status: :retrying,
+          retry_reason: :exception,
+          attempt: event_context[:retry_number],
+          retries: event_context[:resolved_retries],
+          duration: event_context[:duration],
+          total_duration: event_context[:total_duration],
+          attempt_durations: event_context[:attempt_durations],
+          sleep_seconds: event_context[:sleep_seconds],
+          scheduled_sleep_seconds: scheduled_sleep_seconds,
+          actual_sleep_seconds: actual_sleep_seconds,
+          sleep_total: event_context[:sleep_total],
+          budget_decision: event_context[:budget_decision],
+          matched_retry_on: policy_decision&.matched_retry_on,
+          matched_skip_retry_on: policy_decision&.matched_skip_retry_on,
+          matcher_error: policy_decision&.matcher_error,
           exception: exception
         )
+      end
 
-        @notifier.notify_retry(event)
-        @notifier.show_failure_message(exception) if @configuration.display_retry_failure_messages
-        @state_resetter.reset(example_source)
-        @sleep.call(sleep_seconds) if sleep_seconds.positive?
+      def sleep_if_needed(seconds)
+        return 0.0 unless seconds.positive?
+
+        started_at = monotonic_time
+        @sleep.call(seconds)
+        monotonic_time - started_at
+      end
+
+      def clamp_sleep_to_budget(seconds, sleep_total)
+        max_total_sleep = @configuration.max_total_sleep
+        return seconds if max_total_sleep.nil?
+
+        remaining = max_total_sleep - sleep_total.to_f
+        return 0.0 unless remaining.positive?
+
+        [seconds, remaining].min
+      end
+
+      def monotonic_time
+        @clock.call
       end
     end
   end

data/lib/rspec/rewind/rspec_adapter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Rewind
+    class RSpecAdapter
+      def clear_exception(example_source)
+        if example_source.respond_to?(:clear_exception)
+          example_source.clear_exception
+        elsif example_source.instance_variable_defined?(:@exception)
+          example_source.instance_variable_set(:@exception, nil)
+        end
+      end
+
+      def clear_execution_result(example_source)
+        return unless example_source.respond_to?(:execution_result)
+
+        result = example_source.execution_result
+        return unless result
+
+        set_if_writer(result, :status, nil)
+        set_if_writer(result, :exception, nil)
+        set_if_writer(result, :pending_message, nil)
+        set_if_writer(result, :run_time, nil)
+      end
+
+      def clear_lets(example_source)
+        return unless example_source.respond_to?(:example_group_instance)
+
+        group_instance = example_source.example_group_instance
+        return unless group_instance
+
+        if group_instance.respond_to?(:clear_lets)
+          group_instance.clear_lets
+        elsif group_instance.instance_variable_defined?(:@__memoized)
+          group_instance.instance_variable_set(:@__memoized, nil)
+        end
+      end
+
+      private
+
+      def set_if_writer(target, attribute, value)
+        writer = "#{attribute}="
+        target.public_send(writer, value) if target.respond_to?(writer)
+      end
+    end
+  end
+end

data/lib/rspec/rewind/runner.rb

@@ -3,11 +3,12 @@
 module RSpec
   module Rewind
     class Runner
-      def initialize(example:, configuration:)
+      def initialize(example:, configuration:, component_factory: RunnerComponentFactory.new)
         @example = example
-        @configuration = configuration
+        @configuration = configuration.snapshot
+        @component_factory = component_factory
         @context = ExampleContext.new(example: example)
-        @logger = RunnerLogger.new(configuration: configuration, warn_output: method(:warn))
+        @logger = RunnerLogger.new(configuration: @configuration, warn_output: method(:warn))
       end
 
       def run(retries: nil, backoff: nil, wait: nil, retry_on: nil, skip_retry_on: nil, retry_if: nil)
@@ -24,7 +25,7 @@ module RSpec
       private
 
       def components
-        @components ||= RunnerComponents.new(
+        @components ||= @component_factory.build(
           example: @example,
           configuration: @configuration,
           context: @context,

data/lib/rspec/rewind/runner_component_factory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Rewind
+    class RunnerComponentFactory
+      def build(example:, configuration:, context:, logger:)
+        RunnerComponents.new(
+          example: example,
+          configuration: configuration,
+          context: context,
+          logger: logger
+        )
+      end
+    end
+  end
+end

data/lib/rspec/rewind/runner_components.rb

@@ -11,7 +11,10 @@ module RSpec
                   :retry_loop
 
       def initialize(example:, configuration:, context:, logger:)
-        event_builder = RetryEventBuilder.new(example_source: context.source)
+        event_builder = RetryEventBuilder.new(
+          example_source: context.source,
+          metadata_keys: configuration.metadata_report_keys
+        )
         notifier = RetryNotifier.new(
           configuration: configuration,
           debug: logger.method(:debug),
@@ -26,14 +29,15 @@ module RSpec
         retry_delay_resolver = RetryDelayResolver.new(
           configuration: configuration,
           metadata: context.metadata,
-          example: example
+          example: example,
+          warn: logger.method(:reporter_message)
         )
 
         @retry_count_resolver = RetryCountResolver.new(
           configuration: configuration,
           metadata: context.metadata
         )
-        @attempt_runner = AttemptRunner.new
+        @attempt_runner = AttemptRunner.new(clock: configuration.clock)
         @retry_gate = RetryGate.new(
           configuration: configuration,
           retry_policy: retry_policy,
@@ -45,7 +49,8 @@ module RSpec
           event_builder: event_builder,
           notifier: notifier,
           state_resetter: state_resetter,
-          sleep: Kernel.method(:sleep)
+          sleep: configuration.sleeper,
+          clock: configuration.clock
         )
         @flaky_transition = FlakyTransition.new(
           event_builder: event_builder,
@@ -58,7 +63,8 @@ module RSpec
           attempt_runner: @attempt_runner,
           retry_gate: @retry_gate,
           retry_transition: @retry_transition,
-          flaky_transition: @flaky_transition
+          flaky_transition: @flaky_transition,
+          clock: configuration.clock
         )
       end
     end

data/lib/rspec/rewind/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module Rewind
-    VERSION = '0.1.0'
+    VERSION = '1.0.0'
   end
 end

data/lib/rspec/rewind.rb

@@ -1,68 +1,5 @@
 # frozen_string_literal: true
 
-require 'rspec/core'
-require 'time'
+require_relative 'rewind/core'
 
-require_relative 'rewind/version'
-require_relative 'rewind/backoff'
-require_relative 'rewind/retry_budget'
-require_relative 'rewind/flaky_reporter'
-require_relative 'rewind/matcher_validation'
-require_relative 'rewind/configuration'
-require_relative 'rewind/example_context'
-require_relative 'rewind/event'
-require_relative 'rewind/retry_count_resolver'
-require_relative 'rewind/retry_delay_resolver'
-require_relative 'rewind/retry_event_builder'
-require_relative 'rewind/retry_notifier'
-require_relative 'rewind/flaky_transition'
-require_relative 'rewind/attempt_runner'
-require_relative 'rewind/retry_transition'
-require_relative 'rewind/retry_gate'
-require_relative 'rewind/retry_loop'
-require_relative 'rewind/runner_logger'
-require_relative 'rewind/runner_components'
-require_relative 'rewind/example_state_resetter'
-require_relative 'rewind/retry_policy'
-require_relative 'rewind/retry_decision'
-require_relative 'rewind/runner'
-require_relative 'rewind/example_methods'
-
-module RSpec
-  module Rewind
-    class << self
-      def configuration
-        @configuration ||= Configuration.new
-      end
-
-      def configure
-        yield(configuration)
-      end
-
-      def reset_configuration!
-        @configuration = Configuration.new
-      end
-
-      def install!
-        return if @installed
-
-        ::RSpec::Core::Example.include(ExampleMethods)
-        ::RSpec::Core::Example::Procsy.include(ExampleMethods) if defined?(::RSpec::Core::Example::Procsy)
-
-        ::RSpec.configure do |config|
-          config.around(:each) do |example|
-            if example.metadata[:rewind] == false
-              example.run
-            else
-              example.run_with_rewind
-            end
-          end
-        end
-
-        @installed = true
-      end
-    end
-  end
-end
-
-RSpec::Rewind.install!
+RSpec::Rewind.install! unless RSpec::Rewind.auto_install_disabled?