opal-rspec 0.8.0 → 1.0.0

data/lib-opal/opal/rspec/async/example.rb

@@ -1,186 +1,98 @@
-require 'js'
+# await: *await*
 
-module ::RSpec::Core
-  class Example
-    # WAS:
-    #   def run_after_example
-    #     @example_group_class.hooks.run(:after, :example, self)
-    #     verify_mocks
-    #     assign_generated_description if RSpec.configuration.expecting_with_rspec?
-    #   rescue Exception => e
-    #     set_exception(e, "in an `after(:example)` hook")
-    #   ensure
-    #     @example_group_instance.teardown_mocks_for_rspec
-    #   end
-    # NOW:
-    def run_after_example
-      @example_group_class.hooks.run(:after, :example, self).then do
-        verify_mocks
-        assign_generated_description if RSpec.configuration.expecting_with_rspec?
-      end.rescue do |e|
-        set_exception(e, "in an `after(:example)` hook")
-      end.ensure do
-        @example_group_instance.teardown_mocks_for_rspec
-      end
-    end
+module RSpec
+  module Core
+    class Example
+      def run_await(example_group_instance, reporter)
+        # added awaits
+        @example_group_instance = example_group_instance
+        @reporter = reporter
+        RSpec.configuration.configure_example(self, hooks)
+        RSpec.current_example = self
 
-    def run(example_group_instance, reporter)
-      @example_group_instance = example_group_instance
-      RSpec.current_example = self
+        start(reporter)
+        Pending.mark_pending!(self, pending) if pending?
 
-      start(reporter)
-      Pending.mark_pending!(self, pending) if pending?
-
-      # WAS:
-      #   …
-      #     begin
-      #       if skipped?
-      #         Pending.mark_pending! self, skip
-      #       elsif !RSpec.configuration.dry_run?
-      #         with_around_example_hooks do
-      #           begin
-      #             run_before_example
-      #             @example_group_instance.instance_exec(self, &@example_block)
-      #
-      #             if pending?
-      #               Pending.mark_fixed! self
-      #
-      #               raise Pending::PendingExampleFixedError,
-      #                     'Expected example to fail since it is pending, but it passed.',
-      #                     [location]
-      #             end
-      #           rescue Pending::SkipDeclaredInExample
-      #             # no-op, required metadata has already been set by the `skip`
-      #             # method.
-      #           rescue Exception => e
-      #             set_exception(e)
-      #           ensure
-      #             run_after_example
-      #           end
-      #         end
-      #       end
-      #     rescue Exception => e
-      #       set_exception(e)
-      #     ensure
-      #       @example_group_instance.instance_variables.each do |ivar|
-      #         @example_group_instance.instance_variable_set(ivar, nil)
-      #       end
-      #       @example_group_instance = nil
-      #     end
-      #
-      #     finish(reporter)
-      #   ensure
-      #     RSpec.current_example = nil
-      Promise.value(true).then do
-        Promise.value(true).then do
+        begin
           if skipped?
             Pending.mark_pending! self, skip
           elsif !RSpec.configuration.dry_run?
-            with_around_example_hooks do
-              # WAS:
-              #   with_around_example_hooks do
-              #     begin
-              #       run_before_example
-              #       @example_group_instance.instance_exec(self, &@example_block)
-              #
-              #       if pending?
-              #         Pending.mark_fixed! self
-              #
-              #         raise Pending::PendingExampleFixedError,
-              #               'Expected example to fail since it is pending, but it passed.',
-              #               [location]
-              #       end
-              #     rescue Pending::SkipDeclaredInExample
-              #       # no-op, required metadata has already been set by the `skip`
-              #       # method.
-              #     rescue Exception => e
-              #       set_exception(e)
-              #     ensure
-              #       run_after_example
-              #     end
-              #   end
-              # NOW:
-              Promise.value(true).then do
-                run_before_example
-                .then do
-                  # TODO: Use subject! to create a before hook on the fly, might be cleaner than this
-                  # Might be a better way to do this, but then you end up with promises around the expectation handlers, which could get ugly
-                  begin
-                    subj = example_group_instance.subject
-                    if subj.is_a? Promise
-                      return subj.then do |resolved_subject|
-                        # This is a private method, but we're using Opal
-                        example_group_instance.__memoized[:subject] = resolved_subject
-                      end
-                    end
-                  rescue StandardError, JS::Error
-                    # Exception occurred while checking the subject, might be that the example
-                    # group had a described class, was not intending on using it as the subject,
-                    # and the initializer for that described class failed
-                  end
-                  Promise.value(true)
-                end
-                .then do
-                  # WAS:
-                  #   @example_group_instance.instance_exec(self, &@example_block)
-                  # NOW:
-                  Promise.value(@example_group_instance.instance_exec(self, &@example_block)).then do |result|
-                    result
-                  end.rescue do |ex|
-                    case ex
-                    when nil then Exception.new 'Async promise failed for unspecified reason'
-                    when Exception then ex
-                    else Exception.new(ex)
-                    end
-                  end
-                end
-                .then do
-                  # ORIGINAL:
-                  if pending?
-                    Pending.mark_fixed! self
+            with_around_and_singleton_context_hooks_await do
+              begin
+                run_before_example_await
+                RSpec.current_scope = :example
+                @example_group_instance.instance_exec_await(self, &@example_block)
 
-                    raise Pending::PendingExampleFixedError,
-                          'Expected example to fail since it is pending, but it passed.',
-                          [location]
-                  end
-                end
-              end.rescue do |e|
-                # WAS:
-                #   rescue Pending::SkipDeclaredInExample
-                #     # no-op, required metadata has already been set by the `skip`
-                #     # method.
-                #   rescue Exception => e
-                #     set_exception(e)
-                #   ensure
-                #     run_after_example
-                #   end
-                # NOW:
-                case e
-                when Pending::SkipDeclaredInExample
-                  # no-op, required metadata has already been set by the `skip`
-                  # method.
-                when Exception
-                  set_exception(e)
+                if pending?
+                  Pending.mark_fixed! self
+
+                  raise Pending::PendingExampleFixedError,
+                        'Expected example to fail since it is pending, but it passed.',
+                        [location]
                 end
-              end.ensure do
-                run_after_example
+              rescue Pending::SkipDeclaredInExample => _
+                # The "=> _" is normally useless but on JRuby it is a workaround
+                # for a bug that prevents us from getting backtraces:
+                # https://github.com/jruby/jruby/issues/4467
+                #
+                # no-op, required metadata has already been set by the `skip`
+                # method.
+              rescue AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt => e
+                set_exception(e)
+              ensure
+                RSpec.current_scope = :after_example_hook
+                run_after_example_await
               end
             end
           end
-        end.rescue do |e|
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
           set_exception(e)
-        end.ensure do
-          @example_group_instance.instance_variables.each do |ivar|
-            @example_group_instance.instance_variable_set(ivar, nil)
-          end
-          @example_group_instance = nil
+        ensure
+          @example_group_instance = nil # if you love something... let it go
         end
-      end.then do
+
         finish(reporter)
-      end.ensure do |result|
+      ensure
+        execution_result.ensure_timing_set(clock)
         RSpec.current_example = nil
-        # promise always/ensure do not behave exactly like ensure, need to be explicit about value being returned
-        result
+      end
+
+      def run_before_example_await
+        # added awaits
+        @example_group_instance.setup_mocks_for_rspec
+        hooks.run_await(:before, :example, self)
+      end
+
+      def run_after_example_await
+        # added awaits
+        assign_generated_description if defined?(::RSpec::Matchers)
+        hooks.run_await(:after, :example, self)
+        verify_mocks
+      ensure
+        @example_group_instance.teardown_mocks_for_rspec
+      end
+
+      def with_around_and_singleton_context_hooks_await
+        singleton_context_hooks_host = example_group_instance.singleton_class
+        singleton_context_hooks_host.run_before_context_hooks_await(example_group_instance)
+        with_around_example_hooks_await { yield.await }
+      ensure
+        singleton_context_hooks_host.run_after_context_hooks_await(example_group_instance)
+      end
+
+      def with_around_example_hooks_await
+        RSpec.current_scope = :before_example_hook
+        hooks.run_await(:around, :example, self) { yield.await }
+      rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
+        set_exception(e)
+      end
+
+      def instance_exec_await(*args, &block)
+        @example_group_instance.instance_exec_await(*args, &block)
+      end
+
+      class Procsy
+        alias run_await run
       end
     end
   end

data/lib-opal/opal/rspec/async/example_group.rb

@@ -1,96 +1,86 @@
-require 'promise'
+# await: *await*
 
-class ::RSpec::Core::ExampleGroup
-  # @param duration [Integer, Float] time in seconds to wait
-  def delay(duration, &block)
-    `setTimeout(block, duration * 1000)`
-    self
-  end
+module ::RSpec
+  module Core
+    class ExampleGroup
+      # @param duration [Integer, Float] time in seconds to wait
+      def delay(duration, &block)
+        `setTimeout(block, duration * 1000)`
+        self
+      end
 
-  def delay_with_promise(duration, &block)
-    result = Promise.new
-    delay(duration) { result.resolve }
-    result.then(&block)
-  end
+      def delay_with_promise(duration, &block)
+        result = PromiseV2.new
+        delay(duration) { result.resolve }
+        result.then(&block)
+      end
 
-  def self.process_descendants(our_examples_result, reporter)
-    descendants = ordering_strategy.order(children)
-    return Promise.value(our_examples_result) if descendants.empty?
+      def self.run_await(reporter=RSpec::Core::NullReporter)
+        # added awaits
+        return if RSpec.world.wants_to_quit
+        reporter.example_group_started(self)
 
-    results_for_descendants = []
-    # Can use true for this because we're AND'ing everything anyways
-    seed = Promise.value(true)
-    latest_descendant = descendants.inject(seed) do |previous_promise, next_descendant|
-      previous_promise.then do |result|
-        results_for_descendants << result
-        next_descendant.run reporter
+        should_run_context_hooks = descendant_filtered_examples.any?
+        begin
+          RSpec.current_scope = :before_context_hook
+          run_before_context_hooks_await(new('before(:context) hook')) if should_run_context_hooks
+          result_for_this_group = run_examples_await(reporter)
+          results_for_descendants = ordering_strategy.order(children).map_await { |child| child.run_await(reporter) }.all?
+          result_for_this_group && results_for_descendants
+        rescue Pending::SkipDeclaredInExample => ex
+          for_filtered_examples(reporter) { |example| example.skip_with_exception(reporter, ex) }
+          true
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
+          for_filtered_examples(reporter) { |example| example.fail_with_exception(reporter, ex) }
+          RSpec.world.wants_to_quit = true if reporter.fail_fast_limit_met?
+          false
+        ensure
+          RSpec.current_scope = :after_context_hook
+          run_after_context_hooks_await(new('after(:context) hook')) if should_run_context_hooks
+          reporter.example_group_finished(self)
+        end
       end
-    end
-    latest_descendant.then do |result|
-      results_for_descendants << result
-      our_examples_result && results_for_descendants.all?
-    end
-  end
 
-  # Promise oriented version
-  def self.run(reporter)
-    if RSpec.world.wants_to_quit
-      RSpec.world.clear_remaining_example_groups if top_level?
-      return
-    end
+      def self.run_examples_await(reporter)
+        # added awaits
+        ordering_strategy.order(filtered_examples).map_await do |example|
+          next if RSpec.world.wants_to_quit
+          instance = new(example.inspect_output)
+          set_ivars(instance, before_context_ivars)
+          succeeded = example.run_await(instance, reporter)
+          if !succeeded && reporter.fail_fast_limit_met?
+            RSpec.world.wants_to_quit = true
+          end
+          succeeded
+        end.all?
+      end
+
+      # @private
+      def self.run_before_context_hooks_await(example_group_instance)
+        set_ivars(example_group_instance, superclass_before_context_ivars)
 
-    reporter.example_group_started(self)
-    Promise.value(true).then do
-      run_before_context_hooks(new)
-    end.then do
-      run_examples(reporter)
-    end.then do |our_examples_result|
-      process_descendants(our_examples_result, reporter)
-    end.rescue do |ex|
-      result = if ex.is_a? Pending::SkipDeclaredInExample
-        for_filtered_examples(reporter) { |example| example.skip_with_exception(reporter, ex) }
-      else
-        RSpec.world.wants_to_quit = true if fail_fast?
-        for_filtered_examples(reporter) { |example| example.fail_with_exception(reporter, ex) }
+        @currently_executing_a_context_hook = true
+        
+        ContextHookMemoized::Before.isolate_for_context_hook_await(example_group_instance) do
+          hooks.run_await(:before, :context, example_group_instance)
+        end
+      ensure
+        store_before_context_ivars(example_group_instance)
+        @currently_executing_a_context_hook = false
       end
-      result
-    end.always do |result|
-      run_after_context_hooks(new)
-      before_context_ivars.clear
-      reporter.example_group_finished(self)
-      # promise always do not behave exactly like ensure, need to be explicit about value being returned
-      result
-    end
-  end
 
-  # Promise oriented version
-  def self.run_examples(reporter)
-    examples = ordering_strategy.order(filtered_examples)
-    return Promise.value(true) if examples.empty?
+      def self.run_after_context_hooks_await(example_group_instance)
+        set_ivars(example_group_instance, before_context_ivars)
 
-    example_promise = lambda do |example|
-      next Promise.value(nil) if RSpec.world.wants_to_quit
-      instance = new
-      set_ivars(instance, before_context_ivars)
-      # Always returns a promise since we modified the Example class
-      example.run(instance, reporter)
-    end
+        @currently_executing_a_context_hook = true
 
-    results = []
-    # Can use true for this because we're AND'ing everything anyways
-    seed = Promise.value(true)
-    latest_promise = examples.inject(seed) do |previous_promise, next_example|
-      previous_promise.then do |succeeded|
-        RSpec.world.wants_to_quit = true if fail_fast? && !succeeded
-        results << succeeded
-        example_promise[next_example]
+        ContextHookMemoized::After.isolate_for_context_hook_await(example_group_instance) do
+          hooks.run_await(:after, :context, example_group_instance)
+        end
+      ensure
+        before_context_ivars.clear
+        @currently_executing_a_context_hook = false
       end
     end
-
-    latest_promise.then do |succeeded|
-      RSpec.world.wants_to_quit = true if fail_fast? && !succeeded
-      results << succeeded
-      results.all?
-    end
   end
 end

data/lib-opal/opal/rspec/async/hooks.rb

@@ -1,11 +1,101 @@
-class RSpec::Core::Hooks::HookCollection
-  def run
-    # WAS:
-    #   hooks.each { |h| h.run(@example) }
-    # NOW:
-    hooks.inject(Promise.value(true)) do |previous_hook_promise, next_hook|
-      previous_hook_promise.then do
-        Promise.value(next_hook.run(@example))
+# await: *await*
+
+require 'rspec/core/hooks'
+
+module RSpec
+  module Core
+    module Hooks
+      class HookCollections
+        def run_example_hooks_for_await(example, position, each_method)
+          # WAS:
+          # owner_parent_groups.__send__(each_method) do |group|
+          #   group.hooks.run_owned_hooks_for(position, :example, example)
+          # end
+          case each_method
+          when :each
+            groups = owner_parent_groups
+          when :reverse_each
+            groups = owner_parent_groups.reverse
+          else
+            raise "Unsupported each_method: #{each_method}"
+          end
+          groups.each_await do |group|
+            group.hooks.run_owned_hooks_for_await(position, :example, example)
+          end
+        end
+
+        def run_owned_hooks_for_await(position, scope, example_or_group)
+          # WAS:
+          # matching_hooks_for(position, scope, example_or_group).each do |hook|
+          #   hook.run(example_or_group)
+          # end
+
+          matching_hooks_for(position, scope, example_or_group).each_await do |hook|
+            hook.run_await(example_or_group)
+          end
+        end
+
+        def run_await(position, scope, example_or_group)
+          return if RSpec.configuration.dry_run?
+
+          if scope == :context
+            unless example_or_group.class.metadata[:skip]
+              run_owned_hooks_for_await(position, :context, example_or_group)
+            end
+          else
+            case position
+            when :before then run_example_hooks_for_await(example_or_group, :before, :reverse_each)
+            when :after  then run_example_hooks_for_await(example_or_group, :after,  :each)
+            when :around then run_around_example_hooks_for_await(example_or_group) { yield.await }
+            end
+          end
+        end
+
+        def run_around_example_hooks_for_await(example)
+          hooks = FlatMap.flat_map(owner_parent_groups) do |group|
+            group.hooks.matching_hooks_for(:around, :example, example)
+          end
+
+          return yield if hooks.empty? # exit early to avoid the extra allocation cost of `Example::Procsy`
+
+          initial_procsy = Example::Procsy.new(example) { yield.await }
+          hooks.inject(initial_procsy) do |procsy, around_hook|
+            procsy.wrap { around_hook.execute_with_await(example, procsy) }
+          end.call.await
+        end
+      end
+
+      class BeforeHook < Hook
+        def run_await(example)
+          example.instance_exec_await(example, &block)
+        end
+      end
+
+      # @private
+      class AfterHook < Hook
+        def run_await(example)
+          example.instance_exec_await(example, &block)
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
+          example.set_exception(ex)
+        end
+      end
+
+      # @private
+      class AfterContextHook < Hook
+        def run_await(example)
+          example.instance_exec_await(example, &block)
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
+          RSpec.configuration.reporter.notify_non_example_exception(e, "An error occurred in an `after(:context)` hook.")
+        end
+      end
+
+      class AroundHook < Hook
+        def execute_with_await(example, procsy)
+          example.instance_exec_await(procsy, &block)
+          return if procsy.executed?
+          Pending.mark_skipped!(example,
+                                "#{hook_description} did not execute the example")
+        end
       end
     end
   end

data/lib-opal/opal/rspec/async/memoized_helpers.rb

@@ -0,0 +1,32 @@
+module RSpec
+  module Core
+    # This module is included in {ExampleGroup}, making the methods
+    # available to be called from within example blocks.
+    #
+    # @see ClassMethods
+    module MemoizedHelpers
+      class ContextHookMemoized
+        def self.isolate_for_context_hook_await(example_group_instance)
+          exploding_memoized = self
+
+          example_group_instance.instance_exec_await do
+            @__memoized = exploding_memoized
+
+            begin
+              yield.await
+            ensure
+              # This is doing a reset instead of just isolating for context hook.
+              # Really, this should set the old @__memoized back into place.
+              #
+              # Caller is the before and after context hooks
+              # which are both called from self.run
+              # I didn't look at why it made tests fail, maybe an object was getting reused in RSpec tests,
+              # if so, then that probably already works, and its the tests that are wrong.
+              __init_memoized
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib-opal/opal/rspec/async/reporter.rb

@@ -1,5 +1,7 @@
+# await: *await*
+
 class ::RSpec::Core::Reporter
-  def report(expected_example_count)
+  def report_await(expected_example_count)
     # WAS:
     #   start(expected_example_count)
     #   begin
@@ -9,9 +11,10 @@ class ::RSpec::Core::Reporter
     #   end
     # NOW:
     start(expected_example_count)
-    yield(self).ensure do |result|
+    begin
+      yield(self).await
+    ensure
       finish
-      result
     end
   end
 end

data/lib-opal/opal/rspec/async/runner.rb

@@ -1,3 +1,5 @@
+# await: *await*
+
 module ::RSpec::Core
   class Runner
 
@@ -8,37 +10,44 @@ module ::RSpec::Core
       #   status = run(ARGV, $stderr, $stdout).to_i
       #   exit(status) if status != 0
       # NOW:
-      run(ARGV, $stderr, $stdout).then do |status|
-        status = status.to_i
-        exit(status) if status != 0
+      status = run_await(ARGV, $stderr, $stdout).to_i
+      exit(status)
+    end
+
+    def self.run_await(args, err=$stderr, out=$stdout)
+      trap_interrupt
+      options = ConfigurationOptions.new(args)
+
+      if options.options[:runner]
+        options.options[:runner].call(options, err, out)
+      else
+        new(options).run_await(err, out)
       end
     end
 
-    def run_specs(example_groups)
-      @configuration.reporter.report(@world.example_count(example_groups)) do |reporter|
-        hook_context = SuiteHookContext.new
-
-        Promise.value(true).then do
-          @configuration.hooks.run(:before, :suite, hook_context)
-
-          # WAS: example_groups.map { |g| g.run(reporter) }.all? ? 0 : @configuration.failure_exit_code
-          results = []
-          example_groups.inject(Promise.value(true)) do |previous_promise, group|
-            previous_promise.then do |result|
-              results << result
-              group.run reporter
-            end
-          end.then do |result|
-            results << result
-            results.all? ? 0 : @configuration.failure_exit_code
+    def run_await(err, out)
+      setup(err, out)
+      return @configuration.reporter.exit_early(exit_code) if RSpec.world.wants_to_quit
+
+      run_specs_await(@world.ordered_example_groups).tap do
+        persist_example_statuses
+      end
+    end
+
+    def run_specs_await(example_groups)
+      examples_count = @world.example_count(example_groups)
+
+      examples_passed = @configuration.reporter.report_await(examples_count) do |reporter|
+        @configuration.with_suite_hooks_await do
+          if examples_count == 0 && @configuration.fail_if_no_examples
+            return @configuration.failure_exit_code
           end
 
-        end.ensure do |result|
-          @configuration.hooks.run(:after, :suite, hook_context)
-          result
+          example_groups.map_await { |g| g.run_await(reporter) }.all?
         end
       end
-    end
 
+      exit_code(examples_passed)
+    end
   end
 end