opal-connect-rspec 0.5.0

data/spec/opal/before_hooks_spec.rb

@@ -0,0 +1,183 @@
+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/example_spec.rb

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

data/spec/opal/expected_failures.txt

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

data/spec/opal/matchers_spec.rb

@@ -0,0 +1,205 @@
+describe "be_truthy" do
+  it "passes with truthy values" do
+    expect(true).to be_truthy
+    expect(1.0).to be_truthy
+    expect([]).to be_truthy
+  end
+  
+  it 'fails properly with truthy values' do
+    expect(false).to be_truthy
+  end
+
+  it "fails with falsey values" do
+    expect {
+      expect(false).to be_truthy
+    }.to raise_error(Exception)
+
+    expect {
+      expect(nil).to be_truthy
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_falsey" do
+  it "passes with falsey values" do
+    expect(false).to be_falsey
+    expect(nil).to be_falsey
+  end
+
+  it "fails with truthy values" do
+    expect {
+      expect(true).to be_falsey
+    }.to raise_error(Exception)
+
+    expect {
+      expect({}).to be_falsey
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_nil" do
+  it "passes when object is nil" do
+    expect(nil).to be_nil
+  end
+
+  it "fails with any other object" do
+    expect {
+      expect(false).to be_nil
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).to be_nil
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_kind_of" do
+  it "passes if actual is kind of expected class" do
+    expect("foo").to be_kind_of(String)
+    expect("foo").to_not be_kind_of(Numeric)
+  end
+
+  it "passes if actual is kind of superclass of expected class" do
+    expect([]).to be_kind_of(Object)
+  end
+
+  it "fails if expected is not a kind of expected" do
+    expect {
+      expect("foo").to be_kind_of(Integer)
+    }.to raise_error(Exception)
+
+    expect {
+      expect("foo").to_not be_kind_of(String)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eq" do
+  it "matches when actual == expected" do
+    expect(:foo).to eq(:foo)
+  end
+
+  it "does not match when actual != expected" do
+    expect(:foo).not_to eq(42)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(:foo).to eq(42)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).not_to eq(:foo)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eql" do
+  it "matches when expected.eql?(actual)" do
+    expect(1).to eql(1)
+  end
+
+  it "does not match when !expected.eql?(actual)" do
+    expect(1).to_not eql(:foo)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(1).to eql(:bar)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(2).to_not eql(2)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "include" do
+  it "matches if actual includes expected" do
+    expect("foo").to include("f")
+    expect([:foo, :bar, :baz]).to include(:baz)
+    expect({ :yellow => 'lorry' }).to include(:yellow)
+  end
+
+  it "does not match if actual does not inlcude expected" do
+    expect("foo").to_not include("b")
+    expect([:foo, :bar, :baz]).to_not include(:kapow)
+    expect({ :yellow => 'lorry' }).to_not include(:red)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect("bar").to include("z")
+    }.to raise_error(Exception)
+  end
+end
+
+describe "respond_to" do
+  it "matches if actual responds to sym" do
+    expect("foo").to respond_to(:upcase)
+  end
+
+  it "does not match if actual does not respond to sym" do
+    expect(Object.new).to_not respond_to(:upcase)
+  end
+
+  it "fails if actual does not respond to sym" do
+    expect {
+      expect(Object.new).to respond_to(:upcase)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "match" do
+  it "matches if actual matches expected" do
+    expect("foobar").to match(/ar/)
+    expect("foobar").to match("oob")
+  end
+
+  it "does not match if actual does not match expected" do
+    expect("foobar").to_not match(/baz/)
+    expect("foobar").to_not match("woosh")
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      exprct("hello").to match(/world/)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "operator ==" do
+  it "matches if actual == expected" do
+    "hello".should == "hello"
+  end
+
+  it "does not match when actual does not == expected" do
+    "hello".should_not == "world"
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      "hello".should == "world"
+    }.to raise_error(Exception)
+  end
+end
+
+class PredicateTest
+  def foo?
+    true
+  end
+
+  def bar?
+    false
+  end
+end
+
+describe "predicate matchers" do
+  it "works with positive expectations" do
+    expect(PredicateTest.new).to be_foo
+  end
+
+  it "work with negative expectations" do
+    expect(PredicateTest.new).to_not be_bar
+  end
+end