messagebus_ruby_api 0.4.0 → 0.4.4

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe RSpec::Core::SharedContext do
+  describe "hooks" do
+    it "creates a before hook" do
+      before_all_hook = false
+      before_each_hook = false
+      after_each_hook = false
+      after_all_hook = false
+      shared = Module.new do
+        extend RSpec::Core::SharedContext
+        before(:all) { before_all_hook = true }
+        before(:each) { before_each_hook = true }
+        after(:each)  { after_each_hook = true }
+        after(:all)  { after_all_hook = true }
+      end
+      group = RSpec::Core::ExampleGroup.describe do
+        include shared
+        example { }
+      end
+
+      group.run
+
+      before_all_hook.should be_true
+      before_each_hook.should be_true
+      after_each_hook.should be_true
+      after_all_hook.should be_true
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+module RSpec::Core
+
+  describe SharedExampleGroup do
+
+    %w[share_examples_for shared_examples_for].each do |method_name|
+      describe method_name do
+
+        it "is exposed to the global namespace" do
+          Kernel.should respond_to(method_name)
+        end
+
+        it "raises an ArgumentError when adding a second shared example group with the same name" do
+          group = ExampleGroup.describe('example group')
+          group.send(method_name, 'shared group') {}
+          lambda do
+            group.send(method_name, 'shared group') {}
+          end.should raise_error(ArgumentError, "Shared example group 'shared group' already exists")
+        end
+
+        it "captures the given name and block in the Worlds collection of shared example groups" do
+          implementation = lambda {}
+          RSpec.world.shared_example_groups.should_receive(:[]=).with(:foo, implementation)
+          send(method_name, :foo, &implementation)
+        end
+
+      end
+    end
+
+    describe "#share_as" do
+      it "is exposed to the global namespace" do
+        Kernel.should respond_to("share_as")
+      end
+
+      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
+        share_as('Cornucopia') do
+          it "is plentiful" do
+            5.should == 4
+          end
+        end
+        group = ExampleGroup.describe('group') { include Cornucopia }
+        phantom_group = group.children.first
+        phantom_group.description.should eql("")
+        phantom_group.metadata[:shared_group_name].should eql('Cornucopia')
+        phantom_group.examples.length.should == 1
+        phantom_group.examples.first.metadata[:description].should == "is plentiful"
+      end
+    end
+
+    describe "#it_should_behave_like" do
+      it "creates a nested group" do
+        shared_examples_for("thing") {}
+        group = ExampleGroup.describe('fake group')
+        group.it_should_behave_like("thing")
+        group.should have(1).children
+      end
+
+      it "adds shared examples to nested group" do
+        shared_examples_for("thing") do
+          it("does something")
+        end
+        group = ExampleGroup.describe('fake group')
+        shared_group = group.it_should_behave_like("thing")
+        shared_group.should have(1).examples
+      end
+
+      it "adds shared instance methods to nested group" do
+        shared_examples_for("thing") do
+          def foo; end
+        end
+        group = ExampleGroup.describe('fake group')
+        shared_group = group.it_should_behave_like("thing")
+        shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
+      end
+
+      it "adds shared class methods to nested group" do
+        shared_examples_for("thing") do
+          def self.foo; end
+        end
+        group = ExampleGroup.describe('fake group')
+        shared_group = group.it_should_behave_like("thing")
+        shared_group.methods.map{|m| m.to_s}.should include("foo")
+      end
+
+      context "given some parameters" do
+        it "passes the parameters to the shared example group" do
+          passed_params = {}
+
+          shared_examples_for("thing") do |param1, param2|
+            it("has access to the given parameters") do
+              passed_params[:param1] = param1
+              passed_params[:param2] = param2
+            end
+          end
+
+          group = ExampleGroup.describe("group") do
+            it_should_behave_like "thing", :value1, :value2
+          end
+          group.run
+
+          passed_params.should == { :param1 => :value1, :param2 => :value2 }
+        end
+
+        it "adds shared instance methods to nested group" do
+          shared_examples_for("thing") do |param1|
+            def foo; end
+          end
+          group = ExampleGroup.describe('fake group')
+          shared_group = group.it_should_behave_like("thing", :a)
+          shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
+        end
+
+        it "evals the shared example group only once" do
+          eval_count = 0
+          shared_examples_for("thing") { |p| eval_count += 1 }
+          group = ExampleGroup.describe('fake group')
+          shared_group = group.it_should_behave_like("thing", :a)
+          eval_count.should == 1
+        end
+      end
+
+      context "given a block" do
+        it "evaluates the block in nested group" do
+          scopes = []
+          shared_examples_for("thing") do
+            it("gets run in the nested group") do
+              scopes << self.class
+            end
+          end
+          group = ExampleGroup.describe("group") do
+            it_should_behave_like "thing" do
+              it("gets run in the same nested group") do
+                scopes << self.class
+              end
+            end
+          end
+          group.run
+
+          scopes[0].should be(scopes[1])
+        end
+      end
+
+      it "raises when named shared example_group can not be found" do
+        group = ExampleGroup.describe("example_group")
+        lambda do
+          group.it_should_behave_like("a group that does not exist")
+        end.should raise_error(/Could not find shared example group named/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+module RSpec::Core
+
+  describe Subject do
+
+    describe "implicit subject" do
+      describe "with a class" do
+        it "returns an instance of the class" do
+          ExampleGroup.describe(Array).subject.call.should == []
+        end
+      end
+
+      describe "with a Module" do
+        it "returns the Module" do
+          ExampleGroup.describe(Enumerable).subject.call.should == Enumerable
+        end
+      end
+
+      describe "with a string" do
+        it "return the string" do
+          ExampleGroup.describe("Foo").subject.call.should == 'Foo'
+        end
+      end
+
+      describe "with a number" do
+        it "returns the number" do
+          ExampleGroup.describe(15).subject.call.should == 15
+        end
+      end
+
+    end
+
+    describe "explicit subject" do
+      [false, nil].each do |falsy_value|
+        context "with a value of #{falsy_value.inspect}" do
+          it "is evaluated once per example" do
+            group = ExampleGroup.describe(Array)
+            group.before do
+              Object.should_receive(:this_question?).once.and_return(falsy_value)
+            end
+            group.subject do
+              Object.this_question?
+            end
+            group.example do
+              subject
+              subject
+            end
+            group.run.should be_true, "expected subject block to be evaluated only once"
+          end
+        end
+      end
+
+      describe "defined in a top level group" do
+        it "replaces the implicit subject in that group" do
+          group = ExampleGroup.describe(Array)
+          group.subject { [1,2,3] }
+          group.subject.call.should == [1,2,3]
+        end
+      end
+
+      describe "defined in a top level group" do
+        let(:group) do
+          ExampleGroup.describe do
+            subject{ [4,5,6] }
+          end
+        end
+
+        it "is available in a nested group (subclass)" do
+          nested_group = group.describe("I'm nested!") { }
+          nested_group.subject.call.should == [4,5,6]
+        end
+
+        it "is available in a doubly nested group (subclass)" do
+          nested_group = group.describe("Nesting level 1") { }
+          doubly_nested_group = nested_group.describe("Nesting level 2") { }
+          doubly_nested_group.subject.call.should == [4,5,6]
+        end
+      end
+    end
+
+    context "using 'self' as an explicit subject" do
+      it "delegates matcher to the ExampleGroup" do
+        group = ExampleGroup.describe("group") do
+          subject { self }
+          def ok?; true; end
+
+          it { should eq(self) }
+          it { should be_ok }
+        end
+
+        group.run.should be_true
+      end
+    end
+
+    describe "#its" do
+      subject do
+        Class.new do
+          def initialize
+            @call_count = 0
+          end
+
+          def call_count
+            @call_count += 1
+          end
+        end.new
+      end
+
+      context "with a call counter" do
+        its(:call_count) { should eq(1) }
+      end
+
+      context "with nil value" do
+        subject do
+          Class.new do
+            def nil_value
+              nil
+            end
+          end.new
+        end
+        its(:nil_value) { should be_nil }
+      end
+
+      context "with nested attributes" do
+        subject do
+          Class.new do
+            def name
+              "John"
+            end
+          end.new
+        end
+        its("name")            { should eq("John") }
+        its("name.size")       { should eq(4) }
+        its("name.size.class") { should eq(Fixnum) }
+      end
+
+      context "when it is a Hash" do
+        subject do
+          { :attribute => 'value',
+            'another_attribute' => 'another_value' }
+        end
+        its([:attribute]) { should == 'value' }
+        its([:attribute]) { should_not == 'another_value' }
+        its([:another_attribute]) { should == 'another_value' }
+        its([:another_attribute]) { should_not == 'value' }
+        its(:keys) { should =~ ['another_attribute', :attribute] }
+        context "when referring to an attribute without the proper array syntax" do
+          context "it raises an error" do
+            its(:attribute) do
+              expect do
+                should eq('value')
+              end.to raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+
+      context "calling and overriding super" do
+        it "calls to the subject defined in the parent group" do
+          group = ExampleGroup.describe(Array) do
+            subject { [1, 'a'] }
+
+            its(:last) { should == 'a' }
+
+            describe '.first' do
+              def subject; super().first; end
+
+              its(:next) { should == 2 }
+            end
+          end
+
+          group.run.should be_true
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module RSpec::Core
+
+  describe World do
+    let(:world) { RSpec::Core::World.new }
+
+    describe "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        world.example_groups.should include(group)
+      end
+    end
+
+    describe "#apply_inclusion_filters" do
+      let(:group1) { 
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-1", 
+          { :foo => 1, :color => 'blue', :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group2) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-2",
+          { :pending => true, :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group3) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-3", 
+          { :array => [1,2,3,4], :color => 'blue' }
+        ) {}
+      }
+
+      let(:group4) {
+        RSpec::Core::ExampleGroup.describe(Foo, "find these examples") do
+          it('I have no options') {}
+          it("this is awesome", :awesome => true) {}
+          it("this is too", :awesome => true) {}
+          it("not so awesome", :awesome => false) {}
+          it("I also have no options") {}
+        end
+      }
+      
+      let(:example_groups) { [group1, group2, group3, group4] }
+
+      it "finds no groups when given no search parameters" do
+        world.apply_inclusion_filters([]).should == []
+      end
+
+      it "finds matching groups when filtering on :describes (described class or module)" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :describes => Bar }).should == [group1, group2, group3]
+      end
+
+      it "finds matching groups when filtering on :description with text" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => 'Bar find group-1' }).should == [group1]
+      end
+
+      it "finds matching groups when filtering on :description with a lambda" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [group1, group3]
+      end
+
+      it "finds matching groups when filtering on :description with a regular expression" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => /find group/ }).should == [group1, group2, group3]
+      end
+
+      it "finds one group when searching for :pending => true" do
+        world.apply_inclusion_filters(example_groups, :pending => true ).should == [group2]
+      end
+
+      it "finds matching groups when filtering on arbitrary metadata with a number" do
+        world.apply_inclusion_filters(example_groups, :foo => 1 ).should == [group1]
+      end
+
+      it "finds matching groups when filtering on arbitrary metadata with an array" do
+        world.apply_inclusion_filters(example_groups, :array => [1,2,3,4]).should == [group3]
+      end
+
+      it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
+        world.apply_inclusion_filters(example_groups, :array => [4,3,2,1]).should be_empty
+      end
+
+      it "finds matching examples when filtering on arbitrary metadata" do
+        world.apply_inclusion_filters(group4.examples, :awesome => true).should == [group4.examples[1], group4.examples[2]]
+      end
+
+      it "finds matching examples for example that match any of the filters" do
+        world.apply_inclusion_filters(group4.examples, :awesome => true, :something => :else).should == [group4.examples[1], group4.examples[2]]
+      end
+    end
+
+    describe "#apply_exclusion_filters" do
+
+      it "finds nothing if all describes match the exclusion filter" do
+        options = { :network_access => true }
+
+        group1 = ExampleGroup.describe(Bar, "find group-1", options) do
+          it("foo") {}
+          it("bar") {}
+        end
+
+        world.register(group1)
+
+        world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+
+        group2 = ExampleGroup.describe(Bar, "find group-1") do
+          it("foo", :network_access => true) {}
+          it("bar") {}
+        end
+
+        world.register(group2)
+
+        world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
+      end
+
+      it "finds nothing if a regexp matches the exclusion filter" do
+        group = ExampleGroup.describe(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
+          it("foo") {}
+          it("bar") {}
+        end
+        world.register(group)
+        world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
+          :describes => lambda { |b| b == Bar } } ).should == []
+
+        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == []
+      end
+    end
+
+    describe "#preceding_declaration_line (again)" do
+
+      let(:group) do
+        RSpec::Core::ExampleGroup.describe("group") do
+
+          example("example") {}
+
+        end
+      end
+
+      let(:group_declaration_line) { group.metadata[:example_group][:line_number] }
+      let(:example_declaration_line) { group_declaration_line + 2 }
+
+      before { world.register(group) }
+
+      it "returns nil if no example or group precedes the line" do
+        world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+      end
+
+      it "returns the argument line number if a group starts on that line" do
+        world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+      end
+
+      it "returns the argument line number if an example starts on that line" do
+        world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+      end
+
+      it "returns line number of a group that immediately precedes the argument line" do
+        world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+      end
+
+      it "returns line number of an example that immediately precedes the argument line" do
+        world.preceding_declaration_line(example_declaration_line + 1).should eq(example_declaration_line)
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe RSpec::Core do
+
+  describe "#configuration" do
+
+    it "returns the same object every time" do
+      RSpec.configuration.should equal(RSpec.configuration)
+    end
+
+  end
+
+  describe "#configure" do
+
+    it "yields the current configuration" do
+      RSpec.configure do |config|
+        config.should == RSpec::configuration
+      end
+    end
+
+  end
+
+  describe "#world" do
+
+    it "returns the RSpec::Core::World instance the current run is using" do
+      RSpec.world.should be_instance_of(RSpec::Core::World)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,13 @@
+require 'rbconfig'
+
+module RubyForker
+  # Forks a ruby interpreter with same type as ourself.
+  # jruby will fork jruby, ruby will fork ruby etc.
+  def ruby(args, stderr=nil)
+    config       = ::RbConfig::CONFIG
+    interpreter  = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+    cmd = "#{interpreter} #{args}"
+    cmd << " 2> #{stderr}" unless stderr.nil?
+    `#{cmd}`
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'rspec/core'
+require 'autotest/rspec2'
+
+Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+class NullObject
+  private
+  def method_missing(method, *args, &block)
+    # ignore
+  end
+end
+
+def sandboxed(&block)
+  begin
+    @orig_config = RSpec.configuration
+    @orig_world  = RSpec.world
+    new_config = RSpec::Core::Configuration.new
+    new_config.include(RSpec::Matchers)
+    new_world  = RSpec::Core::World.new(new_config)
+    RSpec.instance_variable_set(:@configuration, new_config)
+    RSpec.instance_variable_set(:@world, new_world)
+    object = Object.new
+    object.extend(RSpec::Core::ObjectExtensions)
+    object.extend(RSpec::Core::SharedExampleGroup)
+
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      alias_method :orig_run, :run
+      def run(reporter=nil)
+        @orig_mock_space = RSpec::Mocks::space
+        RSpec::Mocks::space = RSpec::Mocks::Space.new
+        orig_run(reporter || NullObject.new)
+      ensure
+        RSpec::Mocks::space = @orig_mock_space
+      end
+    end
+
+    object.instance_eval(&block)
+  ensure
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      remove_method :run
+      alias_method :run, :orig_run
+      remove_method :orig_run
+    end
+
+    RSpec.instance_variable_set(:@configuration, @orig_config)
+    RSpec.instance_variable_set(:@world, @orig_world)
+  end
+end
+
+def in_editor?
+  ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+end
+
+RSpec.configure do |c|
+  c.color_enabled = !in_editor?
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+  c.filter_run_excluding :ruby => lambda {|version|
+    case version.to_s
+    when "!jruby"
+      RUBY_ENGINE != "jruby"
+    when /^> (.*)/
+      !(RUBY_VERSION.to_s > $1)
+    else
+      !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+    end
+  }
+  c.around do |example|
+    sandboxed { example.run }
+  end
+end

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

@@ -0,0 +1,44 @@
+RSpec::Matchers.define :map_specs do |specs|
+  match do |autotest|
+    @specs = specs
+    @autotest = prepare(autotest)
+    autotest.test_files_for(@file) == specs
+  end
+
+  chain :to do |file|
+    @file = file
+  end
+
+  failure_message_for_should do
+    "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}"
+  end
+
+  def prepare(autotest)
+    find_order = @specs.dup << @file
+    autotest.instance_eval { @find_order = find_order }
+    autotest
+  end
+end
+
+RSpec::Matchers.define :have_interface_for do |method|
+  match do |object|
+    @method = method
+    @object = object
+    object.respond_to?(method) && actual_arity == @expected_arity
+  end
+
+  chain :with do |arity|
+    @expected_arity = arity
+  end
+
+  chain(:argument) {}
+  chain(:arguments) {}
+
+  failure_message_for_should do
+    "#{@object} should have method :#{@method} with #{@expected_arity} argument(s), but it had #{actual_arity}"
+  end
+
+  def actual_arity
+    @object.method(@method).arity
+  end
+end