pupu 0.0.2 → 0.0.3.pre

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

@@ -1,257 +0,0 @@
-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/vendor/rspec/spec/spec/example/subclassing_example_group_spec.rb

@@ -1,25 +0,0 @@
-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/vendor/rspec/spec/spec/example/subject_spec.rb

@@ -1,103 +0,0 @@
-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/vendor/rspec/spec/spec/expectations/differs/default_spec.rb

@@ -1,194 +0,0 @@
-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/vendor/rspec/spec/spec/expectations/extensions/kernel_spec.rb

@@ -1,45 +0,0 @@
-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