hubbub 0.0.6

data/lib/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+module Spec
+  module Example
+    describe ExampleGroup, "with :shared => true" do
+      with_sandboxed_options do
+        attr_reader :formatter, :example_group
+        before(:each) do
+          @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
+          options.formatters << formatter
+          @example_group = Class.new(ExampleGroupDouble).describe("example_group")
+          class << example_group
+            public :include
+          end
+        end
+
+        after(:each) do
+          @formatter.rspec_verify
+          @example_group = nil
+          Spec::Example::SharedExampleGroup.clear
+        end
+        
+        describe "#register" do
+          it "creates a new shared example group with the submitted args" do
+            block = lambda {|a|}
+            group = SharedExampleGroup.new("shared group") do end
+            Spec::Example::SharedExampleGroup.should_receive(:new).with("share me", &block).and_return(group)
+            Spec::Example::SharedExampleGroup.register("share me", &block)
+          end
+
+          it "registers the shared example group" do
+            lambda do
+              Spec::Example::SharedExampleGroup.register "share me" do end
+            end.should change {Spec::Example::SharedExampleGroup.count}.by(1)
+          end
+        end
+
+        it "complains when adding a second shared example_group with the same description" do
+          describe "shared example_group", :shared => true do
+          end
+          lambda do
+            describe "shared example_group", :shared => true do
+            end
+          end.should raise_error(ArgumentError)
+        end
+        
+        it "does NOT add the same group twice" do
+          lambda do
+            2.times do
+              describe "shared example_group which gets loaded twice", :shared => true do
+              end
+            end
+          end.should change {Spec::Example::SharedExampleGroup.count}.by(1)
+        end
+
+        it "does NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
+          lambda do
+            2.times do
+              describe "shared example_group which gets loaded twice", :shared => true do
+              end
+            end
+          end.should_not raise_error(ArgumentError)
+        end
+
+        it "does NOT complain when adding the same shared example_group in same file with different absolute path" do
+          SharedExampleGroup.register(
+            "shared example_group",
+            :shared => true,
+            :location => "/my/spec/a/../shared.rb"
+          )
+          SharedExampleGroup.register(
+            "shared example_group",
+            :shared => true,
+            :location => "/my/spec/b/../shared.rb"
+          )
+        end
+
+        it "complains when adding a different shared example_group with the same name in a different file with the same basename" do
+          SharedExampleGroup.register(
+            "shared example_group",
+            :shared => true,
+            :location => "/my/spec/a/shared.rb"
+          )
+          lambda do
+            SharedExampleGroup.register(
+              "shared example_group",
+              :shared => true,
+              :location => "/my/spec/b/shared.rb"
+            )
+          end.should raise_error(ArgumentError, /already exists/)
+        end
+
+        it "adds examples to current example_group using it_should_behave_like" do
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            it("shared example") {}
+            it("shared example 2") {}
+          end
+
+          example_group.it("example") {}
+          example_group.number_of_examples.should == 1
+          example_group.it_should_behave_like("shared example_group")
+          example_group.number_of_examples.should == 3
+        end
+
+        it "adds examples to from two shared groups" do
+          shared_example_group_1 = SharedExampleGroup.register("shared example_group 1") do
+            it("shared example 1") {}
+          end
+
+          shared_example_group_1 = SharedExampleGroup.register("shared example_group 2") do
+            it("shared example 2") {}
+          end
+
+          example_group.it("example") {}
+          example_group.number_of_examples.should == 1
+          example_group.it_should_behave_like("shared example_group 1", "shared example_group 2")
+          example_group.number_of_examples.should == 3
+        end
+
+        it "adds examples to current example_group using include" do
+          shared_example_group = describe "all things", :shared => true do
+            it "should do stuff" do end
+          end
+        
+          example_group = describe "one thing" do
+            include shared_example_group
+          end
+        
+          example_group.number_of_examples.should == 1
+        end
+
+        it "adds examples to current example_group using it_should_behave_like with a module" do
+          ::AllThings = describe "all things", :shared => true do
+            it "should do stuff" do end
+          end
+        
+          example_group = describe "one thing" do
+            it_should_behave_like ::AllThings
+          end
+        
+          example_group.number_of_examples.should == 1
+        end
+
+        it "runs shared examples" do
+          shared_example_ran = false
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            it("shared example") { shared_example_ran = true }
+          end
+
+          example_ran = false
+
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run(options)
+          example_ran.should be_true
+          shared_example_ran.should be_true
+        end
+
+        it "runs before(:each) and after(:each) from shared example_group" do
+          shared_setup_ran = false
+          shared_teardown_ran = false
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            before(:each) { shared_setup_ran = true }
+            after(:each)  { shared_teardown_ran = true }
+            it("shared example") { shared_example_ran = true }
+          end
+
+          example_ran = false
+
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run(options)
+          example_ran.should be_true
+          shared_setup_ran.should be_true
+          shared_teardown_ran.should be_true
+        end
+
+        it "should run before(:all) and after(:all) only once from shared example_group" do
+          shared_before_all_run_count = 0
+          shared_after_all_run_count = 0
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            before(:all) { shared_before_all_run_count += 1}
+            after(:all)  { shared_after_all_run_count += 1}
+            it("shared example") { shared_example_ran = true }
+          end
+
+          example_ran = false
+
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run(options)
+          example_ran.should be_true
+          shared_before_all_run_count.should == 1
+          shared_after_all_run_count.should == 1
+        end
+
+        it "should include modules, included into shared example_group, into current example_group" do
+          @formatter.should_receive(:add_example_group).with(any_args)
+
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            it("shared example") { shared_example_ran = true }
+          end
+
+          mod1_method_called = false
+          mod1 = Module.new do
+            define_method :mod1_method do
+              mod1_method_called = true
+            end
+          end
+
+          mod2_method_called = false
+          mod2 = Module.new do
+            define_method :mod2_method do
+              mod2_method_called = true
+            end
+          end
+
+          shared_example_group.__send__ :include, mod2
+
+          example_group.it_should_behave_like("shared example_group")
+          example_group.include mod1
+
+          example_group.it("test") do
+            mod1_method
+            mod2_method
+          end
+          example_group.run(options)
+          mod1_method_called.should be_true
+          mod2_method_called.should be_true
+        end
+
+        it "should make methods defined in the shared example_group available in consuming example_group" do
+          shared_example_group = SharedExampleGroup.register("shared example_group xyz") do
+            def a_shared_helper_method
+              "this got defined in a shared example_group"
+            end
+          end
+          example_group.it_should_behave_like("shared example_group xyz")
+          success = false
+          example_group.it("should access a_shared_helper_method") do
+            a_shared_helper_method
+            success = true
+          end
+          example_group.run(options)
+          success.should be_true
+        end
+
+        it "should raise when named shared example_group can not be found" do
+          lambda {
+            example_group.it_should_behave_like("non-existent shared example group")
+            violated
+          }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
+        end
+      end
+    end
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/example/subclassing_example_group_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Spec
+  module Example
+    class GrandParentExampleGroup < Spec::Example::ExampleGroup
+      describe "Grandparent ExampleGroup"
+    end
+
+    class ParentExampleGroup < GrandParentExampleGroup
+      describe "Parent ExampleGroup"
+      it "should bar" do
+      end
+    end
+
+    class ChildExampleGroup < ParentExampleGroup
+      describe "Child ExampleGroup"
+      it "should bam" do
+      end
+    end
+
+    describe ChildExampleGroup do
+
+    end
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/example/subject_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module Spec
+  module Example
+    describe "implicit subject" do
+      describe "with a class" do
+        it "returns an instance of the class" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          example = group.new(ExampleProxy.new)
+          example.subject.should == []
+        end
+      end
+      
+      describe "with a Module" do
+        it "returns the Module" do
+          group = Class.new(ExampleGroupDouble).describe(Enumerable)
+          example = group.new(ExampleProxy.new)
+          example.subject.should == Enumerable
+        end
+      end
+      
+      describe "with a string" do
+        it "return the string" do
+          group = Class.new(ExampleGroupDouble).describe('foo')
+          example = group.new(ExampleProxy.new)
+          example.subject.should == 'foo'
+        end
+      end
+
+      describe "with a number" do
+        it "returns the number" do
+          group = Class.new(ExampleGroupDouble).describe(15)
+          example = group.new(ExampleProxy.new)
+          example.subject.should == 15
+        end
+      end
+      
+    end
+    
+    describe "explicit subject" do
+      describe "defined in a top level group" do
+        it "replaces the implicit subject in that group" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          group.subject { [1,2,3] }
+          example = group.new(ExampleProxy.new)
+          example.subject.should == [1,2,3]
+        end
+      end
+
+      describe "defined in a top level group" do
+        before(:each) do
+          @group = Class.new do
+            extend  Spec::Example::Subject::ExampleGroupMethods
+            include Spec::Example::Subject::ExampleMethods
+            class << self
+              def described_class
+                Array
+              end
+            end
+            def described_class
+              self.class.described_class
+            end
+            
+            subject {
+              [1,2,3]
+            }
+          end
+        end
+
+        it "is available in a nested group (subclass)" do
+          nested_group = Class.new(@group)
+          
+          example = nested_group.new
+          example.subject.should == [1,2,3]
+        end
+
+        it "is available in a doubly nested group (subclass)" do
+          nested_group = Class.new(@group)
+          doubly_nested_group = Class.new(nested_group)
+
+          example = doubly_nested_group.new
+          example.subject.should == [1,2,3]
+        end
+      end
+    end
+
+    describe ".its (to access subject's attributes)" do
+      with_sandboxed_options do
+        it "passes when expectation should pass" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          child = group.its(:length) { should == 0 }
+          child.run(options).should == true
+        end
+        
+        it "fails when expectation should fail" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          child = group.its(:length) { should == 1 }
+          child.run(options).should == false
+        end
+      end
+    end
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/expectations/differs/default_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+module Spec
+  module Fixtures
+    class Animal
+      def initialize(name,species)
+        @name,@species = name,species
+      end
+
+      def inspect
+        <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+        EOA
+      end
+    end
+  end
+end
+
+describe "Diff" do
+  before(:each) do
+    @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+    @differ = Spec::Expectations::Differs::Default.new(@options)
+  end
+
+  it "should output unified diff of two strings" do
+    expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+    actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+    expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+    diff = @differ.diff_as_string(expected, actual)
+    diff.should eql(expected_diff)
+  end
+
+  it "should output unified diff message of two arrays" do
+    expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+    actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+    expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+  
+  it "should output a friendly message if comparing simple hashes" do
+    expected = { "foo" => "bar" }
+    actual   = { "foo" => "baz" }
+    
+    expected_diff = <<'EOD'
+
+Expected the key "foo" to be "bar", but was "baz"
+
+EOD
+
+
+    diff = @differ.diff_as_hash(actual, expected)
+    diff.should == expected_diff
+  end
+  
+  
+  it "should output a friendly message if comparing simple hashes that contain different keys" do
+    expected = { "bar" => "foo" }
+    actual   = { "foo" => "baz" }
+
+    expected_diff = <<'EOD'
+
+Expected hash contains keys that target hash does not: ["bar"]
+Target hash contains keys that expected hash does not: ["foo"]
+Expected the key "bar" to be "foo", but was nil
+
+EOD
+
+
+    diff = @differ.diff_as_hash(actual, expected)
+    diff.should == expected_diff
+  end
+  
+  it "should output diff message if the hash is complex (containing Array or Hash)" do
+    expected = { "foo" => "bar", "fizz" => [1, 2, 3] }
+    actual   = { "foo" => "baz", "fizz" => [1, 2] }
+
+    # UGH - 1.8.7 seems to order hash keys differently than the others
+    if RUBY_VERSION =~ /^1.8.7/
+      expected_diff = <<'EOD'
+
+Expected the key "fizz" to be [1, 2, 3], but was [1, 2]
+Expected the key "foo" to be "bar", but was "baz"
+
+
+@@ -1,2 +1,2 @@
+-{"fizz"=>[1, 2, 3], "foo"=>"bar"}
++{"fizz"=>[1, 2], "foo"=>"baz"}
+EOD
+    else
+      expected_diff = <<'EOD'
+
+Expected the key "fizz" to be [1, 2, 3], but was [1, 2]
+Expected the key "foo" to be "bar", but was "baz"
+
+
+@@ -1,2 +1,2 @@
+-{"foo"=>"bar", "fizz"=>[1, 2, 3]}
++{"foo"=>"baz", "fizz"=>[1, 2]}
+EOD
+    end
+
+    diff = @differ.diff_as_hash(actual, expected)
+    diff.should == expected_diff
+  end
+  
+
+  it "should output unified diff message of two objects" do
+    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+
+end
+
+
+describe "Diff in context format" do
+  before(:each) do
+    @options = Spec::Runner::Options.new(StringIO.new, StringIO.new)
+    @options.diff_format = :context
+    @differ = Spec::Expectations::Differs::Default.new(@options)
+  end
+
+  it "should output unified diff message of two objects" do
+    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+***************
+*** 1,5 ****
+  <Animal
+    name=bob,
+!   species=tortoise
+  >
+--- 1,5 ----
+  <Animal
+    name=bob,
+!   species=giraffe
+  >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Object, "#should" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stub!(:matches?).and_return(true)
+    @matcher.stub!(:failure_message_for_should)
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)    
+    @target.should @matcher
+  end
+  
+  it "asks for a failure_message_for_should when matches? returns false" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
+    lambda {
+      @target.should @matcher
+    }.should fail_with("the failure message")
+  end
+end
+
+describe Object, "#should_not" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.stub!(:failure_message_for_should_not)
+    
+    @target.should_not @matcher
+  end
+  
+  it "asks for a failure_message_for_should_not when matches? returns true" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the failure message for should not")
+  end
+end