given 0.0.1

data/lib/given/errors.rb

@@ -0,0 +1,4 @@
+module Given
+  class GivenError < StandardError; end
+  class UsageError < GivenError; end
+end

data/lib/given/expectation.rb

@@ -0,0 +1,90 @@
+module Given
+  class Expectation
+    include Comparable
+
+    def initialize(value, test_case)
+      @value = value
+      @test_case = test_case
+    end
+
+    def not()
+      NegativeExpectation.new(@value, @test_case)
+    end
+
+    def evaluate_condition
+      yield(@value)
+    end
+
+    def check(condition, msg, *args)
+      bool = evaluate_condition(&condition)
+      @test_case.given_check(bool, msg, [@value, twist] + args)
+      true
+    end
+
+    def twist
+      ""
+    end
+
+    def ==(other)
+      check(
+        lambda { |value| value == other },
+        "<%s> expected to %sbe equal to\n<%s>.\n",
+        other)
+    end
+
+    def >(other)
+      check(lambda { |value| value > other },
+        "<%s> expected to %sbe greater than\n<%s>.\n",
+        other)
+    end
+
+    def <(other)
+      check(lambda { |value| value < other },
+        "<%s> expected to %sbe less than\n<%s>.\n",
+        other)
+    end
+
+    def <=(other)
+      check(lambda { |value| value <= other },
+        "<%s> expected to %sbe less than or equal to\n<%s>.\n",
+        other)
+    end
+    
+    def >=(other)
+      check(lambda { |value| value >= other },
+        "<%s> expected to %sbe greater than or equal to\n<%s>.\n",
+        other)
+    end
+
+    def =~(pattern)
+      check(lambda { |value| value =~ pattern },
+        "<%s> expected to %sbe matched by\n<%s>.\n",
+        pattern)
+    end
+
+    def nil?
+      check(lambda { |value| value.nil? },
+        "<%s> expected to %sbe nil")
+    end
+
+    def method_missing(sym, *args, &block)
+      method_name = sym.to_s
+      if method_name =~ /\?$/
+        check(lambda { |value| value.send(sym, *args, &block) },
+          "<%s> expected to %sbe %s",
+          [method_name[0..-2]])
+      else
+        fail Given::UsageError.new("cannot expect anything about #{sym}")
+      end
+    end
+  end
+
+  class NegativeExpectation < Expectation
+    def evaluate_condition
+      ! yield(@value)
+    end
+    def twist
+      "not "
+    end
+  end
+end

data/lib/given/framework.rb

@@ -0,0 +1,2 @@
+require 'given/framework/suite'
+require 'given/framework/test_case'

data/lib/given/test_unit.rb

@@ -0,0 +1,22 @@
+require 'given'
+require 'test/unit'
+require 'given/test_unit/adapter'
+
+module Given
+  module TestCaseMethods
+    def self.included(mod)
+      mod.module_eval do
+        extend Given::DSL
+        include Given::DSL::TestHelper
+        include Given::TestUnit::Adapter
+      end
+    end
+  end
+
+  class TestCase < Test::Unit::TestCase
+    include Given::TestCaseMethods
+
+    def test_DUMMY
+    end
+  end
+end

data/lib/given/test_unit/adapter.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+
+module Given
+  def self.assertion_failed_exception
+    Test::Unit::AssertionFailedError
+  end
+
+  module TestUnit
+    module Adapter
+      def given_failure(message, code=nil)
+        if code
+          message = "\n#{code.file_line} #{message}\n"
+        end
+        raise Test::Unit::AssertionFailedError.new(message)
+      end
+
+      def given_assert(clause, code)
+        _wrap_assertion do
+          ok = code.run(self)
+          if ! ok
+            given_failure("#{clause} Condition Failed", code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/given/version.rb

@@ -0,0 +1,7 @@
+module Given
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 0
+  VERSION_BUILD = 1
+  VERSION_NUMBERS = [VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD]
+  VERSION = VERSION_NUMBERS.join(".")
+end

data/test/functional/fails_with_test.rb

@@ -0,0 +1,93 @@
+require 'test/test_helper'
+require 'given'
+
+class FailsTest < GivenTestCase
+  def test_fails_with_expected_failure_is_ok
+    assert_all_pass do
+      Given do
+        When { fail "OUCH" }
+        FailsWith(RuntimeError)
+      end
+    end
+  end
+
+  def test_actual_exception_is_available
+    assert_all_pass do
+      Given do
+        When { fail "OUCH" }
+        FailsWith(RuntimeError)
+        Then { exception.class == RuntimeError }
+        And  { exception.message == "OUCH" }
+      end
+    end
+  end
+
+  def test_failure_block_must_be_true
+    line = 0
+    tally = run_tests do
+      Given do
+        When { fail "OUCH" }
+        FailsWith(RuntimeError)
+        Then { exception.class == RuntimeError }
+        line = __LINE__ + 1
+        And  { exception.message == "XXXX" }
+      end
+    end
+    assert ! tally.passed?
+    assert_match(/Then Condition Failed/, failure_message(tally))
+    assert_match(/:#{line}/, failure_message(tally))
+  end
+
+  def test_fails_without_expected_failure_is_not_ok
+    line = 0
+    tally = run_tests do
+      Given do
+        line = __LINE__ + 1
+        When { }
+        FailsWith(RuntimeError)
+      end
+    end
+    assert ! tally.passed?
+    assert_match(/Expected RuntimeError Exception/i, failure_message(tally))
+    assert_match(/:#{line}/, failure_message(tally))
+  end
+
+  class ExpectedError < RuntimeError
+  end
+
+  class ActualError < RuntimeError
+  end
+
+  def test_fails_with_unexpected_failure_is_not_ok
+    line = 0
+    tally = run_tests do
+      Given do
+        line = __LINE__ + 1
+        When { fail ActualError }
+        FailsWith(ExpectedError)
+      end
+    end
+    assert ! tally.passed?
+    assert_match(/Expected FailsTest::ExpectedError Exception/i,
+      failure_message(tally))
+    assert_match(/but got FailsTest::ActualError/i,
+      failure_message(tally))
+    assert_match(/:#{line}/, failure_message(tally))
+  end
+
+  def test_invariants_run_after_failure
+    tally = run_tests do
+      Given do
+        Invariant { false }
+
+        When { fail "OUCH" }
+        FailsWith(RuntimeError)
+      end
+    end
+    assert ! tally.passed?
+  end
+
+  # No Operation
+  def noop
+  end
+end

data/test/functional/invalid_use_test.rb

@@ -0,0 +1,60 @@
+require 'test/test_helper'
+
+class InvalidUseTest < GivenTestCase
+  def test_then_must_be_inside_given
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Then {  }
+      end
+    end
+    assert_equal "A Then clause must be inside a given block", ex.message
+  end
+
+  def test_then_must_be_inside_given_part_2
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Given do end
+        Then {  }
+      end
+    end
+    assert_equal "A Then clause must be inside a given block", ex.message
+  end
+
+  def test_when_must_be_inside_given
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        When {  }
+      end
+    end
+    assert_equal "A When clause must be inside a given block", ex.message
+  end
+
+  def test_when_must_be_inside_given_part_2
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Given do end
+        When {  }
+      end
+    end
+    assert_equal "A When clause must be inside a given block", ex.message
+  end
+
+  def test_fails_with_must_be_inside_given
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        FailsWith(RuntimeError)
+      end
+    end
+    assert_equal "A FailsWith clause must be inside a given block", ex.message
+  end
+
+  def test_fails_with_must_be_inside_given_part_2
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Given do end
+        FailsWith(RuntimeError)
+      end
+    end
+    assert_equal "A FailsWith clause must be inside a given block", ex.message
+  end
+end

data/test/functional/invariant_test.rb

@@ -0,0 +1,87 @@
+require 'test/test_helper'
+
+require 'given'
+
+class InvariantTest < GivenTestCase
+  def test_failing_invariants_fail_all_thens
+    tally = run_tests do
+      Given do
+        Invariant { false }
+        Then { true }
+        Then { true }
+      end
+    end
+    assert ! tally.passed?
+    assert_equal 2, tally.failure_count
+  end
+
+  def test_multiple_invariants_are_all_checked_part_1
+    tally = run_tests do
+      Given do
+        Invariant { false }
+        Invariant { true }
+        Then { true }
+      end
+    end
+    assert ! tally.passed?
+  end
+
+  def test_multiple_invariants_are_all_checked_part_2
+    tally = run_tests do
+      Given do
+        Invariant { true }
+        Invariant { false }
+        Then { true }
+      end
+    end
+    assert ! tally.passed?
+  end
+
+  def test_failing_global_invariants_fail_all_thens
+    line = 0
+    tally = run_tests do
+      line = __LINE__ + 1
+      Invariant { false }
+      Given do
+        Then { true }
+        Then { true }
+      end
+    end
+    assert ! tally.passed?
+    assert_equal 2, tally.failure_count
+    assert_match(/Invariant Condition/, failure_message(tally))
+    assert_match(/:#{line}/, failure_message(tally))
+  end
+
+  def test_invariants_run_after_given_setup
+    assert_all_pass do
+      Invariant { ! @track.nil? }
+      Given(:a_track) do
+        Invariant { ! @track.nil? }
+
+        Then { @track == [] }
+
+        When { @track << :w }
+        Then { @track == [:w] }
+      end
+    end
+  end
+
+  def test_invariants_nest_with_givens
+    assert_all_pass do
+      Given(:a_track) do
+        Invariant { ! @track.nil? }
+
+        Given(:a_track_with_b) do
+          Invariant { @track == [:b] }
+          Then { @track == [:b] }
+        end
+
+        Then { @track == [] }
+      end
+      def a_track_with_b
+        @track << :b
+      end
+    end
+  end
+end

data/test/functional/setup_test.rb

@@ -0,0 +1,79 @@
+require 'test/test_helper'
+
+require 'given'
+
+class SetupTest < GivenTestCase
+  def test_given_setup_is_run
+    assert_all_pass do
+      Given(:a_number) do
+        Then { @number == 10 }
+      end
+      def a_number
+        @number = 10
+      end
+    end
+  end
+
+  def test_multiple_setups_are_run
+    assert_all_pass do
+      Given(:a_number, :another_number) do
+        Then { @number == 10 && @another_number == 20 }
+      end
+      def a_number
+        @number = 10
+      end
+      def another_number
+        @another_number = 20
+      end
+    end
+  end
+
+  def test_setups_can_nest
+    assert_all_pass do
+      Given(:a_number) do
+        Given(:another_number) do
+          Then { @number == 10 && @another_number == 20 }
+        end
+      end
+      def a_number
+        @number = 10
+      end
+      def another_number
+        @another_number = 20
+      end
+    end
+  end
+
+  def test_nested_setups_clean_up
+    assert_all_pass do
+      Given(:set_nil) do
+        Given(:set_non_nil) do
+        end
+        Then { @stuff.nil? }
+      end
+      def set_nil
+        @stuff = nil
+      end
+      def set_non_nil
+        @stuff = :non_nil
+      end
+    end
+  end
+
+  def test_nested_setups_clean_up_even_with_errors
+    assert_all_pass do
+      Given(:set_nil) do
+        Given(:set_non_nil) do
+          fail "OOPS"
+        end rescue nil
+        Then { @stuff.nil? }
+      end
+      def set_nil
+        @stuff = nil
+      end
+      def set_non_nil
+        @stuff = :non_nil
+      end
+    end
+  end
+end