opal-rspec 0.4.3 → 0.5.0.beta1

data/opal/opal/rspec/async.rb

@@ -1,289 +1,4 @@
-module Opal
-  module RSpec
-    # {AsyncHelpers} is automatically included in all example groups to add
-    # support for running specs async. Usually, rspec runners expect all
-    # examples to run synchronously, but this is not ideal in the case for
-    # Opal where a lot of underlying libraries expect the ability to run code
-    # in an asynchronous manner.
-    #
-    # This module defines an {AsyncHelpers::ClassMethods.async} method which
-    # can be used instead of `it` inside an example group, which marks the
-    # example as being async. This makes the runner wait for the example to
-    # complete.
-    #
-    #     describe "Some examples" do
-    #       it "normal example" do
-    #         # normal test code
-    #       end
-    #
-    #       async "async example" do
-    #         # this will wait until completion before moving on
-    #       end
-    #     end
-    #
-    # Marking an example as being async is only half the task. Examples will
-    # also have an instance {AsyncHelpers#async} method defined which is then
-    # used to complete the example. Any code run inside this block will run
-    # inside the context of the example.
-    #
-    #     describe "HTTP requests" do
-    #       async "might take a while" do
-    #         HTTP.get("/url/to/get") do |res|
-    #           async { expect(res).to be_ok }
-    #         end
-    #       end
-    #     end
-    #
-    # As soon as `async` is run inside the block, the example completes. This
-    # means that only 1 `async` call is allowed. However, you can use `async`
-    # multiple times aslong as it is only called once:
-    #
-    #     describe "HTTP requests" do
-    #       async "should work" do
-    #         HTTP.get("/users/1").then |res|
-    #           async { expect(res).to be_ok }
-    #         end.fail do
-    #           async { raise "this should not be called" }
-    #         end
-    #       end
-    #     end
-    #
-    # Here, a promise will either be accepted or rejected, so an `async` block
-    # can be used in each case as only 1 will be called.
-    #
-    # Another helper, {AsyncHelpers#delay} can also be used to run a block of
-    # code after a given time in seconds. This is useful to wait for animations
-    # or time restricted operations to occur.
-    module AsyncHelpers
-      module ClassMethods
-        # Define an async example method. This should be used instead of `it`
-        # to inform the spec runner that the example will need to wait for an
-        # {AsyncHelpers#async} method to complete the test. Any additional
-        # configuration options can be passed to this call, and they just get
-        # delegated to the underlying `#it` call.
-        #
-        # @example
-        #   describe "Some tests" do
-        #     async "should be async" do
-        #       # ... async code
-        #     end
-        #
-        #     it "should work with normal tests" do
-        #       expect(1).to eq(1)
-        #     end
-        #   end
-        #
-        # @param desc [String] description
-        def async(desc, *args, &block)
-          options = ::RSpec::Core::Metadata.build_hash_from(args)
-          Opal::RSpec::AsyncExample.register(self, desc, options, block)
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      # Must be used with {ClassMethods#async} to finish the async action. If
-      # this is not called inside the body then the spec runner will time out
-      # or the error might give a false positive as it is not caught inside
-      # the current example.
-      #
-      # @example Complete expectation after HTTP request
-      #   describe "HTTP calls" do
-      #     async "complete eventually" do
-      #       HTTP.get("/some_url") do |response|
-      #         async { expect(response).to be_ok }
-      #       end
-      #     end
-      #   end
-      #
-      def async(&block)
-        @example.continue_async(block)
-      end
-
-      # Runs the given block after a given duration. You are still required to
-      # use a {#async} block inside the delayed callback. This helper can be
-      # used to simulate IO delays, or just to wait for animations/other
-      # behaviour to finish.
-      #
-      # The `duaration` should be given in seconds, i.e. `1` means 1 second, or
-      # 0.3 means 300ms. The given block is just run after the time delay.
-      #
-      # @example
-      #   describe "Some interaction" do
-      #     async "takes a while to complete" do
-      #       task = start_long_task!
-      #
-      #       delay(1) do
-      #         async { expect(task).to be_completed }
-      #       end
-      #     end
-      #   end
-      #
-      # @param duration [Integer, Float] time in seconds to wait
-      def delay(duration, &block)
-        `setTimeout(block, duration * 1000)`
-        self
-      end
-
-      # Use {#async} instead.
-      #
-      # @deprecated
-      def run_async(&block)
-        async(&block)
-      end
-
-      # Use {#delay} instead.
-      #
-      # @deprecated
-      def set_timeout(*args, &block)
-        delay(*args, &block)
-      end
-    end
-
-    # Runs all async examples from {AsyncExample.examples}.
-    class AsyncRunner
-      def initialize(runner, reporter, finish_block)
-        @runner = runner
-        @reporter = reporter
-        @finish_block = finish_block
-      end
-
-      def run
-        @examples = AsyncExample.examples.clone
-        run_next_example
-      end
-
-      def run_next_example
-        if @examples.empty?
-          finish
-        else
-          run_example @examples.pop
-        end
-      end
-
-      def run_example(example)
-        example_group = example.example_group
-
-        @reporter.example_group_started example_group
-        instance = example_group.new
-
-        example.run(instance, @reporter) do
-          example_finished example
-        end
-      end
-
-      def example_finished(example)
-        @reporter.example_group_finished example.example_group
-        run_next_example
-      end
-
-      # Called once all examples have finished. Just calls back to main
-      # runner to inform it
-      def finish
-        @finish_block.call
-      end
-    end
-
-    # An {AsyncExample} is a subclass of regular example instances which adds
-    # support for running an example, and waiting for a non-sync outcome. All
-    # async examples in a set of spec files will get registered through
-    # {AsyncExample.register}, and added to the {AsyncExample.examples} array
-    # ready for the runner to run.
-    #
-    # You will not need to create new instances of this class directly, and
-    # should instead use {AsyncHelpers} to create async examples.
-    class AsyncExample < ::RSpec::Core::Example
-      include AsyncHelpers
-
-      # Register new async example.
-      #
-      # @see AsyncHelpers::ClassMethods.async
-      def self.register(*args)
-        examples << new(*args)
-      end
-
-      # All async examples in specs.
-      #
-      # @return [Array<AsyncExample>]
-      def self.examples
-        @examples ||= []
-      end
-
-      def run(example_group_instance, reporter, &after_run_block)
-        @example_group_instance = example_group_instance
-        @reporter               = reporter
-        @after_run_block        = after_run_block
-        @finished               = false
-
-        should_wait = true
-
-        ::RSpec.current_example = self
-        example_group_instance.instance_variable_set :@example, self
-
-        start(reporter)
-
-        begin
-          run_before_each
-          @example_group_instance.instance_exec(self, &@example_block)
-        rescue Exception => e
-          set_exception(e)
-          should_wait = false
-        end
-
-        if should_wait
-          delay options[:timeout] || 10 do
-            next if finished?
-
-            set_exception RuntimeError.new("timeout")
-            async_example_finished
-          end
-        else
-          async_example_finished
-        end
-      end
-
-      def continue_async(block)
-        return if finished?
-
-        begin
-          block.call
-        rescue Exception => e
-          set_exception(e)
-        end
-
-        async_example_finished
-      end
-
-      def finished?
-        @finished
-      end
-
-      def async_example_finished
-        @finished = true
-
-        begin
-          run_after_each
-        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
-
-          begin
-            assign_generated_description
-          rescue Exception => e
-            set_exception(e, "while assigning the example description")
-          end
-        end
-
-        finish(@reporter)
-        ::RSpec.current_example = nil
-        @after_run_block.call
-      end
-    end
-  end
-end
+require 'opal/rspec/async/async_example'
+require 'opal/rspec/async/example_group'
+require 'opal/rspec/async/hooks'
+require 'opal/rspec/async/legacy'

data/opal/opal/rspec/browser_formatter.rb

@@ -4,6 +4,8 @@ module Opal
   module RSpec
     class BrowserFormatter < ::RSpec::Core::Formatters::BaseFormatter
       include ERB::Util
+      
+      ::RSpec::Core::Formatters.register self, :dump_summary, :example_group_finished, :example_failed, :example_passed, :example_pending, :message
 
       CSS_STYLES = ::RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES
 
@@ -17,12 +19,25 @@ module Opal
         styles = Element.new(:style, type: 'text/css', css_text: css_text)
         styles.append_to_head
       end
+      
+      def message(notification)
+        @rspec_group  = Element.new(:div, class_name: "example_group passed")
+        @rspec_dl     = Element.new(:dl)
+        @rspec_dt     = Element.new(:dt, class_name: "passed", text: notification.message)
+        @rspec_group << @rspec_dl
+        @rspec_dl << @rspec_dt
+
+        parents = @example_group.parent_groups.size
+        @rspec_dl.style 'margin-left', "#{(parents - 2) * 15}px"
 
-      def example_group_started(example_group)
+        @rspec_results << @rspec_group
+      end
+
+      def example_group_started(notification)
         super
 
         @example_group_failed = false
-        parents = example_group.parent_groups.size
+        parents = @example_group.parent_groups.size
 
         @rspec_group  = Element.new(:div, class_name: "example_group passed")
         @rspec_dl     = Element.new(:dl)
@@ -35,24 +50,44 @@ module Opal
         @rspec_results << @rspec_group
       end
 
-      def example_group_finished(example_group)
-        super
-
+      def example_group_finished(_notification)
         if @example_group_failed
           @rspec_group.class_name = "example_group failed"
           @rspec_dt.class_name = "failed"
           Element.id('rspec-header').class_name = 'failed'
         end
+        
+        if @example_group_pending
+          @rspec_group.class_name = "example_group not_implemented"
+          @rspec_dt.class_name = "pending"          
+          header = Element.id('rspec-header')
+          # Don't want to override failed with pending, which is less important
+          header.class_name = 'not_implemented' unless header.class_name == 'failed'
+        end
       end
+      
+      def example_pending(notification)
+        example = notification.example
+        duration = sprintf("%0.5f", example.execution_result.run_time)
+        
+        pending_message = example.execution_result.pending_message
 
-      def example_failed(example)
-        super
-        duration = sprintf("%0.5f", example.execution_result[:run_time])
+        @example_group_pending = true
+
+        @rspec_dl << Element.new(:dd, class_name: "example not_implemented", html: <<-HTML)
+          <span class="not_implemented_spec_name">#{h example.description} (PENDING: #{h(pending_message)})</span>          
+        HTML
+      end
+
+      def example_failed(notification)
+        example = notification.example
+        duration = sprintf("%0.5f", example.execution_result.run_time)
 
-        error = example.execution_result[:exception]
+        error = example.execution_result.exception
         error_name = error.class.name.to_s
         output = "#{short_padding}#{error_name}:\n"
         error.message.to_s.split("\n").each { |line| output += "#{long_padding}  #{line}\n" }
+        error.backtrace.each {|trace| output += "#{long_padding}  #{trace}\n"}
 
         @example_group_failed = true
 
@@ -65,23 +100,21 @@ module Opal
         HTML
       end
 
-      def example_passed(example)
-        super
-        duration = sprintf("%0.5f", example.execution_result[:run_time])
+      def example_passed(notification)
+        example = notification.example      
+        duration = sprintf("%0.5f", example.execution_result.run_time)
 
         @rspec_dl << Element.new(:dd, class_name: "example passed", html: <<-HTML)
           <span class="passed_spec_name">#{h example.description}</span>
           <span class="duration">#{duration}s</span>
         HTML
-      end
+      end     
 
-      def dump_summary(duration, example_count, failure_count, pending_count)
-        super
-
-        totals = "#{example_count} examples, #{failure_count} failures"
+      def dump_summary(notification)
+        totals = "#{notification.example_count} examples, #{notification.failure_count} failures, #{notification.pending_count} pending"
         Element.id('totals').html = totals
 
-        duration = "Finished in <strong>#{sprintf("%.5f", duration)} seconds</strong>"
+        duration = "Finished in <strong>#{sprintf("%.5f", notification.duration)} seconds</strong>"
         Element.id('duration').html = duration
 
         add_scripts
@@ -116,6 +149,10 @@ module Opal
 
           attrs.each { |name, val| __send__ "#{name}=", val }
         end
+        
+        def class_name
+          `#@native.className`
+        end
 
         def class_name=(name)
           `#@native.className = #{name}`

data/opal/opal/rspec/fixes/caller_filter.rb

@@ -0,0 +1,6 @@
+# This breaks on 2.0.0, so it is here ready for when opal bumps to 2.0.0
+class RSpec::CallerFilter
+  def self.first_non_rspec_line
+    ""
+  end
+end

data/opal/opal/rspec/fixes/example.rb

@@ -0,0 +1,20 @@
+class RSpec::Core::Example
+  # more mutable strings
+  def assign_generated_description
+    if metadata[:description].empty? && (description = RSpec::Matchers.generated_description)
+      metadata[:description] = description
+      metadata[:full_description] = metadata[:full_description] + description # mutable string fix
+    end
+  rescue Exception => e
+    set_exception(e, "while assigning the example description")
+  ensure
+    RSpec::Matchers.clear_generated_description
+  end
+
+  # Fix unnecessary deprecation warnings
+  # Hash.public_instance_methods - Object.public_instance_methods, which is a part of metadata.rb/HashImitatable (included by ExecutionResult), returns the initialize method, which gets marked as deprecated. The intent of the issue_deprecation method though is to shift people away from using this as a hash. Initialize obviously is not indicative of hash usage (any new object will trip this up, and that should not happen).
+  class ExecutionResult
+    # There is no real constructor to preserve in example.rb's ExecutionResult class, so can eliminate the issue_deprecation call this way
+    def initialize; end
+  end
+end

data/opal/opal/rspec/fixes/example_groups.rb

@@ -0,0 +1,32 @@
+module RSpec::ExampleGroups
+  # opal cannot use mutable strings AND opal doesnt support `\A` or `\z` anchors
+  def self.base_name_for(group)
+    return "Anonymous" if group.description.empty?
+
+    # convert to CamelCase
+    name = ' ' + group.description
+    name = name.gsub(/[^0-9a-zA-Z]+([0-9a-zA-Z])/) { |m| m[1].upcase }
+
+    name = name.lstrip         # Remove leading whitespace
+    name = name.gsub(/\W/, '') # JRuby, RBX and others don't like non-ascii in const names
+
+    # Ruby requires first const letter to be A-Z. Use `Nested`
+    # as necessary to enforce that.
+    name = name.gsub(/^([^A-Z]|$)/, 'Nested\1')
+
+    name
+  end
+
+  # opal cannot use mutable strings
+  def self.disambiguate(name, const_scope)
+    return name unless const_scope.const_defined?(name)
+
+    # Add a trailing number if needed to disambiguate from an existing constant.
+    name = name + "_2"
+    while const_scope.const_defined?(name)
+      name = name.next
+    end
+
+    name
+  end
+end

data/opal/opal/rspec/fixes/expectations.rb

@@ -0,0 +1,21 @@
+def (RSpec::Expectations).fail_with(message, expected=nil, actual=nil)
+  if !message
+    raise ArgumentError, "Failure message is nil. Does your matcher define the " +
+                         "appropriate failure_message_for_* method to return a string?"
+  end
+
+  # HAD ALSO:
+  # if actual && expected
+  #   if all_strings?(actual, expected)
+  #     if any_multiline_strings?(actual, expected)
+  #       message # + "\nDiff:" + differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
+  #     end
+  #   elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+  #     message # + "\nDiff:" + differ.diff_as_object(actual, expected)
+  #   end
+  # end
+
+  # diff = differ.diff(actual, expected)
+  # message = "#{message}\nDiff:#{diff}" unless diff.empty?
+  raise RSpec::Expectations::ExpectationNotMetError, message
+end

data/opal/opal/rspec/fixes/formatter.rb

@@ -0,0 +1,62 @@
+RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage.class_eval do
+  def to_s
+    msg =  "#{@data[:deprecated]} is deprecated."
+    msg += " Use #{@data[:replacement]} instead." if @data[:replacement]
+    msg += " Called from #{@data[:call_site]}." if @data[:call_site]
+    msg
+  end
+
+  def too_many_warnings_message
+    msg = "Too many uses of deprecated '#{type}'."
+    msg += " Set config.deprecation_stream to a File for full output."
+    msg
+  end
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter
+  # mutable strings not supported
+  SpecifiedDeprecationMessage = Struct.new(:type) do
+    def initialize(data)
+      @message = data.message
+      super deprecation_type_for(data)
+    end
+
+    def to_s
+      output_formatted @message
+    end
+
+    def too_many_warnings_message
+      "Too many similar deprecation messages reported, disregarding further reports. " + DEPRECATION_STREAM_NOTICE
+    end
+
+    private
+
+    def output_formatted(str)
+      return str unless str.lines.count > 1
+      separator = "#{'-' * 80}"
+      "#{separator}\n#{str.chomp}\n#{separator}"
+    end
+
+    def deprecation_type_for(data)
+      data.message.gsub(/(\w+\/)+\w+\.rb:\d+/, '')
+    end
+  end
+
+  GeneratedDeprecationMessage = Struct.new(:type) do
+    def initialize(data)
+      @data = data
+      super data.deprecated
+    end
+
+    def to_s
+      msg =  "#{@data.deprecated} is deprecated."
+      msg = msg + " Use #{@data.replacement} instead." if @data.replacement
+      msg = msg + " Called from #{@data.call_site}." if @data.call_site
+      msg
+    end
+
+    def too_many_warnings_message
+      "Too many uses of deprecated '#{type}'. " + DEPRECATION_STREAM_NOTICE
+    end
+  end
+end

data/opal/opal/rspec/fixes/kernel.rb

@@ -0,0 +1,35 @@
+# RSpec tries to add context with this. something like this: https://github.com/stacktracejs/stacktrace.js would be better than this but
+# avoiding adding an NPM dependency for now
+module Kernel
+  def caller
+    %x{
+      function getErrorObject(){
+          try { throw Error('') } catch(err) { return err; }
+      }
+
+
+      var err = getErrorObject();
+    }
+    stack = `err.stack`
+    caller_lines = stack.split("\n")[4..-1]
+    caller_lines.reject! {|l| l.strip.empty? }
+    caller_lines.map do |raw_line|
+      if match = /\s*at (.*) \((\S+):(\d+):\d+/.match(raw_line)
+        method, filename, line = match.captures
+        "#{filename}:#{line} in `#{method}'"
+      elsif match = /\s*at (\S+):(\d+):\d+/.match(raw_line)
+        filename, line = match.captures
+        "#{filename}:#{line} in `(unknown method)'"
+      # catch phantom/no 2nd line/col #
+      elsif match = /\s*at (.*) \((\S+):(\d+)/.match(raw_line)
+        method, filename, line = match.captures
+        "#{filename}:#{line} in `#{method}'"
+      elsif match = /\s*at (.*):(\d+)/.match(raw_line)
+        filename, line = match.captures
+        "#{filename}:#{line} in `(unknown method)'"
+      else
+        raise "Don't know how to parse #{raw_line}!"
+      end
+    end
+  end
+end

data/opal/opal/rspec/fixes/matchers.rb

@@ -0,0 +1,15 @@
+# Opal does not support mutable strings
+module RSpec
+  module Matchers
+    module Pretty
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s
+        word = word.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word = word.gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        word = word.tr("-", "_")
+        word = word.downcase
+        word
+      end
+    end
+  end
+end

data/opal/opal/rspec/fixes/mocks.rb

@@ -0,0 +1,13 @@
+# Opal does not support ObjectSpace, so force object __id__'s
+class RSpec::Mocks::Space
+  def id_for(object)
+    object.__id__
+  end
+end
+
+# Buggy under Opal?
+class RSpec::Mocks::MethodDouble
+  def save_original_method!
+    @original_method ||= @method_stasher.original_method
+  end
+end

data/opal/opal/rspec/fixes/reporter.rb

@@ -0,0 +1,12 @@
+class RSpec::Core::Reporter
+  # https://github.com/opal/opal/issues/858
+  # The problem is not directly related to the Reporter class (it has more to do with Formatter's call in add using a splat in the args list and right now, Opal does not run a to_a on a splat before the callee method takes over)
+  def register_listener(listener, *notifications)
+    # Without this, we won't flatten out each notification properly (e.g. example_started, finished, etc.)
+    notifications = notifications[0].to_a unless notifications[0].is_a? Array
+    notifications.each do |notification|
+      @listeners[notification.to_sym] << listener
+    end
+    true
+  end
+end