opal-rspec-cj 0.4.4

data/opal/opal-rspec.rb

@@ -0,0 +1 @@
+require 'opal/rspec'

data/opal/opal/rspec.rb

@@ -0,0 +1,25 @@
+class MiniTest
+  class Unit; end
+end
+
+Test = MiniTest
+
+require 'opal/rspec/requires'
+require 'opal/rspec/fixes'
+require 'opal/rspec/text_formatter'
+require 'opal/rspec/browser_formatter'
+require 'opal/rspec/runner'
+require 'opal/rspec/async'
+
+RSpec.configure do |config|
+  # For now, always use our custom formatter for results
+  config.formatter = Opal::RSpec::Runner.default_formatter
+
+  # Async helpers for specs
+  config.include Opal::RSpec::AsyncHelpers
+
+  # Always support expect() and .should syntax (we should not do this really..)
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end

data/opal/opal/rspec/async.rb

@@ -0,0 +1,289 @@
+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

data/opal/opal/rspec/browser_formatter.rb

@@ -0,0 +1,188 @@
+require 'erb'
+
+module Opal
+  module RSpec
+    class BrowserFormatter < ::RSpec::Core::Formatters::BaseFormatter
+      include ERB::Util
+
+      CSS_STYLES = ::RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES
+
+      def start(example_count)
+        super
+        target = Element.new(`document.body`)
+        target << Element.new(:div, html: REPORT_TEMPLATE)
+        @rspec_results = Element.id('rspec-results')
+
+        css_text = CSS_STYLES + "\n body { padding: 0; margin: 0 }"
+        styles = Element.new(:style, type: 'text/css', css_text: css_text)
+        styles.append_to_head
+      end
+
+      def example_group_started(example_group)
+        super
+
+        @example_group_failed = false
+        parents = example_group.parent_groups.size
+
+        @rspec_group  = Element.new(:div, class_name: "example_group passed")
+        @rspec_dl     = Element.new(:dl)
+        @rspec_dt     = Element.new(:dt, class_name: "passed", text: example_group.description)
+        @rspec_group << @rspec_dl
+        @rspec_dl << @rspec_dt
+
+        @rspec_dl.style 'margin-left', "#{(parents - 2) * 15}px"
+
+        @rspec_results << @rspec_group
+      end
+
+      def example_group_finished(example_group)
+        super
+
+        if @example_group_failed
+          @rspec_group.class_name = "example_group failed"
+          @rspec_dt.class_name = "failed"
+          Element.id('rspec-header').class_name = 'failed'
+        end
+      end
+
+      def example_failed(example)
+        super
+        duration = sprintf("%0.5f", example.execution_result[:run_time])
+
+        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" }
+
+        @example_group_failed = true
+
+        @rspec_dl << Element.new(:dd, class_name: "example failed", html: <<-HTML)
+          <span class="failed_spec_name">#{h example.description}</span>
+          <span class="duration">#{duration}s</span>
+          <div class="failure">
+            <div class="message"><pre>#{h output}</pre></div>
+          </div>
+        HTML
+      end
+
+      def example_passed(example)
+        super
+        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
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        super
+
+        totals = "#{example_count} examples, #{failure_count} failures"
+        Element.id('totals').html = totals
+
+        duration = "Finished in <strong>#{sprintf("%.5f", duration)} seconds</strong>"
+        Element.id('duration').html = duration
+
+        add_scripts
+      end
+
+      def add_scripts
+        content = ::RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS
+        `window.eval(#{content})`
+      end
+
+      def short_padding
+        '  '
+      end
+
+      def long_padding
+        '     '
+      end
+
+      class Element
+        attr_reader :native
+
+        def self.id(id)
+          new(`document.getElementById(id)`)
+        end
+
+        def initialize(el, attrs={})
+          if String === el
+            @native = `document.createElement(el)`
+          else
+            @native = el
+          end
+
+          attrs.each { |name, val| __send__ "#{name}=", val }
+        end
+
+        def class_name=(name)
+          `#@native.className = #{name}`
+        end
+
+        def html=(html)
+          `#@native.innerHTML = #{html}`
+        end
+
+        def text=(text)
+          self.html = text.gsub(/</, '&lt').gsub(/>/, '&gt')
+        end
+
+        def type=(type)
+          `#@native.type = #{type}`
+        end
+
+        def append(child)
+          `#@native.appendChild(#{child.native})`
+        end
+
+        alias << append
+
+        def css_text=(text)
+          %x{
+            if (#@native.styleSheet) {
+              #@native.styleSheet.cssText = #{text};
+            }
+            else {
+              #@native.appendChild(document.createTextNode(#{text}));
+            }
+          }
+        end
+
+        def style(name, value)
+          `#@native.style[#{name}] = value`
+        end
+
+        def append_to_head
+          `document.getElementsByTagName('head')[0].appendChild(#@native)`
+        end
+      end
+
+      REPORT_TEMPLATE = <<-EOF
+<div class="rspec-report">
+
+  <div id="rspec-header">
+    <div id="label">
+      <h1>RSpec Code Examples</h1>
+    </div>
+
+    <div id="display-filters">
+      <input id="passed_checkbox"  name="passed_checkbox"  type="checkbox" checked="checked" onchange="apply_filters()" value="1" /> <label for="passed_checkbox">Passed</label>
+      <input id="failed_checkbox"  name="failed_checkbox"  type="checkbox" checked="checked" onchange="apply_filters()" value="2" /> <label for="failed_checkbox">Failed</label>
+      <input id="pending_checkbox" name="pending_checkbox" type="checkbox" checked="checked" onchange="apply_filters()" value="3" /> <label for="pending_checkbox">Pending</label>
+    </div>
+
+    <div id="summary">
+      <p id="totals">&#160;</p>
+      <p id="duration">&#160;</p>
+    </div>
+  </div>
+
+  <div id="rspec-results" class="results">
+  </div>
+</div>
+EOF
+    end
+  end
+end