messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe OptionParser do
-    before do
-      RSpec.stub(:deprecate)
-    end
-
-    let(:output_file){ mock File }
-
-    before do
-      File.stub(:open).with("foo.txt",'w') { (output_file) }
-    end
-
-    it "does not parse empty args" do
-      parser = Parser.new
-      OptionParser.should_not_receive(:new)
-      parser.parse!([])
-    end
-
-    describe "--formatter" do
-      it "is deprecated" do
-        RSpec.should_receive(:deprecate)
-        Parser.parse!(%w[--formatter doc])
-      end
-
-      it "gets converted to --format" do
-        options = Parser.parse!(%w[--formatter doc])
-        options[:formatters].first.should eq(["doc"])
-      end
-    end
-
-    describe "--format" do
-      it "defines the formatter" do
-        options = Parser.parse!(%w[--format doc])
-        options[:formatters].first.should eq(["doc"])
-      end
-    end
-
-    describe "-f" do
-      it "defines the formatter" do
-        options = Parser.parse!(%w[-f doc])
-        options[:formatters].first.should eq(["doc"])
-      end
-    end
-
-    %w[--out -o].each do |option|
-      describe option do
-        let(:options) { Parser.parse!([option, 'out.txt']) }
-
-        it "sets the output stream for the formatter" do
-          options[:formatters].last.should eq(['progress', 'out.txt'])
-        end
-
-        context "with multiple formatters" do
-          context "after last formatter" do
-            it "sets the output stream for the last formatter" do
-              options = Parser.parse!(['-f', 'progress', '-f', 'doc', option, 'out.txt'])
-              options[:formatters][0].should eq(['progress'])
-              options[:formatters][1].should eq(['doc', 'out.txt'])
-            end
-          end
-
-          context "after first formatter" do
-            it "sets the output stream for the first formatter" do
-              options = Parser.parse!(['-f', 'progress', option, 'out.txt', '-f', 'doc'])
-              options[:formatters][0].should eq(['progress', 'out.txt'])
-              options[:formatters][1].should eq(['doc'])
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,226 +0,0 @@
-require 'spec_helper'
-
-RSpec::Matchers.define :be_pending_with do |message|
-  match do |example|
-    example.metadata[:pending] && example.metadata[:execution_result][:pending_message] == message
-  end
-
-  failure_message_for_should do |example|
-    "expected example to pending with #{message.inspect}, got #{example.metadata[:execution_result][:pending_message].inspect}"
-  end
-end
-
-RSpec::Matchers.define :fail_with do |exception_klass|
-  match do |example|
-    failure_reason(example, exception_klass).nil?
-  end
-
-  failure_message_for_should do |example|
-    "expected example to fail with a #{exception_klass} exception, but #{failure_reason(example, exception_klass)}"
-  end
-
-  def failure_reason(example, exception_klass)
-    result = example.metadata[:execution_result]
-    case
-      when example.metadata[:pending] then "was pending"
-      when result[:status] != 'failed' then result[:status]
-      when !result[:exception].is_a?(exception_klass) then "failed with a #{result[:exception].class}"
-      else nil
-    end
-  end
-end
-
-RSpec::Matchers.define :pass do
-  match do |example|
-    failure_reason(example).nil?
-  end
-
-  failure_message_for_should do |example|
-    "expected example to pass, but #{failure_reason(example)}"
-  end
-
-  def failure_reason(example)
-    result = example.metadata[:execution_result]
-    case
-      when example.metadata[:pending] then "was pending"
-      when result[:status] != 'passed' then result[:status]
-      else nil
-    end
-  end
-end
-
-describe "an example" do
-  context "with no block" do
-    it "is listed as pending with 'Not Yet Implemented'" do
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "has no block"
-      end
-      example = group.examples.first
-      example.run(group.new, stub.as_null_object)
-      example.should be_pending_with('Not Yet Implemented')
-    end
-  end
-
-  context "with no args" do
-    it "is listed as pending with the default message" do
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, stub.as_null_object)
-      example.should be_pending_with(RSpec::Core::Pending::DEFAULT_MESSAGE)
-    end
-  end
-
-  context "with no docstring" do
-    context "declared with the pending method" do
-      it "does not have an auto-generated description" do
-        group = RSpec::Core::ExampleGroup.describe('group') do
-          it "checks something" do
-            (3+4).should == 7
-          end
-          pending do
-            "string".reverse.should == "gnirts"
-          end
-        end
-        example = group.examples.last
-        example.run(group.new, stub.as_null_object)
-        example.description.should be_empty
-      end
-    end
-    context "after another example with some assertion" do
-      it "does not show any message" do
-        group = RSpec::Core::ExampleGroup.describe('group') do
-          it "checks something" do
-            (3+4).should == 7
-          end
-          specify do
-            pending
-          end
-        end
-        example = group.examples.last
-        example.run(group.new, stub.as_null_object)
-        example.description.should be_empty
-      end
-    end
-  end
-
-  context "with a message" do
-    it "is listed as pending with the supplied message" do
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending("just because")
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, stub.as_null_object)
-      example.should be_pending_with('just because')
-    end
-  end
-
-  context "with a block" do
-    def run_example(*pending_args)
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending(*pending_args) { yield }
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, stub.as_null_object)
-      example
-    end
-
-    context "that fails" do
-      def run_example(*pending_args)
-        super(*pending_args) { raise ArgumentError.new }
-      end
-
-      context "when given no options" do
-        it "is listed as pending with the supplied message" do
-          run_example("just because").should be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          run_example.should be_pending_with(RSpec::Core::Pending::DEFAULT_MESSAGE)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "is listed as pending with the supplied message" do
-          run_example("just because", :if => true).should be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          run_example(:if => true).should be_pending_with(RSpec::Core::Pending::DEFAULT_MESSAGE)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and fails" do
-          run_example(                :if => false).should fail_with(ArgumentError)
-          run_example("just because", :if => false).should fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and fails" do
-          run_example(                :unless => true).should fail_with(ArgumentError)
-          run_example("just because", :unless => true).should fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "is listed as pending with the supplied message" do
-          run_example("just because", :unless => false).should be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          run_example(:unless => false).should be_pending_with(RSpec::Core::Pending::DEFAULT_MESSAGE)
-        end
-      end
-    end
-
-    context "that passes" do
-      def run_example(*pending_args)
-        super(*pending_args) { 3.should == 3 }
-      end
-
-      context "when given no options" do
-        it "fails with a PendingExampleFixedError" do
-          run_example("just because").should fail_with(RSpec::Core::PendingExampleFixedError)
-          run_example.should                 fail_with(RSpec::Core::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "fails with a PendingExampleFixedError" do
-          run_example("just because", :if => true).should fail_with(RSpec::Core::PendingExampleFixedError)
-          run_example(                :if => true).should fail_with(RSpec::Core::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and it passes" do
-          run_example(                :if => false).should pass
-          run_example("just because", :if => false).should pass
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and it passes" do
-          run_example(                :unless => true).should pass
-          run_example("just because", :unless => true).should pass
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "fails with a PendingExampleFixedError" do
-          run_example("just because", :unless => false).should fail_with(RSpec::Core::PendingExampleFixedError)
-          run_example(                :unless => false).should fail_with(RSpec::Core::PendingExampleFixedError)
-        end
-      end
-    end
-  end
-end

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

@@ -1,161 +0,0 @@
-require "spec_helper"
-require "rspec/core/rake_task"
-
-module RSpec::Core
-  describe RakeTask do
-    let(:task) { RakeTask.new }
-
-    before do
-      File.stub(:exist?) { false }
-    end
-
-    def with_bundler
-      task.skip_bundler = false
-      File.stub(:exist?) { true }
-      yield
-    end
-
-    def with_rcov
-      task.rcov = true
-      yield
-    end
-
-    def spec_command
-      task.__send__(:spec_command)
-    end
-
-    context "default" do
-      it "renders rspec" do
-        spec_command.should =~ /^-S rspec/
-      end
-    end
-
-    context "with bundler" do
-      context "with Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) { true }
-          task.skip_bundler = false
-          spec_command.should match(/bundle exec/)
-        end
-      end
-
-      context "with non-standard Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) {|f| f =~ /AltGemfile/}
-          task.gemfile = 'AltGemfile'
-          task.skip_bundler = false
-          spec_command.should match(/bundle exec/)
-        end
-      end
-
-      context "without Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) { false }
-          task.skip_bundler = false
-          spec_command.should_not match(/bundle exec/)
-        end
-      end
-    end
-
-    context "with rcov" do
-      it "renders rcov" do
-        with_rcov do
-          spec_command.should =~ /^-S rcov/
-        end
-      end
-    end
-
-    context "with bundler and rcov" do
-      it "renders bundle exec rcov" do
-        with_bundler do
-          with_rcov do
-            spec_command.should =~ /^-S bundle exec rcov/
-          end
-        end
-      end
-    end
-
-    context "with ruby options" do
-      it "renders them before -S" do
-        task.ruby_opts = "-w"
-        spec_command.should =~ /^-w -S rspec/
-      end
-    end
-
-    context "with rcov_opts" do
-      context "with rcov=false (default)" do
-        it "does not add the rcov options to the command" do
-          task.rcov_opts = '--exclude "mocks"'
-          spec_command.should_not =~ /--exclude "mocks"/
-        end
-      end
-
-      context "with rcov=true" do
-        it "renders them after rcov" do
-          task.rcov = true
-          task.rcov_opts = '--exclude "mocks"'
-          spec_command.should =~ /rcov.*--exclude "mocks"/
-        end
-
-        it "ensures that -Ispec:lib is in the resulting command" do
-          task.rcov = true
-          task.rcov_opts = '--exclude "mocks"'
-          spec_command.should =~ /rcov.*-Ispec:lib/
-        end
-      end
-    end
-
-    context "with rspec_opts" do
-      context "with rcov=true" do
-        it "adds the rspec_opts after the rcov_opts and files" do
-          task.stub(:files_to_run) { "this.rb that.rb" }
-          task.rcov = true
-          task.rspec_opts = "-Ifoo"
-          spec_command.should =~ /this.rb that.rb -- -Ifoo/
-        end
-      end
-      context "with rcov=false (default)" do
-        it "adds the rspec_opts" do
-          task.rspec_opts = "-Ifoo"
-          spec_command.should =~ /rspec -Ifoo/
-        end
-      end
-    end
-
-    context "with SPEC=path/to/file" do
-      before do
-        @orig_spec = ENV["SPEC"]
-        ENV["SPEC"] = "path/to/file"
-      end
-
-      after do
-        ENV["SPEC"] = @orig_spec
-      end
-
-      it "sets files to run" do
-        task.__send__(:files_to_run).should eq(["path/to/file"])
-      end
-    end
-
-    context "with paths with quotes" do
-      before do
-        @tmp_dir = File.expand_path('./tmp/rake_task_example/')
-        FileUtils.mkdir_p @tmp_dir
-        @task = RakeTask.new do |t|
-          t.pattern = File.join(@tmp_dir, "*spec.rb")
-        end
-        ["first_spec.rb", "second_\"spec.rb", "third_\'spec.rb"].each do |file_name|
-          FileUtils.touch(File.join(@tmp_dir, file_name))
-        end
-      end
-
-      it "escapes the quotes" do
-        @task.__send__(:files_to_run).sort.should eq([
-          File.join(@tmp_dir, "first_spec.rb"),
-          File.join(@tmp_dir, "second_\\\"spec.rb"),
-          File.join(@tmp_dir, "third_\\\'spec.rb") 
-        ])
-      end
-    end
-  end
-end