messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/spec/rspec/core/hooks_filtering_spec.rb

@@ -1,227 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe "config block hook filtering" do
-    describe "unfiltered hooks" do
-      it "should be ran" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all) { filters << "before all in config"}
-          c.around(:each) {|example| filters << "around each in config"; example.run}
-          c.before(:each) { filters << "before each in config"}
-          c.after(:each) { filters << "after each in config"}
-          c.after(:all) { filters << "after all in config"}
-        end
-        group = ExampleGroup.describe
-        group.example("example") {}
-        group.run
-        filters.should == [
-          "before all in config",
-          "around each in config",
-          "before each in config",
-          "after each in config",
-          "after all in config"
-        ]
-      end
-    end
-
-    describe "hooks with single filters" do
-
-      context "with no scope specified" do
-        it "should be ran around|before|after :each if the filter matches the example group's filter" do
-          filters = []
-          RSpec.configure do |c|
-            c.around(:match => true) {|example| filters << "around each in config"; example.run}
-            c.before(:match => true) { filters << "before each in config"}
-            c.after(:match => true)  { filters << "after each in config"}
-          end
-          group = ExampleGroup.describe(:match => true)
-          group.example("example") {}
-          group.run
-          filters.should == [
-            "around each in config",
-            "before each in config",
-            "after each in config"
-          ]
-        end
-      end
-
-      it "should be ran if the filter matches the example group's filter" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all,  :match => true) { filters << "before all in config"}
-          c.around(:each, :match => true) {|example| filters << "around each in config"; example.run}
-          c.before(:each, :match => true) { filters << "before each in config"}
-          c.after(:each,  :match => true) { filters << "after each in config"}
-          c.after(:all,   :match => true) { filters << "after all in config"}
-        end
-        group = ExampleGroup.describe(:match => true)
-        group.example("example") {}
-        group.run
-        filters.should == [
-          "before all in config",
-          "around each in config",
-          "before each in config",
-          "after each in config",
-          "after all in config"
-        ]
-      end
-
-      it "runs before|after :all hooks on matching nested example groups" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all, :match => true) { filters << :before_all }
-          c.after(:all, :match => true)  { filters << :after_all }
-        end
-
-        example_1_filters = example_2_filters = nil
-
-        group = ExampleGroup.describe "group" do
-          it("example 1") { example_1_filters = filters.dup }
-          describe "subgroup", :match => true do
-            it("example 2") { example_2_filters = filters.dup }
-          end
-        end
-        group.run
-
-        example_1_filters.should be_empty
-        example_2_filters.should == [:before_all]
-        filters.should == [:before_all, :after_all]
-      end
-
-      it "runs before|after :all hooks only on the highest level group that matches the filter" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all, :match => true) { filters << :before_all }
-          c.after(:all, :match => true)  { filters << :after_all }
-        end
-
-        example_1_filters = example_2_filters = example_3_filters = nil
-
-        group = ExampleGroup.describe "group", :match => true do
-          it("example 1") { example_1_filters = filters.dup }
-          describe "subgroup", :match => true do
-            it("example 2") { example_2_filters = filters.dup }
-            describe "sub-subgroup", :match => true do
-              it("example 3") { example_3_filters = filters.dup }
-            end
-          end
-        end
-        group.run
-
-        example_1_filters.should == [:before_all]
-        example_2_filters.should == [:before_all]
-        example_3_filters.should == [:before_all]
-
-        filters.should == [:before_all, :after_all]
-      end
-
-      it "should not be ran if the filter doesn't match the example group's filter" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all,  :match => false) { filters << "before all in config"}
-          c.around(:each, :match => false) {|example| filters << "around each in config"; example.run}
-          c.before(:each, :match => false) { filters << "before each in config"}
-          c.after(:each,  :match => false) { filters << "after each in config"}
-          c.after(:all,   :match => false) { filters << "after all in config"}
-        end
-        group = ExampleGroup.describe(:match => true)
-        group.example("example") {}
-        group.run
-        filters.should == []
-      end
-
-      context "when the hook filters apply to individual examples instead of example groups" do
-        let(:each_filters) { [] }
-        let(:all_filters) { [] }
-
-        let(:group) do
-          md = example_metadata
-          ExampleGroup.describe do
-            it("example", md) { }
-          end
-        end
-
-        def filters
-          each_filters + all_filters
-        end
-
-        before(:each) do
-          af, ef = all_filters, each_filters
-
-          RSpec.configure do |c|
-            c.before(:all,  :foo => :bar) { af << "before all in config"}
-            c.around(:each, :foo => :bar) {|example| ef << "around each in config"; example.run}
-            c.before(:each, :foo => :bar) { ef << "before each in config"}
-            c.after(:each,  :foo => :bar) { ef << "after each in config"}
-            c.after(:all,   :foo => :bar) { af << "after all in config"}
-          end
-
-          group.run
-        end
-
-        describe 'an example with matching metadata' do
-          let(:example_metadata) { { :foo => :bar } }
-
-          it "runs the `:each` hooks" do
-            each_filters.should == [
-              'around each in config',
-              'before each in config',
-              'after each in config'
-            ]
-          end
-
-          it "does not run the `:all` hooks" do
-            all_filters.should be_empty
-          end
-        end
-
-        describe 'an example without matching metadata' do
-          let(:example_metadata) { { :foo => :bazz } }
-
-          it "does not run any of the hooks" do
-            filters.should be_empty
-          end
-        end
-      end
-    end
-
-    describe "hooks with multiple filters" do
-      it "should be ran if all hook filters match the group's filters" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all,  :one => 1)                         { filters << "before all in config"}
-          c.around(:each, :two => 2, :one => 1)              {|example| filters << "around each in config"; example.run}
-          c.before(:each, :one => 1, :two => 2)              { filters << "before each in config"}
-          c.after(:each,  :one => 1, :two => 2, :three => 3) { filters << "after each in config"}
-          c.after(:all,   :one => 1, :three => 3)            { filters << "after all in config"}
-        end
-        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
-        group.example("example") {}
-        group.run
-        filters.should == [
-          "before all in config",
-          "around each in config",
-          "before each in config",
-          "after each in config",
-          "after all in config"
-        ]
-      end
-
-      it "should not be ran if some hook filters don't match the group's filters" do
-        filters = []
-        RSpec.configure do |c|
-          c.before(:all,  :one => 1, :four => 4)                         { filters << "before all in config"}
-          c.around(:each, :two => 2, :four => 4)                         {|example| filters << "around each in config"; example.run}
-          c.before(:each, :one => 1, :two => 2, :four => 4)              { filters << "before each in config"}
-          c.after(:each,  :one => 1, :two => 2, :three => 3, :four => 4) { filters << "after each in config"}
-          c.after(:all,   :one => 1, :three => 3, :four => 4)            { filters << "after all in config"}
-        end
-        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
-        group.example("example") {}
-        group.run
-        filters.should == []
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/spec/rspec/core/hooks_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe Hooks do
-    describe "#around" do
-      context "when not running the example within the around block" do
-        it "does not run the example" do
-          examples = []
-          group = ExampleGroup.describe do
-            around do |example|
-            end
-            it "foo" do
-              examples << self
-            end
-          end
-          group.run
-          examples.should have(0).example
-        end
-      end
-
-      context "when running the example within the around block" do
-        it "runs the example" do
-          examples = []
-          group = ExampleGroup.describe do
-            around do |example|
-              example.run
-            end
-            it "foo" do
-              examples << self
-            end
-          end
-          group.run
-          examples.should have(1).example
-        end
-      end
-
-      context "when running the example within a block passed to a method" do
-        it "runs the example" do
-          examples = []
-          group = ExampleGroup.describe do
-            def yielder
-              yield
-            end
-            around do |example|
-              yielder { example.run }
-            end
-            it "foo" do
-              examples << self
-            end
-          end
-          group.run
-          examples.should have(1).example
-        end
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/spec/rspec/core/kernel_extensions_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "extensions" do
-  describe "debugger" do
-    it "is defined on Kernel" do
-      Kernel.should respond_to(:debugger)
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/spec/rspec/core/let_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe "#let" do
-  let(:counter) do
-    Class.new do
-      def initialize
-        @count = 0
-      end
-      def count
-        @count += 1
-      end
-    end.new
-  end
-
-  it "generates an instance method" do
-    counter.count.should == 1
-  end
-
-  it "caches the value" do
-    counter.count.should == 1
-    counter.count.should == 2
-  end
-end
-
-describe "#let!" do
-  let!(:creator) do
-    class Creator
-      @count = 0
-      def self.count
-        @count += 1
-      end
-    end
-  end
-
-  it "evaluates the value non-lazily" do
-    lambda { Creator.count }.should_not raise_error
-  end
-
-  it "does not interfere between tests" do
-    Creator.count.should == 1
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/spec/rspec/core/metadata_spec.rb

@@ -1,298 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Core
-    describe Metadata do
-
-      describe "#process" do
-        Metadata::RESERVED_KEYS.each do |key|
-          it "prohibits :#{key} as a hash key" do
-            m = Metadata.new
-            expect do
-              m.process('group', key => {})
-            end.to raise_error(/:#{key} is not allowed/)
-          end
-        end
-
-        it "uses :caller if passed as part of the user metadata" do
-          m = Metadata.new
-          m.process('group', :caller => ['example_file:42'])
-          m[:example_group][:location].should == 'example_file:42'
-        end
-      end
-
-      describe "#apply_condition" do
-
-        let(:parent_group_metadata) { Metadata.new.process('parent group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
-        let(:parent_group_line_number) { parent_group_metadata[:example_group][:line_number] }
-        let(:group_metadata) { Metadata.new(parent_group_metadata).process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
-        let(:group_line_number) { group_metadata[:example_group][:line_number] }
-        let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"], :if => true) }
-        let(:example_line_number) { example_metadata[:line_number] }
-        let(:next_example_metadata) { group_metadata.for_example('next_example', :caller => ["foo_spec.rb:#{example_line_number + 2}"]) }
-        let(:world) { World.new }
-
-        before { RSpec.stub(:world) { world } }
-
-        it "matches the group when the line_number is the example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(group_line_number)
-          # this call doesn't really make sense since apply_condition is only called
-          # for example metadata not group metadata
-          group_metadata.apply_condition(:line_number, group_line_number).should be_true
-        end
-
-        it "matches the example when the line_number is the grandparent example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(parent_group_line_number)
-          example_metadata.apply_condition(:line_number, parent_group_line_number).should be_true
-        end
-
-        it "matches the example when the line_number is the parent example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(group_line_number)
-          example_metadata.apply_condition(:line_number, group_line_number).should be_true
-        end
-
-        it "matches the example when the line_number is the example line number" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number)
-          example_metadata.apply_condition(:line_number, example_line_number).should be_true
-        end
-
-        it "matches when the line number is between this example and the next" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number)
-          example_metadata.apply_condition(:line_number, example_line_number + 1).should be_true
-        end
-
-        it "does not match when the line number matches the next example" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number + 2)
-          example_metadata.apply_condition(:line_number, example_line_number + 2).should be_false
-        end
-
-        it "matches a proc that evaluates to true" do
-          example_metadata.apply_condition(:if, lambda { |v| v }).should be_true
-        end
-
-        it "does not match a proc that evaluates to false" do
-          example_metadata.apply_condition(:if, lambda { |v| !v }).should be_false
-        end
-
-        it "passes the metadata hash as the second argument if a given proc expects 2 args" do
-          passed_metadata = nil
-          example_metadata.apply_condition(:if, lambda { |v, m| passed_metadata = m })
-          passed_metadata.should == example_metadata
-        end
-      end
-
-      describe "#for_example" do
-        let(:metadata)           { Metadata.new.process("group description") }
-        let(:mfe)                { metadata.for_example("example description", {:arbitrary => :options}) }
-        let(:line_number)        { __LINE__ - 1 }
-
-        it "stores the description" do
-          mfe[:description].should == "example description"
-        end
-
-        it "stores the full_description (group description + example description)" do
-          mfe[:full_description].should == "group description example description"
-        end
-
-        it "creates an empty execution result" do
-          mfe[:execution_result].should == {}
-        end
-
-        it "extracts file path from caller" do
-          mfe[:file_path].should == __FILE__
-        end
-
-        it "extracts line number from caller" do
-          mfe[:line_number].should == line_number
-        end
-
-        it "extracts location from caller" do
-          mfe[:location].should == "#{__FILE__}:#{line_number}"
-        end
-
-        it "uses :caller if passed as an option" do
-          example_metadata = metadata.for_example('example description', {:caller => ['example_file:42']})
-          example_metadata[:location].should == 'example_file:42'
-        end
-
-        it "merges arbitrary options" do
-          mfe[:arbitrary].should == :options
-        end
-
-        it "points :example_group to the same hash object" do
-          a = metadata.for_example("foo", {})[:example_group]
-          b = metadata.for_example("bar", {})[:example_group]
-          a[:description] = "new description"
-          b[:description].should == "new description"
-        end
-      end
-
-      describe ":describes" do
-        context "with a String" do
-          it "returns nil" do
-            m = Metadata.new
-            m.process('group')
-
-            m = m.for_example("example", {})
-            m[:example_group][:describes].should be_nil
-          end
-        end
-
-        context "with a Symbol" do
-          it "returns nil" do
-            m = Metadata.new
-            m.process(:group)
-
-            m = m.for_example("example", {})
-            m[:example_group][:describes].should be_nil
-          end
-        end
-
-        context "with a class" do
-          it "returns the class" do
-            m = Metadata.new
-            m.process(String)
-
-            m = m.for_example("example", {})
-            m[:example_group][:describes].should be(String)
-          end
-        end
-
-        context "with describes from a superclass metadata" do
-          it "returns the superclass' described class" do
-            sm = Metadata.new
-            sm.process(String)
-
-            m = Metadata.new(sm)
-            m.process(Array)
-
-            m = m.for_example("example", {})
-            m[:example_group][:describes].should be(String)
-          end
-        end
-      end
-
-      describe ":description" do
-        it "just has the example description" do
-          m = Metadata.new
-          m.process('group')
-
-          m = m.for_example("example", {})
-          m[:description].should == "example"
-        end
-
-        context "with a string" do
-          it "provides the submitted description" do
-            m = Metadata.new
-            m.process('group')
-
-            m[:example_group][:description].should == "group"
-          end
-        end
-
-        context "with a non-string" do
-          it "provides the submitted description" do
-            m = Metadata.new
-            m.process('group')
-
-            m[:example_group][:description].should == "group"
-          end
-        end
-
-        context "with a non-string and a string" do
-          it "concats the args" do
-            m = Metadata.new
-            m.process(Object, 'group')
-
-            m[:example_group][:description].should == "Object group"
-          end
-        end
-      end
-
-      describe ":full_description" do
-        it "concats example group name and description" do
-          group_metadata = Metadata.new
-          group_metadata.process('group')
-
-          example_metadata = group_metadata.for_example("example", {})
-          example_metadata[:full_description].should == "group example"
-        end
-
-        it "concats nested example group descriptions" do
-          parent = Metadata.new
-          parent.process(Object, 'parent')
-
-          child = Metadata.new(parent)
-          child.process('child')
-
-          child[:example_group][:full_description].should == "Object parent child"
-        end
-
-        %w[# . ::].each do |char|
-          context "with a 2nd arg starting with #{char}" do
-          it "removes the space" do
-            m = Metadata.new
-            m.process(Array, "#{char}method")
-            m[:example_group][:full_description].should eq("Array#{char}method")
-          end
-          end
-        end
-
-        %w[# . ::].each do |char|
-          context "with a nested description starting with #{char}" do
-          it "removes the space" do
-            parent = Metadata.new
-            parent.process("Object")
-            child = Metadata.new(parent)
-            child.process("#{char}method")
-            child[:example_group][:full_description].should eq("Object#{char}method")
-          end
-          end
-        end
-      end
-
-      describe ":file_path" do
-        it "finds the first non-rspec lib file in the caller array" do
-          m = Metadata.new
-          m.process(:caller => [
-                    "./lib/rspec/core/foo.rb",
-                    "#{__FILE__}:#{__LINE__}"
-          ])
-          m[:example_group][:file_path].should == __FILE__
-        end
-      end
-
-      describe ":line_number" do
-        it "finds the line number with the first non-rspec lib file in the backtrace" do
-          m = Metadata.new
-          m.process({})
-          m[:example_group][:line_number].should == __LINE__ - 1
-        end
-
-        it "finds the line number with the first spec file with drive letter" do
-          m = Metadata.new
-          m.process(:caller => [ "C:/path/to/file_spec.rb:#{__LINE__}" ])
-          m[:example_group][:line_number].should == __LINE__ - 1
-        end
-
-        it "uses the number after the first : for ruby 1.9" do
-          m = Metadata.new
-          m.process(:caller => [ "#{__FILE__}:#{__LINE__}:999" ])
-          m[:example_group][:line_number].should == __LINE__ - 1
-        end
-      end
-
-      describe "child example group" do
-        it "nests the parent's example group metadata" do
-          parent = Metadata.new
-          parent.process(Object, 'parent')
-
-          child = Metadata.new(parent)
-          child.process()
-
-          child[:example_group][:example_group].should == parent[:example_group]
-        end
-      end
-    end
-  end
-end