rspec-given 2.4.1 → 2.4.2

data/lib/rspec/given/version.rb

@@ -3,7 +3,7 @@ module RSpec
     VERSION_NUMBERS = [
       VERSION_MAJOR = 2,
       VERSION_MINOR = 4,
-      VERSION_BUILD = 1,
+      VERSION_BUILD = 2,
     ]
     VERSION = VERSION_NUMBERS.join(".")
   end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Environmental Access" do
+  X = 1
+  Given(:a) { 2 }
+  FauxThen { X + a }
+
+  Then { block_result.should == 3 }
+  Then { ev.eval_string("X").should == "1" }
+  Then { ev.eval_string("a").should == "2" }
+  Then { ev.eval_string("X+a").should == "3" }
+end
+
+module Nested
+  X = 1
+  describe "Environmental Access with Nested modules" do
+    Given(:a) { 2 }
+    FauxThen { X + a }
+    Then { block_result.should == 3 }
+    Then { ev.eval_string("a").should == "2" }
+    Then { ev.eval_string("X").should == "1" }
+    Then { ev.eval_string("a+X").should == "3" }
+  end
+end
+
+describe "Evaluator with error object" do
+  FauxThen { 1 }
+  When(:result) { ev.eval_string("fail 'XYZ'") }
+  Then { result.class.should == RSpec::Given::EvalErr }
+  Then { result.inspect.should == "RuntimeError: XYZ" }
+end

data/spec/lib/rspec/given/ext/numeric_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'rspec/given'
+require 'rspec/given/fuzzy_shortcuts'
+
+describe "Numeric Extensions" do
+  use_natural_assertions_if_supported
+
+  Given(:n) { 10 }
+  Given(:about_n) { about(n) }
+  Given(:delta_n) { about(n).delta(0.001) }
+  Given(:percent_n) { about(n).percent(5) }
+  Given(:epsilon_n) {about(n).epsilon(20) }
+
+  Then { n.±(0.001).exactly_equals?(delta_n) }
+  Then { n.‰(5).exactly_equals?(percent_n) }
+  Then { n.€(20).exactly_equals?(epsilon_n) }
+
+  Then { n.±.exactly_equals?(about_n) }
+  Then { n.‰.exactly_equals?(about_n) }
+  Then { n.€.exactly_equals?(about_n) }
+end

data/spec/lib/rspec/given/ext/numeric_specifications.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'rspec/given'
+require 'rspec/given/fuzzy_shortcuts'
+
+describe "Numeric Extensions" do
+  use_natural_assertions_if_supported
+
+  Given(:n) { 10 }
+  Given(:about_n) { about(n) }
+  Given(:delta_n) { about(n).delta(0.001) }
+  Given(:percent_n) { about(n).percent(5) }
+  Given(:epsilon_n) {about(n).epsilon(20) }
+
+  Then { n.±(0.001).exactly_equals?(delta_n) }
+  Then { n.‰(5).exactly_equals?(percent_n) }
+  Then { n.€(20).exactly_equals?(epsilon_n) }
+
+  Then { n.±.exactly_equals?(about_n) }
+  Then { n.‰.exactly_equals?(about_n) }
+  Then { n.€.exactly_equals?(about_n) }
+end

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

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe RSpec::Given::ClassExtensions do
+  let(:trace) { [] }
+
+  describe "Given with var" do
+    context "with simple given" do
+      Given(:a) { 1 }
+      Then { a.should == 1 }
+    end
+
+    context "is lazy" do
+      Given(:a) { trace << :given; 1 }
+      Then { a.should == 1 }
+      Then { trace.should == [] }
+      Then { a; trace.should == [:given] }
+
+      context "when nested" do
+        Given(:a) { trace << :nested; 2 }
+        Then { a.should == 2 }
+        Then { trace.should == [] }
+        Then { a; trace.should == [:nested] }
+      end
+    end
+  end
+
+  describe "Given without var" do
+    context "is lazy" do
+      Given { trace << :given }
+      Then { trace.should == [:given] }
+
+      context "when nested" do
+        Given { trace << :nested }
+        Then { trace.should == [:given, :nested] }
+      end
+    end
+  end
+
+  describe "Given!" do
+    context "with simple given" do
+      Given!(:a) { 1 }
+      Then { a.should == 1 }
+    end
+
+    context "is not lazy" do
+      Given!(:a) { trace << :given; 1 }
+      Then { a.should == 1 }
+      Then { trace.should == [:given] }
+      Then { a; trace.should == [:given] }
+    end
+
+    context "when preceeded by a Given block" do
+      Given { trace << :given }
+      Given!(:other) { trace << :given_bang }
+      Then { trace.should == [:given, :given_bang] }
+    end
+  end
+
+  describe "Given/Given!/before ordering" do
+    before { trace << :before_outer }
+    Given { trace << :given_outer }
+    Given!(:x_outer) { trace << :given_bang_outer }
+    before { trace << :before2_outer }
+    When { trace << :when_outer }
+    When(:result_outer) { trace << :when_result_outer }
+
+    Then {
+      trace.should == [
+        :before_outer, :before2_outer,
+        :given_outer, :given_bang_outer,
+        :when_outer,
+        :when_result_outer,
+      ]
+    }
+
+    context "with a nested When" do
+      before { trace << :before_inner }
+      Given { trace << :given_inner }
+      Given!(:x_inner) { trace << :given_bang_inner }
+      When(:result_inner) { trace << :when_result_inner }
+      When { trace << :when_inner }
+
+      Then {
+        trace.should == [
+          :before_outer, :before2_outer,
+          :given_outer, :given_bang_outer,
+          :given_inner, :given_bang_inner,
+          :when_outer, :when_result_outer,
+          :before_inner,
+          :when_result_inner, :when_inner,
+        ]
+      }
+    end
+
+    context "without a nested When" do
+      before { trace << :before_inner }
+      Given { trace << :given_inner }
+      Given!(:x_inner) { trace << :given_bang_inner }
+
+      Then {
+        trace.should == [
+          :before_outer, :before2_outer,
+          :given_outer, :given_bang_outer,
+          :given_inner, :given_bang_inner,
+          :when_outer, :when_result_outer,
+          :before_inner,
+        ]
+      }
+    end
+  end
+
+  describe "When without result" do
+    Given { trace << :given }
+    When { trace << :when }
+    Then { trace.should == [:given, :when] }
+
+    context "with nesting" do
+      Given { trace << :nested }
+      Then { trace.should == [:given, :nested, :when] }
+    end
+
+    context "with nesting of When" do
+      Given { trace << :nested }
+      When { trace << :when_nested }
+      Then { trace.should == [:given, :nested, :when, :when_nested] }
+    end
+  end
+
+  describe "When with result" do
+    Given { trace << :given }
+    When(:result) { trace << :when; :result }
+    Invariant { result.should == :result }
+
+    Then { trace.should == [:given, :when] }
+
+    context "with nesting" do
+      Given { trace << :nested }
+      Then { trace.should == [:given, :nested, :when] }
+    end
+
+    context "with nesting of When" do
+      Given { trace << :nested }
+      When { trace << :when_nested }
+      Then { trace.should == [:given, :nested, :when, :when_nested] }
+    end
+  end
+
+  describe "When with unreferenced result" do
+    Given { trace << :given }
+    When(:result) { trace << :when; :result }
+    Then { trace.should == [:given, :when] }
+  end
+
+  describe "Invariant with When" do
+    Given { trace << :given }
+    Invariant { trace << :invariant }
+    When { trace << :when }
+    Then { trace.should == [:given, :when, :invariant] }
+  end
+
+  describe "Invariant without When" do
+    Given { trace << :given }
+    Invariant { trace << :invariant }
+    Then { trace.should == [:given, :invariant] }
+  end
+
+  describe "Then" do
+    Given { trace << :given }
+    Then { trace << :then }
+    And { trace.should == [:given, :then] }
+  end
+
+  describe "Then referencing givens" do
+    Given(:given_value) { :ok }
+    Then { given_value == :ok }
+  end
+
+  describe "Then referencing when results" do
+    When(:result) { :ok }
+    Then { result == :ok }
+  end
+
+  describe "And" do
+    Given { trace << :given }
+    Then { trace << :then }
+    And { trace << :and}
+    And { trace.should == [:given, :then, :and] }
+  end
+
+end
+
+describe "use_natural_assertions" do
+  context "when in JRuby" do
+    CONTEXT = self
+
+    When(:result) { CONTEXT.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/failure_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'rspec/given/failure'
+
+describe RSpec::Given::Failure do
+  Given(:exception) { StandardError.new("Oops") }
+  Given(:failure) { RSpec::Given::Failure.new(exception) }
+
+  Then { lambda { failure.to_s }.should raise_error(StandardError, "Oops") }
+  Then { lambda { failure.call }.should raise_error(StandardError, "Oops") }
+  Then { lambda { failure.nil? }.should raise_error(StandardError, "Oops") }
+  Then { lambda { failure == 0 }.should raise_error(StandardError, "Oops") }
+  Then { lambda { failure != 0 }.should raise_error(StandardError, "Oops") }
+  Then { lambda { failure =~ 0 }.should raise_error(StandardError, "Oops") }
+  Then { lambda { ! failure }.should raise_error(StandardError, "Oops") }
+
+  Then { failure.is_a?(RSpec::Given::Failure).should be_true }
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module RSpec
+  module Given
+
+    DESCRIBE_LINE = __LINE__
+    describe FileCache do
+      Given(:file_name) { __FILE__ }
+      Given(:cache) { FileCache.new }
+
+      When(:result) { cache.get(file_name) }
+
+      context "when reading the file" do
+        Then { result[DESCRIBE_LINE].should =~ /describe FileCache do/ }
+        Then { result.size.should == MAX_LINE }
+      end
+
+      context "when getting the same file twice" do
+        Given { cache.should_receive(:read_lines).once.and_return(["A"]) }
+        When(:result2) { cache.get(file_name) }
+        Then { result.should == ["A"] }
+        Then { result2.should == ["A"] }
+      end
+    end
+  end
+end
+
+MAX_LINE = __LINE__

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

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe RSpec::Given::Fuzzy::FuzzyNumber do
+  use_natural_assertions_if_supported
+  include RSpec::Given::Fuzzy
+
+  describe "attributes" do
+    Given(:number) { about(10).delta(0.0001) }
+    Then { number.exact_value == 10 }
+    Then { number.delta_amount == 0.0001 }
+    Then { number.low_limit == (10 - 0.0001) }
+    Then { number.high_limit == (10 + 0.0001) }
+  end
+
+  describe "#exactly_equals?" do
+    Given(:number) { about(10).delta(0.0001) }
+    Given(:same_number) { about(10).delta(0.0001) }
+    Given(:different_delta) { about(10).delta(0.001) }
+    Given(:different_exact) { about(11).delta(0.0001) }
+
+    Then { number.exactly_equals?(number) }
+    Then { number.exactly_equals?(same_number) }
+
+    Then { ! number.exactly_equals?(different_exact) }
+    Then { ! number.exactly_equals?(different_delta) }
+  end
+
+  describe "fixed deltas" do
+    Given(:exact_number) { 10 }
+    Given(:number) { about(exact_number).delta(0.001) }
+
+    Then { exact_number == number }
+
+    Then { (exact_number + 0.001) == number }
+    Then { (exact_number - 0.001) == number }
+
+    Then { (exact_number + 0.001001) != number }
+    Then { (exact_number - 0.001001) != number }
+  end
+
+  describe "negative deltas" do
+    Given(:exact_number) { 10 }
+    Given(:number) { about(exact_number).delta(-0.001) }
+
+    Then { exact_number == number }
+
+    Then { (exact_number + 0.001) == number }
+    Then { (exact_number - 0.001) == number }
+
+    Then { (exact_number + 0.001001) != number }
+    Then { (exact_number - 0.001001) != number }
+  end
+
+  describe "percentage deltas" do
+    Given(:exact_number) { 1 }
+    Given(:number) { about(exact_number).percent(25) }
+
+    Then { exact_number == number }
+
+    Then { (exact_number + 0.25) == number }
+    Then { (exact_number - 0.25) == number }
+
+    Then { (exact_number + 0.25001) != number }
+    Then { (exact_number - 0.25001) != number }
+  end
+
+  describe "epsilon deltas" do
+    Given(:neps) { 10 }
+    Given(:hi_in_range) { 1 + neps*Float::EPSILON }
+    Given(:lo_in_range) { 1 - neps*Float::EPSILON }
+    Given(:hi_out_of_range) { 1 + (neps+1)*Float::EPSILON }
+    Given(:lo_out_of_range) { 1 - (neps+1)*Float::EPSILON }
+
+    Invariant { exact_number*hi_in_range == number }
+    Invariant { exact_number*lo_in_range == number }
+
+    Invariant { exact_number*hi_out_of_range != number }
+    Invariant { exact_number*lo_out_of_range != number }
+
+    context "when created with default delta" do
+      Given(:number) { about(exact_number) }
+
+      context "when 1" do
+        Given(:exact_number) { 1 }
+        Then { exact_number == number }
+      end
+
+      context "when rather large" do
+        Given(:exact_number) { 1_000_000 }
+        Then { exact_number == number }
+      end
+
+      context "when rather small" do
+        Given(:exact_number) { 0.000_001 }
+        Then { exact_number == number }
+      end
+    end
+
+    context "when created with small epsilon" do
+      Given(:neps) { 100 }
+      Given(:exact_number) { 10 }
+      Given(:number) { about(exact_number).epsilon(neps) }
+      Then { exact_number == number }
+    end
+  end
+
+  describe "#to_s" do
+    Given(:number) { about(10).delta(0.0001) }
+    Then { number.to_s == "<Approximately 10 +/- 0.0001>" }
+  end
+end