spree 0.8.1 → 0.8.2

data/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "Example with stubbed and then called message" do
-      it "should fail if the message is expected and then subsequently not called again" do
-        mock_obj = mock("mock", :msg => nil)
-        mock_obj.msg
-        mock_obj.should_receive(:msg)
-        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/mocks/twice_counts_spec.rb

@@ -1,67 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "TwiceCounts" do
-      before(:each) do
-        @mock = mock("test mock")
-      end
-
-      it "twice should fail when call count is higher than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "twice should fail when call count is lower than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "twice should fail when called twice with wrong args on the first call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-      
-      it "twice should fail when called twice with wrong args on the second call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-      
-      it "twice should pass when called twice" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
-      end
-      
-      it "twice should pass when called twice with specified args" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        @mock.random_call("1", 1)
-        @mock.rspec_verify
-      end
-      
-      it "twice should pass when called twice with unspecified args" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call("1")
-        @mock.random_call(1)
-        @mock.rspec_verify
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/package/bin_spec_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../ruby_forker'
-
-describe "The bin/spec script" do
-  include RubyForker
-  
-  it "should have no warnings" do
-    pending "Hangs on JRuby" if PLATFORM =~ /java/
-    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
-
-    output = ruby "-w #{spec_path} --help 2>&1"
-    output.should_not =~ /warning/n
-  end
-  
-  it "should show the help w/ no args" do
-    pending "Hangs on JRuby" if PLATFORM =~ /java/
-    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
-
-    output = ruby "-w #{spec_path} 2>&1"
-    output.should =~ /^Usage: spec/
-  end
-end

data/vendor/plugins/rspec/spec/spec/runner/class_and_argument_parser_spec.rb

@@ -1,23 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Runner
-    describe ClassAndArgumentsParser, ".parse" do
-      
-      it "should use a single : to separate class names from arguments" do
-        ClassAndArgumentsParser.parse('Foo').should == ['Foo', nil]
-        ClassAndArgumentsParser.parse('Foo:arg').should == ['Foo', 'arg']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg').should == ['Foo::Bar::Zap', 'arg']
-        ClassAndArgumentsParser.parse('Foo:arg1,arg2').should == ['Foo', 'arg1,arg2']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg1,arg2').should == ['Foo::Bar::Zap', 'arg1,arg2']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:drb://foo,drb://bar').should == ['Foo::Bar::Zap', 'drb://foo,drb://bar']
-      end
-
-      it "should raise an error when passed an empty string" do
-        lambda do
-          ClassAndArgumentsParser.parse('')
-        end.should raise_error("Couldn't parse \"\"")
-      end      
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/runner/command_line_spec.rb

@@ -1,141 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Runner
-    describe CommandLine, ".run" do
-      with_sandboxed_options do
-        attr_reader :err, :out
-        before do
-          @err = options.error_stream
-          @out = options.output_stream
-        end
-      
-        it "should run directory" do
-          file = File.dirname(__FILE__) + '/../../../examples/passing'
-          run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out))
-
-          @out.rewind
-          @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
-        end
-
-        it "should run file" do
-          file = File.dirname(__FILE__) + '/../../../examples/failing/predicate_example.rb'
-          run_with(OptionParser.parse([file], @err, @out))
-
-          @out.rewind
-          @out.read.should =~ /3 examples, 2 failures/n
-        end
-
-        it "should raise when file does not exist" do
-          file = File.dirname(__FILE__) + '/doesntexist'
-
-          lambda {
-            Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
-          }.should raise_error
-        end
-
-        it "should return true when in --generate-options mode" do
-          # NOTE - this used to say /dev/null but jruby hangs on that for some reason
-          Spec::Runner::CommandLine.run(
-            OptionParser.parse(['--generate-options', '/tmp/foo'], @err, @out)
-          ).should be_true
-        end
-
-        it "should dump even if Interrupt exception is occurred" do
-          example_group = Class.new(::Spec::Example::ExampleGroup) do
-            describe("example_group")
-            it "no error" do
-            end
-
-            it "should interrupt" do
-              raise Interrupt, "I'm interrupting"
-            end
-          end
-
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reporter.should_receive(:dump)
-          options.add_example_group(example_group)
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        end
-
-        it "should heckle when options have heckle_runner" do
-          example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
-            it "no error" do
-            end
-          end
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.add_example_group example_group
-
-          heckle_runner = mock("heckle_runner")
-          heckle_runner.should_receive(:heckle_with)
-          $rspec_mocks.__send__(:mocks).delete(heckle_runner)
-
-          options.heckle_runner = heckle_runner
-          options.add_example_group(example_group)
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-          heckle_runner.rspec_verify
-        end
-
-        it "should run examples backwards if options.reverse is true" do
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reverse = true
-
-          b1 = Class.new(Spec::Example::ExampleGroup)
-          b2 = Class.new(Spec::Example::ExampleGroup)
-
-          b2.should_receive(:run).ordered
-          b1.should_receive(:run).ordered
-
-          options.add_example_group(b1)
-          options.add_example_group(b2)
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        end
-
-        it "should pass its ExampleGroup to the reporter" do
-          example_group = describe("example_group") do
-            it "should" do
-            end
-          end
-          options = ::Spec::Runner::Options.new(@err, @out)
-          options.add_example_group(example_group)
-
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reporter.should_receive(:add_example_group).with(example_group)
-        
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        end
-
-        it "runs only selected Examples when options.examples is set" do
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-
-          options.examples << "example group expected example"
-          expected_example_was_run = false
-          unexpected_example_was_run = false
-          example_group = describe("example group") do
-            it "expected example" do
-              expected_example_was_run = true
-            end
-            it "unexpected example" do
-              unexpected_example_was_run = true
-            end
-          end
-
-          options.reporter.should_receive(:add_example_group).with(example_group)
-
-          options.add_example_group example_group
-          run_with(options)
-
-          expected_example_was_run.should be_true
-          unexpected_example_was_run.should be_false
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/runner/configuration_spec.rb

@@ -1,301 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Runner
-    describe Configuration do
-      with_sandboxed_options do
-        with_sandboxed_config do
-          describe "#mock_with" do
-            it "should default mock framework to rspec" do
-              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
-            end
-
-            it "should set rspec mocking explicitly" do
-              config.mock_with(:rspec)
-              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
-            end
-
-            it "should set mocha" do
-              config.mock_with(:mocha)
-              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/mocha$/
-            end
-
-            it "should set flexmock" do
-              config.mock_with(:flexmock)
-              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/flexmock$/
-            end
-
-            it "should set rr" do
-              config.mock_with(:rr)
-              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rr$/
-            end
-
-            it "should set an arbitrary adapter module" do
-              adapter = Module.new
-              config.mock_with(adapter)
-              config.mock_framework.should == adapter
-            end
-          end
-
-          describe "#include" do
-          
-            before(:each) do
-              @example_group_class = Class.new(ExampleGroup) {}
-              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
-            end
-
-            it "should include the submitted module in ExampleGroup subclasses" do
-              mod = Module.new
-              config.include mod
-              Class.new(@example_group_class).included_modules.should include(mod)
-            end
-
-            it "should scope modules to be included for a specific type" do
-              mod = Module.new
-              config.include mod, :type => :foobar
-              Class.new(@example_group_class).included_modules.should include(mod)
-            end
-
-            it "should not include modules in a type they are not intended for" do
-              mod = Module.new
-              @other_example_group_class = Class.new(ExampleGroup)
-              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
-
-              config.include mod, :type => :foobar
-
-              Class.new(@other_example_group_class).included_modules.should_not include(mod)
-            end
-            
-            it "accepts an Array of types" do
-              mod = Module.new
-              @other_example_group_class = Class.new(ExampleGroup)
-              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
-
-              config.include mod, :type => [:foobar, :baz]
-
-              Class.new(@example_group_class).included_modules.should include(mod)
-              Class.new(@other_example_group_class).included_modules.should include(mod)
-            end
-
-          end
-      
-          describe "#extend" do
-        
-            before(:each) do
-              @example_group_class = Class.new(ExampleGroup) {}
-              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
-            end
-
-            it "should extend all groups" do
-              mod = Module.new
-              ExampleGroup.should_receive(:extend).with(mod)
-              Spec::Runner.configuration.extend mod
-            end
-      
-            it "should extend specified groups" do
-              mod = Module.new
-              @example_group_class.should_receive(:extend).with(mod)
-              Spec::Runner.configuration.extend mod, :type => :foobar
-            end
-      
-            it "should not extend non-specified groups" do
-              @other_example_group_class = Class.new(ExampleGroup)
-              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
-
-              mod = Module.new
-              @other_example_group_class.should_not_receive(:extend)          
-
-              Spec::Runner.configuration.extend mod, :type => :foobar
-            end
-        
-          end
-        end
-      
-        describe "ordering methods: " do
-        
-          before(:each) do
-            @special_example_group = Class.new(ExampleGroup).describe("special_example_group")
-            @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group")
-            @nonspecial_example_group = Class.new(ExampleGroup).describe("nonspecial_example_group")
-            Spec::Example::ExampleGroupFactory.register(:special, @special_example_group)
-            Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group)
-            Spec::Example::ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
-            @example_group = @special_child_example_group.describe "Special Example Group"
-            @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
-          end
-
-          describe "#prepend_before" do
-            it "prepends the before block on all instances of the passed in type" do
-              order = []
-              config.prepend_before(:all) do
-                order << :prepend__before_all
-              end
-              config.prepend_before(:all, :type => :special) do
-                order << :special_prepend__before_all
-              end
-              config.prepend_before(:all, :type => :special_child) do
-                order << :special_child_prepend__before_all
-              end
-              config.prepend_before(:each) do
-                order << :prepend__before_each
-              end
-              config.prepend_before(:each, :type => :special) do
-                order << :special_prepend__before_each
-              end
-              config.prepend_before(:each, :type => :special_child) do
-                order << :special_child_prepend__before_each
-              end
-              config.prepend_before(:all, :type => :non_special) do
-                order << :special_prepend__before_all
-              end
-              config.prepend_before(:each, :type => :non_special) do
-                order << :special_prepend__before_each
-              end
-              @example_group.it "calls prepend_before" do
-              end
-      
-              @example_group.run(options)
-              order.should == [
-                :prepend__before_all,
-                :special_prepend__before_all,
-                :special_child_prepend__before_all,
-                :prepend__before_each,
-                :special_prepend__before_each,
-                :special_child_prepend__before_each
-              ]
-            end
-          end
-
-          describe "#append_before" do
-
-            it "calls append_before on the type" do
-              order = []
-              config.append_before(:all) do
-                order << :append_before_all
-              end
-              config.append_before(:all, :type => :special) do
-                order << :special_append_before_all
-              end
-              config.append_before(:all, :type => :special_child) do
-                order << :special_child_append_before_all
-              end
-              config.append_before(:each) do
-                order << :append_before_each
-              end
-              config.append_before(:each, :type => :special) do
-                order << :special_append_before_each
-              end
-              config.append_before(:each, :type => :special_child) do
-                order << :special_child_append_before_each
-              end
-              config.append_before(:all, :type => :non_special) do
-                order << :special_append_before_all
-              end
-              config.append_before(:each, :type => :non_special) do
-                order << :special_append_before_each
-              end
-              @example_group.it "calls append_before" do
-              end
-
-              @example_group.run(options)
-              order.should == [
-                :append_before_all,
-                :special_append_before_all,
-                :special_child_append_before_all,
-                :append_before_each,
-                :special_append_before_each,
-                :special_child_append_before_each
-              ]
-            end
-          end
-
-          describe "#prepend_after" do
-
-            it "prepends the after block on all instances of the passed in type" do
-              order = []
-              config.prepend_after(:all) do
-                order << :prepend__after_all
-              end
-              config.prepend_after(:all, :type => :special) do
-                order << :special_prepend__after_all
-              end
-              config.prepend_after(:all, :type => :special) do
-                order << :special_child_prepend__after_all
-              end
-              config.prepend_after(:each) do
-                order << :prepend__after_each
-              end
-              config.prepend_after(:each, :type => :special) do
-                order << :special_prepend__after_each
-              end
-              config.prepend_after(:each, :type => :special) do
-                order << :special_child_prepend__after_each
-              end
-              config.prepend_after(:all, :type => :non_special) do
-                order << :special_prepend__after_all
-              end
-              config.prepend_after(:each, :type => :non_special) do
-                order << :special_prepend__after_each
-              end
-              @example_group.it "calls prepend_after" do
-              end
-
-              @example_group.run(options)
-              order.should == [
-                :special_child_prepend__after_each,
-                :special_prepend__after_each,
-                :prepend__after_each,
-                :special_child_prepend__after_all,
-                :special_prepend__after_all,
-                :prepend__after_all
-              ]
-            end
-          end
-
-          describe "#append_after" do
-
-            it "calls append_after on the type" do
-              order = []
-              config.append_after(:all) do
-                order << :append__after_all
-              end
-              config.append_after(:all, :type => :special) do
-                order << :special_append__after_all
-              end
-              config.append_after(:all, :type => :special_child) do
-                order << :special_child_append__after_all
-              end
-              config.append_after(:each) do
-                order << :append__after_each
-              end
-              config.append_after(:each, :type => :special) do
-                order << :special_append__after_each
-              end
-              config.append_after(:each, :type => :special_child) do
-                order << :special_child_append__after_each
-              end
-              config.append_after(:all, :type => :non_special) do
-                order << :non_special_append_after_all
-              end
-              config.append_after(:each, :type => :non_special) do
-                order << :non_special_append_after_each
-              end
-              @example_group.it "calls append_after" do
-              end
-
-              @example_group.run(options)
-              order.should == [
-                :special_child_append__after_each,
-                :special_append__after_each,
-                :append__after_each,
-                :special_child_append__after_all,
-                :special_append__after_all,
-                :append__after_all
-              ]
-            end
-          end
-        end
-      end
-    end
-  end
-end