ageweke-rspec 1.2.9

data/examples/passing/filtered_formatter.rb

@@ -0,0 +1,17 @@
+require 'spec/runner/formatter/nested_text_formatter'
+
+class FilteredFormatter < Spec::Runner::Formatter::NestedTextFormatter
+  def add_example_group(example_group)
+    if example_group.options[:show] == false
+      @showing = false
+    else
+      @showing = true
+      puts example_group.description 
+    end
+  end
+  
+  def example_passed(example)
+    puts "  " << example.description if @showing unless example.options[:show] == false
+  end
+end
+

data/examples/passing/filtered_formatter_example.rb

@@ -0,0 +1,31 @@
+# This demonstrates how you can write custom formatters to handle arbitrary
+# options passed to the +describe+ and +it+ methods. To see it in action, stand
+# in the project root and say:
+# 
+#   bin/spec -r examples/passing/filtered_formatter.rb examples/passing/filtered_formatter_example.rb -f FilteredFormatter
+#   
+# You should only see the examples and groups below that are not explicitly
+# marked :show => false
+#
+#   group 1
+#     example 1 a
+#   group 3
+#     example 3
+
+
+describe "group 1", :show => true do
+  it "example 1 a", :show => true do
+  end
+  it "example 1 b", :show => false do
+  end
+end
+
+describe "group 2", :show => false do
+  it "example 2" do
+  end
+end
+
+describe "group 3" do
+  it "example 3" do
+  end
+end

data/examples/passing/greeter_spec.rb

@@ -0,0 +1,30 @@
+# greeter.rb
+#
+# Based on http://glu.ttono.us/articles/2006/12/19/tormenting-your-tests-with-heckle
+#
+# Run with:
+#
+#   spec greeter_spec.rb --heckle Greeter
+#
+class Greeter
+  def initialize(person = nil)
+    @person = person
+  end
+
+  def greet
+    @person.nil? ? "Hi there!" : "Hi #{@person}!"
+  end
+end
+
+describe "Greeter" do
+  it "should say Hi to person" do
+    greeter = Greeter.new("Kevin")
+    greeter.greet.should == "Hi Kevin!"
+  end
+
+  it "should say Hi to nobody" do
+    greeter = Greeter.new
+    # Uncomment the next line to make Heckle happy
+    #greeter.greet.should == "Hi there!"
+  end
+end

data/examples/passing/helper_method_example.rb

@@ -0,0 +1,12 @@
+module HelperMethodExample
+  describe "an example group with helper a method" do
+    def helper_method
+      "received call"
+    end
+  
+    it "should make that method available to specs" do
+      helper_method.should == "received call"
+    end
+  end
+end
+

data/examples/passing/implicit_docstrings_example.rb

@@ -0,0 +1,16 @@
+# Run "spec implicit_docstrings_example.rb --format specdoc" to see the output of this file
+
+describe "Examples with no docstrings generate their own:" do
+
+  specify { 3.should be < 5 }
+
+  specify { ["a"].should include("a") }
+
+  specify { [1,2,3].should respond_to(:size) }
+
+end
+
+describe 1 do
+  it { should == 1 }
+  it { should be < 2}
+end

data/examples/passing/io_processor.rb

@@ -0,0 +1,8 @@
+class DataTooShort < StandardError; end
+
+class IoProcessor
+  # Does some fancy stuff unless the length of +io+ is shorter than 32
+  def process(io)
+    raise DataTooShort if io.read.length < 32
+  end
+end

data/examples/passing/io_processor_spec.rb

@@ -0,0 +1,20 @@
+require 'examples/passing/io_processor'
+require 'stringio'
+
+describe "An IoProcessor" do
+  before(:each) do
+    @processor = IoProcessor.new
+  end
+
+  it "should raise nothing when the file is exactly 32 bytes" do
+    lambda {
+      @processor.process(StringIO.new("z"*32))
+    }.should_not raise_error
+  end
+
+  it "should raise an exception when the file length is less than 32 bytes" do
+    lambda {
+      @processor.process(StringIO.new("z"*31))
+    }.should raise_error(DataTooShort)
+  end
+end

data/examples/passing/mocking_example.rb

@@ -0,0 +1,25 @@
+describe "A consumer of a mock" do
+  it "should be able to send messages to the mock" do
+    mock = mock("poke me")
+    mock.should_receive(:poke)
+    mock.poke
+  end
+end
+
+describe "a mock" do
+  it "should be able to mock the same message twice w/ different args" do
+    mock = mock("mock")
+    mock.should_receive(:msg).with(:arg1).and_return(:val1)
+    mock.should_receive(:msg).with(:arg2).and_return(:val2)
+    mock.msg(:arg1).should eql(:val1)
+    mock.msg(:arg2).should eql(:val2)
+  end
+
+  it "should be able to mock the same message twice w/ different args in reverse order" do
+    mock = mock("mock")
+    mock.should_receive(:msg).with(:arg1).and_return(:val1)
+    mock.should_receive(:msg).with(:arg2).and_return(:val2)
+    mock.msg(:arg2).should eql(:val2)
+    mock.msg(:arg1).should eql(:val1)
+  end
+end

data/examples/passing/multi_threaded_example_group_runner.rb

@@ -0,0 +1,26 @@
+class MultiThreadedExampleGroupRunner < Spec::Runner::ExampleGroupRunner
+  def initialize(options, arg)
+    super(options)
+    # configure these
+    @thread_count = 4
+    @thread_wait = 0
+  end
+
+  def run
+    @threads = []
+    q = Queue.new
+    example_groups.each { |b| q << b}
+    success = true
+    @thread_count.times do
+      @threads << Thread.new(q) do |queue|
+        while not queue.empty?
+          example_group = queue.pop
+          success &= example_group.suite.run(nil)
+        end
+      end
+      sleep @thread_wait
+    end
+    @threads.each {|t| t.join}
+    success
+  end
+end

data/examples/passing/nested_classes_example.rb

@@ -0,0 +1,35 @@
+require 'examples/passing/stack'
+
+class StackExamples < Spec::ExampleGroup
+  describe(Stack)
+  before(:each) do
+    @stack = Stack.new
+  end
+end
+
+class EmptyStackExamples < StackExamples
+  describe("when empty")
+  it "should be empty" do
+    @stack.should be_empty
+  end
+end
+
+class AlmostFullStackExamples < StackExamples
+  describe("when almost full")
+  before(:each) do
+    (1..9).each {|n| @stack.push n}
+  end
+  it "should be full" do
+    @stack.should_not be_full
+  end
+end
+
+class FullStackExamples < StackExamples
+  describe("when full")
+  before(:each) do
+    (1..10).each {|n| @stack.push n}
+  end
+  it "should be full" do
+    @stack.should be_full
+  end
+end

data/examples/passing/options_example.rb

@@ -0,0 +1,29 @@
+# This demonstrates the use of the options hash to support custom reporting.
+# To see the result, run this command from the project root:
+# 
+#   bin/spec --require examples/passing/options_formatter.rb examples/passing/options_example.rb \
+#     --format OptionsFormatter
+
+describe "this group will be reported", :report => true do
+  it "this example will be reported", :report => true do
+    # no-op
+  end
+
+  it "this example will not be reported", :report => false do
+    # no-op
+  end
+
+  it "this example will also not be reported", :foo => 'bar' do
+    # no-op
+  end
+
+  it "this example will also also not be reported" do
+    # no-op
+  end
+end
+
+describe "this group will not be reported", :report => false do
+  it "though this example will", :report => true do
+    # no-op
+  end
+end

data/examples/passing/options_formatter.rb

@@ -0,0 +1,20 @@
+# This is an example of how you can use a custom formatter to do custom
+# reporting. This formatter will only report example groups and examples that
+# have :report => true (or anything truthy) in the declaration. See
+# options_example.rb in this directory.  
+
+require 'spec/runner/formatter/base_text_formatter'
+
+class OptionsFormatter < Spec::Runner::Formatter::BaseTextFormatter
+  def example_started(proxy)
+    if proxy.options[:report]
+      puts proxy.description
+    end
+  end
+
+  def example_group_started(proxy)
+    if proxy.options[:report]
+      puts proxy.description
+    end
+  end
+end

data/examples/passing/partial_mock_example.rb

@@ -0,0 +1,27 @@
+class MockableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+describe "A partial mock" do
+
+  it "should work at the class level" do
+    MockableClass.should_receive(:find).with(1).and_return {:stub_return}
+    MockableClass.find(1).should equal(:stub_return)
+  end
+
+  it "should revert to the original after each spec" do
+    MockableClass.find(1).should equal(:original_return)
+  end
+
+  it "can be mocked w/ ordering" do
+    MockableClass.should_receive(:msg_1).ordered
+    MockableClass.should_receive(:msg_2).ordered
+    MockableClass.should_receive(:msg_3).ordered
+    MockableClass.msg_1
+    MockableClass.msg_2
+    MockableClass.msg_3
+  end
+
+end

data/examples/passing/pending_example.rb

@@ -0,0 +1,18 @@
+describe "pending example (using pending method)" do
+  it %Q|should be reported as "PENDING: for some reason"| do
+    pending("for some reason")
+  end
+end
+
+describe "pending example (with no block)" do
+  it %Q|should be reported as "PENDING: Not Yet Implemented"|
+end
+
+describe "pending example (with block for pending)" do
+  it %Q|should have a failing block, passed to pending, reported as "PENDING: for some reason"| do
+    pending("for some reason") do
+      raise "some reason"
+    end
+  end
+end
+

data/examples/passing/predicate_example.rb

@@ -0,0 +1,25 @@
+class BddFramework
+  def intuitive?
+    true
+  end
+  
+  def adopted_quickly?
+    true
+  end
+end
+
+describe "BDD framework" do
+
+  before(:each) do
+    @bdd_framework = BddFramework.new
+  end
+
+  it "should be adopted quickly" do
+    @bdd_framework.should be_adopted_quickly
+  end
+  
+  it "should be intuitive" do
+    @bdd_framework.should be_intuitive
+  end
+
+end

data/examples/passing/shared_example_group_example.rb

@@ -0,0 +1,79 @@
+module SharedExampleGroupExample
+  class OneThing
+    def what_things_do
+      "stuff"
+    end
+  end
+  
+  class AnotherThing
+    def what_things_do
+      "stuff"
+    end
+  end
+  
+  class YetAnotherThing
+    def what_things_do
+      "stuff"
+    end
+  end
+  
+  # A SharedExampleGroup is an example group that doesn't get run.
+  # You can create one like this:
+  share_examples_for "most things" do
+    def helper_method
+      "helper method"
+    end
+    
+    it "should do what things do" do
+      @thing.what_things_do.should == "stuff"
+    end
+  end
+
+  # A SharedExampleGroup is also a module. If you create one like this it gets
+  # assigned to the constant MostThings
+  share_as :MostThings do
+    def helper_method
+      "helper method"
+    end
+    
+    it "should do what things do" do
+      @thing.what_things_do.should == "stuff"
+    end
+  end
+  
+  describe OneThing do
+    # Now you can include the shared example group like this, which 
+    # feels more like what you might say ...
+    it_should_behave_like "most things"
+    
+    before(:each) { @thing = OneThing.new }
+    
+    it "should have access to helper methods defined in the shared example group" do
+      helper_method.should == "helper method"
+    end
+  end
+
+  describe AnotherThing do
+    # ... or you can include the example group like this, which
+    # feels more like the programming language we love.
+    it_should_behave_like MostThings
+    
+    before(:each) { @thing = AnotherThing.new }
+
+    it "should have access to helper methods defined in the shared example group" do
+      helper_method.should == "helper method"
+    end
+  end
+
+  describe YetAnotherThing do
+    # ... or you can include the example group like this, which
+    # feels more like the programming language we love.
+    include MostThings
+    
+    before(:each) { @thing = AnotherThing.new }
+
+    it "should have access to helper methods defined in the shared example group" do
+      helper_method.should == "helper method"
+    end
+  end
+end

data/examples/passing/shared_stack_examples.rb

@@ -0,0 +1,36 @@
+shared_examples_for "non-empty Stack" do
+
+  it { @stack.should_not be_empty }
+  
+  it "should return the top item when sent #peek" do
+    @stack.peek.should == @last_item_added
+  end
+  
+  it "should NOT remove the top item when sent #peek" do
+    @stack.peek.should == @last_item_added
+    @stack.peek.should == @last_item_added
+  end
+  
+  it "should return the top item when sent #pop" do
+    @stack.pop.should == @last_item_added
+  end
+  
+  it "should remove the top item when sent #pop" do
+    @stack.pop.should == @last_item_added
+    unless @stack.empty?
+      @stack.pop.should_not == @last_item_added
+    end
+  end
+  
+end
+
+shared_examples_for "non-full Stack" do
+
+  it { @stack.should_not be_full }
+
+  it "should add to the top when sent #push" do
+    @stack.push "newly added top item"
+    @stack.peek.should == "newly added top item"
+  end
+
+end