opal-rspec 0.4.3 → 0.5.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0e842ffe93edffeb7e5f97c5ebd881053b61642
-  data.tar.gz: ea64cb916e97deaa54763bf386ca1e63d08ea832
+  metadata.gz: dbd011de53ddb59b6953bb90ecddf3082402cc8d
+  data.tar.gz: cfb1bcebd79e37b25dda19aaa9b57e173c446154
 SHA512:
-  metadata.gz: 7d14e6849697b8cca91f618cfabf52ff6abcbc95e7f721949abf3ef250a5606bf9b4a109888f53acf11703407669111fd82e696309d9021b8061d5e129bebd34
-  data.tar.gz: f8d41ede39787d54ddf1e6d859ff9adb7d3e2c271f9bd0a62359bd4580c2f2288463caad92cb41f931abd0e34fe559d4f6f03aee7bebb314b14f6ee0b303fc2a
+  metadata.gz: dea4bff6ec1be0af8b3d3f205407cdbeff969307fd5ae8817653762c5099428c359756ec9ea55630e38350a9b302b41e8dcc091a05c7f8429ca927ba207170ab
+  data.tar.gz: a0ba39d3e3851bf95ad496da0635dd9b0bd2db21aa8875a77da7fa4c3f5a9984f65cd8421fcde54dcc5434ecc5fc85fccd25e639af1c69880a2054a9e3064128

data/.gitignore

@@ -1,3 +1,4 @@
 .DS_Store
 Gemfile.lock
 *.gem
+Gemfile.lock

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.5.0 (edge)
+
+*   By default, any subject, it example block, before(:each), after(:each), and around that returns a promise will be executed asynchronously. Async is NOT yet supported for context level hooks. Async approach from < 0.4.3 will still work.
+
+*   Update to RSpec 3.1 (core is 3.1.7, expectations/support 3.1.2, mocks 3.1.3)
+
+*   Remove copy of source (and just rely on git submodule fetch)
+
 ## 0.4.3 (2015-06-14)
 
 *   Allow the gem to be run under Opal 0.7 and 0.8
@@ -8,7 +16,7 @@
 
 *   Avoid phantomjs warning messages
 
-## 0.4.1
+## 0.4.1 (2015-02-25)
 
 *   Remove predicate matcher fixes as Opal supports $1..$9 special gvars.
 
@@ -21,5 +29,3 @@
 *   Replaced browser formatter to use html printer from rspec
 
 *   Add timeout support to asynchronous specs
-
-## 0.2.1  November 24, 2013

data/Gemfile

@@ -1,8 +1,9 @@
 source 'https://rubygems.org'
 gemspec
 
-gem 'rspec',              path: 'rspec'
-gem 'rspec-support',      path: 'rspec-support'
-gem 'rspec-core',         path: 'rspec-core'
-gem 'rspec-mocks',        path: 'rspec-mocks'
-gem 'rspec-expectations', path: 'rspec-expectations'
+unless Dir['rspec{,-{core,expectations,mocks,support}}'].any?
+  warn 'Run: "git submodule update --init" to get RSpec sources'
+end
+
+# Opal 0.9 still in development
+# gem 'opal', git: 'https://github.com/opal/opal.git'

data/README.md

@@ -51,8 +51,12 @@ in any web browser.
 
 ## Async examples
 
-`opal-rspec` adds support for async specs to rspec. These specs are defined using
-`#async` instead of `#it`:
+`opal-rspec` adds support for async specs to rspec. These specs can be defined using 2 approaches:
+
+1. Promises returned from subject or the `#it` block (preferred)
+1. `#async` instead of `#it` (in use with opal-rspec <= 0.4.3)
+
+### Promise approach
 
 ```ruby
 describe MyClass do
@@ -62,29 +66,85 @@ describe MyClass do
   end
 
   # async example
-  async 'does something else, too' do
-    # ...
+  it 'does something else, too' do
+    promise = Promise.new
+    delay 1 do
+      expect(:foo).to eq(:foo)
+      promise.resolve
+    end
+    promise
+  end
+
+  it 'does another thing' do
+    # Argument is number of seconds, delay_with_promise is a convenience method that will
+    # call setTimeout with the block and return a promise
+    delay_with_promise 0 do
+      expect(:foo).to eq(:foo)
+    end
+  end
+end
+
+describe MyClass2 do
+  # will wait for the before promise to complete before proceeding
+  before do
+    delay_with_promise 0 do
+      puts 'async before 'action
+    end
+  end
+
+  # async subject works too
+  subject do
+    delay_with_promise 0 do
+      42
+    end
+  end
+
+  it { is_expected.to eq 42 }
+
+  # If you use an around block and have async specs, you must use this approach
+  around do |example|
+    puts 'do stuff before'
+    example.run.then do
+      puts 'do stuff after example'
+    end
   end
 end
 ```
 
-This just marks the example as running async. To actually handle the async result,
-you also need to use a `run_async` call inside some future handler:
+Advantages:
+* Assuming your subject under test (or matchers) return/use promises, the syntax is the same for sync or async specs
+
+Limitations:
+* Right now, async `before(:context)` and `after(:context)` hooks cannot be async
+* `let` dependencies cannot be async, only subject
+* Opal-rspec will not timeout while waiting for your async code to finish
+
+### Async/it approach
+
+This is the approach that was supported in opal-rspec <= 0.4.3 and it still works.
 
 ```ruby
-async 'HTTP requests should work' do
-  HTTP.get('/users/1.json') do |res|
-    run_async {
-      expect(res).to be_ok
-    }
-  end
+describe MyClass2 do
+	async 'HTTP requests should work' do
+	  HTTP.get('/users/1.json') do |res|
+	    async {
+	      expect(res).to be_ok
+	    }
+	  end
+	end
 end
 ```
 
-The block passed to `run_async` informs the runner that this spec is finished
+The block passed to the second `async` call informs the runner that this spec is finished
 so it can move on. Any failures/expectations run inside this block will be run
 in the context of the example.
 
+Advantages:
+* Hides promises from the specs
+
+Disadvantages:
+* Requires different syntax for async specs vs. sync specs
+
 ## Contributing
 
 Install required gems at required versions:

data/Rakefile

@@ -4,23 +4,119 @@ Bundler.require
 Bundler::GemHelper.install_tasks
 
 require 'opal/rspec/rake_task'
-Opal::RSpec::RakeTask.new(:default)
+Opal::RSpec::RakeTask.new(:specs_untested)
 
+desc 'Generates an RSpec requires file free of dynamic requires'
+task :generate_requires do
+  # Do this free of any requires used to make this Rake task happen
+  sh 'ruby -Irspec/lib -Irspec-core/lib/rspec -Irspec-support/lib/rspec util/create_requires.rb'
+end
+
+task :default do
+  test_output = `rake specs_untested`
+  raise "Expected test runner to fail due to failed tests, but got return code of #{$?.exitstatus}" if $?.success?
+  count_match = /(\d+) examples, (\d+) failures, (\d+) pending/.match(test_output)
+  raise 'Expected a finished count of test failures/success/etc. but did not see it' unless count_match
+  total, failed, pending = count_match.captures
 
-require 'fileutils'
-desc "Copy RSpec sources"
-task :copy_rspec do
-  gems = %w(rspec rspec-core rspec-expectations rspec-mocks rspec-support)
+  actual_failures = []
+  test_output.scan /\d+\) (.*)/ do |match|
+    actual_failures << match[0].strip
+  end
+  actual_failures.sort!
 
-  gems.each do |gem|
-    spec = Gem::Specification.find_by_name gem
-    lib  = File.join spec.gem_dir, 'lib'
+  failure_messages = []
 
-    Dir["#{lib}/**/*.rb"].each do |file|
-      out = file.sub(/^#{lib}\//, 'opal/')
+  bad_strings = [/.*is still running, after block problem.*/,
+                 /.*should not have.*/,
+                 /.*Expected \d+ after hits but got \d+.*/,
+                 /.*Expected \d+ around hits but got \d+.*/]
 
-      FileUtils.mkdir_p File.dirname(out)
-      FileUtils.cp file, out
+  bad_strings.each do |regex|
+    test_output.scan(regex) do |match|
+      failure_messages << "Expected not to see #{regex} in output, but found match #{match}"
     end
   end
+
+  expected_pending_count = 22
+
+  expected_failures= ['promise should make example fail properly before async block reached',
+                      'promise matcher fails properly',
+                      'promise non-assertion failure in promise no args',
+                      'promise non-assertion failure in promise string arg',
+                      'promise non-assertion failure in promise exception arg',
+                      'pending in example no promise would not fail otherwise, thus fails properly',
+                      'async/sync mix fails properly if a sync test is among async tests',
+                      'async/sync mix can finish running after a long delay and fail properly',
+                      'be_truthy fails properly with truthy values',
+                      'subject sync unnamed assertion fails properly should eq 43',
+                      'subject sync unnamed fails properly during subject create',
+                      'subject async assertion implicit fails properly should eq 43',
+                      'subject async fails properly during creation explicit async',
+                      'subject async fails properly during creation implicit usage',
+                      'subject async assertion explicit async fails properly',
+                      'hooks around sync fails after example should equal 42',
+                      'hooks around sync fails before example',
+                      'hooks around async fails after example after(:each) async fails sync match passes',
+                      'hooks around async fails after example after(:each) async passes sync match passes',
+                      'hooks around async fails after example after(:each) sync fails sync match passes',
+                      'hooks around async fails after example after(:each) sync passes sync match passes',
+                      'hooks around async fails after example before(:each) fails should not reach the example',
+                      'hooks around async fails after example matches another async match',
+                      'hooks around async fails after example matches async match',
+                      'hooks around async fails after example matches async match fails properly',
+                      'hooks around async fails after example matches sync fails properly',
+                      'hooks around async fails after example matches sync match',
+                      'hooks around async fails before example after(:each) async fails sync match passes',
+                      'hooks around async fails before example after(:each) async passes sync match passes',
+                      'hooks around async fails before example after(:each) sync fails sync match passes',
+                      'hooks around async fails before example after(:each) sync passes sync match passes',
+                      'hooks around async fails before example before(:each) fails should not reach the example',
+                      'hooks around async fails before example matches another async match',
+                      'hooks around async fails before example matches async match',
+                      'hooks around async fails before example matches async match fails properly',
+                      'hooks around async fails before example matches sync fails properly',
+                      'hooks around async fails before example matches sync match',
+                      'hooks around async succeeds after(:each) async fails sync match passes',
+                      'hooks around async succeeds after(:each) sync fails sync match passes',
+                      'hooks around async succeeds before(:each) fails should not reach the example',
+                      'hooks around async succeeds matches async match fails properly',
+                      'hooks around async succeeds matches sync fails properly',
+                      'hooks before async with async subject async match fails properly',
+                      'hooks before async with async subject before :each fails properly should not reach the example',
+                      'hooks before async with async subject before :each succeeds, assertion fails properly should not eq 42',
+                      'hooks before async with async subject before :each succeeds, subject fails properly should not reach the example',
+                      'hooks before async with async subject both subject and before(:each) fail properly should not reach the example',
+                      'hooks before async with sync subject async match fails properly',
+                      'hooks before async with sync subject before :each fails properly should not reach the example',
+                      'hooks before async with sync subject match fails properly should not eq 42',
+                      'hooks before sync with sync subject context fails properly should not reach the example',
+                      'hooks before sync with sync subject before :each fails properly should not reach the example',
+                      'hooks before sync with sync subject match fails properly should not eq 42',
+                      'hooks before sync with sync subject first before :each in chain triggers failure inner context should not reach the example',
+                      'hooks after sync after fails should eq 42',
+                      'hooks after sync before fails should not reach the example',
+                      'hooks after sync match fails async match',
+                      'hooks after sync match fails sync match should eq 43',
+                      'hooks after async after(:each) fails properly',
+                      'hooks after async before(:each) fails properly',
+                      'hooks after async match fails properly async match',
+                      'hooks after async match fails properly sync match should eq 43',
+                      'exception handling should fail properly if an exception is raised',
+                      'exception handling should ignore an exception after a failed assertion',
+                      'legacy async fails properly after a long delay'].sort
+  if actual_failures != expected_failures
+    unexpected = actual_failures - expected_failures
+    missing = expected_failures - actual_failures
+    failure_messages << "Expected test failures do not match actual\n"
+    failure_messages << "\nUnexpected fails:\n#{unexpected.join("\n")}\n\nMissing fails:\n#{missing.join("\n")}\n\n"
+  end
+
+  failure_messages << "Expected #{expected_pending_count} pending examples but actual was #{pending}" unless pending == expected_pending_count.to_s
+
+  if failure_messages.empty?
+    puts 'Test successful!'
+  else
+    raise "Test failed, reasons:\n\n#{failure_messages.join("\n")}\n"
+  end
 end

data/lib/opal/rspec/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module RSpec
-    VERSION = '0.4.3'
+    VERSION = '0.5.0.beta1'
   end
 end

data/lib/opal/rspec.rb

@@ -1,20 +1,43 @@
 require 'opal'
 require 'opal/rspec/version'
+require 'opal/minitest'
 
 # Just register our opal code path with opal build tools
 Opal.append_path File.expand_path('../../../opal', __FILE__)
-Opal.append_path File.expand_path('../../../vendor_lib', __FILE__)
+
+# Catch our git submodule included directories
+%w{rspec rspec-core rspec-expectations rspec-mocks rspec-support}.each do |gem|
+  Opal.append_path File.expand_path("../../../#{gem}/lib", __FILE__)
+end
 
 Opal::Processor.dynamic_require_severity = :warning
 
-Opal::Processor.stub_file "rspec/matchers/built_in/have"
-Opal::Processor.stub_file "diff/lcs"
-Opal::Processor.stub_file "diff/lcs/hunk"
-Opal::Processor.stub_file "fileutils"
-Opal::Processor.stub_file "test/unit/assertions"
-Opal::Processor.stub_file "coderay"
-Opal::Processor.stub_file "optparse"
-Opal::Processor.stub_file "shellwords"
-Opal::Processor.stub_file "socket"
-Opal::Processor.stub_file "uri"
-Opal::Processor.stub_file "drb/drb"
+stubs = [
+  'mutex_m', # Used with some threading operations but seems to run OK without this
+  'prettyprint',
+  'tempfile', # Doesn't exist in Opal
+  'diff/lcs',
+  'diff/lcs/block',
+  'diff/lcs/callbacks',
+  'diff/lcs/change',
+  'diff/lcs/hunk',
+  'diff/lcs/internals',
+  'test/unit/assertions',
+
+  # Opal doesn't have optparse, yet
+  'optparse',
+
+  'shellwords',
+  'socket',
+  'uri',
+  'drb/drb',
+
+  # Minitest used to be in stdlib, now is in opal-minitest GEM,
+  # but this file does not exist
+  # (referenced from minitest_assertions_adapter.rb in RSpec)
+  'minitest/unit',
+
+  'cgi/util',
+]
+
+stubs.each {|mod| Opal::Processor.stub_file mod }

data/opal/opal/rspec/async/async_example.rb

@@ -0,0 +1,87 @@
+class ::RSpec::Core::Example  
+  def core_block_run
+    example_promise = Promise.value(@example_group_instance.instance_exec(self, &@example_block))
+    example_promise.then do |result|
+      result      
+    end.rescue do |ex|
+      ex ||= Exception.new 'Async promise failed for unspecified reason'
+      ex = Exception.new ex unless ex.kind_of?(Exception)
+      ex
+    end
+  end
+  
+  def resolve_subject
+    if example_group_instance.respond_to? :subject and example_group_instance.subject.is_a?(Promise)
+      example_group_instance.subject.then do |resolved_subject|
+        # This is a private method, but we're using Opal
+        example_group_instance.__memoized[:subject] = resolved_subject        
+      end
+    else
+      Promise.value
+    end
+  end
+  
+  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
+  
+  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?
+
+    Promise.value.then do
+      Promise.value.then do
+        if skipped?
+          Pending.mark_pending! self, skip
+        elsif !RSpec.configuration.dry_run?
+          with_around_example_hooks do
+            Promise.value.then do
+              run_before_example.then do
+                resolve_subject
+              end.then do
+                core_block_run
+              end.then do
+                if pending?
+                  Pending.mark_fixed! self
+
+                  raise Pending::PendingExampleFixedError,
+                        'Expected example to fail since it is pending, but it passed.',
+                        [location]
+                end
+              end
+            end.rescue do |e|
+              # no-op, required metadata has already been set by the `skip`
+              # method.              
+              unless e.is_a? Pending::SkipDeclaredInExample
+                set_exception(e)
+              end
+            end.ensure do
+              run_after_example
+            end            
+          end
+        end
+      end.rescue do |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
+      end      
+    end.then do
+      finish(reporter)
+    end.ensure do
+      RSpec.current_example = nil
+    end
+  end  
+end

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

@@ -0,0 +1,94 @@
+require 'promise'
+
+class ::RSpec::Core::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 self.process_descendants(our_examples_result, reporter)
+    descendants = ordering_strategy.order(children)
+    return Promise.value our_examples_result if descendants.empty?    
+    
+    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        
+      end
+    end
+    latest_descendant.then do |result|
+      results_for_descendants << result
+      combined_result = our_examples_result && results_for_descendants.all?      
+      combined_result
+    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
+    
+    reporter.example_group_started(self)    
+    Promise.value.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) }
+      end
+      result
+    end.always do
+      run_after_context_hooks(new)
+      before_context_ivars.clear
+      reporter.example_group_finished(self)
+    end
+  end
+  
+  # Promise oriented version
+  def self.run_examples(reporter)   
+    examples = ordering_strategy.order(filtered_examples)
+    return Promise.value true if examples.empty?       
+
+    example_promise = lambda do |example|
+      instance = new
+      set_ivars(instance, before_context_ivars)
+      # Always returns a promise since we modified the Example class
+      example.run(instance, reporter)      
+    end  
+    
+    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]
+      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/opal/opal/rspec/async/hooks.rb

@@ -0,0 +1,46 @@
+class RSpec::Core::Hooks::HookCollection
+  def run
+    hooks.inject(Promise.value) do |previous_hook_promise, next_hook|
+      previous_hook_promise.then do
+        result = next_hook.run @example
+        Promise.value result
+      end
+    end
+  end
+end
+
+# Need to be able to work with a promise, but without modifying proxy, we can't get a promise back from our around hook
+# therefore, modify this so that we pass a promise in
+class RSpec::Core::Hooks::AroundHook
+  def execute_with_promise(use_promise, example, procsy)
+    Promise.value(example.instance_exec(procsy, &block)).then do
+      unless procsy.executed?
+        Pending.mark_skipped!(example, "#{hook_description} did not execute the example")
+      end
+      use_promise.resolve
+    end
+  end
+end
+
+# This is an odd one because of the way around hooks subclass themselves. We mirror the original code, we just carry
+# around a promise with the procsy
+class RSpec::Core::Hooks::AroundHookCollection
+  def run
+    seed = [@initial_procsy, Promise.value]
+    last_procsy, last_promise = hooks.inject(seed) do |procsy_and_around_hook_promise, around_hook|
+      procsy, previous_hook_promise = procsy_and_around_hook_promise
+      new_hook_promise = Promise.new
+      new_procsy = procsy.wrap do
+        previous_hook_promise.then do
+          around_hook.execute_with_promise new_hook_promise, @example, procsy
+        end.rescue do |ex|
+          # because of the way Procsy works, we need to set this here and not in the execute_with_promise method
+          new_hook_promise.reject ex
+        end
+      end
+      [new_procsy, new_hook_promise]
+    end
+    last_procsy.call
+    last_promise        
+  end
+end

data/opal/opal/rspec/async/legacy.rb

@@ -0,0 +1,50 @@
+module Opal
+  module RSpec
+    module AsyncHelpers
+      module ClassMethods        
+        def async(desc, *args, &block)
+          options = ::RSpec::Core::Metadata.build_hash_from(args)
+          options.update(:skip => ::RSpec::Core::Pending::NOT_YET_IMPLEMENTED) unless block
+
+          examples << Opal::RSpec::LegacyAsyncExample.new(self, desc, options, block)
+          examples.last          
+        end
+      end
+      
+      attr_accessor :legacy_promise
+      
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
+      # Use {#async} instead.
+      #
+      # @deprecated
+      def run_async(&block)
+        async(&block)
+      end
+  
+      def async(&block)
+        begin
+          instance_eval &block
+          legacy_promise.resolve
+        rescue Exception => e
+          legacy_promise.reject e
+        end
+      end
+    end
+  end
+end
+
+class Opal::RSpec::LegacyAsyncExample < ::RSpec::Core::Example
+  def initialize(example_group_class, description, user_metadata, example_block=nil)
+    example = self
+    legacy_promise_ex_block = lambda do
+      self.legacy_promise = Promise.new
+      instance_exec(example, &example_block)
+      self.legacy_promise
+    end
+    
+    super example_group_class, description, user_metadata, legacy_promise_ex_block
+  end
+end