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

data/spec-opal/legacy_async_spec.rb

@@ -1,189 +0,0 @@
-require 'opal/rspec/async'
-require 'spec_helper'
-
-# describe 'legacy async' do
-#   include Opal::RSpec::AsyncHelpers
-#
-#   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
-#       1.should == 1
-#     end
-#   end
-#
-#   async "can access let() helpers and before() helpers" do
-#     async do
-#       foo.should eq(100)
-#       @model.should be_kind_of(Object)
-#     end
-#   end
-#
-#   async "can finish running after a long delay" do
-#     obj = [1, 2, 3, 4]
-#
-#     delay(1) do
-#       async { obj.should == [1, 2, 3, 4] }
-#     end
-#   end
-#
-#   async "should make example fail before async block reached" do
-#     expect {
-#       expect(:foo).to eq(:baz)
-#     }.to raise_error(Exception)
-#
-#     delay(0) do
-#       async { expect(42).to eq(42) }
-#     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

data/spec-opal/matchers_spec.rb

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

data/spec-opal/mock_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe "RSpec mocks" do
-  describe "stubs" do
-    it "can stub basic methods" do
-      obj = Object.new
-      expect(obj).to receive(:foo) { 100 }
-      obj.foo.should == 100
-    end
-
-    it "raises an exception when stub returns wrong value" do
-      expect {
-        obj = Object.new
-        expect(obj).to receive(:bar) { 400 }
-        obj.bar.should == 42
-      }.to raise_error(Exception)
-    end
-
-    it "allow" do
-      obj = Object.new
-      allow(obj).to receive(:name) { "Adam B" }
-      allow(obj).to receive(:job).and_return("Eating Fruit Gums")
-
-      expect(obj.name).to eq("Adam B")
-      expect(obj.job).to eq("Eating Fruit Gums")
-    end
-
-    it "expecting arguments" do
-      person = double("person")
-      expect(person).to receive(:foo).with(4, 5, 6)
-      person.foo(4, 5, 6)
-    end
-  end
-
-  describe "doubles" do
-    it "define methods on double" do
-      person = double("person", :name => "Adam")
-      expect(person.name).to eq("Adam")
-    end
-
-    it "once" do
-      person = double("person")
-      expect(person).to receive(:name).once
-      person.name.should eq(nil)
-    end
-
-    it "twice" do
-      person = double("person")
-      expect(person).to receive(:name).twice
-      person.name
-      person.name.should
-    end
-  end
-
-  it "can mock existing methods on objects" do
-    expect(Time).to receive(:now).once.and_call_original
-    Time.now.should be_kind_of(Time)
-  end
-
-  describe 'stubs' do
-    it 'works and displays deprecation' do
-      Object.new.stub :foo
-    end
-  end
-end