rspec-given 2.4.1 → 2.4.2

data/spec/lib/rspec/given/have_failed_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe "#have_failed" do
+  CustomError = Class.new(StandardError)
+  DifferentError = Class.new(StandardError)
+  ExpectationError = RSpec::Expectations::ExpectationNotMetError
+
+  context "with a failure" do
+    When(:result) { fail CustomError, "Ouch" }
+
+    Then { result.should raise_error(CustomError, "Ouch") }
+    Then { result.should have_failed(CustomError, "Ouch") }
+    Then { result.should have_raised(CustomError, "Ouch") }
+
+    Then { expect { result.should be_nil }.to raise_error(CustomError, "Ouch") }
+    Then { expect { result.should == 0 }.to raise_error(CustomError, "Ouch") }
+    Then { expect { result.should_not == 0 }.to raise_error(CustomError, "Ouch") }
+
+    Then { expect { result.should_not have_failed }.to raise_error(ExpectationError) }
+  end
+
+  context "with a standard failure" do
+    When(:result) { fail "Ouch" }
+
+    Then { result.should raise_error(StandardError, "Ouch") }
+    Then { result.should raise_error(StandardError, /^O/) }
+    Then { result.should raise_error(StandardError) }
+    Then { result.should raise_error }
+
+    Then { result.should have_failed(StandardError, "Ouch") }
+    Then { result.should have_failed(StandardError, /^O/) }
+    Then { result.should have_failed(StandardError) }
+    Then { result.should have_failed }
+  end
+
+  context "with a different failure" do
+    When(:result) { fail CustomError, "Ouch" }
+    Then { result.should_not have_failed(DifferentError) }
+    Then { expect { result.should have_failed(DifferentError) }.to raise_error(ExpectationError) }
+  end
+
+  context "with a pending exception" do
+    When(:result) { fail RSpec::Core::Pending::PendingDeclaredInExample, "Required pending in example ... please ignore" }
+    Then { RSpec::Given.fail_with "This example should have been pending" }
+  end
+
+  context "with a non-failure" do
+    When(:result) { :ok }
+    Then { result.should_not have_failed }
+    Then { expect { result.should have_failed }.to raise_error(RSpec::Expectations::ExpectationNotMetError) }
+  end
+
+  context "with natural assertions" do
+    use_natural_assertions_if_supported
+
+    context "with failure" do
+      When(:result) { fail CustomError, "Ouch" }
+      Then { result == have_failed(CustomError, "Ouch") }
+      Then { ! (result != have_failed(CustomError, "Ouch")) }
+      Then { expect { result == :something }.to raise_error(CustomError, "Ouch") }
+    end
+
+    context "with different failure" do
+      When(:result) { fail DifferentError, "Ouch" }
+      Then { ! (result == have_failed(CustomError, "Ouch")) }
+      Then { result != have_failed(CustomError, "Ouch") }
+    end
+
+  end
+end

data/spec/lib/rspec/given/lexical_purity_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+LEXICAL_PURITY_GLOBAL_CONSTANT = 3
+
+describe "Lexical Purity" do
+  use_natural_assertions_if_supported
+
+  A = 1
+  Given(:avalue) { 1 }
+  context "nested" do
+    B = 2
+    Given(:bvalue) { 2 }
+    Then { A == 1 }
+    Then { avalue == 1 }
+    Then { B == 2 }
+    Then { bvalue == 2 }
+    Then { LEXICAL_PURITY_GLOBAL_CONSTANT == 3 }
+  end
+end

data/spec/lib/rspec/given/line_extractor_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module RSpec
+  module Given
+
+    describe LineExtractor do
+
+      class FauxFileCache
+        def initialize(lines)
+          @lines = lines.split(/\n/).map { |ln| ln + "\n" }
+        end
+        def get(file_name)
+          @lines
+        end
+      end
+
+      Given(:line) { 2 }
+      Given(:file_cache) { FauxFileCache.new(input) }
+      Given(:extractor) { LineExtractor.new(file_cache) }
+
+      When(:result) { extractor.line("FILENAME", line) }
+
+      describe "reading a line" do
+        Given(:input) {
+          "  Now is the time\n" +
+          "  for all good men\n" +
+          "  to come to the aid\n" +
+          "  of their fellowmen\n"
+        }
+        Given(:expected_line) { "  for all good men\n" }
+        Then { result.should == expected_line }
+      end
+
+      context "when the line doesn't exist" do
+        Given(:input) { "" }
+        Then { result.should be_nil }
+      end
+
+      context "when the line has leading and trailing white space" do
+        Given(:input) {
+          "  Then { y } \n" +
+          "  Then { x }\n"
+        }
+        Then { result.should == "  Then { x }\n" }
+      end
+
+      context "when the Then is split over several lines with {}" do
+        Given(:input) {
+          "describe 'foobar' do\n" +
+          "  Then {\n" +
+          "    x\n" +
+          "  }\n" +
+          "end\n"
+        }
+        Then { result.should == "  Then {\n    x\n  }\n" }
+      end
+
+      context "when the Then is has blank lines" do
+        Given(:input) {
+          "describe 'foobar' do\n" +
+          "  Then {\n\n" +
+          "    x\n" +
+          "  }\n" +
+          "end\n"
+        }
+        Then { result.should == "  Then {\n\n    x\n  }\n" }
+      end
+
+      context "when the Then is split over several lines with do/end" do
+        Given(:input) {
+          "describe 'foobar' do\n" +
+          "  Then do\n" +
+          "    x\n" +
+          "  end\n" +
+          "end\n"
+        }
+        Then { result.should == "  Then do\n    x\n  end\n" }
+      end
+
+      describe "converting to a string" do
+        Given(:input) { "" }
+        Then { extractor.to_s.should =~ /line *extractor/i }
+      end
+    end
+  end
+end

data/spec/lib/rspec/given/module_methods_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "RSpec::Given.use_natural_assertions" do
+  context "when in JRuby" do
+    When(:result) { RSpec::Given.use_natural_assertions }
+
+    if RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+      Then { result.should_not have_failed(ArgumentError) }
+    else
+      Then { result.should have_failed(ArgumentError) }
+    end
+  end
+end

data/spec/lib/rspec/given/natural_assertion_spec.rb

@@ -0,0 +1,178 @@
+require 'rspec/given'
+require 'spec_helper'
+
+describe RSpec::Given::NaturalAssertion do
+  before do
+    pending "Natural Assertions disabled for JRuby" unless RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+  end
+
+  describe "#content?" do
+    context "with empty block" do
+      FauxThen { }
+      Then { na.should_not have_content }
+    end
+    context "with block returning false" do
+      FauxThen { false }
+      Then { na.should have_content }
+    end
+  end
+
+  describe "detecting RSpec Assertions" do
+    context "with should" do
+      FauxThen { a.should == 1 }
+      Then { na.should be_using_rspec_assertion }
+    end
+
+    context "with should_not" do
+      FauxThen { a.should_not == 1 }
+      Then { na.should be_using_rspec_assertion }
+    end
+
+    context "with expect/to" do
+      FauxThen { expect(a).to eq(1) }
+      Then { na.should be_using_rspec_assertion }
+    end
+
+    context "with expect/not_to" do
+      FauxThen { expect(a).not_to eq(1) }
+      Then { na.should be_using_rspec_assertion }
+    end
+
+    context "with expect and block" do
+      FauxThen { expect { a }.to eq(1) }
+      Then { na.should be_using_rspec_assertion }
+    end
+
+    context "with natural assertion" do
+      FauxThen { a == 1 }
+      Then { na.should_not be_using_rspec_assertion }
+    end
+  end
+
+  describe "failure messages" do
+    let(:msg) { na.message }
+    Invariant { msg.should =~ /^FauxThen expression/ }
+
+    context "with equals assertion" do
+      Given(:a) { 1 }
+      FauxThen { a == 2 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto equal: +2\b/ }
+      Then { msg.should =~ /\bfalse +<- +a == 2\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with equals assertion with do/end" do
+      Given(:a) { 1 }
+      FauxThen do a == 2 end
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto equal: +2\b/ }
+      Then { msg.should =~ /\bfalse +<- +a == 2\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with not-equals assertion" do
+      Given(:a) { 1 }
+      FauxThen { a != 1 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto not equal: +1\b/ }
+      Then { msg.should =~ /\bfalse +<- +a != 1\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with less than assertion" do
+      Given(:a) { 1 }
+      FauxThen { a < 1 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto be less than: +1\b/ }
+      Then { msg.should =~ /\bfalse +<- +a < 1\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with less than or equal to assertion" do
+      Given(:a) { 1 }
+      FauxThen { a <= 0 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto be less or equal to: +0\b/ }
+      Then { msg.should =~ /\bfalse +<- +a <= 0\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with greater than assertion" do
+      Given(:a) { 1 }
+      FauxThen { a > 1 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto be greater than: +1\b/ }
+      Then { msg.should =~ /\bfalse +<- +a > 1\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with greater than or equal to assertion" do
+      Given(:a) { 1 }
+      FauxThen { a >= 3 }
+      Then { msg.should =~ /\bexpected: +1\b/ }
+      Then { msg.should =~ /\bto be greater or equal to: +3\b/ }
+      Then { msg.should =~ /\bfalse +<- +a >= 3\b/ }
+      Then { msg.should =~ /\b1 +<- +a\b/ }
+    end
+
+    context "with match assertion" do
+      Given(:s) { "Hello" }
+      FauxThen { s =~ /HI/ }
+      Then { msg.should =~ /\bexpected: +"Hello"$/ }
+      Then { msg.should =~ /\bto match: +\/HI\/$/ }
+      Then { msg.should =~ /\bnil +<- +s =~ \/HI\/$/ }
+      Then { msg.should =~ /"Hello" +<- +s$/ }
+    end
+
+    context "with not match assertion" do
+      Given(:s) { "Hello" }
+      FauxThen { s !~ /Hello/ }
+      Then { msg.should =~ /\bexpected: +"Hello"$/ }
+      Then { msg.should =~ /\bto not match: +\/Hello\/$/ }
+      Then { msg.should =~ /\bfalse +<- +s !~ \/Hello\/$/ }
+      Then { msg.should =~ /"Hello" +<- +s$/ }
+    end
+
+    context "with exception" do
+      Given(:ary) { nil }
+      FauxThen { ary[1] == 3 }
+      Then { msg.should =~ /\bexpected: +NoMethodError/ }
+      Then { msg.should =~ /\bto equal: +3$/ }
+      Then { msg.should =~ /\bNoMethodError.+NilClass\n +<- +ary\[1\] == 3$/ }
+      Then { msg.should =~ /\bNoMethodError.+NilClass\n +<- +ary\[1\]$/ }
+      Then { msg.should =~ /\bnil +<- +ary$/ }
+    end
+
+    context "with value with newlines" do
+      class FunkyInspect
+        def inspect
+          "XXXX\nYYYY"
+        end
+      end
+      Given(:zzzz) { FunkyInspect.new }
+      FauxThen { zzzz == nil }
+      Then { msg.should =~ /\n  XXXX\n/ }
+      Then { msg.should =~ /\n  YYYY\n/ }
+      Then { msg.should =~ /\n +<- zzzz$/ }
+    end
+  end
+
+  describe "bad Then blocks" do
+    context "with no statements" do
+      FauxThen {  }
+      When(:result) { na.message }
+      Then { result.should_not have_failed(RSpec::Given::InvalidThenError) }
+    end
+
+    context "with multiple statements" do
+      FauxThen {
+        ary = nil
+        ary[1] == 3
+      }
+      When(:result) { na.message }
+      Then { result.should have_failed(RSpec::Given::InvalidThenError, /multiple.*statements/i) }
+    end
+
+  end
+end

data/spec/lib/rspec/given/options_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe "Configuration Options" do
+  let(:trace) { [] }
+
+  describe "inherited options" do
+    context "Outer" do
+      _rgc_context_info[:name] = "Outer"
+      _rgc_context_info[:outer] = true
+
+      Then { _rg_info(:name).should == "Outer" }
+      Then { _rg_info(:outer).should == true }
+      Then { _rg_info(:inner).should == nil }
+
+      context "Inner" do
+        _rgc_context_info[:name] = "Inner"
+        _rgc_context_info[:inner] = true
+
+        Then { _rg_info(:name).should == "Inner" }
+        Then { _rg_info(:outer).should == true }
+        Then { _rg_info(:inner).should == true }
+      end
+    end
+  end
+
+  describe "Global natural assertion configuration" do
+    unless RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+      before do
+        pending "Natural assertions are not supported in JRuby"
+      end
+    end
+
+    before do
+      RSpec::Given.use_natural_assertions false
+    end
+
+    Given(:rspec) { false }
+    Given(:content) { true }
+    Given(:nassert) { stub(:using_rspec_assertion? => rspec, :has_content? => content) }
+
+    after do
+      RSpec::Given.use_natural_assertions false
+    end
+
+    context "with no explicit word on natural assertions" do
+      Then { _rg_need_na_message?(nassert).should be_false }
+
+      context "overridden locally" do
+        use_natural_assertions_if_supported
+        Then { _rg_need_na_message?(nassert).should be_true }
+      end
+    end
+
+    context "with global configuration enabled" do
+      When { RSpec::Given.use_natural_assertions }
+      Then { _rg_need_na_message?(nassert).should be_true }
+
+      context "overridden locally" do
+        use_natural_assertions false
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+
+      context "with rspec assertion" do
+        Given(:rspec) { true }
+        Then {
+          if RSpec::Given::MONKEY
+            # If RSpec was successfully patched to record matchers,
+            # then the "need NA" logic will ignore possible matches in
+            # the source code.
+            _rg_need_na_message?(nassert).should be_true
+          else
+            # If RSpec was not successfully patched to record
+            # matchers, then the "need NA" logic will check for
+            # should/expect in the source.
+            _rg_need_na_message?(nassert).should be_false
+          end
+        }
+      end
+
+      context "without rspec assertion" do
+        Given(:rspec) { false }
+        Then { _rg_need_na_message?(nassert).should be_true }
+      end
+
+      context "without rspec assertion and no content" do
+        Given(:rspec) { false }
+        Given(:content) { false }
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+    end
+
+    context "with global configuration set to always" do
+      When { RSpec::Given.use_natural_assertions :always }
+      Then { _rg_need_na_message?(nassert).should be_true }
+
+      context "overridden locally" do
+        use_natural_assertions false
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+
+      context "with rspec assertion" do
+        Given(:rspec) { true }
+        Then { _rg_need_na_message?(nassert).should be_true }
+      end
+
+      context "without rspec assertion" do
+        Given(:rspec) { false }
+        Then { _rg_need_na_message?(nassert).should be_true }
+      end
+
+      context "without rspec assertion and no content" do
+        Given(:rspec) { false }
+        Given(:content) { false }
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+    end
+
+    context "with global configuration disabled" do
+      When { RSpec::Given.use_natural_assertions false }
+      Then { _rg_need_na_message?(nassert).should be_false }
+
+      context "overridden locally" do
+        use_natural_assertions_if_supported(true)
+        Then { _rg_need_na_message?(nassert).should be_true }
+      end
+
+      context "with rspec assertion" do
+        Given(:rspec) { true }
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+
+      context "without rspec assertion" do
+        Given(:rspec) { false }
+        Then { _rg_need_na_message?(nassert).should be_false }
+      end
+    end
+
+  end
+end