opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-support/spec/rspec/support/warnings_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "rspec/support/warnings"
+require 'rspec/support/spec/shell_out'
+
+describe "rspec warnings and deprecations" do
+  include RSpec::Support::ShellOut
+  let(:warning_object) do
+    Object.new.tap { |o| o.extend(RSpec::Support::Warnings) }
+  end
+
+  it 'works when required in isolation' do
+    out, err, status = run_ruby_with_current_load_path("RSpec.deprecate('foo')", "-rrspec/support/warnings")
+    expect(out).to eq("")
+    expect(err).to start_with("DEPRECATION: foo is deprecated")
+    expect(status.exitstatus).to eq(0)
+  end
+
+  context "when rspec-core is not available" do
+    shared_examples "falling back to Kernel.warn" do |args|
+      let(:method_name) { args.fetch(:method_name) }
+
+      it 'falls back to warning with a plain message' do
+        expect(::Kernel).to receive(:warn).with(/message/)
+        warning_object.send(method_name, 'message')
+      end
+
+      it "handles being passed options" do
+        expect(::Kernel).to receive(:warn).with(/message/)
+        warning_object.send(method_name, "this is the message", :type => :test)
+      end
+    end
+
+    it_behaves_like 'falling back to Kernel.warn', :method_name => :deprecate
+    it_behaves_like 'falling back to Kernel.warn', :method_name => :warn_deprecation
+  end
+
+  shared_examples "warning helper" do |helper|
+    it 'warns with the message text' do
+      expect(::Kernel).to receive(:warn).with(/Message/)
+      warning_object.send(helper, 'Message')
+    end
+
+    it 'sets the calling line' do
+      expect(::Kernel).to receive(:warn).with(/#{__FILE__}:#{__LINE__+1}/)
+      warning_object.send(helper, 'Message')
+    end
+
+    it 'optionally sets the replacement' do
+      expect(::Kernel).to receive(:warn).with(/Use Replacement instead./)
+      warning_object.send(helper, 'Message', :replacement => 'Replacement')
+    end
+  end
+
+  describe "#warning" do
+    it 'prepends WARNING:' do
+      expect(::Kernel).to receive(:warn).with(/WARNING: Message\./)
+      warning_object.warning 'Message'
+    end
+
+    it_should_behave_like 'warning helper', :warning
+  end
+
+  describe "#warn_with message, options" do
+    it_should_behave_like 'warning helper', :warn_with
+  end
+end

data/rspec-support/spec/rspec/support_spec.rb

@@ -0,0 +1,119 @@
+require 'rspec/support'
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+module RSpec
+  describe Support do
+    extend Support::RubyFeatures
+
+    it_behaves_like "a library that issues no warnings when loaded", "rspec-support",
+      # Define methods that some of our rspec/support/spec files use at load time.
+      "module RSpec; def self.configure; end; def self.shared_context(*); end; def self.shared_examples_for(*); end; end",
+      'require "rspec/support"'
+
+    describe '.method_handle_for(object, method_name)' do
+      untampered_class = Class.new do
+        def foo
+          :bar
+        end
+      end
+
+      http_request_class = Struct.new(:method, :uri)
+
+      proxy_class = Struct.new(:original) do
+        undef :=~, :method
+        def method_missing(name, *args, &block)
+          original.__send__(name, *args, &block)
+        end
+      end
+
+      it 'fetches method definitions for vanilla objects' do
+        object = untampered_class.new
+        expect(Support.method_handle_for(object, :foo).call).to eq :bar
+      end
+
+      it 'fetches method definitions for objects with method redefined' do
+        request = http_request_class.new(:get, "http://foo.com/")
+        expect(Support.method_handle_for(request, :uri).call).to eq "http://foo.com/"
+      end
+
+      it 'fetches method definitions for proxy objects' do
+        object = proxy_class.new([])
+        expect(Support.method_handle_for(object, :=~)).to be_a Method
+      end
+
+      it 'fetches method definitions for proxy objects' do
+        object = proxy_class.new([])
+        expect(Support.method_handle_for(object, :=~)).to be_a Method
+      end
+
+      it 'fails with `NameError` when an undefined method is fetched ' +
+         'from an object that has overriden `method` to raise an Exception' do
+        object = double
+        allow(object).to receive(:method).and_raise(Exception)
+        expect {
+          Support.method_handle_for(object, :some_undefined_method)
+        }.to raise_error(NameError)
+      end
+
+      it 'fails with `NameError` when a method is fetched from an object ' +
+         'that has overriden `method` to not return a method' do
+        object = proxy_class.new(double(:method => :baz))
+        expect {
+          Support.method_handle_for(object, :=~)
+        }.to raise_error(NameError)
+      end
+
+      context "for a BasicObject subclass", :if => RUBY_VERSION.to_f > 1.8 do
+        let(:basic_class) do
+          Class.new(BasicObject) do
+            def foo
+              :bar
+            end
+          end
+        end
+
+        let(:basic_class_with_method_override) do
+          Class.new(basic_class) do
+            def method
+              :method
+            end
+          end
+        end
+
+        let(:basic_class_with_kernel) do
+          Class.new(basic_class) do
+            include ::Kernel
+          end
+        end
+
+        let(:basic_class_with_proxying) do
+          Class.new(BasicObject) do
+            def method_missing(name, *args, &block)
+              "foo".__send__(name, *args, &block)
+            end
+          end
+        end
+
+        it 'still works', :if => supports_rebinding_module_methods? do
+          object = basic_class.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+
+        it 'works when `method` has been overriden', :if => supports_rebinding_module_methods? do
+          object = basic_class_with_method_override.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+
+        it 'allows `method` to be proxied', :unless => supports_rebinding_module_methods? do
+          object = basic_class_with_proxying.new
+          expect(Support.method_handle_for(object, :reverse).call).to eq "oof"
+        end
+
+        it 'still works when Kernel has been mixed in' do
+          object = basic_class_with_kernel.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+      end
+    end
+  end
+end

data/rspec-support/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec/support/spec'
+RSpec::Support::Spec.setup_simplecov

data/spec/after_hooks_spec.rb

@@ -0,0 +1,140 @@
+describe 'hooks' do
+  describe 'after' do
+    before :all do
+      @@total = 0
+      @@example_still_in_progress = nil
+    end
+    
+    after :all do
+      expected = 13
+      unless @@total == expected
+        msg = "Expected #{expected} after hits but got #{@@total}"        
+        `console.error(#{msg})`
+      end       
+    end
+    
+    let(:raise_before_error) { false }
+    
+    before do |example|
+      if raise_before_error
+        @@example_still_in_progress = nil
+        raise 'before problem'
+      end
+      if @@example_still_in_progress
+        raise "Another spec (#{@@example_still_in_progress}) is still running, after block problem"
+        @@example_still_in_progress = nil
+      end
+      @@example_still_in_progress = example.description
+    end
+    
+    let(:raise_after_error) { false }    
+    
+    context 'sync' do
+      after do
+        @@total += 1
+        @@example_still_in_progress = nil        
+        raise 'expected after problem' if raise_after_error
+      end
+      
+      subject { 42 }            
+      
+      context 'before fails' do
+        let(:raise_before_error) { true }
+        
+        it 'should not reach the example' do
+          fail 'we reached the example and we should not have!'
+        end
+      end
+      
+      context 'match succeeds' do
+        context 'sync match' do
+          it { is_expected.to eq 42 }
+        end
+        
+        it 'async match' do
+          delay_with_promise 0 do
+            expect(subject).to eq 42
+          end
+        end
+      end
+      
+      context 'match fails' do
+        context 'sync match' do
+          it { is_expected.to eq 43 }
+        end
+        
+        it 'async match' do
+          delay_with_promise 0 do
+            expect(subject).to eq 43
+          end
+        end
+      end     
+      
+      context 'after fails' do
+        let(:raise_after_error) { true }
+        
+        it { is_expected.to eq 42 }
+      end
+      
+      context 'context' do
+        after :context do
+          raise 'it failed in the after context!'
+        end
+            
+        it { is_expected.to eq 42 }
+      end
+    end
+    
+    context 'async' do
+      after do
+        delay_with_promise 0 do
+          @@total += 1
+          @@example_still_in_progress = nil
+          raise 'after problem' if raise_after_error          
+        end
+      end
+
+      subject do
+        delay_with_promise 0 do
+          42
+        end
+      end
+
+      context 'before(:each) fails properly' do
+        let(:raise_before_error) { true }
+
+        it { is_expected.to eq 42 }
+      end
+
+      context 'match succeeds' do
+        context 'sync match' do
+          it { is_expected.to eq 42 }
+        end
+
+        it 'async match' do
+          delay_with_promise 0 do
+            expect(subject).to eq 42
+          end
+        end
+      end
+
+      context 'match fails properly' do
+        context 'sync match' do
+          it { is_expected.to eq 43 }
+        end
+
+        it 'async match' do
+          delay_with_promise 0 do
+            expect(subject).to eq 43
+          end
+        end
+      end
+
+      context 'after(:each) fails properly' do
+        let(:raise_after_error) { true }
+
+        it { is_expected.to eq 42 }
+      end
+    end
+  end
+end

data/spec/around_hooks_spec.rb

@@ -0,0 +1,223 @@
+describe 'hooks' do
+  describe 'around' do
+    RSpec.shared_context :around_count do
+      before do
+        @test_in_progress = nil
+      end
+
+      before :all do
+        @@around_stack = []
+        @@around_completed = 0
+        @@around_failures = []
+      end
+      
+      after :all do
+        raise @@around_failures.join "\n" if @@around_failures.any?
+        raise 'hooks not empty!' unless @@around_stack.empty?
+        unless @@around_completed == @@expected_around_hits
+          msg = "Expected #{@@expected_around_hits} around hits but got #{@@around_completed} for #{self}"        
+          `console.error(#{msg})`
+        end        
+      end    
+    end
+    RSpec.shared_context :async_spec_mix do
+      include_context :around_count     
+      
+      context 'matches' do        
+        it 'async match' do
+          delay_with_promise 0 do
+            1.should == 1
+          end
+        end
+        
+        it 'sync match' do
+          1.should == 1
+        end   
+        
+        it 'sync fails properly' do
+          1.should == 2
+        end
+        
+        it 'another async match' do
+          delay_with_promise 0 do
+            1.should == 1
+          end
+        end
+        
+        it 'async match fails properly' do
+          delay_with_promise 0 do
+            1.should == 2
+          end
+        end     
+      end
+      
+      context 'before(:each) fails' do
+        before do
+          raise 'before fails properly'
+        end
+        
+        it 'should not reach the example' do
+          fail 'we reached the example and we should not have!'
+        end
+      end
+      
+      context 'after(:each)' do
+        context 'async' do
+          after do
+            delay_with_promise 0 do
+              raise 'after fails properly' if raise_after_exception
+            end
+          end
+          
+          context 'passes' do
+            let(:raise_after_exception) { false }
+        
+            it 'sync match passes' do
+              1.should == 1
+            end            
+          end
+          
+          context 'fails' do
+            let(:raise_after_exception) { true }
+            
+            it 'sync match passes' do
+              1.should == 1
+            end            
+          end
+        end
+        
+        context 'sync' do
+          after do
+            raise 'after fails properly' if raise_after_exception
+          end
+          
+          context 'passes' do
+            let(:raise_after_exception) { false }
+        
+            it 'sync match passes' do
+              1.should == 1
+            end            
+          end
+          
+          context 'fails' do
+            let(:raise_after_exception) { true }
+            
+            it 'sync match passes' do
+              1.should == 1
+            end            
+          end
+        end
+      end      
+    end
+    
+    let(:fail_before_example_run) { false }
+    let(:fail_after_example_run) { false }
+    let(:skip_run) { false }
+    
+    context 'sync' do
+      subject { 42 }     
+      
+      around do |example|
+        raise 'around failed before example properly' if fail_before_example_run        
+        look_for = example.description
+        @@around_stack << look_for        
+        example.run unless skip_run
+        last = @@around_stack.pop
+        @@around_failures << "Around hook kept executing even though test #{@test_in_progress} was running!" if @test_in_progress
+        @@around_failures << "Around hooks are messed up because we expected #{look_for} but we popped off #{last}" unless last == look_for
+        @@around_completed += 1
+        raise 'around failed after example properly' if fail_after_example_run       
+      end
+      
+      context 'succeeds' do        
+        before :context do
+          @@expected_around_hits = 1
+        end
+        include_context :around_count
+        
+        it { is_expected.to equal 42 }
+      end
+      
+      context 'fails before example' do
+        before :context do
+          @@expected_around_hits = 0
+        end
+        include_context :around_count
+        
+        let(:fail_before_example_run) { true }
+        
+        it { is_expected.to equal 42 }
+      end
+      
+      context 'fails after example' do
+        before :context do
+          @@expected_around_hits = 1
+        end
+        include_context :around_count
+        
+        let(:fail_after_example_run) { true }
+        
+        it { is_expected.to equal 42 }
+      end
+    end
+    
+    context 'async' do
+      around do |example|
+        raise 'around failed before example properly' if fail_before_example_run        
+        look_for = example.description
+        @@around_stack << look_for
+        clean_ending = lambda do
+          last = @@around_stack.pop
+          @@around_failures << "Around hook kept executing even though test #{@test_in_progress} was running!" if @test_in_progress
+          @@around_failures << "Around hooks are messed up because we expected #{look_for} but we popped off #{last}" unless last == look_for
+          @@around_completed += 1
+          raise 'around failed after example properly' if fail_after_example_run
+        end
+        if skip_run
+          clean_ending.call
+        else
+          example.run.then do
+            clean_ending.call
+          end        
+        end
+      end
+      
+      context 'succeeds' do
+        before :context do
+          @@expected_around_hits = 10
+        end
+      
+        include_context :async_spec_mix
+      end
+    
+      context 'fails before example' do
+        before :context do
+          @@expected_around_hits = 0
+        end
+      
+        let(:fail_before_example_run) { true }
+      
+        include_context :async_spec_mix
+      end
+    
+      context 'fails after example' do
+        before :context do
+          @@expected_around_hits = 10
+        end
+      
+        let(:fail_after_example_run) { true }
+      
+        include_context :async_spec_mix
+      end
+    
+      context 'skip' do
+        before :context do
+          @@expected_around_hits = 10
+        end
+      
+        let(:skip_run) { true }
+        include_context :async_spec_mix
+      end
+    end   
+  end
+end

data/spec/async_spec.rb

@@ -1,9 +1,23 @@
-describe "Asynchronous helpers" do
+describe 'legacy async' do
   let(:foo) { 100 }
 
   before do
     @model = Object.new
   end
+  
+  async "fails properly after a long delay" do
+    obj = [2, 2, 3, 4]
+
+    delay(1) do
+      async { obj.should == [1, 2, 3, 4] }
+    end
+  end
+  
+  async 'allows overriding the timeout', timeout: 15 do
+    delay(11) do
+      async { expect(42).to eq(42) }
+    end
+  end
 
   async "can run examples async" do
     async do
@@ -36,3 +50,135 @@ describe "Asynchronous helpers" do
     end
   end
 end
+
+describe 'promise' do
+  let(:foo) { 100 }    
+  
+  it 'matcher fails properly' do
+    delay_with_promise 0 do
+      1.should == 2
+    end      
+  end
+
+  it 'matcher succeeds' do
+    delay_with_promise 0 do
+      1.should == 1
+    end      
+  end
+
+  context 'non-assertion failure in promise' do
+    it 'no args' do
+      promise = Promise.new
+      delay 0 do
+        promise.reject
+      end
+      promise
+    end
+
+    it 'string arg' do
+      promise = Promise.new
+      delay 0 do
+        promise.reject 'string failure reason here'
+      end
+      promise
+    end
+
+    it 'exception arg' do
+      delay_with_promise 0 do
+        raise TypeError, 'typeerror driven failure reason here'
+      end
+    end
+  end
+  
+  context 'skipped' do
+    it 'via variable', skip: true do
+      obj = [1, 2, 3, 4]
+
+      delay_with_promise 0 do
+        obj.should == [2, 2, 3, 4]
+      end
+    end
+
+    xit 'via xit' do
+      obj = [1, 2, 3, 4]
+
+      delay_with_promise 0 do
+        obj.should == [2, 2, 3, 4]
+      end
+    end    
+  
+    it 'in example, inside promise' do
+      delay_with_promise 0 do
+        skip 'want to skip within'
+      end
+    end
+  
+    it 'in example, outside promise' do
+      skip 'want to skip within'
+      delay_with_promise 0 do
+        1.should == 1
+      end      
+    end    
+  end
+  
+  context 'pending' do
+    it 'in example' do
+      obj = [1, 2, 3, 4]
+
+      delay_with_promise 0 do
+        pending 'want to pend within'
+        obj.should == [2, 2, 3, 4]        
+      end      
+    end
+
+    it 'via variable', pending: 'the reason' do
+      obj = [1, 2, 3, 4]
+
+      delay_with_promise 0 do
+        obj.should == [2, 2, 3, 4]
+      end
+    end    
+  end  
+
+  it "should make example fail properly before async block reached" do
+    expect(:foo).to eq(:baz)
+
+    delay_with_promise(0) do
+      expect(nil).to eq 'we reached this assertion and we should not have'
+    end
+  end  
+end
+
+describe 'async/sync mix' do
+  it 'fails properly if a sync test is among async tests' do
+    1.should == 2
+  end
+  
+  it 'is an async test between 2 sync tests' do
+    delay_with_promise 0 do
+      1.should == 1
+    end    
+  end
+
+  it 'passes correctly if a sync test is among async tests' do
+    1.should == 1
+  end
+
+  it "can finish running after a long delay and fail properly" do
+    @test_in_progress = 'can finish running after a long delay and fail'
+    obj = [1, 2, 3, 4]
+
+    delay_with_promise 1 do
+      obj.should == [2, 2, 3, 4]
+      @test_in_progress = nil
+    end
+  end
+
+  it "can finish running after a long delay and succeed" do
+    obj = [1, 2, 3, 4]
+
+    delay_with_promise 1 do
+      obj.should == [1, 2, 3, 4]
+    end
+  end
+end