rspec 1.2.9 → 1.3.1

data/spec/autotest/failed_results_re_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/autotest/autotest_helper'
+require 'autotest/autotest_helper'
 
 describe "failed_results_re" do
   it "should match a failure" do
@@ -28,4 +28,4 @@ describe "failed_results_re" do
     $1.should == "this example"
     $2.should == "reason\n/path.rb:37:"
   end
-end
+end

data/spec/autotest/rspec_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/autotest/autotest_helper'
+require 'autotest/autotest_helper'
 
 describe Autotest::Rspec do
   describe "adding spec.opts --options" do 
@@ -26,17 +26,21 @@ describe Autotest::Rspec do
       @ruby = @rspec_autotest.ruby
       @spec_cmd = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
       @options = @rspec_autotest.add_options_if_present
+      files = %w[file_one file_two]
       @files_to_test = {
-        :spec => ["file_one", "file_two"]
+        files[0] => [],
+        files[1] => []
       }
       # this is not the inner representation of Autotest!
-      @rspec_autotest.stub!(:files_to_test).and_return @files_to_test
-      @files_to_test.stub!(:keys).and_return @files_to_test[:spec]
-      @to_test = @files_to_test.keys.flatten.join ' '
+      @rspec_autotest.files_to_test = @files_to_test
+      @to_test = files.map { |f| File.expand_path(f) }.join ' '
     end
   
     it "should make the appropriate test command" do
-      @rspec_autotest.make_test_cmd(@files_to_test).should == "#{@ruby} #{@spec_cmd} --autospec #{@to_test} #{@options}"
+      cmd = @rspec_autotest.make_test_cmd(@files_to_test)
+      (cmd =~ /#{@ruby} #{@spec_cmd} --autospec (.*) #{@options}/).should be_true
+      $1.should =~ /#{File.expand_path('file_one')}/
+      $1.should =~ /#{File.expand_path('file_two')}/
     end
 
     it "should return a blank command for no files" do
@@ -108,4 +112,15 @@ describe Autotest::Rspec do
       @rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
     end
   end
+  
+  describe "normalizing file names" do
+    it "should ensure that a single file appears in files_to_test only once" do
+      @rspec_autotest = Autotest::Rspec.new
+      @files_to_test = {}
+      ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file|
+        @files_to_test[file] = []
+      end
+      @rspec_autotest.normalize(@files_to_test).should have(1).file
+    end
+  end
 end

data/spec/spec/dsl/main_spec.rb

@@ -57,7 +57,6 @@ module Spec
         end
       end
 
-    
       describe "#share_as" do
         def self.next_group_name
           @group_number ||= 0
@@ -68,6 +67,15 @@ module Spec
         def group_name
           @group_name ||= self.class.next_group_name
         end
+
+        before(:each) do
+          Spec.stub(:deprecate)
+        end
+
+        it "is deprecated" do
+          Spec.should_receive(:deprecate)
+          share_as group_name do; end
+        end
         
         it "registers a shared ExampleGroup" do
           block = lambda {|a,b|}
@@ -92,4 +100,4 @@ module Spec
     end
   end
 end
-  
+  

data/spec/spec/example/example_group_methods_spec.rb

@@ -732,7 +732,7 @@ module Spec
           end
         end
 
-        describe "#define" do
+        describe "#let" do
           let(:counter) do
             Class.new do
               def initialize
@@ -743,6 +743,7 @@ module Spec
               end
             end.new
           end
+
           it "generates an instance method" do
             counter.count.should == 1
           end
@@ -752,6 +753,25 @@ module Spec
             counter.count.should == 2
           end
         end
+
+        describe "#let!" do
+          let!(:creator) do
+            class Creator
+              @count = 0
+              def self.count
+                @count += 1
+              end
+            end
+          end
+
+          it "evaluates the value non-lazily" do
+            lambda { Creator.count }.should_not raise_error
+          end
+
+          it "does not interfere between tests" do
+            Creator.count.should == 1
+          end
+        end
       end
     end
   end

data/spec/spec/example/example_group_proxy_spec.rb

@@ -4,7 +4,7 @@ module Spec
   module Example
     describe ExampleGroupProxy do
       before(:each) do
-        @group = stub("example group").as_null_object
+        @group = stub("example group",:nested_descriptions => []).as_null_object
       end
       
       attr_reader :group

data/spec/spec/example/example_group_spec.rb

@@ -19,20 +19,9 @@ module Spec
       @@class_variable = "a class variable"
 
       it "can access class variables in examples in Ruby 1.8" do
-        with_ruby 1.8 do
-          @@class_variable.should == "a class variable"
-        end
+        @@class_variable.should == "a class variable"
       end
       
-      it "can NOT access class variables in examples in Ruby 1.9" do
-        with_ruby 1.9 do
-          lambda do
-            @@class_variable.should == "a class variable"
-          end.should raise_error(NameError)
-        end
-      end
-      
-      
     end
 
     class ExampleClassVariablePollutionSpec < ExampleGroup

data/spec/spec/example/example_matcher_spec.rb

@@ -3,10 +3,9 @@ require 'spec_helper'
 module Spec
   module Example
     describe ExampleMatcher, "#matches?" do
-      def match_examples(examples)
-        simple_matcher do |actual, matcher|
-          matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false"
-          matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true"
+
+      Spec::Matchers.define :match_examples do |examples|
+        match do |actual|
           actual.matches?(examples)
         end
       end

data/spec/spec/example/subject_spec.rb

@@ -86,6 +86,13 @@ module Spec
 
     describe ".its (to access subject's attributes)" do
       with_sandboxed_options do
+        it "allows before(:each) blocks on subjects in outer scope" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          group.before(:each) { subject << 1 }
+          child = group.its(:length) { should == 1 }
+          child.run(options).should == true
+        end 
+        
         it "passes when expectation should pass" do
           group = Class.new(ExampleGroupDouble).describe(Array)
           child = group.its(:length) { should == 0 }

data/spec/spec/expectations/wrap_expectation_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 module Spec
   module Matchers
     describe "wrap_expectation" do
+      before { Spec.stub(:deprecate) }
       
       def stub_matcher
         @_stub_matcher ||= simple_matcher do
@@ -27,4 +28,4 @@ module Spec
       end
     end
   end
-end
+end

data/spec/spec/interop/test/unit/spec_spec.rb

@@ -5,43 +5,43 @@ describe "ExampleGroup with test/unit/interop" do
     
   describe "with passing examples" do
     it "should output 0 failures" do
-      output = ruby("#{resources}/spec_that_passes.rb")
+      output = ruby("'#{resources}/spec_that_passes.rb'")
       output.should include("1 example, 0 failures")
     end
 
     it "should return an exit code of 0" do
-      ruby("#{resources}/spec_that_passes.rb")
+      ruby("'#{resources}/spec_that_passes.rb'")
       $?.should == 0
     end
   end
 
   describe "with failing examples" do
     it "should output 1 failure" do
-      output = ruby("#{resources}/spec_that_fails.rb")
+      output = ruby("'#{resources}/spec_that_fails.rb'")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{resources}/spec_that_fails.rb")
+      ruby("'#{resources}/spec_that_fails.rb'")
       $?.should == 256
     end
   end
 
   describe "with example that raises an error" do
     it "should output 1 failure" do
-      output = ruby("#{resources}/spec_with_errors.rb")
+      output = ruby("'#{resources}/spec_with_errors.rb'")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{resources}/spec_with_errors.rb")
+      ruby("'#{resources}/spec_with_errors.rb'")
       $?.should == 256
     end
   end
   
   describe "options hash" do
     it "should be exposed" do
-      output = ruby("#{resources}/spec_with_options_hash.rb")
+      output = ruby("'#{resources}/spec_with_options_hash.rb'")
       output.should include("1 example, 0 failures")
     end
   end

data/spec/spec/interop/test/unit/testcase_spec.rb

@@ -9,42 +9,42 @@ describe "Test::Unit::TestCase" do
   
   describe "with passing test case" do
     it "should output 0 failures" do
-      output = ruby("#{@dir}/test_case_that_passes.rb")
+      output = ruby("'#{@dir}/test_case_that_passes.rb'")
       output.should include("1 example, 0 failures")
     end
 
     it "should return an exit code of 0" do
-      ruby("#{@dir}/test_case_that_passes.rb")
+      ruby("'#{@dir}/test_case_that_passes.rb'")
       $?.should == 0
     end
   end
 
   describe "with failing test case" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/test_case_that_fails.rb")
+      output = ruby("'#{@dir}/test_case_that_fails.rb'")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/test_case_that_fails.rb")
+      ruby("'#{@dir}/test_case_that_fails.rb'")
       $?.should == 256
     end
   end
 
   describe "with test case that raises an error" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/test_case_with_errors.rb")
+      output = ruby("'#{@dir}/test_case_with_errors.rb'")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/test_case_with_errors.rb")
+      ruby("'#{@dir}/test_case_with_errors.rb'")
       $?.should == 256
     end
   end
 
   it "should find all Test::Unit test methods" do
-    output = ruby("#{@dir}/test_case_with_various_names.rb")
+    output = ruby("'#{@dir}/test_case_with_various_names.rb'")
     output.should include("4 examples, 0 failures")
   end
 end

data/spec/spec/interop/test/unit/testsuite_adapter_spec.rb

@@ -4,6 +4,6 @@ describe "TestSuiteAdapter" do
   include TestUnitSpecHelper
   it "should pass" do
     dir = File.dirname(__FILE__)
-    run_script "#{dir}/resources/testsuite_adapter_spec_with_test_unit.rb"
+    run_script "'#{dir}/resources/testsuite_adapter_spec_with_test_unit.rb'"
   end
 end

data/spec/spec/matchers/be_spec.rb

@@ -117,27 +117,143 @@ describe "should_not be_predicate(*args)" do
   end
 end
 
+describe "should be_predicate(&block)" do
+  it "should pass when actual returns true for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(true)
+    actual.should be_happy { delegate.check_happy }
+  end
+
+  it "should fail when actual returns false for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(false)
+    lambda {
+      actual.should be_happy { delegate.check_happy }
+    }.should fail_with("expected happy? to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_happy => true)
+    lambda {
+      Object.new.should be_happy { delegate.check_happy }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not be_predicate(&block)" do
+  it "should pass when actual returns false for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(false)
+    actual.should_not be_happy { delegate.check_happy }
+  end
+
+  it "should fail when actual returns true for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(true)
+    lambda {
+      actual.should_not be_happy { delegate.check_happy }
+    }.should fail_with("expected happy? to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_happy => true)
+    lambda {
+      Object.new.should_not be_happy { delegate.check_happy }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should be_predicate(*args, &block)" do
+  it "should pass when actual returns true for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    actual.should be_older_than(3) { |age| delegate.check_older_than(age) }
+  end
+
+  it "should fail when actual returns false for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    lambda {
+      actual.should be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should fail_with("expected older_than?(3) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_older_than => true)
+    lambda {
+      Object.new.should be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not be_predicate(*args, &block)" do
+  it "should pass when actual returns false for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+  end
+
+  it "should fail when actual returns true for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    lambda {
+      actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should fail_with("expected older_than?(3) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_older_than => true)
+    lambda {
+      Object.new.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should raise_error(NameError)
+  end
+end
+
 describe "should be_true" do
-  it "should pass when actual equal(true)" do
+  it "should pass when actual equal?(true)" do
     true.should be_true
   end
 
-  it "should fail when actual equal(false)" do
+  it "should pass when actual is 1" do
+    1.should be_true
+  end
+
+  it "should fail when actual equal?(false)" do
     lambda {
       false.should be_true
-    }.should fail_with("expected true, got false")
+    }.should fail_with("expected false to be true")
   end
 end
 
 describe "should be_false" do
-  it "should pass when actual equal(false)" do
+  it "should pass when actual equal?(false)" do
     false.should be_false
   end
 
-  it "should fail when actual equal(true)" do
+  it "should pass when actual equal?(nil)" do
+    nil.should be_false
+  end
+
+  it "should fail when actual equal?(true)" do
     lambda {
       true.should be_false
-    }.should fail_with("expected false, got true")
+    }.should fail_with("expected true to be false")
   end
 end
 
@@ -173,6 +289,10 @@ describe "should be <" do
   it "should fail when < operator returns false" do
     lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3")
   end
+
+  it "should describe itself" do
+    be.<(4).description.should == "be < 4"
+  end
 end
 
 describe "should be <=" do
@@ -236,17 +356,32 @@ describe "should_not with operators" do
 end
 
 describe "should be" do
-  it "should pass if actual is true or a set value" do
+  it "should pass if actual is truthy" do
     true.should be
     1.should be
   end
 
   it "should fail if actual is false" do
-    lambda {false.should be}.should fail_with("expected true, got false")
+    lambda {false.should be}.should fail_with("expected false to evaluate to true")
   end
 
   it "should fail if actual is nil" do
-    lambda {nil.should be}.should fail_with("expected true, got nil")
+    lambda {nil.should be}.should fail_with("expected nil to evaluate to true")
+  end
+
+  it "should describe itself" do
+    be.description.should == "be"
+  end
+end
+
+describe "should_not be" do
+  it "should pass if actual is falsy" do
+    false.should_not be
+    nil.should_not be
+  end
+
+  it "should fail on true" do
+    lambda {true.should_not be}.should fail_with("expected true to evaluate to false")
   end
 end
 
@@ -254,9 +389,23 @@ describe "should be(value)" do
   it "should pass if actual.equal?(value)" do
     5.should be(5)
   end
+
   it "should fail if !actual.equal?(value)" do
     lambda { 5.should be(6) }.should fail_with("expected 6, got 5")
   end
+
+  it "should describe itself" do
+    be(5).description.should == "be 5"
+  end
+end
+
+describe "should_not be(value)" do
+  it "should pass if !actual.equal?(value)" do
+    5.should_not be(6)
+  end
+  it "should fail if !actual.equal?(value)" do
+    lambda { 5.should_not be(5) }.should fail_with("expected not 5, got 5")
+  end
 end
 
 describe "'should be' with operator" do
@@ -308,4 +457,4 @@ describe "be_an_instance_of" do
   it "fails when class is higher up hierarchy" do
     5.should_not be_an_instance_of(Numeric)
   end
-end
+end

data/spec/spec/matchers/has_spec.rb

@@ -70,6 +70,115 @@ describe "should_not have_sym(*args)" do
   end
 end
 
+describe "should have_sym(&block)" do
+  it "should pass when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    actual.should have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    lambda {
+      actual.should have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(&block)" do
+  it "should pass when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    actual.should_not have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    lambda {
+      actual.should_not have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should have_sym(*args, &block)" do
+  it "should pass when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    lambda {
+      actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(*args, &block)" do
+  it "should pass when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    lambda {
+      actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+
 describe "has" do
   it "should work when the target implements #send" do
     o = {:a => "A"}