given 0.0.1 → 0.0.2

data/README.textile

@@ -24,6 +24,10 @@ class StackBehavior < Given::TestCase
   Invariant { expect(@stack.depth) >= 0 }
   Invariant { expect(@stack.empty?) == (@stack.depth == 0) }
 
+  def empty_stack
+    @stack = Stack.new
+  end
+
   Given(:empty_stack) do
     Then { expect(@stack.depth) == 0 }
 
@@ -36,6 +40,12 @@ class StackBehavior < Given::TestCase
     Then { expect(exception.message) =~ /empty/ }
   end
 
+  def stack_with_two_items
+    empty_stack
+    @stack.push(:bottom_item)
+    @stack.push(:top_item)
+  end
+
   Given(:stack_with_two_items) {
     Then { expect(@stack.top) == :top_item }
     Then { expect(@stack.depth) == 2}
@@ -52,16 +62,6 @@ class StackBehavior < Given::TestCase
     Then { expect(@result) == :bottom_item }
     Then { expect(@stack.depth) == 0 }
   }
-
-  def empty_stack
-    @stack = Stack.new
-  end
-
-  def stack_with_two_items
-    empty_stack
-    @stack.push(:bottom_item)
-    @stack.push(:top_item)
-  end
 end
 </pre>
 

data/Rakefile

@@ -3,15 +3,16 @@ require 'rake/testtask'
 
 CLOBBER.include("html")
 
-task :default => ["test:units", "test:functionals"]
+task :default => ["test:units", "test:functionals", :examples]
 
 task :tu => "test:units"
 task :tf => "test:functionals"
 
-EXAMPLE_FILES = FileList['examples/*_behavior.rb']
+EXAMPLE_FILES = FileList['examples/**/*_test.rb']
 desc "Run Examples"
-task :examples do
-  ruby "-I.:lib #{EXAMPLE_FILES}"
+Rake::TestTask.new(:examples) do |t|
+  t.test_files = EXAMPLE_FILES
+  t.warning = true
 end
 
 # README Formatting --------------------------------------------------

data/examples/greed/greed_score_test.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+require 'greed/score'
+
+class GreedScoreTest < Given::TestCase
+
+  Invariant { @score.bust? == (@score.points == 0) }
+  Invariant {
+    if @score.unused == 0
+      expect(@score.remaining) == 5
+    else
+      expect(@score.remaining) == @score.unused
+    end
+  }
+  
+  def points(dice)
+    @score = Greed::Score.for(dice)
+    expect(@score.points)
+  end
+
+  Given do
+    Then { points([]) == 0 }
+    Then { points([5]) == 50 }
+    Then { points([5,5]) == 100 }
+    Then { points([1]) == 100 }
+    Then { points([1,1]) == 200 }
+    Then { points([1,5,2,3,6]) == 150 }
+    Then { points([1,1,1]) == 1000 }
+    Then { points([2,2,2]) == 200 }
+    Then { points([3,3,3]) == 300 }
+    Then { points([1,1,1,1]) == 1100 }
+    Then { points([5,5,5,5]) == 550 }
+  end
+
+  def unused(dice)
+    @score = Greed::Score.for(dice)
+    expect(@score.unused)
+  end
+
+  Given do
+    Then { unused([]) == 0 }
+    Then { unused([1,5,2,2,2]) == 0 }
+    Then { unused([1,5,2,2]) == 2 }
+  end
+
+  def a_zero_score
+    @score = Greed::Score.new
+  end
+
+  Given(:a_zero_score) do
+    Then { expect(@score.points) == 0 }
+    Then { expect(@score.unused) == 0 }
+    Then { expect(@score) == Greed::Score.new(0, 0) }
+    Then { expect(@score).not == Greed::Score.new(1, 0) }
+    Then { expect(@score).not == Greed::Score.new(0, 1) }
+    Then { expect(@score).not == :non_score }
+  end
+
+  Given(:a_zero_score) do
+    Then { expect(@score + 0) == 0 }
+    Then { expect(@score + 100) == 0 }
+  end
+
+  def a_100_point_score
+    @score = Greed::Score.new(100, 4)
+  end
+
+  Given(:a_100_point_score) do
+    Then { expect(@score + 0) == 100 }
+    Then { expect(@score + 200) == 300 }
+  end
+
+end

data/examples/greed/greed_turner_test.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+require 'rubygems'
+require 'flexmock/test_unit'
+require 'greed/turner'
+require 'greed/score'
+
+class TurnerTest < Given::TestCase
+  Score = Greed::Score  
+
+  def a_turner_with_a_player
+    @rolls = []
+    @dice = flexmock("dice")
+    @dice.should_receive(:roll).with(Integer).
+      and_return { |n| @rolls.shift[0,n] }
+    @player = flexmock("player")
+    @player.should_receive(:start_turn => nil,
+      :roll_again? => false,
+      :end_turn => nil).by_default
+    @turner = Greed::Turner.new(@player, @dice)
+  end
+
+  def a_bust_roll
+    @rolls << [2, 3, 4, 4, 6]
+  end
+
+  def a_good_roll
+    @rolls << [1, 2, 2, 3, 3]
+  end
+
+  Given(:a_turner_with_a_player, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).never
+      @player.should_receive(:end_turn).once.with(0)
+    end
+  end
+
+  Given(:a_turner_with_a_player, :a_good_roll, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 4)).and_return(true)
+      @player.should_receive(:end_turn).once.with(0)
+    end
+  end
+
+  Given(:a_turner_with_a_player, :a_good_roll, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 4)).and_return(true)
+      @player.should_receive(:end_turn).once.with(0)
+    end
+  end
+
+  # Goal "Show that a player who stops after a good roll gets the score"
+  Given(:a_turner_with_a_player, :a_good_roll, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 4)).and_return(false)
+      @player.should_receive(:end_turn).once.with(100)
+    end
+  end
+
+  Given(:a_turner_with_a_player, :a_good_roll, :a_good_roll, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 4)).and_return(true)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 3)).and_return(false)
+      @player.should_receive(:end_turn).once.with(200)
+    end
+  end
+
+  def two_good_rolls
+    6.times { a_good_roll }
+  end
+
+  #Goal "Show that a turn ends when roll_again? returns false."
+  Given(:a_turner_with_a_player, :two_good_rolls, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 4)).and_return(true)
+      @player.should_receive(:roll_again?).once.with(Score.new(100, 3)).and_return(false)
+      @player.should_receive(:end_turn).once.with(200)
+    end
+  end
+
+  def six_good_rolls
+    6.times { a_good_roll }
+  end
+
+  # Goal "Show that scoring all the dice resets number rolled to 5.
+  Given(:a_turner_with_a_player, :six_good_rolls, :a_bust_roll) do
+    When { @turner.take_turn(400) }
+    Expecting do
+      @player.should_receive(:start_turn).once.with(0, 400)
+      @player.should_receive(:roll_again?).and_return(true).times(5)
+      @player.should_receive(:roll_again?).and_return(false)
+      @player.should_receive(:end_turn).once.with(600)
+    end
+  end
+end

data/examples/greed/score.rb

@@ -0,0 +1,101 @@
+# Greed is a dice game.  The rules to Greed varies, depending on who
+# you talk to, but the rules we are using are:
+#
+# * You can roll up to 5 dice
+#
+# * Any triplet of ones is worth 1000
+# 
+# * Any triplet of any other face value is worth 100 times the face
+#   value (e.g. 3 fours is worth 400 points)
+#
+# * Any ones not used in a triplet are worth 100 points
+#
+# * Any fives not used in a triplet are worth 50 points.
+#
+# * Any 2, 3, 4, or 6 faces not used in a triplet are worth 0 points
+#   are are counted as unused dice.
+#
+module Greed
+  # Score:
+  # * Tracks the points for a roll of dice
+  # * Reports the points for a roll
+  # * Reports the number of unused faces in a roll.
+  class Score
+    attr_reader :points, :unused
+
+    # Return the score object for a roll.  A roll is a list of
+    # integers representing the faces showing after a roll of dice.
+    def self.for(roll)
+      @score = new
+      @score.score(roll)
+      @score
+    end
+
+    def initialize(points=0, unused=0)
+      @points = points
+      @unused = unused
+    end
+
+    def to_s
+      "score<#{points},#{unused}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def ==(other)
+      other.kind_of?(Greed::Score) &&
+        points == other.points &&
+        unused == other.unused
+    end
+
+    def remaining
+      unused == 0 ? 5 : unused
+    end
+
+    def bust?
+      points == 0
+    end
+
+    def +(previous_turn_score)
+      bust? ? 0 : previous_turn_score + points
+    end
+
+    def score(roll)
+      (1..6).each do |face|
+        score_face(count_faces(face, roll), face)
+      end
+    end
+
+    def score_face(count, face)
+      if count >= 3 && face == 1
+        count -= 3
+        @points += 1000
+      elsif count >= 3
+        count -= 3
+        @points += face * 100
+      end
+      if face == 1 || face == 5
+        @points += count * score_single(face)
+      else
+        @unused += count
+      end
+    end
+
+    def score_single(die)
+      if die == 1
+        100
+      elsif die == 5
+        50 
+     else
+        0
+      end
+    end
+
+    def count_faces(face, dice)
+      dice.select { |f| f == face }.size
+    end
+
+  end
+end

data/examples/greed/test_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../test_helper'))
+

data/examples/greed/turner.rb

@@ -0,0 +1,21 @@
+require 'greed/score'
+
+module Greed
+  class Turner
+    def initialize(player, dice=d)
+      @dice = dice
+      @player = player
+    end
+
+    def take_turn(highest_score)
+      @player.start_turn(0, highest_score)
+      turn_score = 0
+      score = Score.new(0,0)
+      begin
+        score = Score.for(@dice.roll(score.unused.nonzero? || 5))
+        turn_score = score + turn_score
+      end while ! score.bust? && @player.roll_again?(score)
+      @player.end_turn(turn_score)
+    end
+  end
+end

data/examples/stack_test.rb

@@ -5,6 +5,10 @@ class StackBehavior < Given::TestCase
   Invariant { expect(@stack.depth) >= 0 }
   Invariant { expect(@stack.empty?) == (@stack.depth == 0) }
 
+  def empty_stack
+    @stack = Stack.new
+  end
+
   Given(:empty_stack) do
     Then { expect(@stack.depth) == 0 }
 
@@ -17,6 +21,12 @@ class StackBehavior < Given::TestCase
     Then { expect(exception.message) =~ /empty/ }
   end
 
+  def stack_with_two_items
+    empty_stack
+    @stack.push(:bottom_item)
+    @stack.push(:top_item)
+  end
+
   Given(:stack_with_two_items) {
     Then { expect(@stack.top) == :top_item }
     Then { expect(@stack.depth) == 2}
@@ -33,14 +43,4 @@ class StackBehavior < Given::TestCase
     Then { expect(@result) == :bottom_item }
     Then { expect(@stack.depth) == 0 }
   }
-
-  def empty_stack
-    @stack = Stack.new
-  end
-
-  def stack_with_two_items
-    empty_stack
-    @stack.push(:bottom_item)
-    @stack.push(:top_item)
-  end
 end

data/examples/test_helper.rb

@@ -0,0 +1,5 @@
+$: << File.dirname(__FILE__)
+
+require 'test/unit'
+require 'given/test_unit'
+

data/lib/given/dsl.rb

@@ -25,6 +25,7 @@ module Given
       @_given_setup_codes ||= []
       @_given_invariant_codes ||= []
       @_given_when_code = DO_NOTHING
+      @_given_mock_codes = []
       @_given_exception_class = nil
       old_setups = @_given_setup_codes
       old_invariants = @_given_invariant_codes
@@ -40,9 +41,17 @@ module Given
     def When(&when_code)
       _given_must_have_context("When")
       @_given_when_code = Code.new('W', when_code)
+      @_given_mock_codes = []
+
       @_given_exception_class = nil
     end
 
+    def Expecting(&mock_code)
+      _given_must_have_context("Mock")
+      @_given_mock_codes << AnonymousCode.new(mock_code)
+      Then { true }
+    end
+
     def Then(&then_code)
       _given_must_have_context("Then")
       _given_make_test_method("Then", Code.new('T', then_code), @_given_exception_class)
@@ -86,9 +95,11 @@ module Given
     def _given_make_test_method(clause, then_code, exception_class)
       setup_codes = @_given_setup_codes
       when_code = @_given_when_code
+      mock_codes = @_given_mock_codes
       invariant_codes = @_given_invariant_codes
       define_method _given_test_name(setup_codes, when_code, then_code) do
         setup_codes.each do |s| send s end
+        mock_codes.each do |m| m.run(self) end
         if exception_class.nil?
           when_code.run(self)
         else

data/lib/given/version.rb

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

data/test/functional/expecting_test.rb

@@ -0,0 +1,54 @@
+require 'test/test_helper'
+
+require 'given'
+
+class ExpectingTest < GivenTestCase
+  def test_mocks_are_called_before_when
+    assert_all_pass do
+      def trace
+        @trace ||= []
+      end
+      Given do
+        When { trace << :when }
+        Expecting { trace << :mock }
+        Then { expect(trace) == [:mock, :when] }
+      end
+    end
+  end
+
+  def test_mocks_without_when_still_runs_a_test
+    assert_all_pass do
+      Given do
+        Expecting { }
+      end
+    end
+  end
+
+  def test_mocks_dont_leak_across_whens
+    assert_all_pass do
+      def trace
+        @trace ||= []
+      end
+      Given do
+        Expecting { trace << :m1 }
+
+        When { }
+        Then { expect(trace) == [] }
+      end
+    end
+  end
+
+  def test_mocks_will_stack
+    assert_all_pass do
+      def trace
+        @trace ||= []
+      end
+      Given do
+        When { }
+        Expecting { trace << :m1 }
+        Expecting { trace << :m2 }
+        Then { expect(trace) == [:m1, :m2] }
+      end
+    end
+  end
+end

data/test/functional/invalid_use_test.rb

@@ -39,6 +39,25 @@ class InvalidUseTest < GivenTestCase
     assert_equal "A When clause must be inside a given block", ex.message
   end
 
+  def test_mock_must_be_inside_given
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Expecting {  }
+      end
+    end
+    assert_equal "A Mock clause must be inside a given block", ex.message
+  end
+
+  def test_mock_must_be_inside_given_part_2
+    ex = assert_raise(Given::UsageError) do
+      run_tests do
+        Given do end
+        Expecting {  }
+      end
+    end
+    assert_equal "A Mock 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: given
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Jim Weirich
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-17 00:00:00 -04:00
+date: 2009-10-26 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,7 @@ files:
 - lib/given/test_unit.rb
 - lib/given/version.rb
 - lib/given.rb
+- test/functional/expecting_test.rb
 - test/functional/fails_with_test.rb
 - test/functional/invalid_use_test.rb
 - test/functional/invariant_test.rb
@@ -48,8 +49,14 @@ files:
 - test/given/expectation_test.rb
 - test/given/test_unit/adapter_contract.rb
 - test/test_helper.rb
+- examples/greed/greed_score_test.rb
+- examples/greed/greed_turner_test.rb
+- examples/greed/score.rb
+- examples/greed/test_helper.rb
+- examples/greed/turner.rb
 - examples/stack.rb
 - examples/stack_test.rb
+- examples/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/jimweirich/Given
 licenses: []