opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/spec-opal/around_hooks_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-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
-
-    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
-  end
-end

data/spec-opal/async_spec.rb

@@ -1,134 +0,0 @@
-require 'opal/rspec/async'
-require 'spec_helper'
-
-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

data/spec-opal/before_hooks_spec.rb

@@ -1,185 +0,0 @@
-require 'spec_helper'
-
-describe 'hooks' do
-  describe 'before' do
-    context 'async' do
-      let(:raise_before_error) { false }
-      before do
-        delay_with_promise 0 do
-          raise 'problem in before' if raise_before_error
-          @test_value = 42
-        end
-      end
-
-      context 'with sync subject' do
-        subject { 42 }
-
-        context 'succeeds' do
-          it { is_expected.to eq @test_value }
-        end
-
-        context 'before :each fails properly' 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 fails properly' do
-          it { is_expected.to_not eq @test_value }
-        end
-
-        context 'async match' do
-          it 'succeeds' do
-            delay_with_promise 0 do
-              expect(subject).to eq @test_value
-            end
-          end
-
-          it 'fails properly' do
-            delay_with_promise 0 do
-              expect(subject).to_not eq @test_value
-            end
-          end
-        end
-      end
-
-      context 'with async subject' do
-        let(:raise_before_subj_error) { false }
-
-        subject do
-          delay_with_promise 0 do
-            raise 'problem in subject' if raise_before_subj_error
-            42
-          end
-        end
-
-        context 'both succeed' do
-          it { is_expected.to eq @test_value }
-        end
-
-        context 'both subject and before(:each) fail properly' do
-          let(:raise_before_error) { true }
-          let(:raise_before_subj_error) { true }
-
-          it 'should not reach the example' do
-            fail 'we reached the example and we should not have!'
-          end
-        end
-
-        context 'before :each succeeds, assertion fails properly' do
-          it { is_expected.to_not eq @test_value }
-        end
-
-        context 'before :each fails properly' 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 'before :each succeeds, subject fails properly' do
-          let(:raise_before_subj_error) { true }
-
-          it 'should not reach the example' do
-            fail 'we reached the example and we should not have!'
-          end
-        end
-
-        context 'async match' do
-          it 'succeeds' do
-            delay_with_promise 0 do
-              expect(subject).to eq @test_value
-            end
-          end
-
-          it 'fails properly' do
-            delay_with_promise 0 do
-              expect(subject).to_not eq @test_value
-            end
-          end
-        end
-      end
-    end
-
-    context 'sync' do
-      context 'with sync subject' do
-        subject { 42 }
-
-        context 'context' do
-          context 'success' do
-            before :context do
-              @@before_context_both_sync = 22
-            end
-
-            before do
-              raise "@@before_context_both_sync should already be 22!" unless @@before_context_both_sync == 22
-              @test_value = 42
-            end
-
-            it { is_expected.to eq @test_value }
-          end
-
-          context 'fails properly' do
-            before :context do
-              raise 'it failed in the before context!'
-              @@before_context_both_sync = 55
-            end
-
-            before do
-              raise "we reached before:each and we should not have!" if @@before_context_both_sync == 55
-            end
-
-            it 'should not reach the example' do
-              fail 'we reached the example and we should not have!'
-            end
-          end
-        end
-
-        context 'succeeds' do
-          before do
-            @test_value = 42
-          end
-
-          it { is_expected.to eq @test_value }
-        end
-
-        context 'before :each fails properly' do
-          before do
-            raise 'before :each failed properly'
-          end
-
-          it 'should not reach the example' do
-            fail 'we reached the example and we should not have!'
-          end
-        end
-
-        context 'first before :each in chain triggers failure' do
-          before do
-            raise 'first before :each fails, this is correct'
-          end
-
-          context 'inner context' do
-            before do
-              raise 'we reached the inner before :each and we should not have'
-            end
-
-            it 'should not reach the example' do
-              fail 'we reached the example and we should not have!'
-            end
-          end
-        end
-
-        context 'match fails properly' do
-          before do
-            @test_value = 42
-          end
-
-          it { is_expected.to_not eq @test_value }
-        end
-      end
-    end
-  end
-end

data/spec-opal/browser-formatter/opal_browser_formatter_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe 'Opal::RSpec::BrowserFormatter' do
-  context 'group' do
-    it 'passes' do
-      expect(42).to eq 42
-    end
-
-    xit 'a skipped example' do
-    end
-
-    it 'a failed example' do
-      expect(42).to eq 43
-    end
-  end
-end

data/spec-opal/example_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-module SomeHelpers
-  def opal_rspec_helper
-    let(:defined_opal_helper) { :it_works }
-  end
-end
-
-module SomeMoreHelpers
-  def opal_rspec_include_helper
-    42
-  end
-end
-
-RSpec.configure do |c|
-  c.extend SomeHelpers
-  c.include SomeMoreHelpers
-end
-
-describe "RSpec include and extend" do
-  opal_rspec_helper
-
-  it "works for extend" do
-    defined_opal_helper.should == :it_works
-  end
-
-  it "works for include" do
-    opal_rspec_include_helper.should == 42
-  end
-end
-
-$count = 0
-
-describe "let" do
-  let(:count) { $count += 1 }
-
-  it "memoizes the value" do
-    count.should eq(1)
-    count.should eq(1)
-  end
-
-  it "is not cached across examples" do
-    count.should eq(2)
-  end
-end
-
-describe "helper methods" do
-  def some_helper
-    :present
-  end
-
-  it "should be available" do
-    some_helper.should eq(:present)
-  end
-
-  describe "nested group" do
-    it "should work in nested groups" do
-      some_helper.should eq(:present)
-    end
-  end
-end
-
-describe "nested describes" do
-  it "works in multiple places" do
-    1.should eq(1)
-  end
-
-  describe "nested" do
-    it "and here" do
-      1.should_not eq(2)
-    end
-  end
-end
-
-describe "subject" do
-  subject { [1, 2, 3] }
-
-  it "a new instance should be the subject" do
-    subject.should be_kind_of(Array)
-  end
-
-  describe "nested subjects" do
-    before { subject << 4 }
-
-    it "should work with before and example" do
-      subject.should == [1, 2, 3, 4]
-    end
-  end
-end
-
-describe Hash do
-  it "should create a new instance of subject for classes" do
-    subject.should == {}
-  end
-
-  it "provides the subject as the described_class" do
-    expect(described_class).to eq(Hash)
-  end
-end
-
-describe [1, 2, 3] do
-  it "can use an object instance as a subject" do
-    expect(subject).to eq([1, 2, 3])
-  end
-end
-
-describe "Simple expectations" do
-  before do
-    @bar = 200
-  end
-
-  it "should eat" do
-    @bar.should == 200
-  end
-
-  after do
-    @bar.class
-  end
-end
-
-describe "should syntax" do
-  it "should work for positive" do
-    [1, 2, 3].should == [1, 2, 3]
-  end
-
-  it "should work for negative" do
-    [1, 2, 3].should_not == [4, 5, 6]
-  end
-end
-
-describe "expect syntax" do
-  it "positive expectation" do
-    expect(100).to eq(100)
-  end
-
-  it "negative expectation" do
-    expect(100).to_not eq(300)
-  end
-end
-
-describe "Normal errors" do
-  it "should still work" do
-    lambda { raise "wtf son" }.should raise_error(Exception)
-  end
-end
-
-describe "let on an inner scope" do
-  describe "inner context" do
-    let(:foo) { :bar }
-
-    it "should still work" do
-      foo.should eq(:bar)
-    end
-  end
-end
-
-describe "#context" do
-  context "inner context" do
-    let(:foo) { :bar }
-
-    it "should still work" do
-      foo.should eq(:bar)
-    end
-  end
-end
-
-describe 'exception handling' do
-  it "should fail properly if an exception is raised" do
-    raise 'problem'
-  end
-
-  it "should ignore an exception after a failed assertion" do
-    expect(42).to eq(43)
-    raise 'problem'
-  end
-end