ageweke-rspec 1.2.9

data/examples/passing/simple_matcher_example.rb

@@ -0,0 +1,29 @@
+describe "arrays" do
+  def contain_same_elements_as(expected)
+    simple_matcher "array with same elements in any order as #{expected.inspect}" do |actual|
+      if actual.size == expected.size
+        a, e = actual.dup, expected.dup
+        until e.empty? do
+          if i = a.index(e.pop) then a.delete_at(i) end
+        end
+        a.empty?
+      else
+        false
+      end
+    end
+  end
+  
+  describe "can be matched by their contents disregarding order" do
+    subject { [1,2,2,3] }
+    it { should contain_same_elements_as([1,2,2,3]) }
+    it { should contain_same_elements_as([2,3,2,1]) }
+    it { should_not contain_same_elements_as([3,3,2,1]) }
+  end
+  
+  describe "fail the match with different contents" do
+    subject { [1,2,3] }
+    it { should_not contain_same_elements_as([2,3,4])}
+    it { should_not contain_same_elements_as([1,2,2,3])}
+    it { should_not contain_same_elements_as([1,2])}
+  end
+end

data/examples/passing/stack.rb

@@ -0,0 +1,36 @@
+class StackUnderflowError < RuntimeError
+end
+
+class StackOverflowError < RuntimeError
+end
+
+class Stack
+  
+  def initialize
+    @items = []
+  end
+  
+  def push object
+    raise StackOverflowError if @items.length == 10
+    @items.push object
+  end
+  
+  def pop
+    raise StackUnderflowError if @items.empty?
+    @items.delete @items.last
+  end
+  
+  def peek
+    raise StackUnderflowError if @items.empty?
+    @items.last
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def full?
+    @items.length == 10
+  end
+  
+end

data/examples/passing/stack_spec.rb

@@ -0,0 +1,63 @@
+require 'examples/passing/stack'
+require 'examples/passing/shared_stack_examples'
+
+describe Stack, " (empty)" do
+  before(:each) do
+    @stack = Stack.new
+  end
+  
+  # This uses @stack (because the described class is Stack) auto-generates the
+  # description "should be empty"
+  it { should be_empty }
+  
+  it_should_behave_like "non-full Stack"
+  
+  it "should complain when sent #peek" do
+    lambda { @stack.peek }.should raise_error(StackUnderflowError)
+  end
+  
+  it "should complain when sent #pop" do
+    lambda { @stack.pop }.should raise_error(StackUnderflowError)
+  end
+end
+
+describe Stack, " (with one item)" do
+  before(:each) do
+    @stack = Stack.new
+    @stack.push 3
+    @last_item_added = 3
+  end
+
+  it_should_behave_like "non-empty Stack"
+  it_should_behave_like "non-full Stack"
+
+end
+
+describe Stack, " (with one item less than capacity)" do
+  before(:each) do
+    @stack = Stack.new
+    (1..9).each { |i| @stack.push i }
+    @last_item_added = 9
+  end
+  
+  it_should_behave_like "non-empty Stack"
+  it_should_behave_like "non-full Stack"
+end
+
+describe Stack, " (full)" do
+  before(:each) do
+    @stack = Stack.new
+    (1..10).each { |i| @stack.push i }
+    @last_item_added = 10
+  end
+
+  # NOTE that this one auto-generates the description "should be full"
+  it { @stack.should be_full }  
+
+  it_should_behave_like "non-empty Stack"
+
+  it "should complain on #push" do
+    lambda { @stack.push Object.new }.should raise_error(StackOverflowError)
+  end
+  
+end

data/examples/passing/stack_spec_with_nested_example_groups.rb

@@ -0,0 +1,66 @@
+require 'examples/passing/stack'
+require 'examples/passing/shared_stack_examples'
+
+describe Stack do
+  
+  before(:each) do
+    @stack = Stack.new
+  end
+
+  describe "(empty)" do
+
+    it { @stack.should be_empty }
+  
+    it_should_behave_like "non-full Stack"
+  
+    it "should complain when sent #peek" do
+      lambda { @stack.peek }.should raise_error(StackUnderflowError)
+    end
+  
+    it "should complain when sent #pop" do
+      lambda { @stack.pop }.should raise_error(StackUnderflowError)
+    end
+
+  end
+
+  describe "(with one item)" do
+    
+    before(:each) do
+      @stack.push 3
+      @last_item_added = 3
+    end
+
+    it_should_behave_like "non-empty Stack"
+    it_should_behave_like "non-full Stack"
+
+  end
+
+  describe "(with one item less than capacity)" do
+    
+    before(:each) do
+      (1..9).each { |i| @stack.push i }
+      @last_item_added = 9
+    end
+  
+    it_should_behave_like "non-empty Stack"
+    it_should_behave_like "non-full Stack"
+  end
+
+  describe "(full)" do
+    
+    before(:each) do
+      (1..10).each { |i| @stack.push i }
+      @last_item_added = 10
+    end
+
+    it { @stack.should be_full }  
+
+    it_should_behave_like "non-empty Stack"
+
+    it "should complain on #push" do
+      lambda { @stack.push Object.new }.should raise_error(StackOverflowError)
+    end
+  
+  end
+
+end

data/examples/passing/stubbing_example.rb

@@ -0,0 +1,67 @@
+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/passing/yielding_example.rb

@@ -0,0 +1,31 @@
+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/ruby1.9.compatibility/access_to_constants_spec.rb

@@ -0,0 +1,85 @@
+# courtesy of Matthias Hennemeyer
+#
+# The following should pass against ruby 1.8 and 1.9. It currently only passes
+# 1.8 (as of 1/2/2009)
+#
+# Once cucumber supports ruby 1.9, this should be moved to cucumber scenarios instead. 
+module Foo 
+  module Bar
+    
+    module ModuleInEnclosingModule;end
+    class ClassInEnclosingModule;end 
+    def method_in_enclosing_module;end
+    CONSTANT_IN_ENCLOSING_MODULE = 0
+
+    describe "Examples trying to access constants defined in an enclosing module" do
+
+      it "can access Modules" do
+        ModuleInEnclosingModule
+      end
+      it "can access Classes" do
+        ClassInEnclosingModule.new
+      end
+      it "can access CONSTANTS" do
+        CONSTANT_IN_ENCLOSING_MODULE
+      end
+      it "can NOT access methods" do
+        lambda {method_in_enclosing_module}.should raise_error(/undefined/)
+      end
+
+      describe "from a nested example group" do
+
+        it "can access Modules" do
+          ModuleInEnclosingModule
+        end
+        it "can access Classes" do
+          ClassInEnclosingModule.new
+        end
+        it "can access CONSTANTS" do
+          CONSTANT_IN_ENCLOSING_MODULE
+        end
+        it "can NOT access methods" do
+          lambda {method_in_enclosing_module}.should raise_error(/undefined/)
+        end
+
+      end 
+
+    end
+    
+    describe "Examples trying to access constants defined in the example group" do
+      
+      module ModuleDefinedInGroup;end
+      class ClassDefinedInGroup; end 
+      def method_defined_in_group; end
+      CONSTANT_DEFINED_IN_GROUP = 0
+
+      it "can access Modules" do
+        ModuleDefinedInGroup
+      end
+      it "can access Classes" do
+        ClassDefinedInGroup.new
+      end
+      it "can access CONSTANTS" do
+        CONSTANT_DEFINED_IN_GROUP
+      end
+      it "can access methods" do
+        method_defined_in_group
+      end
+      
+      describe "that live inside a nested group" do
+        it "can access Modules" do
+          ModuleDefinedInGroup
+        end
+        it "can access Classes" do
+          ClassDefinedInGroup.new
+        end
+        it "can access CONSTANTS" do
+          CONSTANT_DEFINED_IN_GROUP
+        end
+        it "can access methods" do
+          method_defined_in_group
+        end
+      end
+    end 
+  end 
+end

data/features/before_and_after_blocks/before_and_after_blocks.feature

@@ -0,0 +1,167 @@
+Feature: before and after blocks
+
+  As a developer using RSpec
+  I want to execute arbitrary code before and after each example
+  So that I can control the environment in which it is run
+
+    This is supported by the before and after methods which each take a symbol
+    indicating the scope, and a block of code to execute.
+
+    before(:each) blocks are run before each example
+    before(:all) blocks are run once before all of the examples in a group
+    before(:suite) blocks are run once before the entire suite
+
+    after(:each) blocks are run after each example
+    after(:all) blocks are run once after all of the examples in a group
+    after(:suite) blocks are run once after the entire suite
+
+    Before and after blocks are called in the following order:
+      before suite
+      before all
+      before each
+      after each
+      after all
+      after suite
+
+    Before and after blocks can be defined in the example groups to which they
+    apply or in a configuration. When defined in a configuration, they can be
+    applied to all groups or subsets of all groups defined by example group
+    types.
+
+  Scenario: define before(:each) block in example group
+    Given a file named "before_each_in_example_group_spec.rb" with:
+      """
+      class Thing
+        def widgets
+          @widgets ||= []
+        end
+      end
+
+      describe Thing do
+        before(:each) do
+          @thing = Thing.new
+        end
+
+        context "initialized in before(:each)" do
+          it "has 0 widgets" do
+            @thing.should have(0).widgets
+          end
+
+          it "can get accept new widgets" do
+            @thing.widgets << Object.new
+          end
+
+          it "does not share state across examples" do
+            @thing.should have(0).widgets
+          end
+        end
+      end
+      """
+    When I run "spec before_each_in_example_group_spec.rb"
+    Then the stdout should include "3 examples, 0 failures"
+
+  Scenario: define before(:all) block in example group
+    Given a file named "before_all_in_example_group_spec.rb" with:
+      """
+      class Thing
+        def widgets
+          @widgets ||= []
+        end
+      end
+
+      describe Thing do
+        before(:all) do
+          @thing = Thing.new
+        end
+
+        context "initialized in before(:all)" do
+          it "has 0 widgets" do
+            @thing.should have(0).widgets
+          end
+
+          it "can get accept new widgets" do
+            @thing.widgets << Object.new
+          end
+
+          it "shares state across examples" do
+            @thing.should have(1).widgets
+          end
+        end
+      end
+      """
+    When I run "spec before_all_in_example_group_spec.rb"
+    Then the stdout should include "3 examples, 0 failures"
+
+  Scenario: define before and after blocks in configuration
+    Given a file named "befores_in_configuration_spec.rb" with:
+      """
+      Spec::Runner.configure do |config|
+        config.before(:suite) do
+          $before_suite = "before suite"
+        end
+        config.before(:each) do
+          @before_each = "before each"
+        end
+        config.before(:all) do
+          @before_all = "before all"
+        end
+      end
+
+      describe "stuff in before blocks" do
+        describe "with :suite" do
+          it "should be available in the example" do
+            $before_suite.should == "before suite"
+          end
+        end
+        describe "with :all" do
+          it "should be available in the example" do
+            @before_all.should == "before all"
+          end
+        end
+        describe "with :each" do
+          it "should be available in the example" do
+            @before_each.should == "before each"
+          end
+        end
+      end
+      """
+    When I run "spec befores_in_configuration_spec.rb"
+    Then the stdout should include "3 examples, 0 failures"
+
+  Scenario: before/after blocks are run in order
+    Given a file named "ensure_block_order_spec.rb" with:
+      """
+      Spec::Runner.configure do |config|
+        config.before(:suite) do
+          puts "before suite"
+        end
+        config.after(:suite) do
+          puts "after suite"
+        end
+      end
+
+      describe "before and after callbacks" do
+        before(:all) do
+          puts "before all"
+        end
+
+        before(:each) do
+          puts "before each"
+        end
+
+        after(:each) do
+          puts "after each"
+        end
+
+        after(:all) do
+          puts "after all"
+        end
+
+        it "gets run in order" do
+
+        end
+      end
+      """
+    When I run "spec ensure_block_order_spec.rb"
+    Then the stdout should include /before suite\nbefore all\nbefore each\nafter each\n\.after all\n.*after suite/m
+