messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/access_running_example.feature

@@ -0,0 +1,53 @@
+Feature: access running example
+
+  In order to take advantage of services that are available
+    in my examples when I'm writing matchers
+  As a spec author
+  I want to call methods on the running example
+
+  If the method exists in the context of the example, it gets
+  called. If not, a NoMethodError is raised on the Matcher itself
+  (not the example).
+
+  Scenario: call method defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        def foo
+          "foo"
+        end
+
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run "rspec ./example_spec.rb"
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: call method _not_ defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run "rspec ./example_spec.rb"
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "undefined local variable"
+    And the output should contain "RSpec::Matchers::Matcher"
+    And the output should not contain "ExampleGroup"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_diffable_matcher.feature

@@ -0,0 +1,27 @@
+Feature: define diffable matcher
+
+  When a matcher is defined as diffable, and the --diff
+  flag is set, the output will include a diff of the submitted
+  objects.
+
+  @wip
+  Scenario: define a diffable matcher
+    Given a file named "diffable_matcher_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_just_like do |expected|
+        match do |actual|
+          actual == expected
+        end
+        
+        diffable
+      end
+
+      describe "this" do
+        it {should be_just_like("that")}
+      end
+      """
+    When I run "rspec ./diffable_matcher_spec.rb --diff"
+    Then the exit status should not be 0
+
+    And the output should contain "should be just like that"
+    And the output should contain "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_matcher.feature

@@ -0,0 +1,311 @@
+Feature: define matcher
+
+  In order to express my domain clearly in my code examples
+  As an RSpec user
+  I want a shortcut to define custom matchers
+
+  Scenario: define a matcher with default messages
+    Given a file named "matcher_with_default_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+
+      """
+    When I run "rspec ./matcher_with_default_message_spec.rb --format documentation"
+    Then the exit status should not be 0
+
+    And the output should contain "should be a multiple of 3"
+    And the output should contain "should not be a multiple of 4"
+    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
+    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
+
+    And the output should contain "4 examples, 2 failures"
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "expected 9 not to be a multiple of 3"
+
+  Scenario: overriding the failure_message_for_should
+    Given a file named "matcher_with_failure_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should do |actual|
+          "expected that #{actual} would be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+      """
+    When I run "rspec ./matcher_with_failure_message_spec.rb"
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would be a multiple of 4"
+
+  Scenario: overriding the failure_message_for_should_not
+    Given a file named "matcher_with_failure_for_message_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should_not do |actual|
+          "expected that #{actual} would not be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+      """
+    When I run "rspec ./matcher_with_failure_for_message_spec.rb"
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would not be a multiple of 3"
+
+  Scenario: overriding the description
+    Given a file named "matcher_overriding_description_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        description do
+          "be multiple of #{expected}"
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+      """
+    When I run "rspec ./matcher_overriding_description_spec.rb --format documentation"
+    Then the exit status should be 0
+    And the stdout should contain "2 examples, 0 failures"
+    And the stdout should contain "should be multiple of 3"
+    And the stdout should contain "should not be multiple of 4"
+
+  Scenario: with no args
+    Given a file named "matcher_with_no_args_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_7_fingers do
+        match do |thing|
+          thing.fingers.length == 7
+        end
+      end
+
+      class Thing
+        def fingers; (1..7).collect {"finger"}; end
+      end
+
+      describe Thing do
+        it {should have_7_fingers}
+      end
+      """
+    When I run "rspec ./matcher_with_no_args_spec.rb --format documentation"
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should have 7 fingers"
+
+  Scenario: with multiple args
+    Given a file named "matcher_with_multiple_args_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
+        match do |sum|
+          a + b + c + d == sum
+        end
+      end
+
+      describe 10 do
+        it {should be_the_sum_of(1,2,3,4)}
+      end
+      """
+    When I run "rspec ./matcher_with_multiple_args_spec.rb --format documentation"
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
+
+  Scenario: with helper methods
+    Given a file named "matcher_with_internal_helper_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_same_elements_as do |sample|
+        match do |actual|
+          similar?(sample, actual)
+        end
+
+        def similar?(a, b)
+          a.sort == b.sort
+        end
+      end
+
+      describe "these two arrays" do
+        specify "should be similar" do
+          [1,2,3].should have_same_elements_as([2,3,1])
+        end
+      end
+      """
+    When I run "rspec ./matcher_with_internal_helper_spec.rb"
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+
+  Scenario: scoped in a module
+    Given a file named "scoped_matcher_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      module MyHelpers
+        extend RSpec::Matchers::DSL
+
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+      end
+
+      describe "group with MyHelpers" do
+        include MyHelpers
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+      end
+
+      describe "group without MyHelpers" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run "rspec ./scoped_matcher_spec.rb"
+    Then the stdout should contain "2 examples, 0 failures"
+
+  Scenario: scoped in an example group
+    Given a file named "scoped_matcher_spec.rb" with:
+      """
+      require 'rspec/expectations'
+
+      describe "group with matcher" do
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+
+        describe "nested group" do
+          it "has access to the defined matcher" do
+            5.should be_just_like(5)
+          end
+        end
+
+      end
+
+      describe "group without matcher" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run "rspec scoped_matcher_spec.rb"
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: matcher with separate logic for should and should_not
+    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
+      """
+      RSpec::Matchers.define :contain do |*expected|
+        match_for_should do |actual|
+          expected.all? { |e| actual.include?(e) }
+        end
+
+        match_for_should_not do |actual|
+          expected.none? { |e| actual.include?(e) }
+        end
+      end
+
+      describe [1, 2, 3] do
+        it { should contain(1, 2) }
+        it { should_not contain(4, 5, 6) }
+
+        # deliberate failures
+        it { should contain(1, 4) }
+        it { should_not contain(1, 4) }
+      end
+      """
+    When I run "rspec matcher_with_separate_should_not_logic_spec.rb"
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                    |
+      | expected [1, 2, 3] to contain 1 and 4     |
+      | expected [1, 2, 3] not to contain 1 and 4 |
+
+  Scenario: use define_method to create a helper method with access to matcher params
+    Given a file named "define_method_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        define_method :is_multiple? do |actual|
+          actual % expected == 0
+        end
+        match { |actual| is_multiple?(actual) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run "rspec define_method_spec.rb"
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -0,0 +1,38 @@
+Feature: define matcher outside rspec
+
+  In order to express my domain clearly in my code examples
+  As a non-rspec user
+  I want a shortcut to define custom matchers
+
+  Scenario: define a matcher with default messages
+    Given a file named "test_multiples.rb" with:
+      """
+      require "rspec/expectations"
+      require "test/unit"
+      
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+      
+      class Test::Unit::TestCase
+        include RSpec::Matchers
+      end
+      
+      class TestMultiples < Test::Unit::TestCase
+      
+        def test_9_should_be_a_multiple_of_3
+          9.should be_a_multiple_of(3)
+        end
+
+        def test_9_should_be_a_multiple_of_4
+          9.should be_a_multiple_of(4)
+        end
+        
+      end
+      """
+    When I run "ruby test_multiples.rb"
+    Then the exit status should not be 0 
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "2 tests, 0 assertions, 0 failures, 1 errors"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -0,0 +1,24 @@
+Feature: define matcher with fluent interface
+
+  Use the chain() method to define matchers with a fluent interface.
+  
+  Scenario: chained method with argumetn
+    Given a file named "between_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_bigger_than do |first|
+        match do |actual|
+          (actual > first) && (actual < @second)
+        end
+
+        chain :but_smaller_than do |second|
+          @second = second
+        end
+      end
+
+      describe 5 do
+        it { should be_bigger_than(4).but_smaller_than(6) }
+      end
+      """
+    When I run "rspec between_spec.rb --format documentation"
+    Then the output should contain "1 example, 0 failures"
+    And  the output should contain "should be bigger than 4"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/customized_message.feature

@@ -0,0 +1,22 @@
+Feature: customized message
+
+  RSpec tries to provide useful failure messages, but for cases in which you
+  want more specific information, you can define your own message right in the
+  example. This works for any matcher _other than the operator matchers_.
+  
+  Scenario: customize failure message
+    Given a file named "example_spec.rb" with:
+      """
+      describe Array do
+        context "when created with `new`" do
+          it "is empty" do
+            array = Array.new
+            array << 1 # trigger a failure to demonstrate the message
+            array.should be_empty, "expected empty array, got #{array.inspect}"
+          end
+        end
+      end
+
+      """
+    When I run "rspec example_spec.rb --format documentation"
+    Then the output should contain "expected empty array, got [1]"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/diffing.feature

@@ -0,0 +1,85 @@
+Feature: diffing
+
+  When appropriate, failure messages will automatically include a diff.
+
+  Scenario: diff for a multiline string
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a multiline string" do
+        it "is like another string" do
+          expected = <<-EXPECTED
+      this is the
+        expected
+          string
+      EXPECTED
+          actual = <<-ACTUAL
+      this is the
+        actual
+          string
+      ACTUAL
+          actual.should eq(expected)
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain:
+      """
+             Diff:
+             @@ -1,4 +1,4 @@
+              this is the
+             -  expected
+             +  actual
+                  string
+      """
+
+  Scenario: diff for a multiline string and a regexp
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a multiline string" do
+        it "is like another string" do
+          expected = /expected/m
+          actual = <<-ACTUAL
+      this is the
+        actual
+          string
+      ACTUAL
+          actual.should =~ expected
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain:
+      """
+             Diff:
+             @@ -1,2 +1,4 @@
+             -/expected/m
+             +this is the
+             +  actual
+             +    string
+      """
+
+  Scenario: no diff for a single line strings
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a single line string" do
+        it "is like another string" do
+          expected = "this string"
+          actual   = "that string"
+          actual.should eq(expected)
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should not contain "Diff:"
+
+  Scenario: no diff for numbers
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a number" do
+        it "is like another number" do
+          1.should eq(2)
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should not contain "Diff:"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/implicit_docstrings.feature

@@ -0,0 +1,52 @@
+Feature: implicit docstrings
+
+  As an RSpec user
+  I want examples to generate their own names
+  So that I can reduce duplication between example names and example code
+
+  Scenario: run passing examples
+    Given a file named "implicit_docstrings_spec.rb" with:
+    """
+    describe "Examples with no docstrings generate their own:" do
+
+      specify { 3.should be < 5 }
+
+      specify { [1,2,3].should include(2) }
+
+      specify { [1,2,3].should respond_to(:size) }
+
+    end
+    """
+
+    When I run "rspec ./implicit_docstrings_spec.rb -fdoc"
+
+    Then the output should contain "should be < 5"
+    And the output should contain "should include 2"
+    And the output should contain "should respond to #size"
+
+  Scenario: run failing examples
+    Given a file named "failing_implicit_docstrings_spec.rb" with:
+    """
+    describe "Failing examples with no descriptions" do
+
+      # description is auto-generated as "should equal(5)" based on the last #should
+      it do
+        3.should equal(2)
+        5.should equal(5)
+      end
+
+      it { 3.should be > 5 }
+
+      it { [1,2,3].should include(4) }
+
+      it { [1,2,3].should_not respond_to(:size) }
+
+    end
+    """
+
+    When I run "rspec ./failing_implicit_docstrings_spec.rb -fdoc"
+
+    Then the output should contain "should equal 2"
+    And the output should contain "should be > 5"
+    And the output should contain "should include 4"
+    And the output should contain "should not respond to #size"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,22 @@
+# Useful for when the output is slightly different on different versions of ruby
+Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
+  unless [string1, string2].any? { |s| combined_output =~ Regexp.compile(s) }
+    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{combined_output}}
+  end
+end
+
+Then /^the output should contain all of these:$/ do |table|
+  table.raw.flatten.each do |string|
+    assert_partial_output(string)
+  end
+end
+
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  Then %q{the output should contain "0 failures"}
+  Then %q{the exit status should be 0}
+end
+
+Then /^the example should fail$/ do
+  Then %q{the output should contain "1 failure"}
+  Then %q{the exit status should not be 0}
+end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba'

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/test_frameworks/test_unit.feature

@@ -0,0 +1,46 @@
+Feature: Test::Unit integration
+
+  RSpec-expectations is a stand-alone gem that can be used without
+  the rest of RSpec.  It can easily be used with another test
+  framework such as Test::Unit if you like RSpec's should/should_not
+  syntax but prefer the test organization of another framework.
+
+  Scenario: Basic Test::Unit usage
+    Given a file named "rspec_expectations_test.rb" with:
+      """
+      require 'test/unit'
+      require 'rspec/expectations'
+
+      class RSpecExpectationsTest < Test::Unit::TestCase
+        RSpec::Matchers.define :be_an_integer do
+          match { |actual| Integer === actual }
+        end
+
+        def be_an_int
+          RSpec.deprecate(:be_an_int, :be_an_integer)
+          be_an_integer
+        end
+
+        def test_passing_expectation
+          x = 1 + 3
+          x.should == 4
+        end
+
+        def test_failing_expectation
+          array = [1, 2]
+          array.should be_empty
+        end
+
+        def test_expect_matcher
+          expect { @a = 5 }.to change { @a }.from(nil).to(5)
+        end
+
+        def test_custom_matcher_and_deprecation_warning
+          1.should be_an_int
+        end
+      end
+      """
+     When I run "ruby rspec_expectations_test.rb"
+     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 errors"
+      And the output should contain "expected empty? to return true, got false"
+      And the output should contain "be_an_int is deprecated"