gem_repackager 0.1.0

data/support/gems/rspec-core-2.11.1/spec/rspec/core/example_spec.rb

@@ -0,0 +1,370 @@
+require 'spec_helper'
+
+describe RSpec::Core::Example, :parent_metadata => 'sample' do
+  let(:example_group) do
+    RSpec::Core::ExampleGroup.describe('group description')
+  end
+
+  let(:example_instance) do
+    example_group.example('example description')
+  end
+
+  it_behaves_like "metadata hash builder" do
+    def metadata_hash(*args)
+      example = example_group.example('example description', *args)
+      example.metadata
+    end
+  end
+
+  describe "#exception" do
+    it "supplies the first exception raised, if any" do
+      example = example_group.example { raise "first" }
+      example_group.after { raise "second" }
+      example_group.run
+      example.exception.message.should eq("first")
+    end
+
+    it "returns nil if there is no exception" do
+      example = example_group.example('example') { }
+      example_group.run
+      example.exception.should be_nil
+    end
+
+    it "returns false for pending_fixed? if not pending fixed" do
+      example = example_group.example { fail }
+      example_group.run
+      example.exception.should_not be_pending_fixed
+    end
+
+    it "returns true for pending_fixed? if pending fixed" do
+      example = example_group.example do
+        pending("fixed") {}
+      end
+      example_group.run
+      example.exception.should be_pending_fixed
+    end
+  end
+
+  describe "when there is no explicit description" do
+    def expect_with(*frameworks)
+      RSpec.configuration.stub(:expecting_with_rspec?).and_return(frameworks.include?(:rspec))
+
+      if frameworks.include?(:stdlib)
+        example_group.class_eval do
+          def assert(val)
+            raise "Expected #{val} to be true" unless val
+          end
+        end
+      end
+    end
+
+    context "when `expect_with :rspec` is configured" do
+      before(:each) { expect_with :rspec }
+
+      it "uses the matcher-generated description" do
+        example_group.example { 5.should eq(5) }
+        example_group.run
+        example_group.examples.first.description.should eq("should eq 5")
+      end
+
+      it "uses the file and line number if there is no matcher-generated description" do
+        example = example_group.example {}
+        example_group.run
+        example.description.should match(/example at #{relative_path(__FILE__)}:#{__LINE__ - 2}/)
+      end
+
+      it "uses the file and line number if there is an error before the matcher" do
+        example = example_group.example { 5.should eq(5) }
+        example_group.before { raise }
+        example_group.run
+        example.description.should match(/example at #{relative_path(__FILE__)}:#{__LINE__ - 3}/)
+      end
+    end
+
+    context "when `expect_with :rspec, :stdlib` is configured" do
+      before(:each) { expect_with :rspec, :stdlib }
+
+      it "uses the matcher-generated description" do
+        example_group.example { 5.should eq(5) }
+        example_group.run
+        example_group.examples.first.description.should eq("should eq 5")
+      end
+
+      it "uses the file and line number if there is no matcher-generated description" do
+        example = example_group.example {}
+        example_group.run
+        example.description.should match(/example at #{relative_path(__FILE__)}:#{__LINE__ - 2}/)
+      end
+
+      it "uses the file and line number if there is an error before the matcher" do
+        example = example_group.example { 5.should eq(5) }
+        example_group.before { raise }
+        example_group.run
+        example.description.should match(/example at #{relative_path(__FILE__)}:#{__LINE__ - 3}/)
+      end
+    end
+
+    context "when `expect_with :stdlib` is configured" do
+      before(:each) { expect_with :stdlib }
+
+      it "does not attempt to get the generated description from RSpec::Matchers" do
+        RSpec::Matchers.should_not_receive(:generated_description)
+        example_group.example { assert 5 == 5 }
+        example_group.run
+      end
+
+      it "uses the file and line number" do
+        example = example_group.example { assert 5 == 5 }
+        example_group.run
+        example.description.should match(/example at #{relative_path(__FILE__)}:#{__LINE__ - 2}/)
+      end
+    end
+  end
+
+  describe '#described_class' do
+    it "returns the class (if any) of the outermost example group" do
+      described_class.should eq(RSpec::Core::Example)
+    end
+  end
+
+  describe "accessing metadata within a running example" do
+    it "has a reference to itself when running" do
+      example.description.should eq("has a reference to itself when running")
+    end
+
+    it "can access the example group's top level metadata as if it were its own" do
+      example.example_group.metadata.should include(:parent_metadata => 'sample')
+      example.metadata.should include(:parent_metadata => 'sample')
+    end
+  end
+
+  describe "accessing options within a running example" do
+    it "can look up option values by key", :demo => :data do
+      example.metadata[:demo].should eq(:data)
+    end
+  end
+
+  describe "#run" do
+    it "sets its reference to the example group instance to nil" do
+      group = RSpec::Core::ExampleGroup.describe do
+        example('example') { 1.should eq(1) }
+      end
+      group.run
+      group.examples.first.instance_variable_get("@example_group_instance").should be_nil
+    end
+
+    it "runs after(:each) when the example passes" do
+      after_run = false
+      group = RSpec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { 1.should eq(1) }
+      end
+      group.run
+      after_run.should be_true, "expected after(:each) to be run"
+    end
+
+    it "runs after(:each) when the example fails" do
+      after_run = false
+      group = RSpec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { 1.should eq(2) }
+      end
+      group.run
+      after_run.should be_true, "expected after(:each) to be run"
+    end
+
+    it "runs after(:each) when the example raises an Exception" do
+      after_run = false
+      group = RSpec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { raise "this error" }
+      end
+      group.run
+      after_run.should be_true, "expected after(:each) to be run"
+    end
+
+    context "with an after(:each) that raises" do
+      it "runs subsequent after(:each)'s" do
+        after_run = false
+        group = RSpec::Core::ExampleGroup.describe do
+          after(:each) { after_run = true }
+          after(:each) { raise "FOO" }
+          example('example') { 1.should eq(1) }
+        end
+        group.run
+        after_run.should be_true, "expected after(:each) to be run"
+      end
+
+      it "stores the exception" do
+        group = RSpec::Core::ExampleGroup.describe
+        group.after(:each) { raise "FOO" }
+        example = group.example('example') { 1.should eq(1) }
+
+        group.run
+
+        example.metadata[:execution_result][:exception].message.should eq("FOO")
+      end
+    end
+
+    it "wraps before/after(:each) inside around" do
+      results = []
+      group = RSpec::Core::ExampleGroup.describe do
+        around(:each) do |e|
+          results << "around (before)"
+          e.run
+          results << "around (after)"
+        end
+        before(:each) { results << "before" }
+        after(:each) { results << "after" }
+        example { results << "example" }
+      end
+
+      group.run
+      results.should eq([
+        "around (before)",
+        "before",
+        "example",
+        "after",
+        "around (after)"
+      ])
+    end
+
+    context "clearing ivars" do
+      it "sets ivars to nil to prep them for GC" do
+        group = RSpec::Core::ExampleGroup.describe do
+          before(:all)  { @before_all  = :before_all }
+          before(:each) { @before_each = :before_each }
+          after(:each)  { @after_each = :after_each }
+          after(:all)   { @after_all  = :after_all }
+        end
+        group.example("does something") do
+          @before_all.should eq(:before_all)
+          @before_each.should eq(:before_each)
+        end
+        group.run(double.as_null_object).should be_true
+        group.new do |example|
+          %w[@before_all @before_each @after_each @after_all].each do |ivar|
+            example.instance_variable_get(ivar).should be_nil
+          end
+        end
+      end
+
+      it "does not impact the before_all_ivars which are copied to each example" do
+        group = RSpec::Core::ExampleGroup.describe do
+          before(:all) { @before_all = "abc" }
+          example("first") { @before_all.should_not be_nil }
+          example("second") { @before_all.should_not be_nil }
+        end
+        group.run.should be_true
+      end
+    end
+
+    context 'when the example raises an error' do
+      def run_and_capture_reported_message(group)
+        reported_msg = nil
+        # We can't use should_receive(:message).with(/.../) here,
+        # because if that fails, it would fail within our example-under-test,
+        # and since there's already two errors, it would just be reported again.
+        RSpec.configuration.reporter.stub(:message) { |msg| reported_msg = msg }
+        group.run
+        reported_msg
+      end
+
+      it "prints any around hook errors rather than silencing them" do
+        group = RSpec::Core::ExampleGroup.describe do
+          around(:each) { |e| e.run; raise "around" }
+          example("e") { raise "example" }
+        end
+
+        message = run_and_capture_reported_message(group)
+        message.should =~ /An error occurred in an around.* hook/i
+      end
+
+      it "prints any after hook errors rather than silencing them" do
+        group = RSpec::Core::ExampleGroup.describe do
+          after(:each) { raise "after" }
+          example("e") { raise "example" }
+        end
+
+        message = run_and_capture_reported_message(group)
+        message.should =~ /An error occurred in an after.* hook/i
+      end
+
+      it 'does not print mock expectation errors' do
+        group = RSpec::Core::ExampleGroup.describe do
+          example do
+            foo = mock
+            foo.should_receive(:bar)
+            raise "boom"
+          end
+        end
+
+        message = run_and_capture_reported_message(group)
+        message.should be_nil
+      end
+    end
+  end
+
+  describe "#pending" do
+    context "in the example" do
+      it "sets the example to pending" do
+        group = RSpec::Core::ExampleGroup.describe do
+          example { pending }
+        end
+        group.run
+        group.examples.first.should be_pending
+      end
+
+      it "allows post-example processing in around hooks (see https://github.com/rspec/rspec-core/issues/322)" do
+        blah = nil
+        group = RSpec::Core::ExampleGroup.describe do
+          around do |example|
+            example.run
+            blah = :success
+          end
+          example { pending }
+        end
+        group.run
+        blah.should be(:success)
+      end
+    end
+      
+    context "in before(:each)" do
+      it "sets each example to pending" do
+        group = RSpec::Core::ExampleGroup.describe do
+          before(:each) { pending }
+          example {}
+          example {}
+        end
+        group.run
+        group.examples.first.should be_pending
+        group.examples.last.should be_pending
+      end
+    end
+
+    context "in before(:all)" do
+      it "sets each example to pending" do
+        group = RSpec::Core::ExampleGroup.describe do
+          before(:all) { pending }
+          example {}
+          example {}
+        end
+        group.run
+        group.examples.first.should be_pending
+        group.examples.last.should be_pending
+      end
+    end
+
+    context "in around(:each)" do
+      it "sets the example to pending" do
+        group = RSpec::Core::ExampleGroup.describe do
+          around(:each) { pending }
+          example {}
+        end
+        group.run
+        group.examples.first.should be_pending
+      end
+    end
+
+  end
+end

data/support/gems/rspec-core-2.11.1/spec/rspec/core/filter_manager_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+module RSpec::Core
+  describe FilterManager do
+    def opposite(name)
+      name =~ /^in/ ? name.sub(/^(in)/,'ex') : name.sub(/^(ex)/,'in')
+    end
+
+    %w[include inclusions exclude exclusions].each_slice(2) do |name, type|
+      describe "##{name}" do
+        it "merges #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => :bar
+          filter_manager.send name, :baz => :bam
+          filter_manager.send(type).should eq(:foo => :bar, :baz => :bam)
+        end
+
+        it "overrides previous #{type} with (via merge)" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send name, :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send name, :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should be_empty
+        end
+      end
+
+      describe "##{name}!" do
+        it "replaces existing #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1, :bar => 2
+          filter_manager.send "#{name}!", :foo => 3
+          filter_manager.send(type).should eq(:foo => 3)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}!", :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should be_empty
+        end
+      end
+
+      describe "##{name}_with_low_priority" do
+        it "ignores new #{type} if same key exists" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          filter_manager.send(type).should eq(:foo => 1)
+        end
+
+        it "ignores new #{type} if same key exists in opposite" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 1
+          filter_manager.send(type).should be_empty
+          filter_manager.send(opposite(type)).should eq(:foo => 1)
+        end
+
+        it "keeps new #{type} if same key exists in opposite but values are different" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should eq(:foo => 1)
+        end
+      end
+    end
+
+    describe "#prune" do
+      def filterable_object_with(args = {})
+        object = double('a filterable object')
+        object.stub(:any_apply?) { |f| Metadata.new(args).any_apply?(f) }
+        object
+      end
+
+      it "includes objects with tags matching inclusions" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+
+      it "excludes objects with tags matching exclusions" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+
+      it "prefers exclusion when matches previously set inclusion" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        filter_manager.exclude :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+
+      it "prefers inclusion when matches previously set exclusion" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.include :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+
+      it "prefers previously set inclusion when exclusion matches but has lower priority" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        filter_manager.exclude_with_low_priority :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+
+      it "prefers previously set exclusion when inclusion matches but has lower priority" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.include_with_low_priority :foo => :bar
+        filter_manager.prune([included, excluded]).should eq([included])
+      end
+    end
+
+    describe "#inclusions#description" do
+      it 'cleans up the description' do
+        project_dir = File.expand_path('.')
+        lambda { }.inspect.should include(project_dir)
+        lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+        lambda { }.inspect.should include('0x')
+
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => lambda { }
+
+        filter_manager.inclusions.description.should_not include(project_dir)
+        filter_manager.inclusions.description.should_not include(' (lambda)')
+        filter_manager.inclusions.description.should_not include('0x')
+      end
+    end
+
+    describe "#exclusions#description" do
+      it 'cleans up the description' do
+        project_dir = File.expand_path('.')
+        lambda { }.inspect.should include(project_dir)
+        lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+        lambda { }.inspect.should include('0x')
+
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => lambda { }
+
+        filter_manager.exclusions.description.should_not include(project_dir)
+        filter_manager.exclusions.description.should_not include(' (lambda)')
+        filter_manager.exclusions.description.should_not include('0x')
+      end
+
+      it 'returns `{}` when it only contains the default filters' do
+        filter_manager = FilterManager.new
+        filter_manager.exclusions.description.should eq({}.inspect)
+      end
+
+      it 'includes other filters' do
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.exclusions.description.should eq({ :foo => :bar }.inspect)
+      end
+
+      it 'deprecates an overridden :if filter' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:if.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :if => :custom_filter
+      end
+
+      it 'deprecates an :if filter overridden with low priority' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:if.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :if => :custom_filter
+      end
+
+      it 'deprecates an overridden :unless filter' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:unless.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :unless => :custom_filter
+      end
+
+      it 'deprecates an :unless filter overridden with low priority' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:unless.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :unless => :custom_filter
+      end
+
+      it 'includes an overriden :if filter' do
+        RSpec.stub(:warn_deprecation)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :if => :custom_filter
+        filter_manager.exclusions.description.should eq({ :if => :custom_filter }.inspect)
+      end
+
+      it 'includes an overriden :unless filter' do
+        RSpec.stub(:warn_deprecation)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :unless => :custom_filter
+        filter_manager.exclusions.description.should eq({ :unless => :custom_filter }.inspect)
+      end
+    end
+
+    it "clears the inclusion filter on include :line_numbers" do
+      filter_manager = FilterManager.new
+      filter_manager.include :foo => :bar
+      filter_manager.include :line_numbers => [100]
+      filter_manager.inclusions.should eq(:line_numbers => [100])
+    end
+
+    it "clears the inclusion filter on include :locations" do
+      filter_manager = FilterManager.new
+      filter_manager.include :foo => :bar
+      filter_manager.include :locations => { "path/to/file.rb" => [37] }
+      filter_manager.inclusions.should eq(:locations => { "path/to/file.rb" => [37] })
+    end
+
+    it "clears the inclusion filter on include :full_description" do
+      filter_manager = FilterManager.new
+      filter_manager.include :foo => :bar
+      filter_manager.include :full_description => "this and that"
+      filter_manager.inclusions.should eq(:full_description => "this and that")
+    end
+
+    [:locations, :line_numbers, :full_description].each do |filter|
+      it "does nothing on include if already set standalone filter #{filter}" do
+        filter_manager = FilterManager.new
+        filter_manager.include filter => "a_value"
+        filter_manager.include :foo => :bar
+        filter_manager.inclusions.should eq(filter => "a_value")
+      end
+    end
+  end
+end