given 0.0.1

data/test/functional/then_test.rb

@@ -0,0 +1,62 @@
+require 'test/test_helper'
+
+require 'given'
+
+class ThenTest < GivenTestCase
+  def test_then_passes_when_block_is_true
+    assert_all_pass do
+      Given do
+        Then { true }
+      end
+    end
+  end
+
+  def test_then_fails_if_block_is_false
+    tally = run_tests do
+      Given do
+        Then { false }
+      end
+    end
+    assert ! tally.passed?
+  end
+
+  def test_then_fails_if_block_fails
+    tally = run_tests do
+      Given do
+        Then { fail "OUCH" }
+      end
+    end
+    assert ! tally.passed?
+  end
+
+  def test_multiple_thens_create_multiple_tests
+    assert_all_pass(2) do
+      Given do
+        Then { true }
+        Then { true }
+      end
+    end
+  end
+
+  def test_and_is_an_alias_for_then
+    assert_all_pass(3) do
+      Given do
+        Then { true }
+        And { true }
+        And { true }
+      end
+    end
+  end
+
+  def test_multiple_thens_with_tested_givens_create_multiple_tests
+    assert_all_pass(3) do
+      Given do
+        Given do
+          Then { true }
+        end
+        Then { true }
+        Then { true }
+      end
+    end
+  end
+end

data/test/functional/when_test.rb

@@ -0,0 +1,43 @@
+require 'test/test_helper'
+
+require 'given'
+
+class WhenTest < GivenTestCase
+  def test_whens_are_executed_after_all_setups_but_before_thens
+    assert_all_pass do
+      Given(:a, :b) do
+        When { @track << :c }
+        Then { @track == [:a, :b, :c] }
+      end
+      def a() @track = [:a] end
+      def b() @track << :b end
+    end
+  end
+
+  def test_whens_do_not_stack_linearly
+    assert_all_pass do
+      Given(:a_track) do
+        When { @track << :a }
+        Then { @track == [:a] }
+
+        When { @track << :b }
+        Then { @track == [:b] }
+      end
+    end
+  end
+
+  def test_whens_cleanup_from_nested_whens
+    assert_all_pass do
+      Given(:a_track) do
+        When { @track << :a }
+
+        Given do
+          When { @track << :b }
+          Then { @track == [:b] }
+        end
+
+        Then { @track == [] }
+      end
+    end
+  end
+end

data/test/given/anonymous_code_contract.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'given/test_unit'
+require 'given/anonymous_code'
+
+class AnonymousCodeContract < Given::TestCase
+  Given(:an_anonymous_code_snippet) do
+    Then { @code.run(self) == :result }
+    Then { @code.line_marker.nil? }
+    Then { @code.file_line.nil? }
+  end
+
+  def an_anonymous_code_snippet
+    @code = Given::AnonymousCode.new(lambda { :result })
+  end
+end

data/test/given/expectation_test.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'given/test_unit'
+
+require 'given/expectation'
+
+class ExpectationContract < Given::TestCase
+  Given do
+    Then { expect(1) == 1 }
+    Then { expect(2) > 1 }
+    Then { expect(2) >= 1 }
+    Then { expect(2) >= 2 }
+    Then { expect(2) < 3 }
+    Then { expect(2) <= 3 }
+    Then { expect(2) <= 2 }
+    Then { expect("abc") =~ /^a/ }
+    Then { expect("abc").not =~ /^b/ }
+    Then { expect(nil).nil? }
+    Then { expect([]).empty? }
+    Then { expect([1].size) == 1 }
+  end
+
+  Given do
+    When { expect([]).size }
+    FailsWith(Given::UsageError)
+    Then { expect(exception.message) =~ /x/ }
+  end
+
+  Given do
+    Then { expect(1).not == 2 }
+    Then { expect(2).not <= 1 }
+    Then { expect(2).not < 1 }
+    Then { expect(2).not < 2 }
+    Then { expect(2).not >= 3 }
+    Then { expect(2).not > 3 }
+    Then { expect(2).not > 2 }
+    Then { expect("abc").not =~ /^b/ }
+    Then { expect(1).not.nil? }
+    Then { expect([1]).not.empty? }
+    Then { expect([1,2].size).not == 1 }
+  end
+
+  Given do
+    When { expect(1) == 2 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<1> expected to be equal to.*<2>/m }
+
+    When { expect(1).not == 1 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<1> expected to not be equal to.*<1>/m }
+
+    When { expect(2) > 3 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<2> expected to be greater than.*<3>/m }
+
+    When { expect(3) < 2 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<3> expected to be less than.*<2>/m }
+    
+    When { expect(3) <= 2 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<3> expected to be less than or equal to.*<2>/m }
+    
+    When { expect(2) >= 3 }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<2> expected to be greater than or equal to.*<3>/m }
+    
+    When { expect("abc") =~ /^x/ }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<abc> expected to be matched by.*\^x/m }
+
+    When { expect(1).nil? }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<1> expected to be nil/m }
+
+    When { expect([1]).empty? }
+    FailsWith(Given.assertion_failed_exception)
+    Then { expect(exception.message) =~ /<1> expected to be empty\.?$/m }
+
+  end
+
+end

data/test/given/test_unit/adapter_contract.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'given/test_unit'
+
+class AdapterTest < Given::TestCase
+  include Given::TestUnit::Adapter
+
+  Code = Given::Code
+
+  def add_assertion
+    super
+    @assertion_counted = true
+  end
+
+  Given do
+    When { given_assert("Then", Code.new("T", lambda { true })) }
+    Then { @assertion_counted }
+
+    When {
+      @line = __LINE__ + 1
+      given_assert("Then", Code.new('T', lambda { false }))
+    }
+    FailsWith(Test::Unit::AssertionFailedError) do
+      Then {
+        exception.message =~ /#{__FILE__}:#{@line}/
+      }
+    end
+
+    When {
+      given_assert("Then", Code.new('T', lambda { fail "OUCH" }))
+    }
+    FailsWith(RuntimeError) do
+      Then { exception.message == "OUCH" }
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,190 @@
+require 'test/unit'
+require 'given'
+require 'given/test_unit/adapter'
+
+class GivenTestCase < Test::Unit::TestCase
+  private
+
+  # Reach inside the tally object and return the first failure message
+  def failure_message(tally)
+    failures = tally.instance_eval { @failures }
+    failures.first.instance_eval { @message }
+  end
+
+  def assert_all_pass(run_count=nil, &block)
+    tally = run_tests(&block)
+    assert tally.passed?, tally.inspect
+    unless run_count.nil?
+      assert_equal(run_count, tally.run_count,
+        "Wrong number of test runs")
+    end
+  end
+
+  def run_tests(&block)
+    tests = test_class(&block)
+    suite = tests.suite
+    tally = Test::Unit::TestResult.new
+    suite.run(tally) { }
+    tally
+  end
+
+  def test_class(&block)
+    Class.new(GivenFauxTestCase, &block)
+  end
+
+  def default_test
+  end
+end  
+
+# Fake TestCase for testing.  This has everything the real
+# Test::Unit::TestCase has, except that it won't trigger auto-testing.
+# We use this to construct test cases.
+class FauxTestCase
+  include Test::Unit::Assertions
+  include Test::Unit::Util::BacktraceFilter
+  include Given::DSL::TestHelper
+  extend Given::DSL
+  
+  attr_reader :method_name
+  
+  STARTED = name + "::STARTED"
+  FINISHED = name + "::FINISHED"
+  
+  ##
+  # These exceptions are not caught by #run.
+  
+  PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
+    SystemExit]
+  
+  # Creates a new instance of the fixture for running the
+  # test represented by test_method_name.
+  def initialize(test_method_name)
+    unless(respond_to?(test_method_name) and
+        (method(test_method_name).arity == 0 ||
+          method(test_method_name).arity == -1))
+      throw :invalid_test
+    end
+    @method_name = test_method_name
+    @test_passed = true
+  end
+  
+  # Rolls up all of the test* methods in the fixture into
+  # one suite, creating a new instance of the fixture for
+  # each method.
+  def self.suite
+    method_names = public_instance_methods(true)
+    tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+    suite = Test::Unit::TestSuite.new(name)
+    tests.sort.each do
+      |test|
+      catch(:invalid_test) do
+        suite << new(test)
+      end
+    end
+    if (suite.empty?)
+      catch(:invalid_test) do
+        suite << new("default_test")
+      end
+    end
+    return suite
+  end
+  
+  # Runs the individual test method represented by this
+  # instance of the fixture, collecting statistics, failures
+  # and errors in result.
+  def run(result)
+    yield(STARTED, name)
+    @_result = result
+    begin
+      setup
+      __send__(@method_name)
+    rescue Test::Unit::AssertionFailedError => e
+      add_failure(e.message, e.backtrace)
+    rescue Exception
+      raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+      add_error($!)
+    ensure
+      begin
+        teardown
+      rescue Test::Unit::AssertionFailedError => e
+        add_failure(e.message, e.backtrace)
+      rescue Exception
+        raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+        add_error($!)
+      end
+    end
+    result.add_run
+    yield(FINISHED, name)
+  end
+  
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+  end
+  
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+  def teardown
+  end
+  
+  def default_test
+    flunk("No tests were specified")
+  end
+  
+  # Returns whether this individual test passed or
+  # not. Primarily for use in teardown so that artifacts
+  # can be left behind if the test fails.
+  def passed?
+    return @test_passed
+  end
+  private :passed?
+  
+  def size
+    1
+  end
+  
+  def add_assertion
+    @_result.add_assertion
+  end
+  private :add_assertion
+  
+  def add_failure(message, all_locations=caller())
+    @test_passed = false
+    @_result.add_failure(Test::Unit::Failure.new(name, filter_backtrace(all_locations), message))
+  end
+  private :add_failure
+  
+  def add_error(exception)
+    @test_passed = false
+    @_result.add_error(Test::Unit::Error.new(name, exception))
+  end
+  private :add_error
+  
+  # Returns a human-readable name for the specific test that
+  # this instance of TestCase represents.
+  def name
+    "#{@method_name}(#{self.class.name})"
+  end
+  
+  # Overridden to return #name.
+  def to_s
+    name
+  end
+  
+  # It's handy to be able to compare TestCase instances.
+  def ==(other)
+    return false unless(other.kind_of?(self.class))
+    return false unless(@method_name == other.method_name)
+    self.class == other.class
+  end
+end
+
+
+class GivenFauxTestCase < FauxTestCase
+  include Given::TestUnit::Adapter
+
+  # A track array is used by many tests to record the order of events.
+  def a_track
+    @track = []
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: given
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Weirich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-17 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |
+  Given is a specification framework that allows explicit definition of the
+  pre and post-conditions for code under test.  Given is an alternative
+  to the traditional RSpec and Test::Unit frameworks.
+
+email: jim.weirich@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.textile
+- lib/given/anonymous_code.rb
+- lib/given/code.rb
+- lib/given/dsl.rb
+- lib/given/errors.rb
+- lib/given/expectation.rb
+- lib/given/framework.rb
+- lib/given/test_unit/adapter.rb
+- lib/given/test_unit.rb
+- lib/given/version.rb
+- lib/given.rb
+- test/functional/fails_with_test.rb
+- test/functional/invalid_use_test.rb
+- test/functional/invariant_test.rb
+- test/functional/setup_test.rb
+- test/functional/then_test.rb
+- test/functional/when_test.rb
+- test/given/anonymous_code_contract.rb
+- test/given/expectation_test.rb
+- test/given/test_unit/adapter_contract.rb
+- test/test_helper.rb
+- examples/stack.rb
+- examples/stack_test.rb
+has_rdoc: true
+homepage: http://github.com/jimweirich/Given
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+- --title
+- Rake -- Ruby Make
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: given
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Given/When/Then Specification Framework.
+test_files: []
+