dchelimsky-rspec 1.1.10

data/examples/pure/stubbing_example.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "A consumer of a stub" do
+  it "should be able to stub methods on any Object" do
+    obj = Object.new
+    obj.stub!(:foobar).and_return {:return_value}
+    obj.foobar.should equal(:return_value)
+  end
+end
+
+class StubbableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+describe "A stubbed method on a class" do
+  it "should return the stubbed value" do
+    StubbableClass.stub!(:find).and_return(:stub_return)
+    StubbableClass.find(1).should equal(:stub_return)
+  end
+  
+  it "should revert to the original method after each spec" do
+    StubbableClass.find(1).should equal(:original_return)
+  end
+
+  it "can stub! and mock the same message" do
+    StubbableClass.stub!(:msg).and_return(:stub_value)
+    StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value)
+
+    StubbableClass.msg.should equal(:stub_value)
+    StubbableClass.msg(:other_arg).should equal(:stub_value)
+    StubbableClass.msg(:arg).should equal(:mock_value)
+    StubbableClass.msg(:another_arg).should equal(:stub_value)
+    StubbableClass.msg(:yet_another_arg).should equal(:stub_value)
+    StubbableClass.msg.should equal(:stub_value)
+  end
+end
+
+describe "A mock" do
+  it "can stub!" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:value)
+    (1..10).each {mock.msg.should equal(:value)}
+  end
+  
+  it "can stub! and mock" do
+    mock = mock("stubbing mock")
+    mock.stub!(:stub_message).and_return(:stub_value)
+    mock.should_receive(:mock_message).once.and_return(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+    mock.mock_message.should equal(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+  end
+  
+  it "can stub! and mock the same message" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:stub_value)
+    mock.should_receive(:msg).with(:arg).and_return(:mock_value)
+    mock.msg.should equal(:stub_value)
+    mock.msg(:other_arg).should equal(:stub_value)
+    mock.msg(:arg).should equal(:mock_value)
+    mock.msg(:another_arg).should equal(:stub_value)
+    mock.msg(:yet_another_arg).should equal(:stub_value)
+    mock.msg.should equal(:stub_value)
+  end
+end
+
+    

data/examples/pure/yielding_example.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MessageAppender
+  
+  def initialize(appendage)
+    @appendage = appendage
+  end
+  
+  def append_to(message)
+    if_told_to_yield do
+      message << @appendage
+    end
+  end
+    
+end
+
+describe "a message expectation yielding to a block" do
+  it "should yield if told to" do
+    appender = MessageAppender.new("appended to")
+    appender.should_receive(:if_told_to_yield).and_yield
+    message = ""
+    appender.append_to(message)
+    message.should == "appended to"
+  end
+
+  it "should not yield if not told to" do
+    appender = MessageAppender.new("appended to")
+    appender.should_receive(:if_told_to_yield)
+    message = ""
+    appender.append_to(message)
+    message.should == ""
+  end
+end

data/examples/stories/adder.rb

@@ -0,0 +1,13 @@
+class Adder
+  def initialize
+    @addends = []
+  end
+  
+  def <<(val)
+    @addends << val
+  end
+  
+  def sum
+    @addends.inject(0) { |sum_so_far, val| sum_so_far + val }
+  end
+end

data/examples/stories/addition

@@ -0,0 +1,34 @@
+This is a story about a calculator. The text up here above the Story: declaration
+won't be processed, so you can write whatever you wish!
+
+Story: simple addition
+
+  As an accountant
+  I want to add numbers
+  So that I can count beans
+
+  Scenario: add one plus one
+    Given an addend of 1
+    And an addend of 1
+    
+    When the addends are addeds
+    
+    Then the sum should be 3
+    And the corks should be popped
+  
+  Scenario: add two plus five
+    Given an addend of 2
+    And an addend of 5
+    
+    When the addends are added
+    
+    Then the sum should be 7
+    Then it should snow
+    
+  Scenario: add three more
+    GivenScenario add two plus five
+    And an addend of 3
+    
+    When the addends are added
+    
+    Then the sum should be 10

data/examples/stories/addition.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), "adder")
+
+# with_steps_for :addition, :more_addition do
+with_steps_for :addition, :more_addition do
+  # Then("the corks should be popped") { }
+  run File.expand_path(__FILE__).gsub(".rb","")
+end
+

data/examples/stories/calculator.rb

@@ -0,0 +1,65 @@
+$:.push File.join(File.dirname(__FILE__), *%w[.. .. lib])
+require 'spec'
+
+class AdditionMatchers < Spec::Story::StepGroup
+  steps do |add|
+    add.given("an addend of $addend") do |addend|
+      @adder ||= Adder.new
+      @adder << addend.to_i
+    end
+  end
+end
+
+steps = AdditionMatchers.new do |add|  
+  add.then("the sum should be $sum") do |sum|
+    @sum.should == sum.to_i
+  end
+end
+
+steps.when("they are added") do
+  @sum = @adder.sum
+end
+
+# This Story uses steps (see above) instead of blocks
+# passed to Given, When and Then
+
+Story "addition", %{
+  As an accountant
+  I want to add numbers
+  So that I can count some beans
+}, :steps_for => steps do
+  Scenario "2 + 3" do
+    Given "an addend of 2"
+    And "an addend of 3"
+    When "they are added"
+    Then "the sum should be 5"
+  end
+  
+  # This scenario uses GivenScenario, which silently runs
+  # all the steps in a previous scenario.
+  
+  Scenario "add 4 more" do
+    GivenScenario "2 + 3"
+    Given "an addend of 4"
+    When "they are added"
+    Then "the sum should be 9"
+  end
+end
+
+# And the class that makes the story pass
+
+class Adder
+  def << addend
+    addends << addend
+  end
+  
+  def sum
+    @addends.inject(0) do |result, addend|
+      result + addend.to_i
+    end
+  end
+  
+  def addends
+    @addends ||= []
+  end
+end

data/examples/stories/game-of-life/.loadpath

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<loadpath>
+	<pathentry path="" type="src"/>
+	<pathentry path="org.rubypeople.rdt.launching.RUBY_CONTAINER" type="con"/>
+</loadpath>

data/examples/stories/game-of-life/README.txt

@@ -0,0 +1,21 @@
+John Conway's Game of Life
+
+The Rules
+---------
+The Game of Life was invented by John Conway (as you might have gathered).
+The game is played on a field of cells, each of which has eight neighbors (adjacent cells).
+A cell is either occupied (by an organism) or not.
+The rules for deriving a generation from the previous one are these:
+
+Survival
+--------
+If an occupied cell has 2 or 3 neighbors, the organism survives to the next generation.
+
+Death
+-----
+If an occupied cell has 0, 1, 4, 5, 6, 7, or 8 occupied neighbors, the organism dies
+(0, 1: of loneliness; 4 thru 8: of overcrowding).
+
+Birth
+-----
+If an unoccupied cell has 3 occupied neighbors, it becomes occupied.

data/examples/stories/game-of-life/behaviour/everything.rb

@@ -0,0 +1,6 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..')
+
+require 'spec'
+require 'behaviour/examples/examples'
+require 'behaviour/stories/stories'

data/examples/stories/game-of-life/behaviour/examples/examples.rb

@@ -0,0 +1,3 @@
+require 'spec'
+require 'behaviour/examples/game_behaviour'
+require 'behaviour/examples/grid_behaviour'

data/examples/stories/game-of-life/behaviour/examples/game_behaviour.rb

@@ -0,0 +1,35 @@
+require 'life'
+
+describe Game do
+  it 'should have a grid' do
+    # given
+    game = Game.new(5, 5)
+    
+    # then
+    game.grid.should be_kind_of(Grid)
+  end
+  
+  it 'should create a cell' do
+    # given
+    game = Game.new(2, 2)
+    expected_grid = Grid.from_string( 'X. ..' )
+    
+    # when
+    game.create_at(0, 0)
+    
+    # then
+    game.grid.should == expected_grid
+  end
+  
+  it 'should destroy a cell' do
+    # given
+    game = Game.new(2,2)
+    game.grid = Grid.from_string('X. ..')
+    
+    # when
+    game.destroy_at(0,0)
+    
+    # then
+    game.grid.should == Grid.from_string('.. ..')
+  end
+end

data/examples/stories/game-of-life/behaviour/examples/grid_behaviour.rb

@@ -0,0 +1,66 @@
+describe Grid do
+  it 'should be empty when created' do
+    # given
+    expected_contents = [
+      [0, 0, 0],
+      [0, 0, 0]
+    ]
+    grid = Grid.new(2, 3)
+    
+    # when
+    contents = grid.contents
+    
+    # then
+    contents.should == expected_contents
+  end
+  
+  it 'should compare equal based on its contents' do
+    # given
+    grid1 = Grid.new(2, 3)
+    grid2 = Grid.new(2, 3)
+    
+    # then
+    grid1.should == grid2
+  end
+  
+  it 'should be able to replace its contents' do
+    # given
+    grid = Grid.new(2,2)
+    new_contents = [[0,1,0], [1,0,1]]
+    
+    # when
+    grid.contents = new_contents
+    
+    # then
+    grid.contents.should == new_contents
+    grid.rows.should == 2
+    grid.columns.should == 3
+  end
+  
+  it 'should add an organism' do
+    # given
+    grid = Grid.new(2, 2)
+    expected = Grid.new(2, 2)
+    expected.contents = [[1,0],[0,0]]
+    
+    # when
+    grid.create_at(0,0)
+    
+    # then
+    grid.should == expected
+  end
+  
+  it 'should create itself from a string' do
+    # given
+    expected = Grid.new 3, 3
+    expected.create_at(0,0)
+    expected.create_at(1,0)
+    expected.create_at(2,2)
+    
+    # when
+    actual = Grid.from_string "X.. X.. ..X"
+    
+    # then
+    actual.should == expected
+  end
+end

data/examples/stories/game-of-life/behaviour/stories/CellsWithLessThanTwoNeighboursDie.story

@@ -0,0 +1,21 @@
+Story: cells with less than two neighbours die
+
+As a game producer
+I want cells with less than two neighbours to die
+So that I can illustrate how the game works to people with money
+
+Scenario: cells with zero or one neighbour die
+
+Given the grid looks like
+........
+.XX.XX..
+.XX.....
+....X...
+........
+When the next step occurs
+Then the grid should look like
+........
+.XX.....
+.XX.....
+........
+........

data/examples/stories/game-of-life/behaviour/stories/CellsWithMoreThanThreeNeighboursDie.story

@@ -0,0 +1,21 @@
+Story: cells with more than three neighbours die
+
+	As a game producer
+	I want cells with more than three neighbours to die
+	So that I can show the people with money how we are getting on
+
+	Scenario: blink
+
+		Given the grid looks like
+			.....
+			...XX
+			...XX
+			.XX..
+			.XX..
+		When the next step occurs
+		Then the grid should look like
+			.....
+			...XX
+			....X
+			.X...
+			.XX..

data/examples/stories/game-of-life/behaviour/stories/EmptySpacesWithThreeNeighboursCreateACell.story

@@ -0,0 +1,42 @@
+Story: Empty spaces with three neighbours create a cell
+
+As a game producer
+I want empty cells with three neighbours to die
+So that I have a minimum feature set to ship
+
+Scenario: the glider
+
+Given the grid looks like
+...X..
+..X...
+..XXX.
+......
+......
+When the next step occurs
+Then the grid should look like
+......
+..X.X.
+..XX..
+...X..
+......
+When the next step occurs
+Then the grid should look like
+......
+..X...
+..X.X.
+..XX..
+......
+When the next step occurs
+Then the grid should look like
+......
+...X..
+.XX...
+..XX..
+......
+When the next step occurs
+Then the grid should look like
+......
+..X...
+.X....
+.XXX..
+......