ageweke-rspec 1.2.9

data/spec/spec/example/example_matcher_spec.rb

@@ -0,0 +1,86 @@
+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"
+          actual.matches?(examples)
+        end
+      end
+      
+      it "should match correct example_group and example" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_examples(["example_group example"])
+      end
+      
+      it "should not match wrong example" do
+        matcher = ExampleMatcher.new("example_group", "other example")
+        matcher.should_not match_examples(["example_group example"])
+      end
+      
+      it "should not match wrong example_group" do
+        matcher = ExampleMatcher.new("other example_group", "example")
+        matcher.should_not match_examples(["example_group example"])
+      end
+      
+      it "should match example only" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_examples(["example"])
+      end
+
+      it "should match example_group only" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_examples(["example_group"])
+      end
+
+      it "should match example_group ending with before(:all)" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_examples(["example_group before(:all)"])
+      end
+      
+      it "should escape regexp chars" do
+        matcher = ExampleMatcher.new("(con|text)", "[example]")
+        matcher.should_not match_examples(["con p"])
+      end
+      
+      it "should match when example_group is modularized" do
+        matcher = ExampleMatcher.new("MyModule::MyClass", "example")
+        matcher.should match_examples(["MyClass example"])
+      end      
+    end
+
+    describe ExampleMatcher, "#matches? normal case" do
+      it "matches when passed in example matches" do
+        matcher = ExampleMatcher.new("Foo", "bar")
+        matcher.matches?(["no match", "Foo bar"]).should == true
+      end
+
+      it "does not match when no passed in examples match" do
+        matcher = ExampleMatcher.new("Foo", "bar")
+        matcher.matches?(["no match1", "no match2"]).should == false
+      end
+    end
+
+    describe ExampleMatcher, "#matches? where description has '::' in it" do
+      it "matches when passed in example matches" do
+        matcher = ExampleMatcher.new("Foo::Bar", "baz")
+        matcher.matches?(["no match", "Foo::Bar baz"]).should == true
+      end
+
+      it "does not match when no passed in examples match" do
+        matcher = ExampleMatcher.new("Foo::Bar", "baz")
+        matcher.matches?(["no match1", "no match2"]).should == false
+      end
+    end
+    
+    describe ExampleMatcher, "called with nil example" do
+      it "does not puke" do
+        matcher = ExampleMatcher.new("Foo::Bar", nil)
+        matcher.matches?(["anything"]).should == false
+      end
+    end
+  end
+end

data/spec/spec/example/example_methods_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+class Thing
+  attr_reader :arg
+  def initialize(arg=nil)
+    @arg = arg || :default
+  end
+  def ==(other)
+    @arg == other.arg
+  end
+  def eql?(other)
+    @arg == other.arg
+  end
+end
+
+module Spec
+  module Example
+    describe ExampleMethods do
+      module ModuleThatIsReopened; end
+
+      module Spec::Example::ExampleMethods
+        include ModuleThatIsReopened
+      end
+
+      module ModuleThatIsReopened
+        def module_that_is_reopened_method; end
+      end
+      
+      describe "with an included module that is reopened" do
+        it "should have reopened methods" do
+          method(:module_that_is_reopened_method).should_not be_nil
+        end
+      end
+
+      describe "#should" do
+        before(:each) do
+          @example_group = Class.new(ExampleGroupDouble)
+          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+        end
+        
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(::Thing)
+            @example_group.example { should == ::Thing.new(:default) }
+            @example_group.example { should eql(::Thing.new(:default)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(::Thing)
+            @example_group.subject { ::Thing.new(:other) }
+            @example_group.example { should == ::Thing.new(:other) }
+            @example_group.example { should eql(::Thing.new(:other)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+		
+        context "in an ExampleGroup using 'self' as an explicit subject" do
+          it "delegates matcher to the ExampleGroup" do
+            @example_group.describe(::Thing)
+            @example_group.subject { self }
+            @example_group.example { should == self }
+            @example_group.example { should eql(self) }
+            @example_group.example do
+              self.instance_eval("def method_ok?; true end")
+              should be_method_ok
+            end
+            @example_group.run(@options).should be_true
+          end
+        end
+      end
+
+      describe "#should_not" do
+        before(:each) do
+          @example_group = Class.new(ExampleGroupDouble)
+          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+        end
+
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(::Thing)
+            @example_group.example { should_not == ::Thing.new(:other) }
+            @example_group.example { should_not eql(::Thing.new(:other)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(::Thing)
+            @example_group.subject { ::Thing.new(:other) }
+            @example_group.example { should_not == ::Thing.new(:default) }
+            @example_group.example { should_not eql(::Thing.new(:default)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+		
+        context "in an ExampleGroup using 'self' as an explicit subject" do
+          it "delegates matcher to the ExampleGroup" do
+            @example_group.describe(::Thing)
+            @example_group.subject { self }
+            @example_group.example { should_not == ::Thing.new(:default) }
+            @example_group.example { should_not eql(::Thing.new(:default)) }
+            @example_group.example do
+              self.instance_eval("def method_ok?; false end")
+              should_not be_method_ok
+            end
+            @example_group.run(@options).should be_true
+          end
+        end
+      end
+    end
+
+    describe "#options" do
+      it "should expose the options hash" do
+        example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end
+        example.options[:this].should == 'that'
+      end
+    end
+    
+    describe "#set_instance_variables_from_hash" do
+      it "preserves the options" do
+        example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end
+        example.set_instance_variables_from_hash({:@_options => {}})
+        example.options[:this].should == 'that'
+      end
+    end
+    
+    describe "#description" do
+      it "returns the supplied description" do
+        example = ExampleGroupDouble.new ExampleProxy.new("name") do; end
+        example.description.should == "name"
+      end
+      it "returns the generated description if there is no description supplied" do
+        example = ExampleGroupDouble.new ExampleProxy.new do; end
+        Spec::Matchers.stub!(:generated_description).and_return('this message')
+        example.description.should == "this message"
+      end
+      it "warns if there is no supplied or generated description" do
+        example = ExampleGroupDouble.new ExampleProxy.new(nil, {}, "this backtrace") do; end
+        Spec::Matchers.stub!(:generated_description).and_return(nil)
+        Spec.should_receive(:warn).with("No description supplied for example declared on this backtrace")
+        example.description
+      end
+    end
+    
+    describe "#expect" do
+      it "aliases #should with #to on the proc" do
+        a = 3
+        expect { a += 1 }.to change{a}.from(3).to(4)
+      end
+
+      it "aliases #should_not with #to_not on the proc" do
+        a = 3
+        expect { nil }.to_not change{a}
+      end
+    end
+
+  end
+end

data/spec/spec/example/example_proxy_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Spec
+  module Example
+
+    describe ExampleProxy do
+
+      describe "#description" do
+        it "provides the submitted description" do
+          proxy = ExampleProxy.new("the description")
+          proxy.description.should   == "the description"
+        end
+      end
+      
+      describe "#update" do
+        it "updates the description" do
+          proxy = ExampleProxy.new("old description")
+          proxy.update("new description")
+          proxy.description.should == "new description"
+        end
+      end
+
+      describe "#options" do
+        it "provides the submitted options" do
+          proxy = ExampleProxy.new(:ignore, {:these => :options})
+          proxy.options.should           == {:these => :options}
+        end
+      end
+
+      describe "#backtrace (DEPRECATED - use #location)" do
+        before(:each) do
+          Spec.stub!(:deprecate)
+        end
+        
+        it "is deprecated" do
+          Spec.should_receive(:deprecate)
+          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
+          proxy.backtrace
+        end
+        
+        it "provides the location of the declaration of this group" do
+          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
+          proxy.backtrace.should             == "path/to/location:37"
+        end
+      end
+      
+      describe "#location" do
+        it "provides the location of the declaration of this group" do
+          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
+          proxy.location.should              == "path/to/location:37"
+        end
+      end
+      
+    end
+
+  end
+end

data/spec/spec/example/helper_method_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+# This was added to prove that http://rspec.lighthouseapp.com/projects/5645/tickets/211
+# was fixed in ruby 1.9.1
+
+module HelperMethodExample
+  describe "a helper method" do
+    def helper_method
+      "received call"
+    end
+  
+    it "is available to examples in the same group" do
+      helper_method.should == "received call"
+    end
+    
+    describe "from a nested group" do
+      it "is available to examples in a nested group" do
+        helper_method.should == "received call"
+      end
+    end
+    
+  end
+end
+

data/spec/spec/example/nested_example_group_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Spec
+  module Example
+    describe 'Nested Example Groups' do
+      parent = self
+      
+      def count
+        @count ||= 0
+        @count = @count + 1
+        @count
+      end
+
+      before(:all) do
+        count.should == 1
+      end
+
+      before(:all) do
+        count.should == 2
+      end
+
+      before(:each) do
+        count.should == 3
+      end
+
+      before(:each) do
+        count.should == 4
+      end
+
+      it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do
+        count.should == 5
+      end
+
+      after(:each) do
+        count.should == 7
+      end
+
+      after(:each) do
+        count.should == 6
+      end
+
+      after(:all) do
+        count.should == 9
+      end
+
+      after(:all) do
+        count.should == 8
+      end
+
+      describe 'nested example group' do
+        self.superclass.should == parent
+        
+        it "should run all before and after callbacks" do
+          count.should == 5
+        end
+      end
+    end
+
+    describe "Nested Example Groups" do
+      describe "description options", :other_options => "other options" do
+        it "includes :location" do
+          self.class.options[:location].should match(/#{__FILE__}/)
+        end
+
+        it "includes any other options" do
+          self.class.options[:other_options].should == "other options"
+        end
+      end
+    end
+  end
+end

data/spec/spec/example/pending_module_spec.rb

@@ -0,0 +1,58 @@
+module Spec
+  module Example
+    describe Pending do
+      
+      context "when no block is supplied" do
+        it "raises an ExamplePendingError if no block is supplied" do
+          lambda {
+            pending "TODO"
+          }.should raise_error(ExamplePendingError, /TODO/)
+        end
+      end
+      
+      context "when the supplied block fails" do
+        it "raises an ExamplePendingError if a supplied block fails as expected" do
+          lambda {
+            pending "TODO" do
+              raise "oops"
+            end
+          }.should raise_error(ExamplePendingError, /TODO/)
+        end
+      end
+      
+      context "when the supplied block fails with a mock" do
+        it "raises an ExamplePendingError if a supplied block fails as expected with a mock" do
+          lambda {
+            pending "TODO" do
+              m = mock("thing")
+              m.should_receive(:foo)
+              m.rspec_verify
+            end
+          }.should raise_error(ExamplePendingError, /TODO/)
+        end
+      end
+      
+      context "when the supplied block passes" do
+        it "raises a PendingExampleFixedError" do
+          lambda {
+            pending "TODO" do
+              # success!
+            end
+          }.should raise_error(PendingExampleFixedError, /TODO/)
+        end
+      end
+    end
+    
+    describe ExamplePendingError do
+      it "should have the message provided" do
+        ExamplePendingError.new("a message").message.should == "a message"
+      end
+    end
+    
+    describe NotYetImplementedError do
+      it "should have the message 'Not Yet Implemented'" do
+        NotYetImplementedError.new.message.should == "Not Yet Implemented"
+      end
+    end
+  end
+end