rspec 0.0.10

data/failing_examples/predicate_example.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class BddFramework
+  def intuitive?
+    true
+  end
+
+  def adopted_quickly?
+    #this will cause failures because it reallly SHOULD be adopted quickly
+    false
+  end
+end
+
+describe "BDD framework" do
+
+  before(:each) do
+    @bdd_framework = BddFramework.new
+  end
+
+  it "should be adopted quickly" do
+    #this will fail because it reallly SHOULD be adopted quickly
+    @bdd_framework.should be_adopted_quickly
+  end
+
+  it "should be intuitive" do
+    @bdd_framework.should be_intuitive
+  end
+
+end

data/failing_examples/raising_example.rb

@@ -0,0 +1,47 @@
+describe "This example" do
+  
+  it "should show that a NoMethodError is raised but an Exception was expected" do
+    proc { ''.nonexistent_method }.should raise_error
+  end
+  
+  it "should pass" do
+    proc { ''.nonexistent_method }.should raise_error(NoMethodError)
+  end
+  
+  it "should show that a NoMethodError is raised but a SyntaxError was expected" do
+    proc { ''.nonexistent_method }.should raise_error(SyntaxError)
+  end
+  
+  it "should show that nothing is raised when SyntaxError was expected" do
+    proc { }.should raise_error(SyntaxError)
+  end
+
+  it "should show that a NoMethodError is raised but a Exception was expected" do
+    proc { ''.nonexistent_method }.should_not raise_error
+  end
+  
+  it "should show that a NoMethodError is raised" do
+    proc { ''.nonexistent_method }.should_not raise_error(NoMethodError)
+  end
+  
+  it "should also pass" do
+    proc { ''.nonexistent_method }.should_not raise_error(SyntaxError)
+  end
+  
+  it "should show that a NoMethodError is raised when nothing expected" do
+    proc { ''.nonexistent_method }.should_not raise_error(Exception)
+  end
+  
+  it "should show that the wrong message was received" do
+    proc { raise StandardError.new("what is an enterprise?") }.should raise_error(StandardError, "not this")
+  end
+  
+  it "should show that the unexpected error/message was thrown" do
+    proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "abc")
+  end
+  
+  it "should pass too" do
+    proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "xyz")
+  end
+  
+end

data/failing_examples/spec_helper.rb

@@ -0,0 +1,3 @@
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+require "spec"

data/failing_examples/syntax_error_example.rb

@@ -0,0 +1,7 @@
+describe "when passing a block to a matcher" do
+  it "you should use {} instead of do/end" do
+    Object.new.should satisfy do
+      "this block is being passed to #should instead of #satisfy - use {} instead"
+    end
+  end
+end

data/failing_examples/team_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+class Team
+  attr_reader :players
+  def initialize
+    @players = Players.new
+  end
+end
+
+class Players
+  def initialize
+    @players = []
+  end
+  def size
+    @players.size
+  end
+  def include? player
+    raise "player must be a string" unless player.is_a?(String)
+    @players.include? player
+  end
+end
+
+describe "A new team" do
+  
+  before(:each) do
+    @team = Team.new
+  end
+  
+  it "should have 3 players (failing example)" do
+    @team.should have(3).players
+  end
+  
+  it "should include some player (failing example)" do
+    @team.players.should include("Some Player")
+  end
+
+  it "should include 5 (failing example)" do
+    @team.players.should include(5)
+  end
+  
+  it "should have no players"
+  
+end

data/failing_examples/timeout_behaviour.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Something really slow" do
+  it "should be failed by RSpec when it takes longer than --timeout" do
+    sleep(2)
+  end
+end

data/init.rb

@@ -0,0 +1,9 @@
+# Placeholder to satisfy Rails.
+#
+# Do NOT add any require statements to this file. Doing
+# so will cause Rails to load this plugin all of the time.
+#
+# Running 'ruby script/generate rspec' will
+# generate spec/spec_helper.rb, which includes the necessary
+# require statements and configuration. This file should
+# be required by all of your spec files.

data/lib/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rspec" if File.exist?('spec') && ENV['RSPEC']
+end

data/lib/autotest/rspec.rb

@@ -0,0 +1,72 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^spec/.*\.rb$%) { |filename, _| 
+    filename 
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| 
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^spec/.*_spec\.rb$%
+  }
+end
+
+class RspecCommandError < StandardError; end
+
+class Autotest::Rspec < Autotest
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+  
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:\Z?/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return "#{ruby} -S #{spec_command} #{add_options_if_present} #{files_to_test.keys.flatten.join(' ')}"
+  end
+  
+  def add_options_if_present # :nodoc:
+    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+  end
+
+  # Finds the proper spec command to use.  Precendence is set in the
+  # lazily-evaluated method spec_commands.  Alias + Override that in
+  # ~/.autotest to provide a different spec command then the default
+  # paths provided.
+  def spec_command(separator=File::ALT_SEPARATOR)
+    unless defined? @spec_command then
+      @spec_command = spec_commands.find { |cmd| File.exists? cmd }
+
+      raise RspecCommandError, "No spec command could be found!" unless @spec_command
+
+      @spec_command.gsub! File::SEPARATOR, separator if separator
+    end
+    @spec_command
+  end
+
+  # Autotest will look for spec commands in the following
+  # locations, in this order:
+  #
+  #   * bin/spec
+  #   * default spec bin/loader installed in Rubygems
+  def spec_commands
+    [
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')),
+      File.join(Config::CONFIG['bindir'], 'spec')
+    ]
+  end
+end

data/lib/spec.rb

@@ -0,0 +1,30 @@
+require 'spec/matchers'
+require 'spec/expectations'
+require 'spec/example'
+require 'spec/extensions'
+require 'spec/runner'
+require 'spec/adapters'
+
+if Object.const_defined?(:Test)
+  require 'spec/interop/test'
+end
+
+module Spec
+  class << self
+    def run?
+      @run || rspec_options.examples_run?
+    end
+
+    def run
+      return true if run?
+      result = rspec_options.run_examples
+      @run = true
+      result
+    end
+    attr_writer :run
+    
+    def exit?
+      !Object.const_defined?(:Test) || Test::Unit.run?
+    end
+  end
+end

data/lib/spec/adapters.rb

@@ -0,0 +1 @@
+require 'spec/adapters/ruby_engine'

data/lib/spec/adapters/ruby_engine.rb

@@ -0,0 +1,26 @@
+require 'spec/adapters/ruby_engine/mri'
+require 'spec/adapters/ruby_engine/rubinius'
+
+module Spec
+  module Adapters
+    module RubyEngine
+    
+      ENGINES = {
+        'mri' => MRI.new,
+        'rbx' => Rubinius.new
+      }
+    
+      def self.engine
+        if Object.const_defined?('RUBY_ENGINE')
+          return Object.const_get('RUBY_ENGINE')
+        else
+          return 'mri'
+        end
+      end
+    
+      def self.adapter
+        return ENGINES[engine]
+      end
+    end
+  end
+end

data/lib/spec/adapters/ruby_engine/mri.rb

@@ -0,0 +1,8 @@
+module Spec
+  module Adapters
+    module RubyEngine
+      class MRI
+      end
+    end
+  end
+end

data/lib/spec/adapters/ruby_engine/rubinius.rb

@@ -0,0 +1,8 @@
+module Spec
+  module Adapters
+    module RubyEngine
+      class Rubinius
+      end
+    end
+  end
+end

data/lib/spec/example.rb

@@ -0,0 +1,12 @@
+require 'timeout'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/module_inclusion_warnings'
+require 'spec/example/example_group_methods'
+require 'spec/example/example_methods'
+require 'spec/example/example_group'
+require 'spec/example/shared_example_group'
+require 'spec/example/example_group_factory'
+require 'spec/example/errors'
+require 'spec/example/configuration'
+require 'spec/example/example_matcher'

data/lib/spec/example/configuration.rb

@@ -0,0 +1,158 @@
+module Spec
+  module Example
+    class Configuration
+      # Chooses what mock framework to use. Example:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with :rspec, :mocha, :flexmock, or :rr
+      #   end
+      #
+      # To use any other mock framework, you'll have to provide your own
+      # adapter. This is simply a module that responds to the following
+      # methods:
+      #
+      #   setup_mocks_for_rspec
+      #   verify_mocks_for_rspec
+      #   teardown_mocks_for_rspec.
+      #
+      # These are your hooks into the lifecycle of a given example. RSpec will
+      # call setup_mocks_for_rspec before running anything else in each
+      # Example. After executing the #after methods, RSpec will then call
+      # verify_mocks_for_rspec and teardown_mocks_for_rspec (this is
+      # guaranteed to run even if there are failures in
+      # verify_mocks_for_rspec).
+      #
+      # Once you've defined this module, you can pass that to mock_with:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with MyMockFrameworkAdapter
+      #   end
+      #
+      def mock_with(mock_framework)
+        @mock_framework = case mock_framework
+        when Symbol
+          mock_framework_path(mock_framework.to_s)
+        else
+          mock_framework
+        end
+      end
+      
+      def mock_framework # :nodoc:
+        @mock_framework ||= mock_framework_path("rspec")
+      end
+      
+      # :call-seq:
+      #   include(Some::Helpers)
+      #   include(Some::Helpers, More::Helpers)
+      #   include(My::Helpers, :type => :key)
+      #
+      # Declares modules to be included in multiple example groups
+      # (<tt>describe</tt> blocks). With no :type, the modules listed will be
+      # included in all example groups. Use :type to restrict the inclusion to
+      # a subset of example groups. The value assigned to :type should be a
+      # key that maps to a class that is either a subclass of
+      # Spec::Example::ExampleGroup or extends Spec::Example::ExampleGroupMethods
+      # and includes Spec::Example::ExampleMethods
+      #
+      #   config.include(My::Pony, My::Horse, :type => :farm)
+      #
+      # Only example groups that have that type will get the modules included:
+      #
+      #   describe "Downtown", :type => :city do
+      #     # Will *not* get My::Pony and My::Horse included
+      #   end
+      #
+      #   describe "Old Mac Donald", :type => :farm do
+      #     # *Will* get My::Pony and My::Horse included
+      #   end
+      #
+      def include(*args)
+        args << {} unless Hash === args.last
+        modules, options = args_and_options(*args)
+        required_example_group = get_type_from_options(options)
+        required_example_group = required_example_group.to_sym if required_example_group
+        modules.each do |mod|
+          ExampleGroupFactory.get(required_example_group).send(:include, mod)
+        end
+      end
+
+      # Defines global predicate matchers. Example:
+      #
+      #   config.predicate_matchers[:swim] = :can_swim?
+      #
+      # This makes it possible to say:
+      #
+      #   person.should swim # passes if person.can_swim? returns true
+      #
+      def predicate_matchers
+        @predicate_matchers ||= {}
+      end
+      
+      # Prepends a global <tt>before</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def prepend_before(*args, &proc)
+        scope, options = scope_and_options(*args)
+        example_group = ExampleGroupFactory.get(
+          get_type_from_options(options)
+        )
+        example_group.prepend_before(scope, &proc)
+      end
+      
+      # Appends a global <tt>before</tt> block to all example groups.
+      #
+      # If you want to restrict the block to a subset of all the example
+      # groups then specify this in a Hash as the last argument:
+      #
+      #   config.prepend_before(:all, :type => :farm)
+      #
+      # or
+      #
+      #   config.prepend_before(:type => :farm)
+      #
+      def append_before(*args, &proc)
+        scope, options = scope_and_options(*args)
+        example_group = ExampleGroupFactory.get(
+          get_type_from_options(options)
+        )
+        example_group.append_before(scope, &proc)
+      end
+      alias_method :before, :append_before
+
+      # Prepends a global <tt>after</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def prepend_after(*args, &proc)
+        scope, options = scope_and_options(*args)
+        example_group = ExampleGroupFactory.get(
+          get_type_from_options(options)
+        )
+        example_group.prepend_after(scope, &proc)
+      end
+      alias_method :after, :prepend_after
+      
+      # Appends a global <tt>after</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def append_after(*args, &proc)
+        scope, options = scope_and_options(*args)
+        example_group = ExampleGroupFactory.get(
+          get_type_from_options(options)
+        )
+        example_group.append_after(scope, &proc)
+      end
+
+    private
+
+      def scope_and_options(*args)
+        args, options = args_and_options(*args)
+        scope = (args[0] || :each), options
+      end
+
+      def get_type_from_options(options)
+        options[:type] || options[:behaviour_type]
+      end
+    
+      def mock_framework_path(framework_name)
+        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "plugins", "mock_frameworks", framework_name))
+      end
+    end
+  end
+end