rspec 0.8.2 → 0.9.0

data/spec/spec/callback/object_with_class_callback_spec.rb

@@ -1,19 +0,0 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/../../spec_helper"
-
-context "An Object with class callback" do
-  specify "should notify the class callback" do
-    klass = Class.new do
-      class << self
-        callback_events :the_callback
-      end
-    end
-
-    klass_callback_called = false
-    klass.the_callback {klass_callback_called = true}
-    obj = klass.new
-    obj.send(:notify_class_callbacks, :the_callback)
-
-    klass_callback_called.should == true
-  end
-end

data/spec/spec/expectations/should/should_==_spec.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-require 'spec/expectations/differs/default'
-
-context "should ==" do
-  
-  specify "should pass when objects are ==" do
-    lambda do
-      "apple".should == "apple"
-    end.should_pass
-  end
-
-  specify "should fail when objects are not ==" do
-    lambda do
-      "1".should == 1
-    end.should_fail_with "expected 1, got \"1\" (using ==)"
-  end
-
-end

data/spec/spec/expectations/should/should_=~_spec.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-context "should =~" do
-  specify "should pass when =~ operator returns non-nil" do
-    "foo".should =~ /oo/
-  end
-
-  specify "should fail when =~ operator returns nil" do
-    lambda do
-      "fu".should =~ /oo/
-    end.should_fail_with "expected =~ /oo/, got \"fu\""
-  end
-end

data/spec/spec/expectations/should/should_be_a_kind_of_spec.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be_a_kind_of" do
-  specify "should fail when target is not specified class" do
-    lambda do
-      5.should_be_a_kind_of(String)
-    end.should_fail_with "expected kind_of?(String) to return true, got false"
-  end
-
-  specify "should pass when target is of specified class" do
-    lambda do
-      5.should_be_a_kind_of(Fixnum)
-    end.should_pass
-  end
-
-  specify "should pass when target is of subclass of specified class" do
-    lambda do
-      5.should_be_a_kind_of(Integer)
-    end.should_pass
-  end
-end

data/spec/spec/expectations/should/should_be_an_instance_of_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be_an_instance_of" do
-  specify "should fail when target is not specified class (OLD STYLE)" do
-    lambda do
-      5.should_be_an_instance_of(Integer)
-    end.should_fail_with "expected instance_of?(Integer) to return true, got false"
-  end
-
-  specify "should pass when target is specified class (OLD STYLE)" do
-    lambda do
-      5.should_be_an_instance_of(Fixnum)
-    end.should_pass
-  end
-
-begin
-  specify "should fail when target is not specified class" do
-    lambda do
-      5.should be_instance_of(Integer)
-    end.should_fail_with "expected instance_of?(Integer) to return true, got false"
-  end
-
-  specify "should pass when target is specified class" do
-    lambda do
-      5.should be_instance_of(Fixnum)
-    end.should_pass
-  end
-end
-
-end

data/spec/spec/expectations/should/should_be_arbitrary_predicate_spec.rb

@@ -1,81 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-module Spec
-  module Expectations
-    module Helper
-      context "should_be_<arbitrary predicate>" do
-        specify "should fail when method returns something other than true false or nil" do
-          mock=HandCodedMock.new(5)
-          lambda do
-            mock.should_be_funny
-          end.should_pass
-          mock.__verify
-        end
-    
-        specify "should fail when predicate accepts args and returns false" do
-          mock=HandCodedMock.new(false)
-          lambda do
-            mock.should_be_hungry(1, 2, 3)
-          end.should_fail_with "expected hungry?(1, 2, 3) to return true, got false"
-          mock.__verify
-        end
-    
-        specify "should fail when predicate returns false" do
-          mock=HandCodedMock.new(false)
-          lambda do
-            mock.should_be_funny
-          end.should_fail
-        end
-    
-        specify "should fail when predicate returns nil" do
-          mock=HandCodedMock.new(nil)
-          lambda do
-            mock.should_be_funny
-          end.should_fail
-          mock.__verify
-        end
-    
-        specify "should pass when predicate accepts args and returns true" do
-          mock=HandCodedMock.new(true)
-          lambda do
-            mock.should_be_hungry(1, 2, 3)
-          end.should_pass
-          mock.__verify
-        end
-    
-        specify "should pass when predicate returns true" do
-          mock=HandCodedMock.new(true)
-          lambda do
-            mock.should_be_funny
-          end.should_pass
-          mock.__verify
-        end
-
-        specify "should raise when target does not respond to predicate" do
-          lambda do
-            5.should_be_funny
-          end.should_raise(NameError)
-        end
-
-        specify "should support multi word predicates with should" do
-          lambda do
-            HandCodedMock.new(true).should_multi_word_predicate
-          end.should_pass
-        end
-    
-        specify "should support multi word predicates with should be" do
-          lambda do
-            HandCodedMock.new(true).should_be_multi_word_predicate
-          end.should_pass
-        end
-    
-        specify "should support present tense (i.e. t.should_exist evaluates t.exists?)" do
-          mock=HandCodedMock.new(true)
-          lambda do
-            mock.should_exist
-          end.should_pass
-        end
-      end
-    end
-  end
-end

data/spec/spec/expectations/should/should_be_close_spec.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be_close" do
-  specify "should not raise when values are within bounds" do
-    3.5.should_be_close(3.5, 0.5)
-    3.5.should_be_close(3.1, 0.5)
-    3.5.should_be_close(3.01, 0.5)
-    3.5.should_be_close(3.9, 0.5)
-    3.5.should_be_close(3.99, 0.5)
-  end
-
-  specify "should raise when values are outside bounds" do
-    lambda { 3.5.should_be_close(3.0, 0.5) }.should_fail_with "expected 3.0 +/- (<0.5), got 3.5"
-    lambda { 3.5.should_be_close(2.0, 0.5) }.should_fail
-    lambda { 3.5.should_be_close(3.0, 0.5) }.should_fail
-    lambda { 3.5.should_be_close(4.0, 0.5) }.should_fail
-  end
-end

data/spec/spec/expectations/should/should_be_comparison_operator_spec.rb

@@ -1,44 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-context "should_be <" do
-  specify "should pass when < operator returns true" do
-    3.should_be < 4
-  end
-
-  specify "should fail when < operator returns false" do
-    lambda { 3.should_be < 3 }.should_fail_with "expected < 3, got 3"
-  end
-end
-
-context "should_be <=" do
-  specify "should pass when <= operator returns true" do
-    3.should_be <= 4
-    4.should_be <= 4
-  end
-
-  specify "should fail when <= operator returns false" do
-    lambda { 3.should_be <= 2 }.should_fail
-  end
-end
-
-context "should_be >=" do
-  specify "should pass when >= operator returns true" do
-    4.should_be >= 4
-    5.should_be >= 4
-  end
-
-  specify "should fail when >= operator returns false" do
-    lambda { 3.should_be >= 4 }.should_fail
-  end
-end
-
-context "should_be >" do
-  specify "should pass when > operator returns true" do
-    5.should_be > 4
-  end
-
-  specify "should fail when > operator returns false" do
-    lambda { 3.should_be > 4 }.should_fail
-  end
-end
-

data/spec/spec/expectations/should/should_be_false_spec.rb

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be false" do
-  specify "should fail when target is true" do
-    lambda do
-      true.should_be false
-    end.should_fail_with "expected false, got true (using .equal?)"
-  end
-
-  specify "should fail when target is a number" do
-    lambda do
-      5.should_be false
-    end.should_fail
-  end
-
-  specify "should fail when target is a some random object" do
-    lambda do
-      self.should_be false
-    end.should_fail
-  end
-
-  specify "should fail when target is a string" do
-    lambda do
-      "false".should_be false
-    end.should_fail
-  end
-
-  specify "should fail when target is nil" do
-    lambda do
-      nil.should_be false
-    end.should_raise
-  end
-
-  specify "should pass when target is false" do
-    lambda do
-      false.should_be false
-    end.should_not_raise
-  end
-end

data/spec/spec/expectations/should/should_be_spec.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be" do
-  specify "should pass when objects are the same instance" do
-    :apple.should_be(:apple)
-  end
-
-  specify "should fail when objects are not the same instance" do
-    lambda { "apple".should_be("apple") }.should_fail
-  end
-end

data/spec/spec/expectations/should/should_be_true_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-context "should_be true" do
-  specify "should fail when object is false" do
-    lambda { false.should_be(true) }.should_fail
-  end
-
-  specify "should fail when object is nil" do
-    lambda { nil.should_be(true) }.should_fail
-  end
-
-  specify "should fail when object is a number" do
-    lambda { 5.should_be(true) }.should_fail
-  end
-
-  specify "should fail when object is a some random object" do
-    lambda { self.should_be(true) }.should_fail
-  end
-
-  specify "should fail when object is a string" do
-    lambda { "true".should_be(true) }.should_raise
-  end
-
-  specify "should pass when object is true" do
-    true.should_be(true)
-  end
-end

data/spec/spec/expectations/should/should_change_spec.rb

@@ -1,184 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-class SomethingExpected
-  attr_accessor :some_value
-end
-
-context "should_change(actual, message)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 5
-  end
-
-  specify "should pass when actual is modified by the block" do
-    lambda {@instance.some_value = 6}.should_change(@instance, :some_value)
-  end
-
-  specify "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {}.should_change(@instance, :some_value)
-    end.should_fail_with "some_value should have changed, but is still 5"
-  end
-end
-
-context "should_change { block }" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 5
-  end
-
-  specify "should pass when actual is modified by the block" do
-    lambda {@instance.some_value = 6}.should_change { @instance.some_value }
-  end
-
-  specify "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {}.should_change{ @instance.some_value }
-    end.should_fail_with "result should have changed, but is still 5"
-  end
-end
-
-context "should_change(actual, message).by(expected)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 5
-  end
-
-  specify "should pass when attribute is changed by expected amount" do
-    lambda { @instance.some_value += 1 }.should_change(@instance, :some_value).by(1)
-  end
-
-  specify "should fail when the attribute is changed by unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should_change(@instance, :some_value).by(1)
-    end.should_fail_with "some_value should have been changed by 1, but was changed by 2"
-  end
-
-  specify "should fail when the attribute is changed by unexpected amount in the opposite direction" do
-    lambda do
-      lambda { @instance.some_value -= 1 }.should_change(@instance, :some_value).by(1)
-    end.should_fail_with "some_value should have been changed by 1, but was changed by -1"
-  end
-end
-
-context "should_change{ block }.by(expected)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 5
-  end
-
-  specify "should pass when attribute is changed by expected amount" do
-    lambda { @instance.some_value += 1 }.should_change{@instance.some_value}.by(1)
-  end
-
-  specify "should fail when the attribute is changed by unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should_change{@instance.some_value}.by(1)
-    end.should_fail_with "result should have been changed by 1, but was changed by 2"
-  end
-
-  specify "should fail when the attribute is changed by unexpected amount in the opposite direction" do
-    lambda do
-      lambda { @instance.some_value -= 1 }.should_change{@instance.some_value}.by(1)
-    end.should_fail_with "result should have been changed by 1, but was changed by -1"
-  end
-end
-
-context "should_change(actual, message).from(old)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-
-  specify "should pass when attribute is == to expected value before executing block" do
-    lambda { @instance.some_value = "astring" }.should_change(@instance, :some_value).from("string")
-  end
-
-  specify "should fail when attribute is not == to expected value before executing block" do
-    lambda do
-      lambda { @instance.some_value = "knot" }.should_change(@instance, :some_value).from("cat")
-    end.should_fail_with "some_value should have initially been \"cat\", but was \"string\""
-  end
-end
-
-context "should_change{ block }.from(old)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-
-  specify "should pass when attribute is == to expected value before executing block" do
-    lambda { @instance.some_value = "astring" }.should_change{@instance.some_value}.from("string")
-  end
-
-  specify "should fail when attribute is not == to expected value before executing block" do
-    lambda do
-      lambda { @instance.some_value = "knot" }.should_change{@instance.some_value}.from("cat")
-    end.should_fail_with "result should have initially been \"cat\", but was \"string\""
-  end
-end
-
-context "should_change(actual, message).to(new)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-  
-  specify "should pass when attribute is == to expected value after executing block" do
-    lambda { @instance.some_value = "cat" }.should_change(@instance, :some_value).to("cat")
-  end
-
-  specify "should fail when attribute is not == to expected value after executing block" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should_change(@instance, :some_value).from("string").to("dog")
-    end.should_fail_with "some_value should have been changed to \"dog\", but is now \"cat\""
-  end
-end
-
-context "should_change{ block }.to(new)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-  
-  specify "should pass when attribute is == to expected value after executing block" do
-    lambda { @instance.some_value = "cat" }.should_change{@instance.some_value}.to("cat")
-  end
-
-  specify "should fail when attribute is not == to expected value after executing block" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should_change{@instance.some_value}.from("string").to("dog")
-    end.should_fail_with "result should have been changed to \"dog\", but is now \"cat\""
-  end
-end
-
-context "should_change(actual, message).from(old).to(new)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-  
-  specify "should pass when #to comes before #from" do
-    lambda { @instance.some_value = "cat" }.should_change(@instance, :some_value).to("cat").from("string")
-  end
-
-  specify "should pass when #from comes before #to" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should_change(@instance, :some_value).from("string").to("cat")
-    end.should_pass
-  end
-end
-
-context "should_change{ block }.from(old).to(new)" do
-  setup do
-    @instance = SomethingExpected.new
-    @instance.some_value = 'string'
-  end
-  
-  specify "should pass when #to comes before #from" do
-    lambda { @instance.some_value = "cat" }.should_change{@instance.some_value}.to("cat").from("string")
-  end
-
-  specify "should pass when #from comes before #to" do
-    lambda { @instance.some_value = "cat" }.should_change{@instance.some_value}.from("string").to("cat")
-  end
-end