+++ /dev/null
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module ApiMapHelpers
- def self.included(klass)
- klass.extend(ClassMethods)
- end
-
- def boundary_params(key)
- case key
- when :valid
- '-0.3565352711206896,51.464740877658045,-0.2686446461206896,51.508686190158045'
- when :min_lat_more_than_max_lat
- '-0.3565352711206896,51.508686190158045,-0.2686446461206896,51.464740877658045'
- when :min_lon_more_than_max_lon
- '51.464740877658045,-0.2686446461206896,51.508686190158045,-0.3565352711206896'
- end
- end
-
- module ClassMethods
- def otherasdfa
- end
- end
-end
-
-describe "When accessing /api/0.5/map" do
- controller_name :api
- include ApiMapHelpers
-
- before(:each) do
- end
-
- it "should _return success_ with _correct boundary longitudes/latitudes_" do
- get :map, :bbox => boundary_params(:valid)
- response.should be_success
- end
-
- it "should return an _error_ when _minimum longitude more than or equal to maximum longitude_" do
- get :map, :bbox => boundary_params(:min_lat_more_than_max_lat)
- response.should_not be_success
- end
-
- it "should return an error unless minimum latitude less than maximum latitude" do
- get :map, :bbox => boundary_params(:min_lon_more_than_max_lon)
- response.should_not be_success
- end
-
- it "should return an error unless latitudes are between -90 and 90 degrees" do
- pending
- end
-
- it "should return an error unless longitudes are between -180 and 180 degrees" do
- pending
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe ApiHelper do
-
- #Delete this example and add some real ones or delete this file
- it "should include the ApiHelper" do
- included_modules = self.metaclass.send :included_modules
- included_modules.should include(ApiHelper)
- end
-
-end
+++ /dev/null
---exclude "spec/*,gems/*"
---rails
\ No newline at end of file
+++ /dev/null
---colour
---format
-progress
---loadby
-mtime
---reverse
---backtrace
\ No newline at end of file
+++ /dev/null
-# This file is copied to ~/spec when you run 'ruby script/generate rspec'
-# from the project root directory.
-ENV["RAILS_ENV"] = "test"
-require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
-require 'spec'
-require 'spec/rails'
-
-require 'ruby-debug'
-
-Spec::Runner.configure do |config|
- # If you're not using ActiveRecord you should remove these
- # lines, delete config/database.yml and disable :active_record
- # in your config/boot.rb
- config.use_transactional_fixtures = true
- config.use_instantiated_fixtures = false
- config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
-
- # == Fixtures
- #
- # You can declare fixtures for each example_group like this:
- # describe "...." do
- # fixtures :table_a, :table_b
- #
- # Alternatively, if you prefer to declare them only once, you can
- # do so right here. Just uncomment the next line and replace the fixture
- # names with your fixtures.
- #
- # config.global_fixtures = :table_a, :table_b
- #
- # If you declare global fixtures, be aware that they will be declared
- # for all of your examples, even those that don't use them.
- #
- # == Mock Framework
- #
- # RSpec uses it's own mocking framework by default. If you prefer to
- # use mocha, flexmock or RR, uncomment the appropriate line:
- #
- # config.mock_with :mocha
- # config.mock_with :flexmock
- # config.mock_with :rr
-end
+++ /dev/null
-dir = File.dirname(__FILE__)
-Dir[File.expand_path("#{dir}/**/*.rb")].uniq.each do |file|
- require file
-end
\ No newline at end of file
+++ /dev/null
-ENV["RAILS_ENV"] = "test"
-require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
-require 'spec/rails/story_adapter'
\ No newline at end of file
+++ /dev/null
-== Version 1.1.2
-
-Minor bug fixes/enhancements.
-
-* RSpec's Autotest subclasses compatible with ZenTest-3.8.0 (thanks to Ryan Davis for making it easier on Autotest subs).
-* Applied patch from idl to add spec/lib to rake stats. Closes #226.
-* calling setup_fixtures and teardown_fixtures for Rails >= r8570. Closes #219.
-* Applied patch from Josh Knowles using ActiveSupport's Inflector (when available) to make 'should have' read a bit better. Closes #197.
-* Fixed regression in 1.1 that caused failing examples to fail to generate their own names. Closes #209.
-* Applied doc patch from Jens Krämer for capturing content_for
-* Applied patch from Alexander Lang to clean up story steps after each story. Closes #198.
-* Applied patch from Josh Knowles to support 'string_or_response.should have_text(...)'. Closes #193.
-* Applied patch from Ian Dees to quiet the Story Runner backtrace. Closes #183.
-* Complete support for defining steps with regexp 'names'.
-
-== Version 1.1.1
-
-Bug fix release.
-
-* Fix regression in 1.1.0 that caused transactions to not get rolled back between examples.
-* Applied patch from Bob Cotton to reintroduce ExampleGroup.description_options. Closes LH[#186]
-
-== Version 1.1.0
-
-The "tell me a story and go nest yourself" release.
-
-* Applied patch from Mike Vincent to handle generators rails > 2.0.1. Closes LH[#181]
-* Formatter.pending signature changed so it gets passed an ExampleGroup instance instead of the name ( LH[#180])
-* Fixed LH[#180] Spec::Rails::Example::ModelExampleGroup and friends show up in rspec/rails output
-* Spec::Rails no longer loads ActiveRecord extensions if it's disabled in config/boot.rb
-* Applied LH[#178] small annoyances running specs with warnings enabled (Patch from Mikko Lehtonen)
-* Tighter integration with Rails fixtures. Take advantage of fixture caching to get performance improvements (Thanks to Pat Maddox, Nick Kallen, Jonathan Barnes, and Curtis)
-
-== Version 1.1.0-RC1
-
-Textmate Bundle users - this release adds a new RSpec bundle that highlights describe, it, before and after and
-provides navigation to descriptions and examples (rather than classes and methods). When you first install this,
-it is going to try to hijack all of your .rb files. All you need to do is open a .rb file that does not end with
-'spec.rb' and change the bundle selection from RSpec to Ruby. TextMate will do the right thing from then on.
-
-Shortcuts for tab-activated snippets all follow the TextMate convention of 2 or 3 letters of the first word, followed by the first letter of each subsequent word. So "should have_at_least" would be triggered by shhal.
-
-We reduced the scope for running spec directories, files, a single file or individual spec in TextMate to source.ruby.rspec. This allowed us to restore the standard Ruby shortcuts:
-
-CMD-R runs all the specs in one file
-CMD-SHIFT-R runs an individual spec
-CMD-OPT-R runs any files or directories selected in the TextMate drawer
-
-rspec_on_rails users - don't forget to run script/generate rspec
-
-* Added shared_examples_for method, which you can (should) use instead of describe Foo, :shared => true
-* Applied LH[#168] Fix describe Object, "description contains a # in it" (Patch from Martin Emde)
-* Applied LH[#15] Reverse loading of ActionView::Base helper modules (Patch from Mark Van Holstyn)
-* Applied LH[#149] Update contribute page to point towards lighthouse (Patch from Josh Knowles)
-* Applied LH[#142] verify_rcov fails with latest rcov (Patch from Kyle Hargraves)
-* Applied LH[#10] Allow stubs to yield and return values (Patch from Pat Maddox)
-* Fixed LH[#139] version.rb in trunk missing svn last changed number
-* Applied LH[#14] Adding support for by_at_least/by_at_most in Change matcher (Patch from Saimon Moore)
-* Applied LH[#12] Fix for TM when switching to alternate file (Patch from Trevor Squires)
-* Applied LH[#133] ExampleMatcher should match against before(:all) (Patch from Bob Cotton)
-* Applied LH[#134] Only load spec inside spec_helper.rb (Patch from Mark Van Holstyn)
-* RSpec now bails immediately if there are examples with identical names.
-* Applied LH[#132] Plain Text stories should support Given and Given: (Patch from Jarkko Laine)
-* Applied patch from Pat Maddox: Story Mediator - the glue that binds the plain text story parser with the rest of the system
-* Applied LH[#16] Have SimpleMatchers expose their description for specdocs (Patch from Bryan Helmkamp)
-* Stories now support --colour
-* Changed the DSL modules to Example (i.e. Spec::Example instead of Spec::DSL)
-* Applied [#15608] Story problem if parenthesis used in Given, When, Then or And (Patch from Sinclair Bain)
-* Applied [#15659] GivenScenario fails when it is a RailsStory (Patch from Nathan Sutton)
-* Fixed [#15639] rcov exclusion configuration. (Spec::Rails projects can configure rcov with spec/rcov.opts)
-* The rdoc formatter (--format rdoc) is gone. It was buggy and noone was using it.
-* Changed Spec::DSL::Behaviour to Spec::DSL::ExampleGroup
-* Changed Spec::DSL::SharedBehaviour to Spec::DSL::SharedExampleGroup
-* Applied [#14023] Small optimization for heavily proxied objects. (Patch from Ian Leitch)
-* Applied [#13943] ProfileFormatter (Top 10 slowest examples) (Patch from Ian Leitch)
-* Fixed [#15232] heckle is not working correctly in trunk (as of r2801)
-* Applied [#14399] Show pending reasons in HTML report (Patch from Bryan Helmkamp)
-* Discovered fixed: [#10263] mock "leak" when setting an expectation in a block passed to mock#should_receive
-* Fixed [#14671] Spec::DSL::ExampleRunner gives "NO NAME because of --dry-run" for every example for 'rake spec:doc'
-* Fixed [#14543] rspec_scaffold broken with Rails 2.0
-* Removed Patch [#10577] Rails with Oracle breaks 0.9.2 - was no longer necessary since we moved describe to the Main object (instead of Object)
-* Fixed [#14527] specs run twice on rails 1.2.4 and rspec/rspec_on_rails trunk
-* Applied [#14043] Change output ordering to show pending before errors (Patch from Mike Mangino)
-* Applied [#14095] Don't have ./script/generate rspec create previous_failures.txt (Patch from Bryan Helmkamp)
-* Applied [#14254] Improved error handling for Object#should and Object#should_not (Patch from Antti Tarvainen)
-* Applied [#14186] Remove dead code from message_expecation.rb (Patch from Antti Tarvainen)
-* Applied [#14183] Tiny improvement on mock_spec.rb (Patch from Antti Tarvainen)
-* Applied [#14208] Fix to Mock#method_missing raising NameErrors instead of MockExpectationErrors (Patch from Antti Tarvainen)
-* Applied [#14255] Fixed examples in mock_spec.rb and shared_behaviour_spec.rb (Patch from Antti Tarvainen)
-* Applied [#14362] partially mocking objects that define == can blow up (Patch from Pat Maddox)
-* test_ methods with an arity of 0 defined in a describe block or Example object will be run as an Example, providing a seamless transition from Test::Unit
-* Removed BehaviourRunner
-* Fixed [#13969] Spec Failures on Trunk w/ Autotest
-* Applied [#14156] False positives with should_not (Patch from Antti Tarvainen)
-* Applied [#14170] route_for and params_from internal specs fixed (Patch from Antti Tarvainen)
-* Fixed [#14166] Cannot build trunk
-* Applied [#14142] Fix for bug #11602: Nested #have_tag specifications fails on the wrong line number (Patch from Antti Tarvainen)
-* Removed warn_if_no_files argument and feature
-* Steps (Given/When/Then) with no blocks are treated as pending
-* Applied [#13913] Scenario should treat no code block as pending (Patch from Evan Light)
-* Fixed [#13370] Weird mock expectation error (Patch from Mike Mangino)
-* Applied [#13952] Fix for performance regression introduced in r2096 (Patch from Ian Leitch)
-* Applied [#13881] Dynamically include Helpers that are included on ActionView::Base (Patch from Brandon Keepers)
-* Applied [#13833] ActionView::Helpers::JavaScriptMacrosHelper removed after 1.2.3 (Patch from Yurii Rashkovskii)
-* Applied [#13814] RSpec on Rails w/ fixture-scenarios (Patch from Shintaro Kakutani)
-* Add ability to define Example subclass instead of using describe
-* Applied Patch from James Edward Gray II to improve syntax highlighting in TextMate
-* Fixed [#13579] NoMethodError not raised for missing helper methods
-* Fixed [#13713] form helper method 'select' can not be called when calling custom helper methods from specs
-* Example subclasses Test::Unit::TestCase
-* Added stub_everything method to create a stub that will return itself for any message it doesn't understand
-* Added stories directory with stories/all.rb and stories/helper.rb when you script/generate rspec
-* Applied [#13554] Add "And" so you can say Given... And... When... Then... And...
-* Applied [#11254] RSpec syntax coloring and function pop-up integration in TextMate (Patch from Wincent Colaiuta)
-* Applied [#13143] ActionView::Helpers::RecordIdentificationHelper should be included if present (Patch from Jay Levitt)
-* Applied [#13567] patch to allow stubs to yield consecutive values (Patch from Rupert Voelcker)
-* Applied [#13559] reverse version of route_for (Patch from Rupert Voelcker)
-* Added [#13532] /lib specs should get base EvalContext
-* Applied [#13451] Add a null_object option to mock_model (Patch from James Deville)
-* Applied [#11919] Making non-implemented specs easy in textmate (Patch from Scott Taylor)
-* Applied [#13274] ThrowSymbol recognized a NameError triggered by Kernel#method_missing as a thrown Symbol
-* Applied [#12722] the alternate file command does not work in rails views due to scope (Patch from Carl Porth)
-* Behaviour is now a Module that is used by Example class methods and SharedBehaviour
-* Added ExampleDefinition
-* Added story runner framework based on rbehave [#12628]
-* Applied [#13336] Helper directory incorrect for rake stats in statsetup task (Patch from Curtis Miller)
-* Applied [#13339] Add the ability for spec_parser to parse describes with :behaviour_type set (Patch from Will Leinweber and Dav Yaginuma)
-* Fixed [#13271] incorrect behaviour with expect_render and stub_render
-* Applied [#13129] Fix failing specs in spec_distributed (Patch from Bob Cotton)
-* Applied [#13118] Rinda support for Spec::Distributed (Patch from Bob Cotton)
-* Removed BehaviourEval
-* Removed Behaviour#inherit
-* Moved implementation of install_dependencies to example_rails_app
-* Renamed RSPEC_DEPS to VENDOR_DEPS
-* Added Example#not_implemented?
-* You can now stub!(:msg).with(specific args)
-* describe("A", Hash, "with one element") will generate description "A Hash with one element" (Tip from Ola Bini)
-* Applied [#13016] [DOC] Point out that view specs render, well, a view (Patch from Jay Levitt)
-* Applied [#13078] Develop rspec with autotest (Patch from Scott Taylor)
-* Fixed [#13065] Named routes throw a NoMethodError in Helper specs (Patches from James Deville and Mike Mangino)
-* Added (back) the verbose attribute in Spec::Rake::SpecTask
-* Changed documentation to point at the new http svn URL, which is more accessible.
-
-== Version 1.0.8
-
-Another bugfix release - this time to resolve the version mismatch
-
-== Version 1.0.7
-
-Quick bugfix release to ensure that you don't have to have the rspec gem installed
-in order to use autotest with rspec_on_rails.
-
-* Fixed [#13015] autotest gives failure in 'spec_command' after upgrade 1.0.5 to 1.0.6
-
-== Version 1.0.6
-
-The "holy cow, batman, it's been a long time since we released and there are a ton of bug
-fixes, patches and even new features" release.
-
-Warning: Spec::Rails users: In fixing 11508, we've removed the raise_controller_errors method. As long as you
-follow the upgrade instructions and run 'script/generate rspec' you'll be fine, but if you skip this
-step you need to manually go into spec_helper.rb and remove the call to that method (if present - it
-might not be if you haven't upgraded in a while).
-
-Warning: Implementors of custom formatters. Formatters will now be sent an Example object instead of just a
-String for #example_started, #example_passed and #example_failed. In certain scenarios
-(Spec::Ui with Spec::Distributed), the formatter must ask the Example for its sequence number instead of
-keeping track of a sequence number internal to the formatter. Most of you shouldn't need to upgrade
-your formatters though - the Example#to_s method returns the example name/description, so you should be
-able to use the passed Example instance as if it were a String.
-
-* Applied [#12986] Autotest Specs + Refactoring (Patch from Scott Tayler)
-* Added a #close method to formatters, which allows them to gracefully close streams.
-* Applied [#12935] Remove requirement that mocha must be installed as a gem when used as mocking framework. (Patch from Ryan Kinderman).
-* Fixed [#12893] RSpec's Autotest should work with rspec's trunk
-* Fixed [#12865] Partial mock error when object has an @options instance var
-* Applied [#12701] Allow checking of content captured with content_for in view specs (Patch from Jens Kr�mer)
-* Applied [#12817] Cannot include same shared behaviour when required with absolute paths (Patch from Ian Leitch)
-* Applied [#12719] rspec_on_rails should not include pagination helper (Patch from Matthijs Langenberg)
-* Fixed [#12714] helper spec not finding rails core helpers
-* Applied [#12611] should_not redirect_to implementation (Patch from Yurii Rashkovskii)
-* Applied [#12682] Not correctly aliasing original 'stub!' and 'should_receive' methods for ApplicationController (Patch from Matthijs Langenberg)
-* Disabled controller.should_receive(:render) and controller.stub!(:render). Use expect_render or stub_render instead.
-* Applied [#12484] Allow a Behaviour's Description to flow through to the Formatter (Patch from Bob Cotton)
-* Fixed [#12448] The spec:plugins rake task from rspec_on_rails should ignore specs from the rspec_on_rails plugin
-* Applied [#12300] rr integration (patch from Kyle Hargraves)
-* Implemented [#12284] mock_with :rr (integration with RR mock framework: http://rubyforge.org/projects/pivotalrb/)
-* Applied [#12237] (tiny) added full path to mate in switch_command (Patch from Carl Porth)
-* Formatters will now be sent an Example object instead of just a String for certain methods
-* All Spec::Rake::SpecTask attributes can now be procs, which allows for lazy evaluation.
-* Changed the Spec::Ui interfaces slightly. See examples.
-* Applied [#12174] mishandling of paths with spaces in spec_mate switch_command (Patch from Carl Porth)
-* Implemented [#8315] File "Go to..." functionality
-* Applied [#11917] Cleaner Spec::Ui error for failed Selenium connection (Patch from Ian Dees)
-* Applied [#11888] rspec_on_rails spews out warnings when assert_select is used with an XML response (Patch from Ian Leitch)
-* Applied [#12010] Nicer failure message formatting (Patch from Wincent Colaiuta)
-* Applied [#12156] smooth open mate patch (Patch from Ienaga Eiji)
-* Applied [#10577] Rails with Oracle breaks 0.9.2. (Patch from Sinclair Bain)
-* Fixed [#12079] auto-generated example name incomplete: should have 1 error on ....]
-* Applied [#12066] Docfix for mocks/mocks.page (Patch from Kyle Hargraves)
-* Fixed [#11891] script/generate rspec_controller fails to create appropriate views (from templates) on edge rails
-* Applied [#11921] Adds the correct controller_name from derived_controller_name() to the ViewExampleGroupController (Patch from Eloy Duran)
-* Fixed [#11903] config.include with behaviour_type 'hash' does not work
-* Examples without blocks and pending is now reported with a P instead of a *
-* Pending blocks that now pass are rendered blue
-* New behaviour for after: If an after block raises an error, the other ones will still run instead of bailing at the first.
-* Made it possible to run spec from RSpec.tmbundle with --drb against a Rails spec_server.
-* Applied [#11868] Add ability for pending to optionally hold a failing block and to fail when it passes (Patch from Bob Cotton)
-* Fixed [#11843] watir_behaviour missing from spec_ui gem
-* Added 'switch between source and spec file' command in Spec::Mate (based on code from Ruy Asan)
-* Applied [#11509] Documentation - RSpec requires hpricot
-* Applied [#11807] Daemonize spec_server and rake tasks to manage them. (patch from Kyosuke MOROHASHI)
-* Added pending(message) method
-* Fixed [#11777] should render_template doesn't check paths correctly
-* Fixed [#11749] Use of 'rescue => e' does not catch all exceptions
-* Fixed [#11793] should raise_error('with a message') does not work correctly
-* Fixed [#11774] Mocks should respond to :kind_of? in the same way they respond to :is_a?
-* Fixed [#11508] Exceptions are not raised for Controller Specs (removed experimental raise_controller_errors)
-* Applied [#11615] Partial mock methods give ambiguous failures when given a method name as a String (Patch from Jay Phillips)
-* Fixed [#11545] Rspec doesn't handle should_receive on ActiveRecord associations (Patch from Ian White)
-* Fixed [#11514] configuration.use_transactional_fixtures is ALWAYS true, regardless of assignment
-* Improved generated RESTful controller examples to cover both successful and unsuccessful POST and PUT
-* Changed TextMate snippets for controllers to pass controller class names to #describe rather than controller_name.
-* Changed TextMate snippets for mocks to use no_args() and any_args() instead of the deprecated Symbols.
-* Applied [#11500] Documentation: no rails integration specs in 1.0
-* Renamed SpecMate's shortcuts for running all examples and focused examples to avoid conflicts (CMD-d and CMD-i)
-* Added a TextMate snippet for custom matchers, lifted from Geoffrey Grosenbach's RSpec peepcode show.
-* The translator translates mock constraints to the new matchers that were introduced in 1.0.4
-* Documented environment variables for Spec::Rake::SpecTask. Renamed SPECOPTS and RCOVOPTS to SPEC_OPTS and RCOV_OPTS.
-* Fixed [#10534] Windows: undefined method 'controller_name'
-
-== Version 1.0.5
-Bug fixes. Autotest plugin tweaks.
-
-* Fixed [#11378] fix to 10814 broke drb (re-opened #10814)
-* Fixed [#11223] Unable to access flash from rails helper specs
-* Fixed [#11337] autotest runs specs redundantly
-* Fixed [#11258] windows: autotest won't run
-* Applied [#11253] Tweaks to autotest file mappings (Patch from Wincent Colaiuta)
-* Applied [#11252] Should be able to re-load file containing shared behaviours without raising an exception (Patch from Wincent Colaiuta)
-* Fixed [#11247] standalone autotest doesn't work because of unneeded autotest.rb
-* Applied [#11221] Autotest support does not work w/o Rails Gem installed (Patch from Josh Knowles)
-
-== Version 1.0.4
-The getting ready for JRuby release.
-
-* Fixed [#11181] behaviour_type scoping of config.before(:each) is not working
-* added mock argument constraint matchers (anything(), boolean(), an_instance_of(Type)) which work with rspec or mocha
-* added mock argument constraint matchers (any_args(), no_args()) which only work with rspec
-* deprecated rspec's symbol mock argument constraint matchers (:any_args, :no_args, :anything, :boolean, :numeric, :string)
-* Added tarball of rspec_on_rails to the release build to support folks working behind a firewall that blocks svn access.
-* Fixed [#11137] rspec incorrectly handles flash after resetting the session
-* Fixed [#11143] Views code for ActionController::Base#render broke between 1.0.0 and 1.0.3 on Rails Edge r6731
-* Added raise_controller_errors for controller examples in Spec::Rails
-
-== Version 1.0.3
-Bug fixes.
-
-* Fixed [#11104] Website uses old specify notation
-* Applied [#11101] StringHelpers.starts_with?(prefix) assumes a string parameter for _prefix_
-* Removed 'rescue nil' which was hiding errors in controller examples.
-* Fixed [#11075] controller specs fail when using mocha without integrated_views
-* Fixed problem with redirect_to failing incorrectly against edge rails.
-* Fixed [#11082] RspecResourceGenerator should be RspecScaffoldGenerator
-* Fixed [#10959] Focused Examples do not work for Behaviour defined with constant with modules
-
-== Version 1.0.2
-This is just to align the version numbers in rspec and rspec_on_rails.
-
-== Version 1.0.1
-This is a maintenance release with mostly cleaning up, and one minor enhancement -
-Modules are automatically included when described directly.
-
-* Renamed Spec::Rails' rspec_resource generator to rspec_scaffold.
-* Removed Spec::Rails' be_feed matcher since it's based on assert_select_feed which is not part of Rails (despite that docs for assert_select_encoded says it is).
-* describe(SomeModule) will include that module in the examples. Like for Spec::Rails helpers, but now also in core.
-* Header in HTML report will be yellow instead of red if there is one failed example
-* Applied [#10951] Odd instance variable name in rspec_model template (patch from Kyle Hargraves)
-* Improved integration with autotest (Patches from Ryan Davis and David Goodland)
-* Some small fixes to make all specs run on JRuby.
-
-== Version 1.0.0
-The stake in the ground release. This represents a commitment to the API as it is. No significant
-backwards compatibility changes in the API are expected after this release.
-
-* Fixed [#10923] have_text matcher does not support should_not
-* Fixed [#10673] should > and should >= broken
-* Applied [#10921] Allow verify_rcov to accept greater than threshold coverage %'s via configuration
-* Applied [#10920] Added support for not implemented examples (Patch from Chad Humphries and Ken Barker)
-* Patch to allow not implemented examples. This works by not providing a block to the example. (Patch from Chad Humphries, Ken Barker)
-* Yanked support for Rails 1.1.6 in Spec::Rails
-* RSpec.tmbundle uses CMD-SHIFT-R to run focused examples now.
-* Spec::Rails now bundles a spec:rcov task by default (suggestion from Kurt Schrader)
-* Fixed [#10814] Runner loads shared code, test cases require them again
-* Fixed [#10753] Global before and after
-* Fixed [#10774] Allow before and after to be specified in config II
-* Refactored Spec::Ui examples to use new global before and after blocks.
-* Added instructions about how to get Selenium working with Spec::Ui (spec_ui/examples/selenium/README.txt)
-* Fixed [#10805] selenium.rb missing from gem?
-* Added rdocs explaining how to deal with errors in Rails' controller actions
-* Applied [#10770] Finer grained includes.
-* Fixed [#10747] Helper methods defined in shared specs are not visible when shared spec is used
-* Fixed [#10748] Shared descriptions in separate files causes 'already exists' error
-* Applied [#10698] Running with --drb executes specs twice (patch from Ruy Asan)
-* Fixed [#10871] 0.9.4 - Focussed spec runner fails to run specs in descriptions with type and string when there is no leading space in the string
-
-== Version 0.9.4
-This release introduces massive improvements to Spec::Ui - the user interface functional testing
-extension to RSpec. There are also some minor bug fixes to the RSpec core.
-
-* Massive improvements to Spec::Ui. Complete support for all Watir's ie.xxx(how, what) methods. Inline screenshots and HTML.
-* Reactivated --timeout, which had mysteriously been deactivated in a recent release.
-* Fixed [#10669] Kernel#describe override does not cover Kernel#context
-* Applied [#10636] Added spec for OptionParser in Runner (Patch from Scott Taylor)
-* Added [#10516] should_include should be able to accept multiple items
-* Applied [#10631] redirect_to matcher doesn't respect request.host (Patch from Tim Lucas)
-* Each formatter now flushes their own IO. This is to avoid buffering of output.
-* Fixed [#10670] IVarProxy#delete raises exception when instance variable does not exist
-
-== Version 0.9.3
-This is a bugfix release.
-
-* Fixed [#10594] Failing Custom Matcher show NAME NOT GENERATED description
-* describe(SomeType, "#message") will not add a space: "SomeType#message" (likewise for '.')
-* describe(SomeType, "message") will have a decription with a space: "SomeType message"
-* Applied [#10566] prepend_before and prepend_after callbacks
-* Applied [#10567] Call setup and teardown using before and after callbacks
-
-== Version 0.9.2
-This is a quick maintenance release.
-
-* Added some website love
-* Fixed [#10542] reverse predicate matcher syntax
-* Added a spec:translate Rake task to make 0.9 translation easier with Spec:Rails
-* Better translation of should_redirect_to
-* Fixed --colour support for Windows. This is a regression that was introduced in 0.9.1
-* Applied [#10460] Make SpecRunner easier to instantiate without using commandline args
-
-== Version 0.9.1
-
-This release introduces #describe and #it (aliased as #context and #specify for
-backwards compatibility). This allows you to express specs like this:
-
- describe SomeClass do # Creates a Behaviour
- it "should do something" do # Creates an Example
- end
- end
-
-The command line features four new options that give you more control over what specs
-are being run and in what order. This can be used to verify that your specs are
-independent (by running in opposite order with --reverse). It can also be used to cut
-down feedback time by running the most recently modified specs first (--loadby mtime --reverse).
-
-Further, --example replaces the old --spec option, and it can now take a file name of
-spec names as an alternative to just a spec name. The --format failing_examples:file.txt
-option allows you to output an --example compatible file, which makes it possible to only
-rerun the specs that failed in the last run. Spec::Rails uses all of these four options
-by default to optimise your RSpec experience.
-
-There is now a simple configuration model. For Spec::Rails, you do something like this:
-
- Spec::Runner.configure do |config|
- config.use_transactional_fixtures = true
- config.use_instantiated_fixtures = false
- config.fixture_path = RAILS_ROOT + '/spec/fixtures'
- end
-
-You can now use mocha or flexmock with RSpec if you prefer either to
-RSpec's own mock framework. Just put this:
-
- Spec::Runner.configure do |config|
- config.mock_with :mocha
- end
-
-or this:
-
- Spec::Runner.configure do |config|
- config.mock_with :flexmock
- end
-
-in a file that is loaded before your specs. You can also
-configure included modules and predicate_matchers:
-
- Spec::Runner.configure do |config|
- config.include SomeModule
- config.predicate_matchers[:does_something?] = :do_something
- end
-
-See Spec::DSL::Behaviour for more on predicate_matchers
-
-* Sugar FREE!
-* Added [10434 ] Please Make -s synonymous with -e for autotest compat. This is temporary until autotest uses -e instead of -s.
-* Fixed [#10133] custom predicate matchers
-* Applied [#10473] Add should exist (new matcher) - Patch from Bret Pettichord
-* Added another formatter: failing_behaviours. Writes the names of the failing behaviours for use with --example.
-* Applied [#10315] Patch to fix pre_commit bug 10313 - pre_commit_rails: doesn't always build correctly (Patch from Antii Tarvainen)
-* Applied [#10245] Patch to HTML escape the behavior name when using HTML Formatter (Patch from Josh Knowles)
-* Applied [#10410] redirect_to does not behave consistently with regards to query string parameter ordering (Patch from Nicholas Evans)
-* Applied [#9605] Patch for ER 9472, shared behaviour (Patch by Bob Cotton)
-* The '--format rdoc' option no longer causes a dry-run by default. --dry-run must be used explicitly.
-* It's possible to specify the output file in the --format option (See explanation in --help)
-* Several --format options may be specified to output several formats in one run.
-* The --out option is gone. Use --format html:path/to/my.html instead (or similar).
-* Spec::Runner::Formatter::BaseTextFormatter#initialize only takes one argument - an IO. dry_run and color are setters.
-* Made Spec::Ui *much* easier to install. It will be released separately. Check out trunk/spec_ui/examples
-* HTML reports now include a syntax highlighted snippet of the source code where the spec failed (needs the syntax gem)
-* Added [#10262] Better Helper testing of Erb evaluation block helpers
-* Added [#9735] support flexmock (thanks to Jim Weirich for his modifications to flexmock to support this)
-* Spec::Rails controller specs will no longer let mock exception ripple through to the response.
-* Fixed [#9260] IvarProxy does not act like a hash.
-* Applied [#9458] The rspec_scaffold generator does not take into account class nesting (Patch from Steve Tendon)
-* Applied [#9132] Rakefile spec:doc can fail without preparing database (Patch from Steve Ross)
-* Applied [#9678] Custom runner command line switch, and multi-threaded runner (Patch from Bob Cotton)
-* Applied [#9926] Rakefile - RSPEC_DEPS constant as an Array of Hashes instead of an Array of Arrays (Patch from Scott Taylor)
-* Applied [#9925] Changed ".rhtml" to "template" in REST spec generator (Patch from Scott Taylor)
-* Applied [#9852] Patch for RSpec's Website using Webgen 0.4.2 (Patch from Scott Taylor)
-* Fixed [#6523] Run rspec on rails without a db
-* Fixed [#9295] rake spec should run anything in the spec directory (not just rspec's standard dirs)
-* Added [#9786] infer controller and helper names from the described type
-* Fixed [#7795] form_tag renders action='/view_spec' in view specs
-* Fixed [#9767] rspec_on_rails should not define rescue_action on controllers
-* Fixed [#9421] --line doesn't work with behaviours that use class names
-* Fixed [#9760] rspec generators incompatible with changes to edge rails
-* Added [#9786] infer controller and helper names from the described type
-* Applied a simplified version of [#9282] Change to allow running specs from textmate with rspec installed as a rails plugin (and no rspec gem installed)
-* Applied [#9700] Make Spec::DSL::Example#name public / Add a --timeout switch. A great way to prevent specs from getting slow.
-* In Rails, script/generate rspec will generate a spec.opts file that optimises faster/more efficient running of specs.
-* Added [#9522] support using rspec's expectations with test/unit
-* Moved rspec_on_rails up to the project root, simplifying the download url
-* Fixed [#8103] RSpec not installing spec script correctly.
-* The --spec option is replaced by the --example option.
-* The --loadby option no longer supports a file argument. Use --example file_name instead.
-* The --example option can now take a file name as an argument. The file should contain example names.
-* Internal classes are named Behaviour/Example (rather than Context/Specification).
-* You can now use mocha by saying config.mock_with :mocha in a spec_helper
-* before_context_eval is replaced by before_eval.
-* Applied [#9509] allow spaced options in spec.opts
-* Applied [#9510] Added File for Ruby 1.8.6
-* Applied [#9511] Clarification to README file in spec/
-* Moved all of the Spec::Rails specs down to the plugins directory - now you can run the specs after you install.
-* Updated RSpec.tmbundle to the 0.9 syntax and replaced context/specify with describe/it.
-* Applied [#9232] ActionController::Base#render is sometimes protected (patch from Dan Manges)
-* Added --reverse option, allowing contexts/specs to be run in reverse order.
-* Added --loadby option, allowing better control over load order for spec files. mtime and file.txt supported.
-* Implemented [#8696] --order option (see --reverse and --loadby)
-* Added describe/it as aliases for context/specify - suggestion from Dan North.
-* Applied [#7637] [PATCH] add skip-migration option to rspec_scaffold generator
-* Added [#9167] string.should have_tag
-* Changed script/rails_spec_server to script/spec_server and added script/spec (w/ path to vendor/plugins/rspec)
-* Fixed [#8897] Error when mixing controller spec with/without integrated views and using template system other than rhtml
-* Updated sample app specs to 0.9 syntax
-* Updated generated specs to 0.9 syntax
-* Applied [#8994] trunk: generated names for be_ specs (Multiple patches from Yurii Rashkovskii)
-* Applied [#9983]: Allow before and after to be called in BehaviourEval. This is useful for shared examples.
-
-== Version 0.8.2
-
-Replaced assert_select fork with an assert_select wrapper for have_tag. This means that "should have_rjs" no longer supports :hide or :effect, but you can still use should_have_rjs for those.
-
-== Version 0.8.1
-
-Quick "in house" bug-fix
-
-== Version 0.8.0
-
-This release introduces a new approach to handling expectations using Expression Matchers.
-
-See Upgrade[http://rspec.rubyforge.org/upgrade.html], Spec::Expectations, Spec::Matchers and RELEASE-PLAN for more info.
-
-This release also improves the spec command line by adding DRb support and making it possible to
-store command line options in a file. This means a more flexible RSpec experience with Rails,
-Rake and editor plugins like TextMate.
-
-It also sports myriad new features, bug fixes, patches and general goodness:
-
-* Fixed [#8928] rspec_on_rails 0.8.0-RC1 controller tests make double call to setup_with_fixtures
-* Fixed [#8925] Documentation bug in 0.8.0RC1 rspec website
-* Applied [#8132] [PATCH] RSpec breaks "rake db:sessions:create" in a rails project that has the rspec_on_rails plugin (Patch from Erik Kastner)
-* Fixed [#8789] --line and --spec not working when the context has parenhesis in the name
-* Added [#8783] auto generate spec names from last expectation
-* --heckle now fails if the heckled class or module is not found.
-* Fixed [#8771] Spec::Mocks::BaseExpectation#with converts hash params to array of arrays with #collect
-* Fixed [#8750] should[_not]_include backwards compatibility between 0.8.0-RC1 and 0.7.5.1 broken
-* Fixed [#8646] Context Runner does not report on Non standard exceptions and return a 0 return code
-* RSpec on Rails' spec_helper.rb will only force RAILS_ENV to test if it was not specified on the command line.
-* Fixed [#5485] proc#should_raise and proc#should_not_raise output
-* Added [#8484] should_receive with blocks
-* Applied [#8218] heckle_runner.rb doesn't work with heckle >= 1.2.0 (Patch from Michal Kwiatkowski)
-* Fixed [#8240] Cryptic error message when no controller_name
-* Applied [#7461] [PATCH] Contexts don't call Module::included when they include a module
-* Removed unintended block of test/unit assertions in rspec_on_rails - they should all, in theory, now be accessible
-* Added mock_model method to RSpec on Rails, which stubs common methods. Based on http://metaclass.org/2006/12/22/making-a-mockery-of-activerecord
-* Fixed [#8165] Partial Mock Errors when respond_to? is true but the method is not in the object
-* Fixed [#7611] Partial Mocks override Subclass methods
-* Fixed [#8302] Strange side effect when mocking a class method
-* Applied [#8316] to_param should return a stringified key in resource generator's controller spec (Patch from Chris Anderson)
-* Applied [#8216] shortcut for creating object stub
-* Applied [#8008] Correct generated specs for view when calling resource generator (Patch from Jonathan Tron)
-* Fixed [#7754] Command-R fails to run spec in TextMate (added instruction from Luke Redpath to the website)
-* Fixed [#7826] RSpect.tmbundle web page out of date.
-* RSpec on Rails specs are now running against RoR 1.2.1 and 1.2.2
-* rspec_scaffold now generates specs for views
-* In a Rails app, RSpec core is only loaded when RAILS_ENV==test (init.rb)
-* Added support for target.should arbitrary_expectation_handler and target.should_not arbitrary_expectation_handler
-* Fixed [#7533] Spec suite fails and the process exits with a code 0
-* Fixed [#7565] Subsequent stub! calls for method fail to override the first call to method
-* Applied [#7524] Incorrect Documentation for 'pattern' in Rake task (patch from Stephen Duncan)
-* Fixed [#7409] default fixtures do not appear to run.
-* Fixed [#7507] "render..and return" doesn't return
-* Fixed [#7509] rcov/rspec incorrectly includes boot.rb (Patch from Courtenay)
-* Fixed [#7506] unnecessary complex output on failure of response.should be_redirect
-* Applied [#6098] Make scaffold_resource generator. Based on code from Pat Maddox.
-* The drbspec command is gone. Use spec --drb instead.
-* The drb option is gone from the Rake task. Pass --drb to spec_opts instead.
-* New -X/--drb option for running specs against a server like spec/rails' script/rails_spec_server
-* New -O/--options and -G/--generate flags for file-based options (handy for spec/rails)
-* Applied [#7339] Turn off caching in HTML reports
-* Applied [#7419] "c option for colorizing output does not work with rails_spec" (Patch from Shintaro Kakutani)
-* Applied [#7406] [PATCH] 0.7.5 rspec_on_rails loads fixtures into development database (Patch from Wilson Bilkovich)
-* Applied [#7387] Allow stubs to return consecutive values (Patch from Pat Maddox)
-* Applied [#7393] Fix for rake task (Patch from Pat Maddox)
-* Reinstated support for response.should_render (in addition to controller.should_render)
-
-== Version 0.7.5.1
-
-Bug fix release to allow downloads of rspec gem using rubygems 0.9.1.
-
-== Version 0.7.5
-This release adds support for Heckle - Seattle'rb's code mutation tool.
-There are also several bug fixes to the RSpec core and the RSpec on Rails plugin.
-
-* Removed svn:externals on rails versions and plugins
-* Applied [#7345] Adding context_setup and context_teardown, with specs and 100% rcov
-* Applied [#7320] [PATCH] Allow XHR requests in controller specs to render RJS templates
-* Applied [#7319] Migration code uses drop_column when it should use remove_column (patch from Pat Maddox)
-* Added support for Heckle
-* Applied [#7282] dump results even if spec is interrupted (patch from Kouhei Sutou)
-* Applied [#7277] model.should_have(n).errors_on(:attribute) (patch from Wilson Bilkovich)
-* Applied [#7270] RSpec render_partial colliding with simply_helpful (patch from David Goodlad)
-* Added [#7250] stubs should support throwing
-* Added [#7249] stubs should support yielding
-* Fixed [#6760] fatal error when accessing nested finders in rspec
-* Fixed [#7179] script/generate rspec_scaffold generates incorrect helper name
-* Added preliminary support for assert_select (response.should_have)
-* Fixed [#6971] and_yield does not work when the arity is -1
-* Fixed [#6898] Can we separate rspec from the plugins?
-* Added [#7025] should_change should accept a block
-* Applied [#6989] partials with locals (patch from Micah Martin)
-* Applied [#7023] Typo in team.page
-
-== Version 0.7.4
-
-This release features a complete redesign of the reports generated with --format html.
-As usual there are many bug fixes - mostly related to spec/rails.
-
-* Applied [#7010] Fixes :spacer_template does not work w/ view spec (patch from Shintaro Kakutani)
-* Applied [#6798] ensure two ':' in the first backtrace line for Emacs's 'next-error' command (patch from Kouhei Sutou)
-* Added Much nicer reports to generated website
-* Much nicer reports with --format --html (patch from Luke Redpath)
-* Applied [#6959] Calls to render and redirect in controllers should return true
-* Fixed [#6981] helper method is not available in partial template.
-* Added [#6978] mock should tell you the expected and actual args when receiving the right message with the wrong args
-* Added the possibility to tweak the output of the HtmlFormatter (by overriding extra_failure_content).
-* Fixed [#6936] View specs don't include ApplicationHelper by default
-* Fixed [#6903] Rendering a partial in a view makes the view spec blow up
-* Added callback library from Brian Takita
-* Added [#6925] support controller.should_render :action_name
-* Fixed [#6884] intermittent errors related to method binding
-* Fixed [#6870] rspec on edge rails spec:controller fixture loading fails
-* Using obj.inspect for all messages
-* Improved performance by getting rid of instance_exec (instance_eval is good enough because we never need to pass it args)
-
-== Version 0.7.3
-
-Almost normal bug fix/new feature release.
-
-A couple of things you need to change in your rails specs:
-# spec_helper.rb is a little different (see http://rspec.rubyforge.org/upgrade.html)
-# use controller.should_render before OR after the action (controller.should_have_rendered is deprecated)
-
-* Applied [#6577] messy mock backtrace when frozen to edge rails (patch from Jay Levitt)
-* Fixed [#6674] rspec_on_rails fails on @session deprecation warning
-* Fixed [#6780] routing() was failing...fix included - works for 1.1.6 and edge (1.2)
-* Fixed [#6835] bad message with arbitrary predicate
-* Added [#6731] Partial templates rendered
-* Fixed [#6713] helper methods not rendered in view tests?
-* Fixed [#6707] cannot run controller / helper tests via rails_spec or spec only works with rake
-* Applied [#6417] lambda {...}.should_change(receiver, :message) (patch from Wilson Bilkovich)
-* Eliminated dependency on ZenTest
-* Fixed [#6650] Reserved characters in the TextMate bundle break svn on Win32
-* Fixed [#6643] script/generate rspec_controller: invalid symbol generation for 'controller_name' for *modularized* controllers
-* The script/rails_spec command has been moved to bin/drbspec in RSpec core (installed by the gem)
-
-== Version 0.7.2
-
-This release introduces a brand new RSpec bundle for TextMate, plus some small bugfixes.
-
-* Packaged RSpec.tmbundle.tgz as part of the distro
-* Fixed [#6593] Add moving progress bar to HtmlFormatter using Javascript
-* Applied [#6265] should_raise should accept an Exception object
-* Fixed [#6616] Can't run Rails specs with RSpec.tmbundle
-* Fixed [#6411] Can't run Rails specs with ruby
-* Added [#6589] New -l --line option. This is useful for IDE/editor runners/extensions.
-* Fixed [#6615] controller.should_render_rjs should support :partial => 'path/to/template'
-
-== Version 0.7.1
-
-Bug fixes and a couple o' new features.
-
-* Fixed [#6575] Parse error in aliasing the partial mock original method (patch by Brian Takita)
-* Fixed [#6277] debris left by stubbing (trunk) [submitted by dastels] (fixed by fix to [#6575])
-* Fixed [#6575] Parse error in aliasing the partial mock original method
-* Fixed [#6555] should_have_tag does not match documentation
-* Fixed [#6567] SyntaxError should not stop entire run
-* Fixed [#6558] integrated views look for template even when redirected
-* Fixed [#6547] response.should be_redirect broken in 0.7.0
-* Applied [#6471] Easy way to spec routes
-* Applied [#6587] Rspec on Rails displays "Spec::Rails::ContextFactory" as context name
-* Applied [#6514] Document has trivial typos.
-* Added [#6560] controller.session should be available before the action
-* Added support for should_have_rjs :visual_effect
-* Different printing and colours for unmet expectations (red) and other exceptions (magenta)
-* Simplified method_missing on mock_methods to make it less invasive on partial mocks.
-
-== Version 0.7.0
-
-This is the "Grow up and eat your own dog food release". RSpec is now used on itself and
-we're no longer using Test::Unit to test it. Although, we are still extending Test::Unit
-for the rails plugin (indirectly - through ZenTest)
-
-IMPORTANT NOTE: THIS RELEASE IS NOT 100% BACKWARDS COMPATIBLE TO 0.6.x
-
-There are a few changes that will require that you change your existing specs.
-
-RSpec now handles equality exactly like ruby does:
-
-# actual.should_equal(expected) will pass if actual.equal?(expected) returns true
-# actual.should eql(expected) will pass if actual.eql?(expected) returns true
-# actual.should == expected will pass if actual == expected) returns true
-
-At the high level, eql? implies equivalence, while equal? implies object identity. For more
-information on how ruby deals w/ equality, you should do this:
-
-ri equal?
-
-or look at this:
-
-http://www.ruby-doc.org/core/classes/Object.html#M001057
-
-Also, we left in should_be as a synonym for should_equal, so the only specs that should break are the
-ones using should_equal (which used to use <code>==</code> instead of <code>.equal?</code>).
-
-Lastly, should_be used to handle true and false differently from any other values. We've removed
-this special handling, so now actual.should_be true will fail for any value other than true (it
-used to pass for any non-nil, non-false value), and actual.should_be false will fail for any
-value other than false (it used to pass for nil or false).
-
-Here's what you'll need to do to update your specs:
-# search for "should_equal" and replace with "should_eql"
-# run specs
-
-If any specs still fail, they are probably related to should be_true or should_be_false using
-non-boolean values. Those you'll just have to inspect manually and adjust appropriately (sorry!).
-
---------------------------------------------------
-Specifying multiple return values in mocks now works like this:
-
-mock.should_receive(:message).and_return(1,2,3)
-
-It used to work like this:
-
-mock.should_receive(:message).and_return([1,2,3])
-
-but we decided that was counter intuitive and otherwise lame.
-
-Here's what you'll need to do to update your specs:
-# search for "and_return(["
-# get rid of the "[" and "]"
-
---------------------------------------------------
-RSpec on Rails now supports the following (thanks to ZenTest upon which it is built):
-
-# Separate specs for models, views, controllers and helpers
-# Controller specs are completely decoupled from the views by default (though you can tell them to couple themselves if you prefer)
-# View specs are completely decoupled from app-specific controllers
-
-See http://rspec.rubyforge.org/documentation/rails/index.html for more information
---------------------------------------------------
-As usual, there are also other new features and bug fixes:
-
-* Added lots of documentation on mocks/stubs and the rails plugin.
-* Added support for assigns[key] syntax for controller specs (to align w/ pre-existing syntax for view specs)
-* Added support for controller.should_redirect_to
-* RSpec on Rails automatically checks whether it's compatible with the installed RSpec
-* Applied [#6393] rspec_on_rails uses deprecated '@response' instead of the accessor
-* RSpec now has 100% spec coverage(!)
-* Added support for stubbing and partial mocking
-* Progress (....F..F.) is now coloured. Tweaked patch from KAKUTANI Shintaro.
-* Backtrace now excludes the rcov runner (/usr/local/bin/rcov)
-* Fixed [#5539] predicates do not work w/ rails
-* Added [#6091] support for Regexp matching messages sent to should_raise
-* Added [#6333] support for Regexp matching in mock arguments
-* Applied [#6283] refactoring of diff support to allow selectable formats and custom differs
-* Fixed [#5564] "ruby spec_file.rb" doesn't work the same way as "spec spec_file.rb"
-* Fixed [#6056] Multiple output of failing-spec notice
-* Fixed [#6233] Colours in specdoc
-* Applied [#6207] Allows --diff option to diff target and expected's #inspect output (Patch by Lachie Cox)
-* Fixed [#6203] Failure messages are misleading - consider using inspect.
-* Added [#6334] subject.should_have_xyz will try to call subject.has_xyz? - use this for hash.should_have_key(key)
-* Fixed [#6017] Rake task should ignore empty or non-existent spec-dirs
-
-== Version 0.6.4
-
-In addition to a number of bug fixes and patches, this release begins to formalize the support for
-RSpec on Rails.
-
-* Added Christopher Petrilli's TextMate bundle to vendor/textmate/RSpec.tmbundle
-* Fixed [#5909], once again supporting multi_word_predicates
-* Applied [#5873] - response.should_have_rjs (initial patch from Jake Howerton, based on ARTS by Kevin Clark)
-* Added generation of view specs for rspec_on_rails
-* Applied [#5815] active_record_subclass.should_have(3).records
-* Added support in "rake stats" for view specs (in spec/views)
-* Applied [#5801] QuickRef.pdf should say RSpec, not rSpec
-* Applied [#5728] rails_spec_runner fails on Windows (Patch from Lindsay Evans).
-* Applied [#5708] RSpec Rails plugin rspec_controller generator makes specs that do not parse.
-* Cleaned up RSpec on Rails so it doesn't pollute as much during bootstrapping.
-* Added support for response.should_have_tag and response.should_not_have_tag (works just like assert_tag in rails)
-* Added new -c, --colour, --color option for colourful (red/green) output. Inspired from Pat Eyler's Redgreen gem.
-* Added examples for Watir and Selenium under the gem's vendor directory.
-* Renamed rails_spec_runner to rails_spec_server (as referred to in the docs)
-* Added support for trying a plural for arbitrary predicates. E.g. Album.should_exist(:name => "Hey Jude") will call Album.exists?(:name => "Hey Jude")
-* Added support for should_have to work with methods taking args returning a collection. E.g. @dave.should_have(3).albums_i_have_that_this_guy_doesnt(@aslak)
-* Added [#5570] should_not_receive(:msg).with(:specific, "args")
-* Applied [#5065] to support using define_method rather than method_missing to capture expected messages on mocks. Thanks to Eero Saynatkari for the tip that made it work.
-* Restructured directories and Modules in order to separate rspec into three distinct Modules: Spec::Expectations, Spec::Runner and Spec::Mocks. This will allow us to more easily integrate other mock frameworks and/or allow test/unit users to take advantage of the expectation API.
-* Applied [#5620] support any boolean method and arbitrary comparisons (5.should_be < 6) (Patch from Mike Williams)
-
-== Version 0.6.3
-
-This release fixes some minor bugs related to RSpec on Rails
-Note that if you upgrade a rails app with this version of the rspec_on_rails plugin
-you should remove your lib/tasks/rspec.rake if it exists.
-
-* Backtraces from drb (and other standard ruby libraries) are now stripped from backtraces.
-* Applied [#5557] Put rspec.rake into the task directory of the RSpec on Rails plugin (Patch from Daniel Siemssen)
-* Applied [#5556] rails_spec_server loads environment.rb twice (Patch from Daniel Siemssen)
-
-== Version 0.6.2
-This release fixes a couple of regressions with the rake task that were introduced in the previous version (0.6.1)
-
-* Fixed [#5518] ruby -w: warnings in 0.6.1
-* Applied [#5525] fix rake task path to spec tool for gem-installed rspec (patch from Riley Lynch)
-* Fixed a teensey regression with the rake task - introduced in 0.6.1. The spec command is now quoted so it works on windows.
-
-== Version 0.6.1
-This is the "fix the most annoying bugs release" of RSpec. There are 9 bugfixes this time.
-Things that may break backwards compatibility:
-1) Spec::Rake::SpecTask no longer has the options attribute. Use ruby_opts, spec_opts and rcov_opts instead.
-
-* Fixed [#4891] RCOV task failing on windows
-* Fixed [#4896] Shouldn't modify user's $LOAD_PATH (Tip from Gavin Sinclair)
-* Fixed [#5369] ruby -w: warnings in RSpec 0.5.16 (Tip from Suraj Kurapati)
-* Applied [#5141] ExampleMatcher doesn't escape strings before matching (Patch from Nikolai Weibull).
-* Fixed [#5224] Move 'require diff-lcs' from test_helper.rb to diff_test.rb (Tip from Chris Roos)
-* Applied [#5449] Rake stats for specs (Patch from Nick Sieger)
-* Applied [#5468, #5058] Fix spec runner to correctly run controller specs (Patch from Daniel Siemssen)
-* Applied fixes to rails_spec_server to improve its ability to run several times. (Patch from Daniel Siemssen)
-* Changed RCov::VerifyTask to fail if the coverage is above the threshold. This is to ensure it gets bumped when coverage improves.
-
-== Version 0.6.0
-This release makes an official commitment to underscore_syntax (with no more support for dot.syntax)
-
-* Fixed bug (5292) that caused mock argument matching to fail
-* Converted ALL tests to use underscore syntax
-* Fixed all remaining problems with underscores revealed by converting all the tests to underscores
-* Enhanced sugar to support combinations of methods (i.e. once.and_return)
-* Simplified helper structure taking advantage of dot/underscore combos (i.e. should.be.an_instance_of, which can be expressed as should be_an_instance_of)
-* Added support for at_most in mocks
-* Added support for should_not_receive(:msg) (will be removing should_receive(:msg).never some time soon)
-* Added support for should_have_exactly(5).items_in_collection
-
-== Version 0.5.16
-This release improves Rails support and test2spec translation.
-
-* Fixed underscore problems that occurred when RSpec was used in Rails
-* Simplified the Rails support by packaging it as a plugin instead of a generator gem.
-* Fixed [#5063] 'rspec_on_rails' require line in spec_helper.rb
-* Added pre_commit rake task to reduce risk of regressions. Useful for RSpec developers and patchers.
-* Added failure_message to RSpec Rake task
-* test2spec now defines converted helper methods outside of the setup block (bug #5057).
-
-== Version 0.5.15
-This release removes a prematurely added feature that shouldn't have been added.
-
-* Removed support for differences that was added in 0.5.14. The functionality is not aligned with RSpec's vision.
-
-== Version 0.5.14
-This release introduces better ways to extend specs, improves some of the core API and
-a experimental support for faster rails specs.
-
-* Added proc methods for specifying differences (increments and decrements). See difference_test.rb
-* Methods can now be defined alongside specs. This obsoletes the need for defining methods in setup. (Patch #5002 from Brian Takita)
-* Sugar (underscores) now works correctly with should be_a_kind_of and should be_an_instance_of
-* Added support for include and inherit in contexts. (Patch #4971 from Brian Takita)
-* Added rails_spec and rails_spec_server for faster specs on rails (still buggy - help needed)
-* Fixed bug that caused should_render to break if given a :symbol (in Rails)
-* Added support for comparing exception message in should_raise and should_not_raise
-
-== Version 0.5.13
-This release fixes some subtle bugs in the mock API.
-
-* Use fully-qualified class name of Exceptions in failure message. Easier to debug that way.
-* Fixed a bug that caused mocks to yield a one-element array (rather than the element) when one yield arg specified.
-* Mocks not raise AmbiguousReturnError if an explicit return is used at the same time as an expectation block.
-* Blocks passed to yielding mocks can now raise without causing mock verification to fail.
-
-== Version 0.5.12
-This release adds diff support for failure messages, a HTML formatter plus some other
-minor enhancements.
-
-* Added HTML formatter.
-* Added fail_on_error option to spectask.
-* Added support for diffing, using the diff-lcs Rubygem (#2648).
-* Remove RSpec on Rails files from backtrace (#4694).
-* All of RSpec's own tests run successfully after translation with test2spec.
-* Added --verbose mode for test2spec - useful for debugging when classes fail to translate.
-* Output of various formatters is now flushed - to get more continuous output.
-
-== Version 0.5.11
-This release makes test2spec usable with Rails (with some manual steps).
-See http://rspec.rubyforge.org/tools/rails.html for more details
-
-* test2spec now correctly translates bodies of helper methods (non- test_*, setup and teardown ones).
-* Added more documentation about how to get test2spec to work with Rails.
-
-== Version 0.5.10
-This version features a second rewrite of test2spec - hopefully better than the previous one.
-
-* Improved test2spec's internals. It now transforms the syntax tree before writing out the code.
-
-== Version 0.5.9
-This release improves test2spec by allowing more control over the output
-
-* Added --template option to test2spec, which allows for custom output driven by ERB
-* Added --quiet option to test2spec
-* Removed unnecessary dependency on RubyToC
-
-== Version 0.5.8
-This release features a new Test::Unit to RSpec translation tool.
-Also note that the RubyGem of the previous release (0.5.7) was corrupt.
-We're close to being able to translate all of RSpec's own Test::Unit
-tests and have them run successfully!
-
-* Updated test2spec documentation.
-* Replaced old test2rspec with a new test2spec, which is based on ParseTree and RubyInline.
-
-== Version 0.5.7
-This release changes examples and documentation to recommend underscores rather than dots,
-and addresses some bugfixes and changes to the spec commandline.
-
-* spec DIR now works correctly, recursing down and slurping all *.rb files
-* All documentation and examples are now using '_' instead of '.'
-* Custom external formatters can now be specified via --require and --format.
-
-== Version 0.5.6
-This release fixes a bug in the Rails controller generator
-
-* The controller generator did not write correct source code (missing 'do'). Fixed.
-
-== Version 0.5.5
-This release adds initial support for Ruby on Rails in the rspec_generator gem.
-
-* [Rails] Reorganised Lachie's original code to be a generator packaged as a gem rather than a plugin.
-* [Rails] Imported code from http://lachie.info/svn/projects/rails_plugins/rspec_on_rails (Written by Lachie Cox)
-* Remove stack trace lines from TextMate's Ruby bundle
-* Better error message from spectask when no spec files are found.
-
-== Version 0.5.4
-The "the tutorial is ahead of the gem" release
-
-* Support for running a single spec with --spec
-* Exitcode is now 1 unless all specs pass, in which case it's 0.
-* -v, --version now both mean the same thing
-* For what was verbose output (-v), use --format specdoc or -f s
-* --format rdoc always runs in dry-run mode
-* Removed --doc and added --format and --dry-run
-* Refactored towards more pluggable formatters
-* Use webgen's execute tag when generating website (more accurate)
-* Fixed incorrect quoting of spec_opts in SpecTask
-* Added patch to enable underscored shoulds like 1.should_equal(1) - patch from Rich Kilmer
-* Removed most inherited instance method from Mock, making more methods mockable.
-* Made the RCovVerify task part of the standard toolset.
-* Documented Rake task and how to use it with Rcov
-* Implemented <ruby></ruby> tags for website (hooking into ERB, RedCloth and syntax)
-* RSpec Rake task now takes spec_opts and out params so it can be used for doc generation
-* RCov integration for RSpec Rake task (#4058)
-* Group all results instead of printing them several times (#4057)
-* Mocks can now yield
-* Various improvements to error reporting (including #4191)
-* backtrace excludes rspec code - use -b to include it
-* split examples into examples (passing) and failing_examples
-
-== Version 0.5.3
-The "hurry up, CoR is in two days" release.
-
-* Don't run rcov by default
-* Make separate task for running tests with RCov
-* Added Rake task to fail build if coverage drops below a certain threshold
-* Even more failure output cleanup (simplification)
-* Added duck_type constraint for mocks
-
-== Version 0.5.2
-This release has minor improvements to the commandline and fixes some gem warnings
-
-* Readded README to avoid RDoc warnings
-* Added --version switch to commandline
-* More changes to the mock API
-
-== Version 0.5.1
-This release is the first release of RSpec with a new website. It will look better soon.
-
-* Added initial documentation for API
-* Added website based on webgen
-* Modified test task to use rcov
-* Deleted unused code (thanks, rcov!)
-* Various changes to the mock API,
-* Various improvements to failure reporting
-
-== Version 0.5.0
-This release introduces a new API and obsolesces previous versions.
-
-* Moved source code to separate subfolders
-* Added new DSL runner based on instance_exec
-* Added spike for testdox/rdoc generation
-* merge Astels' and Chelimsky's work on ShouldHelper
-* this would be 0.5.0 if I updated the documentation
-* it breaks all of your existing specifications. We're not sorry.
-
-== Version 0.3.2
-
-The "srbaker is an idiot" release.
-
-* also forgot to update the path to the actual Subversion repository
-* this should be it
-
-== Version 0.3.1
-
-This is just 0.3.0, but with the TUTORIAL added to the documentation list.
-
-* forgot to include TUTORIAL in the documentation
-
-== Version 0.3.0
-
-It's been a while since last release, lots of new stuff is available. For instance:
-
-* improvements to the runners
-* addition of should_raise expectation (thanks to Brian Takita)
-* some documentation improvements
-* RSpec usable as a DSL
-
-== Version 0.2.0
-
-This release provides a tutorial for new users wishing to get started with
-RSpec, and many improvements.
-
-* improved reporting in the spec runner output
-* update the examples to the new mock api
-* added TUTORIAL, a getting started document for new users of RSpec
-
-== Version 0.1.7
-
-This release improves installation and documentation, mock integration and error reporting.
-
-* Comparison errors now print the class name too.
-* Mocks now take an optional +options+ parameter to specify behaviour.
-* Removed __expects in favour of should_receive
-* Added line number reporting in mock error messages for unreceived message expectations.
-* Added should_match and should_not_match.
-* Added a +mock+ method to Spec::Context which will create mocks that autoverify (no need to call __verify).
-* Mocks now require names in the constructor to ensure sensible error messages.
-* Made 'spec' executable and updated usage instructions in README accordingly.
-* Made more parts of the Spec::Context API private to avoid accidental usage.
-* Added more RDoc to Spec::Context.
-
-== Version 0.1.6
-
-More should methods.
-
-* Added should_match and should_not_match.
-
-== Version 0.1.5
-
-Included examples and tests in gem.
-
-== Version 0.1.4
-
-More tests on block based Mock expectations.
-
-== Version 0.1.3
-
-Improved mocking:
-
-* block based Mock expectations.
-
-== Version 0.1.2
-
-This release adds some improvements to the mock API and minor syntax improvements
-
-* Added Mock.should_expect for a more consistent DSL.
-* Added MockExpectation.and_returns for a better DSL.
-* Made Mock behave as a null object after a call to Mock.ignore_missing
-* Internal syntax improvements.
-* Improved exception trace by adding exception class name to error message.
-* Renamed some tests for better consistency.
-
-== Version 0.1.1
-
-This release adds some shoulds and improves error reporting
-
-* Added should be_same_as and should_not be_same_as.
-* Improved error reporting for comparison expectations.
-
-== Version 0.1.0
-
-This is the first preview release of RSpec, a Behaviour-Driven Development library for Ruby
-
-* Added Rake script with tasks for gems, rdoc etc.
-* Added an XForge task to make release go easier.
+++ /dev/null
-Copyright (c) 2005-2007 The RSpec Development Team
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+++ /dev/null
-== RSpec
-
-RSpec is a Behaviour Driven Development framework with tools to express User Stories
-with Executable Scenarios and Executable Examples at the code level.
-
-RSpec ships with several modules:
-
-Spec::Story provides a framework for expressing User Stories
-
-Spec::Example provides a framework for expressing code Examples
-
-Spec::Matchers provides Expression Matchers for use with Spec::Expectations
-and Spec::Mocks.
-
-Spec::Expectations supports setting expectations on your objects so you
-can do things like:
-
- result.should equal(expected_result)
-
-Spec::Mocks supports creating Mock Objects, Stubs, and adding Mock/Stub
-behaviour to your existing objects.
-
-== Installation
-
-The simplest approach is to install the gem:
-
- gem install -r rspec #mac users must sudo
-
-== Building the RSpec gem
-If you prefer to build the gem locally, check out source from svn://rubyforge.org/var/svn/rspec/trunk. Then
-do the following:
-
- rake gem
- gem install pkg/rspec-0.x.x.gem (you may have to sudo)
-
-== Running RSpec's specs
-In order to run RSpec's full suite of specs (rake pre_commit) you must install the following gems:
-
-* rake # Runs the build script
-* rcov # Verifies that the code is 100% covered by specs
-* webby # Generates the static HTML website
-* syntax # Required to highlight ruby code
-* diff-lcs # Required if you use the --diff switch
-* win32console # Required by the --colour switch if you're on Windows
-* meta_project # Required in order to make releases at RubyForge
-* heckle # Required if you use the --heckle switch
-* hpricot # Used for parsing HTML from the HTML output formatter in RSpec's own specs
-
-Once those are all installed, you should be able to run the suite with the following steps:
-
-* svn co svn://rubyforge.org/var/svn/rspec/trunk rspec
-* cd rspec
-* rake install_dependencies
-* cd example_rails_app
-* export RSPEC_RAILS_VERSION=1.2.3
-* rake rspec:generate_mysql_config
-* mysql -u root < db/mysql_setup.sql
-* cd ..
-* rake pre_commit
-
-Note that RSpec itself - once built - doesn't have any dependencies outside the Ruby core
-and stdlib - with a few exceptions:
-
-* The spec command line uses diff-lcs when --diff is specified.
-* The spec command line uses heckle when --heckle is specified.
-* The Spec::Rake::SpecTask needs RCov if RCov is enabled in the task.
-
-See http://rspec.rubyforge.org for further documentation.
-
-== Contributing
-
+++ /dev/null
-$:.unshift('lib')
-require 'rubygems'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rake/clean'
-require 'rake/rdoctask'
-require 'rake/testtask'
-require 'spec/version'
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(File.expand_path("#{dir}/../pre_commit/lib"))
-require "pre_commit"
-
-# Some of the tasks are in separate files since they are also part of the website documentation
-load File.dirname(__FILE__) + '/rake_tasks/examples.rake'
-load File.dirname(__FILE__) + '/rake_tasks/examples_with_rcov.rake'
-load File.dirname(__FILE__) + '/rake_tasks/failing_examples_with_html.rake'
-load File.dirname(__FILE__) + '/rake_tasks/verify_rcov.rake'
-
-PKG_NAME = "rspec"
-PKG_VERSION = Spec::VERSION::STRING
-PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
-PKG_FILES = FileList[
- '[A-Z]*',
- 'lib/**/*.rb',
- 'spec/**/*.rb',
- 'examples/**/*',
- 'plugins/**/*',
- 'stories/**/*'
-]
-
-task :default => [:verify_rcov]
-task :verify_rcov => [:spec, :stories]
-
-desc "Run all specs"
-Spec::Rake::SpecTask.new do |t|
- t.spec_files = FileList['spec/**/*_spec.rb']
- t.spec_opts = ['--options', 'spec.opts']
- unless ENV['NO_RCOV']
- t.rcov = true
- t.rcov_dir = '../doc/output/coverage'
- t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec,examples,\/var\/lib\/gems,\/Library\/Ruby,\.autotest']
- end
-end
-
-desc "Run all stories"
-task :stories do
- html = 'story_server/prototype/rspec_stories.html'
- ruby "stories/all.rb --colour --format plain --format html:#{html}"
- unless IO.read(html) =~ /<span class="param">/m
- raise 'highlighted parameters are broken in story HTML'
- end
-end
-
-desc "Run all specs and store html output in doc/output/report.html"
-Spec::Rake::SpecTask.new('spec_html') do |t|
- t.spec_files = FileList['spec/**/*_spec.rb', '../../RSpec.tmbundle/Support/spec/*_spec.rb']
- t.spec_opts = ['--format html:../doc/output/report.html','--backtrace']
-end
-
-desc "Run all failing examples"
-Spec::Rake::SpecTask.new('failing_examples') do |t|
- t.spec_files = FileList['failing_examples/**/*_spec.rb']
-end
-
-desc 'Generate RDoc'
-rd = Rake::RDocTask.new do |rdoc|
- rdoc.rdoc_dir = '../doc/output/rdoc'
- rdoc.options << '--title' << 'RSpec' << '--line-numbers' << '--inline-source' << '--main' << 'README'
- rdoc.rdoc_files.include('README', 'CHANGES', 'MIT-LICENSE', 'UPGRADE', 'lib/**/*.rb')
-end
-
-spec = Gem::Specification.new do |s|
- s.name = PKG_NAME
- s.version = PKG_VERSION
- s.summary = Spec::VERSION::DESCRIPTION
- s.description = <<-EOF
- RSpec is a behaviour driven development (BDD) framework for Ruby. RSpec was
- created in response to Dave Astels' article _A New Look at Test Driven Development_
- which can be read at: http://daveastels.com/index.php?p=5 RSpec is intended to
- provide the features discussed in Dave's article.
- EOF
-
- s.files = PKG_FILES.to_a
- s.require_path = 'lib'
-
- s.has_rdoc = true
- s.rdoc_options = rd.options
- s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$|^EXAMPLES.rd$/ }.to_a
-
- s.bindir = 'bin'
- s.executables = ['spec', 'spec_translator']
- s.default_executable = 'spec'
- s.author = "RSpec Development Team"
- s.email = "rspec-devel@rubyforge.org"
- s.homepage = "http://rspec.rubyforge.org"
- s.platform = Gem::Platform::RUBY
- s.rubyforge_project = "rspec"
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
- pkg.need_zip = true
- pkg.need_tar = true
-end
-
-def egrep(pattern)
- Dir['**/*.rb'].each do |fn|
- count = 0
- open(fn) do |f|
- while line = f.gets
- count += 1
- if line =~ pattern
- puts "#{fn}:#{count}:#{line}"
- end
- end
- end
- end
-end
-
-desc "Look for TODO and FIXME tags in the code"
-task :todo do
- egrep /(FIXME|TODO|TBD)/
-end
-
-task :clobber do
- core.clobber
-end
-
-task :release => [:clobber, :verify_committed, :verify_user, :spec, :publish_packages, :tag, :publish_news]
-
-desc "Verifies that there is no uncommitted code"
-task :verify_committed do
- IO.popen('svn stat') do |io|
- io.each_line do |line|
- raise "\n!!! Do a svn commit first !!!\n\n" if line =~ /^\s*M\s*/
- end
- end
-end
-
-desc "Creates a tag in svn"
-task :tag do
- from = `svn info #{File.dirname(__FILE__)}`.match(/URL: (.*)\/rspec/n)[1]
- to = from.gsub(/trunk/, "tags/#{Spec::VERSION::TAG}")
- current = from.gsub(/trunk/, "tags/CURRENT")
-
- puts "Creating tag in SVN"
- tag_cmd = "svn cp #{from} #{to} -m \"Tag release #{Spec::VERSION::FULL_VERSION}\""
- `#{tag_cmd}` ; raise "ERROR: #{tag_cmd}" unless $? == 0
-
- puts "Removing CURRENT"
- remove_current_cmd = "svn rm #{current} -m \"Remove tags/CURRENT\""
- `#{remove_current_cmd}` ; raise "ERROR: #{remove_current_cmd}" unless $? == 0
-
- puts "Re-Creating CURRENT"
- create_current_cmd = "svn cp #{to} #{current} -m \"Copy #{Spec::VERSION::TAG} to tags/CURRENT\""
- `#{create_current_cmd}` ; "ERROR: #{create_current_cmd}" unless $? == 0
-end
-
-desc "Run this task before you commit. You should see 'OK TO COMMIT'"
-task(:pre_commit) {core.pre_commit}
-
-desc "Build the website, but do not publish it"
-task(:website) {core.website}
-
-task(:rdoc_rails) {core.rdoc_rails}
-
-task :verify_user do
- raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
-end
-
-desc "Upload Website to RubyForge"
-task :publish_website => [:verify_user, :website] do
- unless Spec::VERSION::RELEASE_CANDIDATE
- publisher = Rake::SshDirPublisher.new(
- "rspec-website@rubyforge.org",
- "/var/www/gforge-projects/#{PKG_NAME}",
- "../doc/output"
- )
- publisher.upload
- else
- puts "** Not publishing packages to RubyForge - this is a prerelease"
- end
-end
-
-desc "Upload Website archive to RubyForge"
-task :archive_website => [:verify_user, :website] do
- publisher = Rake::SshDirPublisher.new(
- "rspec-website@rubyforge.org",
- "/var/www/gforge-projects/#{PKG_NAME}/#{Spec::VERSION::TAG}",
- "../doc/output"
- )
- publisher.upload
-end
-
-desc "Package the Rails plugin"
-task :package_rspec_on_rails do
- mkdir 'pkg' rescue nil
- rm_rf 'pkg/rspec_on_rails' rescue nil
- `svn export ../rspec_on_rails pkg/rspec_on_rails-#{PKG_VERSION}`
- Dir.chdir 'pkg' do
- `tar cvzf rspec_on_rails-#{PKG_VERSION}.tgz rspec_on_rails-#{PKG_VERSION}`
- end
-end
-task :pkg => :package_rspec_on_rails
-
-desc "Package the RSpec.tmbundle"
-task :package_tmbundle do
- mkdir 'pkg' rescue nil
- rm_rf 'pkg/RSpec.tmbundle' rescue nil
- `svn export ../RSpec.tmbundle pkg/RSpec.tmbundle`
- Dir.chdir 'pkg' do
- `tar cvzf RSpec-#{PKG_VERSION}.tmbundle.tgz RSpec.tmbundle`
- end
-end
-task :pkg => :package_tmbundle
-
-desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
-task :publish_packages => [:verify_user, :package] do
- release_files = FileList[
- "pkg/#{PKG_FILE_NAME}.gem",
- "pkg/#{PKG_FILE_NAME}.tgz",
- "pkg/rspec_on_rails-#{PKG_VERSION}.tgz",
- "pkg/#{PKG_FILE_NAME}.zip",
- "pkg/RSpec-#{PKG_VERSION}.tmbundle.tgz"
- ]
- unless Spec::VERSION::RELEASE_CANDIDATE
- require 'meta_project'
- require 'rake/contrib/xforge'
-
- Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
- # Never hardcode user name and password in the Rakefile!
- xf.user_name = ENV['RUBYFORGE_USER']
- xf.files = release_files.to_a
- xf.release_name = "RSpec #{PKG_VERSION}"
- end
- else
- puts "SINCE THIS IS A PRERELEASE, FILES ARE UPLOADED WITH SSH, NOT TO THE RUBYFORGE FILE SECTION"
- puts "YOU MUST TYPE THE PASSWORD #{release_files.length} TIMES..."
-
- host = "rspec-website@rubyforge.org"
- remote_dir = "/var/www/gforge-projects/#{PKG_NAME}"
-
- publisher = Rake::SshFilePublisher.new(
- host,
- remote_dir,
- File.dirname(__FILE__),
- *release_files
- )
- publisher.upload
-
- puts "UPLADED THE FOLLOWING FILES:"
- release_files.each do |file|
- name = file.match(/pkg\/(.*)/)[1]
- puts "* http://rspec.rubyforge.org/#{name}"
- end
-
- puts "They are not linked to anywhere, so don't forget to tell people!"
- end
-end
-
-desc "Publish news on RubyForge"
-task :publish_news => [:verify_user] do
- unless Spec::VERSION::RELEASE_CANDIDATE
- require 'meta_project'
- require 'rake/contrib/xforge'
- Rake::XForge::NewsPublisher.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |news|
- # Never hardcode user name and password in the Rakefile!
- news.user_name = ENV['RUBYFORGE_USER']
- end
- else
- puts "** Not publishing news to RubyForge - this is a prerelease"
- end
-end
-
-def core
- PreCommit::Core.new(self)
-end
+++ /dev/null
-=== Before releasing 1.1.0:
-
+++ /dev/null
-= Upgrading existing code to RSpec-0.9
-
-== General (see below for Spec::Rails specifics)
-
-=== New Syntax for should and should_not
-
-* Use translator (should get 90% of your code)
-* Manually fix "parenthesis" warnings
-
-=== Change before_context_eval to before_eval
-
-before_context_eval is an un-published hook used by
-Spec::Rails to create specialized behaviour contexts.
-Most of you don't need to change this, but for those
-who have exploited it, you'll need to change it to
-before_eval.
-
-== Spec::Rails
-
-=== spec_helper.rb
-
-We've added a new way to configure Spec::Runner to do
-things like use_transactional_fixtures and use_instantiated_fixtures.
-You'll need to update spec/spec_helper.rb accordingly. You can either
-just re-generate it:
-
- script/generate rspec
-
-Or modify spec_helper.rb based on the template, which can be found at:
-
- vendor/plugins/rspec_on_rails/generators/rspec/templates/spec_helper.rb
\ No newline at end of file
+++ /dev/null
-#!/usr/bin/env ruby
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
-require 'spec'
-exit ::Spec::Runner::CommandLine.run(rspec_options)
+++ /dev/null
-#!/usr/bin/env ruby
-raise "\n\nUsage: spec_translator from_dir to_dir\n\n" if ARGV.size != 2
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
-require 'spec/translator'
-t = ::Spec::Translator.new
-from = ARGV[0]
-to = ARGV[1]
-t.translate(from, to)
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-# Run spec w/ -fs to see the output of this file
-
-describe "Examples with no descriptions" do
-
- # description is auto-generated as "should equal(5)" based on the last #should
- it do
- 3.should equal(3)
- 5.should equal(5)
- end
-
- it { 3.should be < 5 }
-
- it { ["a"].should include("a") }
-
- it { [1,2,3].should respond_to(:size) }
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-$global = 0
-
-describe "State created in before(:all)" do
- before :all do
- @sideeffect = 1
- $global +=1
- end
-
- before :each do
- @isolated = 1
- end
-
- it "should be accessible from example" do
- @sideeffect.should == 1
- $global.should == 1
- @isolated.should == 1
-
- @sideeffect += 1
- @isolated += 1
- end
-
- it "should not have sideffects" do
- @sideeffect.should == 1
- $global.should == 2
- @isolated.should == 1
-
- @sideeffect += 1
- @isolated += 1
- end
-
- after :each do
- $global += 1
- end
-
- after :all do
- $global.should == 3
- $global = 0
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-def behave_as_electric_musician
- respond_to(:read_notes, :turn_down_amp)
-end
-
-def behave_as_musician
- respond_to(:read_notes)
-end
-
-module BehaveAsExample
-
- class BluesGuitarist
- def read_notes; end
- def turn_down_amp; end
- end
-
- class RockGuitarist
- def read_notes; end
- def turn_down_amp; end
- end
-
- class ClassicGuitarist
- def read_notes; end
- end
-
- describe BluesGuitarist do
- it "should behave as guitarist" do
- BluesGuitarist.new.should behave_as_electric_musician
- end
- end
-
- describe RockGuitarist do
- it "should behave as guitarist" do
- RockGuitarist.new.should behave_as_electric_musician
- end
- end
-
- describe ClassicGuitarist do
- it "should not behave as guitarist" do
- ClassicGuitarist.new.should behave_as_musician
- end
- end
-
-end
+++ /dev/null
-module AnimalSpecHelper
- class Eat
- def initialize(food)
- @food = food
- end
-
- def matches?(animal)
- @animal = animal
- @animal.eats?(@food)
- end
-
- def failure_message
- "expected #{@animal} to eat #{@food}, but it does not"
- end
-
- def negative_failure_message
- "expected #{@animal} not to eat #{@food}, but it does"
- end
- end
-
- def eat(food)
- Eat.new(food)
- end
-end
-
-module Animals
- class Animal
- def eats?(food)
- return foods_i_eat.include?(food)
- end
- end
-
- class Mouse < Animal
- def foods_i_eat
- [:cheese]
- end
- end
-
- describe Mouse do
- include AnimalSpecHelper
- before(:each) do
- @mouse = Animals::Mouse.new
- end
-
- it "should eat cheese" do
- @mouse.should eat(:cheese)
- end
-
- it "should not eat cat" do
- @mouse.should_not eat(:cat)
- end
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require 'spec/runner/formatter/progress_bar_formatter'
-
-# Example of a formatter with custom bactrace printing. Run me with:
-# ruby bin/spec failing_examples -r examples/custom_formatter.rb -f CustomFormatter
-class CustomFormatter < Spec::Runner::Formatter::ProgressBarFormatter
- def backtrace_line(line)
- line.gsub(/([^:]*\.rb):(\d*)/) do
- "<a href=\"file://#{File.expand_path($1)}\">#{$1}:#{$2}</a> "
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Some integers" do
- (1..10).each do |n|
- it "The root of #{n} square should be #{n}" do
- Math.sqrt(n*n).should == n
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-class FileAccessor
- def open_and_handle_with(pathname, processor)
- pathname.open do |io|
- processor.process(io)
- end
- end
-end
-
-if __FILE__ == $0
- require File.dirname(__FILE__) + '/io_processor'
- require 'pathname'
-
- accessor = FileAccessor.new
- io_processor = IoProcessor.new
- file = Pathname.new ARGV[0]
-
- accessor.open_and_handle_with(file, io_processor)
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/file_accessor'
-require 'stringio'
-
-describe "A FileAccessor" do
- # This sequence diagram illustrates what this spec specifies.
- #
- # +--------------+ +----------+ +-------------+
- # | FileAccessor | | Pathname | | IoProcessor |
- # +--------------+ +----------+ +-------------+
- # | | |
- # open_and_handle_with | | |
- # -------------------->| | open | |
- # | |--------------->| | |
- # | | io | | |
- # | |<...............| | |
- # | | | process(io) |
- # | |---------------------------------->| |
- # | | | | |
- # | |<..................................| |
- # | | |
- #
- it "should open a file and pass it to the processor's process method" do
- # This is the primary actor
- accessor = FileAccessor.new
-
- # These are the primary actor's neighbours, which we mock.
- file = mock "Pathname"
- io_processor = mock "IoProcessor"
-
- io = StringIO.new "whatever"
- file.should_receive(:open).and_yield io
- io_processor.should_receive(:process).with(io)
-
- accessor.open_and_handle_with(file, io_processor)
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-# 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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
-
+++ /dev/null
-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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-context "A legacy spec" do
- setup do
- end
-
- specify "should work fine" do
- end
-
- teardown do
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
+++ /dev/null
-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
-
-MultiThreadedBehaviourRunner = MultiThreadedExampleGroupRunner
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/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
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
-
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
+++ /dev/null
-examples/custom_expectation_matchers.rb
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-
-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 module. If you create one like this
- # it gets assigned to the constant AllThings
- 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
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[spec_helper])
-
-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
\ No newline at end of file
+++ /dev/null
-lib_path = File.expand_path("#{File.dirname(__FILE__)}/../../lib")
-$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
-require 'spec'
+++ /dev/null
-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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + "/stack"
-require File.dirname(__FILE__) + '/shared_stack_examples'
-
-describe Stack, " (empty)" do
- before(:each) do
- @stack = Stack.new
- end
-
- # NOTE that this one auto-generates the description "should be empty"
- 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 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
+++ /dev/null
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/stack'
-require File.dirname(__FILE__) + '/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
+++ /dev/null
-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
-
-
+++ /dev/null
-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
\ No newline at end of file
+++ /dev/null
-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
+++ /dev/null
-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
-
+++ /dev/null
-$:.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 => 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
+++ /dev/null
-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.
+++ /dev/null
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib')
-$:.unshift File.join(File.dirname(__FILE__), '..')
-
-require 'spec'
-require 'behaviour/examples/examples'
-require 'behaviour/stories/stories'
+++ /dev/null
-require 'spec'
-require 'behaviour/examples/game_behaviour'
-require 'behaviour/examples/grid_behaviour'
+++ /dev/null
-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
+++ /dev/null
-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
+++ /dev/null
-Story: cells with less than two neighbours die\r
-\r
-As a game producer\r
-I want cells with less than two neighbours to die\r
-So that I can illustrate how the game works to people with money\r
-\r
-Scenario: cells with zero or one neighbour die\r
-\r
-Given the grid looks like\r
-........\r
-.XX.XX..\r
-.XX.....\r
-....X...\r
-........\r
-When the next step occurs\r
-Then the grid should look like\r
-........\r
-.XX.....\r
-.XX.....\r
-........\r
-........\r
+++ /dev/null
-Story: cells with more than three neighbours die\r
-\r
-As a game producer\r
-I want cells with more than three neighbours to die\r
-So that I can show the people with money how we are getting on\r
-\r
-Scenario: blink\r
-\r
-Given the grid looks like\r
-.....\r
-...XX\r
-...XX\r
-.XX..\r
-.XX..\r
-When the next step occurs\r
-Then the grid should look like\r
-.....\r
-...XX\r
-....X\r
-.X...\r
-.XX..\r
+++ /dev/null
-Story: Empty spaces with three neighbours create a cell\r
-\r
-As a game producer\r
-I want empty cells with three neighbours to die\r
-So that I have a minimum feature set to ship\r
-\r
-Scenario: the glider\r
-\r
-Given the grid looks like\r
-...X..\r
-..X...\r
-..XXX.\r
-......\r
-......\r
-When the next step occurs\r
-Then the grid should look like\r
-......\r
-..X.X.\r
-..XX..\r
-...X..\r
-......\r
-When the next step occurs\r
-Then the grid should look like\r
-......\r
-..X...\r
-..X.X.\r
-..XX..\r
-......\r
-When the next step occurs\r
-Then the grid should look like\r
-......\r
-...X..\r
-.XX...\r
-..XX..\r
-......\r
-When the next step occurs\r
-Then the grid should look like\r
-......\r
-..X...\r
-.X....\r
-.XXX..\r
-......\r
+++ /dev/null
-Story: I can create a cell\r
-\r
-As a game producer\r
-I want to create a cell\r
-So that I can show the grid to people\r
-\r
-Scenario: nothing to see here\r
-\r
-Given a 3 x 3 game\r
-Then the grid should look like\r
-...\r
-...\r
-...\r
-\r
-Scenario: all on its lonesome\r
-\r
-Given a 3 x 3 game\r
-When I create a cell at 1, 1\r
-Then the grid should look like\r
-...\r
-.X.\r
-...\r
-\r
-Scenario: the grid has three cells\r
-\r
-Given a 3 x 3 game\r
-When I create a cell at 0, 0\r
-and I create a cell at 0, 1\r
-and I create a cell at 2, 2\r
-Then the grid should look like\r
-XX.\r
-...\r
-..X\r
-\r
-Scenario: more cells more more\r
-\r
-Given the grid has three cells\r
-When I create a celll at 3, 1\r
-Then the grid should look like\r
-XX.\r
-..X\r
-..X\r
+++ /dev/null
-Story: I can kill a cell\r
-\r
-As a game producer\r
-I want to kill a cell\r
-So that when I make a mistake I dont have to start again\r
-\r
-Scenario: bang youre dead\r
-\r
-Given the grid looks like\r
-XX.\r
-.X.\r
-..X\r
-When I destroy the cell at 0, 1\r
-Then the grid should look like\r
-X..\r
-.X.\r
-..X\r
+++ /dev/null
-Story: The grid wraps\r
-\r
-As a game player\r
-I want the grid to wrap\r
-So that untidy stuff at the edges is avoided\r
-\r
-Scenario: crowded in the corners\r
-\r
-Given the grid looks like\r
-X.X\r
-...\r
-X.X\r
-When the next step is taken\r
-Then the grid should look like\r
-X.X\r
-...\r
-X.X\r
-\r
-\r
-Scenario: the glider returns\r
-\r
-Given the glider\r
-......\r
-..X...\r
-.X....\r
-.XXX..\r
-......\r
-When the next step is taken\r
-and the next step is taken\r
-and the next step is taken\r
-and the next step is taken\r
-Then the grid should look like\r
-......\r
-......\r
-.X....\r
-X.....\r
-XXX...\r
-When the next step is taken\r
-Then the grid should look like\r
-.X....\r
-......\r
-......\r
-X.X...\r
-XX....\r
-When the next step is taken\r
-Then the grid should look like\r
-XX....\r
-......\r
-......\r
-X.....\r
-X.X...\r
-\r
-\r
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[helper])
-
-Story "I can create a cell",
- %(As a game producer
- I want to create a cell
- So that I can show the grid to people), :steps_for => :life do
-
- Scenario "nothing to see here" do
- Given "a game with dimensions", 3, 3 do |rows,cols|
- @game = Game.new(rows,cols)
- end
-
- Then "the grid should look like", %(
- ...
- ...
- ...
- )
- end
-
- Scenario "all on its lonesome" do
- Given "a game with dimensions", 2, 2
- When "I create a cell at", 1, 1 do |row,col|
- @game.create_at(row,col)
- end
- Then "the grid should look like", %(
- ..
- .X
- )
- end
-
- Scenario "the grid has three cells" do
- Given "a game with dimensions", 3, 3
- When "I create a cell at", 0, 0
- When "I create a cell at", 0, 1
- When "I create a cell at", 2, 2
- Then "the grid should look like", %(
- XX.
- ...
- ..X
- )
- end
-
- Scenario "more cells more more" do
- GivenScenario "the grid has three cells"
- When "I create a cell at", 2, 0
- Then "the grid should look like", %(
- XX.
- ...
- X.X
- )
- end
-end
+++ /dev/null
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(File.expand_path("#{dir}/../../../../../../rspec/lib"))
-require 'spec'
-$LOAD_PATH.unshift(File.expand_path("#{dir}/../../"))
-require "#{dir}/../../life"
-require File.join(File.dirname(__FILE__), *%w[steps])
\ No newline at end of file
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[helper])
-
-Story 'I can kill a cell',
- %(As a game producer
- I want to kill a cell
- So that when I make a mistake I don't have to start again), :steps_for => :life do
-
- Scenario "bang, you're dead" do
-
- Given 'a game that looks like', %(
- XX.
- .X.
- ..X
- ) do |dots|
- @game = Game.from_string dots
- end
- When 'I destroy the cell at', 0, 1 do |row,col|
- @game.destroy_at(row,col)
- end
- Then 'the grid should look like', %(
- X..
- .X.
- ..X
- )
- end
-end
+++ /dev/null
-steps_for :life do
- Then "the grid should look like" do |dots|
- @game.grid.should == Grid.from_string(dots)
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[helper])
-require 'behaviour/stories/create_a_cell'
-require 'behaviour/stories/kill_a_cell'
+++ /dev/null
-Story: Show the game field
- As a game player
- I want to see the field
- so that I can observe the progress of the organisms
-
-Scenario: an empty field
- Given a new game starts
- When the game displays the field
- Then the field should be empty
-
-
-
-
-
-StoryBuilder story = stories.createStory().called("a story")
- .asA("person")
- .iWant("to do something")
- .soThat("I can rule the world");
-story.addScenario().called("happy path").as()
- .given("some context")
- .when("some event happens")
- .then("expect some outcome");
+++ /dev/null
-$: << File.dirname(__FILE__)
-require 'life/game'
-require 'life/grid'
+++ /dev/null
-class Game
- attr_accessor :grid
- def initialize(rows,cols)
- @grid = Grid.new(rows, cols)
- end
-
- def create_at(row,col)
- @grid.create_at(row,col)
- end
-
- def destroy_at(row,col)
- @grid.destroy_at(row, col)
- end
-
- def self.from_string(dots)
- grid = Grid.from_string(dots)
- game = new(grid.rows, grid.columns)
- game.instance_eval do
- @grid = grid
- end
- return game
- end
-end
+++ /dev/null
-class Grid
-
- attr_accessor :contents
-
- def initialize(rows, cols)
- @contents = []
- rows.times do @contents << [0] * cols end
- end
-
- def rows
- @contents.size
- end
-
- def columns
- @contents[0].size
- end
-
- def ==(other)
- self.contents == other.contents
- end
-
- def create_at(row,col)
- @contents[row][col] = 1
- end
-
- def destroy_at(row,col)
- @contents[row][col] = 0
- end
-
- def self.from_string(str)
- row_strings = str.split(' ')
- grid = new(row_strings.size, row_strings[0].size)
-
- row_strings.each_with_index do |row, row_index|
- row_chars = row.split(//)
- row_chars.each_with_index do |col_char, col_index|
- grid.create_at(row_index, col_index) if col_char == 'X'
- end
- end
- return grid
- end
-
-end
+++ /dev/null
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'spec/story'
-
-# won't have to do this once plain_text_story_runner is moved into the library
-# require File.join(File.dirname(__FILE__), "plain_text_story_runner")
-
-Dir[File.join(File.dirname(__FILE__), "steps/*.rb")].each do |file|
- require file
-end
\ No newline at end of file
+++ /dev/null
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
-
-# This creates steps for :addition
-steps_for(:addition) do
- Given("an addend of $addend") do |addend|
- @adder ||= Adder.new
- @adder << addend.to_i
- end
-end
-
-# This appends to them
-steps_for(:addition) do
- When("the addends are added") { @sum = @adder.sum }
-end
-
-steps_for(:more_addition) do
- Then("the sum should be $sum") { |sum| @sum.should == sum.to_i }
-end
+++ /dev/null
-Autotest.add_discovery do
- "rspec" if File.exist?('spec')
-end
+++ /dev/null
-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 tests_for_file(filename)
- super.select { |f| @files.has_key? f }
- end
-
- alias :specs_for_file :tests_for_file
-
- def failed_results(results)
- results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m)
- end
-
- def handle_results(results)
- @files_to_test = consolidate_failures failed_results(results)
- unless @files_to_test.empty? then
- hook :red
- else
- hook :green
- end unless $TESTING
- @tainted = true unless @files_to_test.empty?
- end
-
- def consolidate_failures(failed)
- filters = Hash.new { |h,k| h[k] = [] }
- failed.each do |spec, failed_trace|
- @files.keys.select{|f| f =~ /spec\//}.each do |f|
- if failed_trace =~ Regexp.new(f)
- filters[f] << spec
- break
- end
- 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
- 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
- @spec_command ||= spec_commands.each do |command|
- if File.exists?(command)
- return @alt_separator ? (command.gsub @separator, @alt_separator) : command
- end
- end
- raise RspecCommandError, "No spec command could be found!"
- 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
+++ /dev/null
-require 'spec/version'
-require 'spec/matchers'
-require 'spec/expectations'
-require 'spec/example'
-require 'spec/extensions'
-require 'spec/runner'
-
-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
-
-at_exit do \
- unless $! || Spec.run?; \
- success = Spec.run; \
- exit success if Spec.exit?; \
- end \
-end
\ No newline at end of file
+++ /dev/null
-require 'timeout'
-require 'forwardable'
-require 'spec/example/pending'
-require 'spec/example/module_reopening_fix'
-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'
+++ /dev/null
-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
- # setup_mocks_for_rspec, verify_mocks_for_rspec and 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
-
- # Declares modules to be included in all example groups (<tt>describe</tt> blocks).
- #
- # config.include(My::Bottle, My::Cup)
- #
- # If you want to restrict the inclusion to a subset of all the example groups then
- # specify this in a Hash as the last argument:
- #
- # 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.should_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
+++ /dev/null
-module Spec
- module Example
- class ExamplePendingError < StandardError
- end
-
- class PendingExampleFixedError < StandardError
- end
- end
-end
+++ /dev/null
-module Spec
- module Example
- # The superclass for all regular RSpec examples.
- class ExampleGroup
- extend Spec::Example::ExampleGroupMethods
- include Spec::Example::ExampleMethods
-
- def initialize(defined_description, &implementation)
- @_defined_description = defined_description
- @_implementation = implementation
- end
- end
- end
-end
-
-Spec::ExampleGroup = Spec::Example::ExampleGroup
+++ /dev/null
-module Spec
- module Example
- class ExampleGroupFactory
- class << self
- def reset
- @example_group_types = nil
- default(ExampleGroup)
- end
-
- # Registers an example group class +klass+ with the symbol
- # +type+. For example:
- #
- # Spec::Example::ExampleGroupFactory.register(:farm, Spec::Farm::Example::FarmExampleGroup)
- #
- # This will cause Main#describe from a file living in
- # <tt>spec/farm</tt> to create example group instances of type
- # Spec::Farm::Example::FarmExampleGroup.
- def register(id, example_group_class)
- @example_group_types[id] = example_group_class
- end
-
- # Sets the default ExampleGroup class
- def default(example_group_class)
- old = @example_group_types
- @example_group_types = Hash.new(example_group_class)
- @example_group_types.merge(old) if old
- end
-
- def get(id=nil)
- if @example_group_types.values.include?(id)
- id
- else
- @example_group_types[id]
- end
- end
-
- def create_example_group(*args, &block)
- opts = Hash === args.last ? args.last : {}
- if opts[:shared]
- SharedExampleGroup.new(*args, &block)
- else
- superclass = determine_superclass(opts)
- superclass.describe(*args, &block)
- end
- end
-
- protected
-
- def determine_superclass(opts)
- id = if opts[:type]
- opts[:type]
- elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.join('|')})/
- $2 == '' ? nil : $2.to_sym
- end
- get(id)
- end
-
- end
- self.reset
- end
- end
-end
+++ /dev/null
-module Spec
- module Example
-
- module ExampleGroupMethods
- class << self
- def description_text(*args)
- args.inject("") do |result, arg|
- result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
- result << arg.to_s
- end
- end
- end
-
- attr_reader :description_text, :description_args, :description_options, :spec_path
-
- def inherited(klass)
- super
- klass.register
- end
-
- # Makes the describe/it syntax available from a class. For example:
- #
- # class StackSpec < Spec::ExampleGroup
- # describe Stack, "with no elements"
- #
- # before
- # @stack = Stack.new
- # end
- #
- # it "should raise on pop" do
- # lambda{ @stack.pop }.should raise_error
- # end
- # end
- #
- def describe(*args, &example_group_block)
- if example_group_block
- self.subclass("Subclass") do
- describe(*args)
- module_eval(&example_group_block)
- end
- else
- set_description(*args)
- before_eval
- self
- end
- end
-
- # Use this to pull in examples from shared example groups.
- # See Spec::Runner for information about shared example groups.
- def it_should_behave_like(shared_example_group)
- case shared_example_group
- when SharedExampleGroup
- include shared_example_group
- else
- example_group = SharedExampleGroup.find_shared_example_group(shared_example_group)
- unless example_group
- raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
- end
- include(example_group)
- end
- end
-
- # :call-seq:
- # predicate_matchers[matcher_name] = method_on_object
- # predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
- #
- # Dynamically generates a custom matcher that will match
- # a predicate on your class. RSpec provides a couple of these
- # out of the box:
- #
- # exist (or state expectations)
- # File.should exist("path/to/file")
- #
- # an_instance_of (for mock argument constraints)
- # mock.should_receive(:message).with(an_instance_of(String))
- #
- # == Examples
- #
- # class Fish
- # def can_swim?
- # true
- # end
- # end
- #
- # describe Fish do
- # predicate_matchers[:swim] = :can_swim?
- # it "should swim" do
- # Fish.new.should swim
- # end
- # end
- def predicate_matchers
- @predicate_matchers ||= {:an_instance_of => :is_a?}
- end
-
- # Creates an instance of Spec::Example::Example and adds
- # it to a collection of examples of the current example group.
- def it(description=nil, &implementation)
- e = new(description, &implementation)
- example_objects << e
- e
- end
-
- alias_method :specify, :it
-
- # Use this to temporarily disable an example.
- def xit(description=nil, opts={}, &block)
- Kernel.warn("Example disabled: #{description}")
- end
-
- def run
- examples = examples_to_run
- return true if examples.empty?
- reporter.add_example_group(self)
- return dry_run(examples) if dry_run?
-
- plugin_mock_framework
- define_methods_from_predicate_matchers
-
- success, before_all_instance_variables = run_before_all
- success, after_all_instance_variables = execute_examples(success, before_all_instance_variables, examples)
- success = run_after_all(success, after_all_instance_variables)
- end
-
- def description
- result = ExampleGroupMethods.description_text(*description_parts)
- if result.nil? || result == ""
- return to_s
- else
- result
- end
- end
-
- def described_type
- description_parts.find {|part| part.is_a?(Module)}
- end
-
- def description_parts #:nodoc:
- parts = []
- execute_in_class_hierarchy do |example_group|
- parts << example_group.description_args
- end
- parts.flatten.compact
- end
-
- def set_description(*args)
- args, options = args_and_options(*args)
- @description_args = args
- @description_options = options
- @description_text = ExampleGroupMethods.description_text(*args)
- @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
- if described_type.class == Module
- include described_type
- end
- self
- end
-
- def examples #:nodoc:
- examples = example_objects.dup
- add_method_examples(examples)
- rspec_options.reverse ? examples.reverse : examples
- end
-
- def number_of_examples #:nodoc:
- examples.length
- end
-
- # Registers a block to be executed before each example.
- # This method prepends +block+ to existing before blocks.
- def prepend_before(*args, &block)
- scope, options = scope_and_options(*args)
- parts = before_parts_from_scope(scope)
- parts.unshift(block)
- end
-
- # Registers a block to be executed before each example.
- # This method appends +block+ to existing before blocks.
- def append_before(*args, &block)
- scope, options = scope_and_options(*args)
- parts = before_parts_from_scope(scope)
- parts << block
- end
- alias_method :before, :append_before
-
- # Registers a block to be executed after each example.
- # This method prepends +block+ to existing after blocks.
- def prepend_after(*args, &block)
- scope, options = scope_and_options(*args)
- parts = after_parts_from_scope(scope)
- parts.unshift(block)
- end
- alias_method :after, :prepend_after
-
- # Registers a block to be executed after each example.
- # This method appends +block+ to existing after blocks.
- def append_after(*args, &block)
- scope, options = scope_and_options(*args)
- parts = after_parts_from_scope(scope)
- parts << block
- end
-
- def remove_after(scope, &block)
- after_each_parts.delete(block)
- end
-
- # Deprecated. Use before(:each)
- def setup(&block)
- before(:each, &block)
- end
-
- # Deprecated. Use after(:each)
- def teardown(&block)
- after(:each, &block)
- end
-
- def before_all_parts # :nodoc:
- @before_all_parts ||= []
- end
-
- def after_all_parts # :nodoc:
- @after_all_parts ||= []
- end
-
- def before_each_parts # :nodoc:
- @before_each_parts ||= []
- end
-
- def after_each_parts # :nodoc:
- @after_each_parts ||= []
- end
-
- # Only used from RSpec's own examples
- def reset # :nodoc:
- @before_all_parts = nil
- @after_all_parts = nil
- @before_each_parts = nil
- @after_each_parts = nil
- end
-
- def register
- rspec_options.add_example_group self
- end
-
- def unregister #:nodoc:
- rspec_options.remove_example_group self
- end
-
- def run_before_each(example)
- execute_in_class_hierarchy do |example_group|
- example.eval_each_fail_fast(example_group.before_each_parts)
- end
- end
-
- def run_after_each(example)
- execute_in_class_hierarchy(:superclass_first) do |example_group|
- example.eval_each_fail_slow(example_group.after_each_parts)
- end
- end
-
- private
- def dry_run(examples)
- examples.each do |example|
- rspec_options.reporter.example_started(example)
- rspec_options.reporter.example_finished(example)
- end
- return true
- end
-
- def run_before_all
- before_all = new("before(:all)")
- begin
- execute_in_class_hierarchy do |example_group|
- before_all.eval_each_fail_fast(example_group.before_all_parts)
- end
- return [true, before_all.instance_variable_hash]
- rescue Exception => e
- reporter.failure(before_all, e)
- return [false, before_all.instance_variable_hash]
- end
- end
-
- def execute_examples(success, instance_variables, examples)
- return [success, instance_variables] unless success
-
- after_all_instance_variables = instance_variables
- examples.each do |example_group_instance|
- success &= example_group_instance.execute(rspec_options, instance_variables)
- after_all_instance_variables = example_group_instance.instance_variable_hash
- end
- return [success, after_all_instance_variables]
- end
-
- def run_after_all(success, instance_variables)
- after_all = new("after(:all)")
- after_all.set_instance_variables_from_hash(instance_variables)
- execute_in_class_hierarchy(:superclass_first) do |example_group|
- after_all.eval_each_fail_slow(example_group.after_all_parts)
- end
- return success
- rescue Exception => e
- reporter.failure(after_all, e)
- return false
- end
-
- def examples_to_run
- all_examples = examples
- return all_examples unless specified_examples?
- all_examples.reject do |example|
- matcher = ExampleMatcher.new(description.to_s, example.description)
- !matcher.matches?(specified_examples)
- end
- end
-
- def specified_examples?
- specified_examples && !specified_examples.empty?
- end
-
- def specified_examples
- rspec_options.examples
- end
-
- def reporter
- rspec_options.reporter
- end
-
- def dry_run?
- rspec_options.dry_run
- end
-
- def example_objects
- @example_objects ||= []
- end
-
- def execute_in_class_hierarchy(superclass_last=false)
- classes = []
- current_class = self
- while is_example_group?(current_class)
- superclass_last ? classes << current_class : classes.unshift(current_class)
- current_class = current_class.superclass
- end
- superclass_last ? classes << ExampleMethods : classes.unshift(ExampleMethods)
-
- classes.each do |example_group|
- yield example_group
- end
- end
-
- def is_example_group?(klass)
- Module === klass && klass.kind_of?(ExampleGroupMethods)
- end
-
- def plugin_mock_framework
- case mock_framework = Spec::Runner.configuration.mock_framework
- when Module
- include mock_framework
- else
- require Spec::Runner.configuration.mock_framework
- include Spec::Plugins::MockFramework
- end
- end
-
- def define_methods_from_predicate_matchers # :nodoc:
- all_predicate_matchers = predicate_matchers.merge(
- Spec::Runner.configuration.predicate_matchers
- )
- all_predicate_matchers.each_pair do |matcher_method, method_on_object|
- define_method matcher_method do |*args|
- eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
- end
- end
- end
-
- def scope_and_options(*args)
- args, options = args_and_options(*args)
- scope = (args[0] || :each), options
- end
-
- def before_parts_from_scope(scope)
- case scope
- when :each; before_each_parts
- when :all; before_all_parts
- end
- end
-
- def after_parts_from_scope(scope)
- case scope
- when :each; after_each_parts
- when :all; after_all_parts
- end
- end
-
- def before_eval
- end
-
- def add_method_examples(examples)
- instance_methods.sort.each do |method_name|
- if example_method?(method_name)
- examples << new(method_name) do
- __send__(method_name)
- end
- end
- end
- end
-
- def example_method?(method_name)
- should_method?(method_name)
- end
-
- def should_method?(method_name)
- !(method_name =~ /^should(_not)?$/) &&
- method_name =~ /^should/ && (
- instance_method(method_name).arity == 0 ||
- instance_method(method_name).arity == -1
- )
- end
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Example
- class ExampleMatcher
- def initialize(example_group_description, example_name)
- @example_group_description = example_group_description
- @example_name = example_name
- end
-
- def matches?(specified_examples)
- specified_examples.each do |specified_example|
- return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
- end
- false
- end
-
- protected
- def matches_literal_example?(specified_example)
- specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/
- end
-
- def matches_example_not_considering_modules?(specified_example)
- specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/
- end
-
- def example_group_regex
- Regexp.escape(@example_group_description)
- end
-
- def example_group_with_before_all_regexp
- Regexp.escape("#{@example_group_description} before(:all)")
- end
-
- def example_group_regex_not_considering_modules
- Regexp.escape(@example_group_description.split('::').last)
- end
-
- def example_regexp
- Regexp.escape(@example_name)
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Example
- module ExampleMethods
- extend ExampleGroupMethods
- extend ModuleReopeningFix
-
- PENDING_EXAMPLE_BLOCK = lambda {
- raise Spec::Example::ExamplePendingError.new("Not Yet Implemented")
- }
-
- def execute(options, instance_variables)
- options.reporter.example_started(self)
- set_instance_variables_from_hash(instance_variables)
-
- execution_error = nil
- Timeout.timeout(options.timeout) do
- begin
- before_example
- run_with_description_capturing
- rescue Exception => e
- execution_error ||= e
- end
- begin
- after_example
- rescue Exception => e
- execution_error ||= e
- end
- end
-
- options.reporter.example_finished(self, execution_error)
- success = execution_error.nil? || ExamplePendingError === execution_error
- end
-
- def instance_variable_hash
- instance_variables.inject({}) do |variable_hash, variable_name|
- variable_hash[variable_name] = instance_variable_get(variable_name)
- variable_hash
- end
- end
-
- def violated(message="")
- raise Spec::Expectations::ExpectationNotMetError.new(message)
- end
-
- def eval_each_fail_fast(procs) #:nodoc:
- procs.each do |proc|
- instance_eval(&proc)
- end
- end
-
- def eval_each_fail_slow(procs) #:nodoc:
- first_exception = nil
- procs.each do |proc|
- begin
- instance_eval(&proc)
- rescue Exception => e
- first_exception ||= e
- end
- end
- raise first_exception if first_exception
- end
-
- def description
- @_defined_description || @_matcher_description || "NO NAME"
- end
-
- def set_instance_variables_from_hash(ivars)
- ivars.each do |variable_name, value|
- # Ruby 1.9 requires variable.to_s on the next line
- unless ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].include?(variable_name.to_s)
- instance_variable_set variable_name, value
- end
- end
- end
-
- def run_with_description_capturing
- begin
- return instance_eval(&(@_implementation || PENDING_EXAMPLE_BLOCK))
- ensure
- @_matcher_description = Spec::Matchers.generated_description
- Spec::Matchers.clear_generated_description
- end
- end
-
- protected
- include Matchers
- include Pending
-
- def before_example
- setup_mocks_for_rspec
- self.class.run_before_each(self)
- end
-
- def after_example
- self.class.run_after_each(self)
- verify_mocks_for_rspec
- ensure
- teardown_mocks_for_rspec
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Example
- # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak)
- module ModuleReopeningFix
- def child_modules
- @child_modules ||= []
- end
-
- def included(mod)
- child_modules << mod
- end
-
- def include(mod)
- super
- child_modules.each do |child_module|
- child_module.__send__(:include, mod)
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Example
- module Pending
- def pending(message = "TODO")
- if block_given?
- begin
- yield
- rescue Exception => e
- raise Spec::Example::ExamplePendingError.new(message)
- end
- raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
- else
- raise Spec::Example::ExamplePendingError.new(message)
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Example
- class SharedExampleGroup < Module
- class << self
- def add_shared_example_group(new_example_group)
- guard_against_redefining_existing_example_group(new_example_group)
- shared_example_groups << new_example_group
- end
-
- def find_shared_example_group(example_group_description)
- shared_example_groups.find do |b|
- b.description == example_group_description
- end
- end
-
- def shared_example_groups
- # TODO - this needs to be global, or at least accessible from
- # from subclasses of Example in a centralized place. I'm not loving
- # this as a solution, but it works for now.
- $shared_example_groups ||= []
- end
-
- private
- def guard_against_redefining_existing_example_group(new_example_group)
- existing_example_group = find_shared_example_group(new_example_group.description)
- return unless existing_example_group
- return if new_example_group.equal?(existing_example_group)
- return if spec_path(new_example_group) == spec_path(existing_example_group)
- raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
- end
-
- def spec_path(example_group)
- File.expand_path(example_group.spec_path)
- end
- end
- include ExampleGroupMethods
- public :include
-
- def initialize(*args, &example_group_block)
- describe(*args)
- @example_group_block = example_group_block
- self.class.add_shared_example_group(self)
- end
-
- def included(mod) # :nodoc:
- mod.module_eval(&@example_group_block)
- end
-
- def execute_in_class_hierarchy(superclass_last=false)
- classes = [self]
- superclass_last ? classes << ExampleMethods : classes.unshift(ExampleMethods)
- classes.each do |example_group|
- yield example_group
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/matchers'
-require 'spec/expectations/errors'
-require 'spec/expectations/extensions'
-require 'spec/expectations/handler'
-
-module Spec
-
- # Spec::Expectations lets you set expectations on your objects.
- #
- # result.should == 37
- # team.should have(11).players_on_the_field
- #
- # == How Expectations work.
- #
- # Spec::Expectations adds two methods to Object:
- #
- # should(matcher=nil)
- # should_not(matcher=nil)
- #
- # Both methods take an optional Expression Matcher (See Spec::Matchers).
- #
- # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
- # it returns +true+, the spec passes and execution continues. If it returns
- # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
- #
- # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
- # it returns +false+, the spec passes and execution continues. If it returns
- # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
- #
- # RSpec ships with a standard set of useful matchers, and writing your own
- # matchers is quite simple. See Spec::Matchers for details.
- module Expectations
- class << self
- attr_accessor :differ
-
- # raises a Spec::Expectations::ExpectationNotMetError with message
- #
- # When a differ has been assigned and fail_with is passed
- # <code>expected</code> and <code>target</code>, passes them
- # to the differ to append a diff message to the failure message.
- def fail_with(message, expected=nil, target=nil) # :nodoc:
- if Array === message && message.length == 3
- message, expected, target = message[0], message[1], message[2]
- end
- unless (differ.nil? || expected.nil? || target.nil?)
- if expected.is_a?(String)
- message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
- elsif !target.is_a?(Proc)
- message << "\nDiff:" << self.differ.diff_as_object(target, expected)
- end
- end
- Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
- end
- end
- end
-end
+++ /dev/null
-begin
- require 'rubygems'
- require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
- require 'diff/lcs/hunk'
-rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
-
-require 'pp'
-
-module Spec
- module Expectations
- module Differs
-
- # TODO add some rdoc
- class Default
- def initialize(options)
- @options = options
- end
-
- # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
- def diff_as_string(data_old, data_new)
- data_old = data_old.split(/\n/).map! { |e| e.chomp }
- data_new = data_new.split(/\n/).map! { |e| e.chomp }
- output = ""
- diffs = Diff::LCS.diff(data_old, data_new)
- return output if diffs.empty?
- oldhunk = hunk = nil
- file_length_difference = 0
- diffs.each do |piece|
- begin
- hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
- file_length_difference)
- file_length_difference = hunk.file_length_difference
- next unless oldhunk
- # Hunks may overlap, which is why we need to be careful when our
- # diff includes lines of context. Otherwise, we might print
- # redundant lines.
- if (context_lines > 0) and hunk.overlaps?(oldhunk)
- hunk.unshift(oldhunk)
- else
- output << oldhunk.diff(format)
- end
- ensure
- oldhunk = hunk
- output << "\n"
- end
- end
- #Handle the last remaining hunk
- output << oldhunk.diff(format) << "\n"
- end
-
- def diff_as_object(target,expected)
- diff_as_string(PP.pp(target,""), PP.pp(expected,""))
- end
-
- protected
- def format
- @options.diff_format
- end
-
- def context_lines
- @options.context_lines
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Expectations
- # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
- # will report unmet RSpec expectations as failures rather than errors.
- superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
- eval(c) rescue nil
- end.compact.first
-
- class ExpectationNotMetError < superclass
- end
- end
-end
+++ /dev/null
-require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/string_and_symbol'
+++ /dev/null
-module Spec
- module Expectations
- # rspec adds #should and #should_not to every Object (and,
- # implicitly, every Class).
- module ObjectExpectations
- # :call-seq:
- # should(matcher)
- # should == expected
- # should === expected
- # should =~ expected
- #
- # receiver.should(matcher)
- # => Passes if matcher.matches?(receiver)
- #
- # receiver.should == expected #any value
- # => Passes if (receiver == expected)
- #
- # receiver.should === expected #any value
- # => Passes if (receiver === expected)
- #
- # receiver.should =~ regexp
- # => Passes if (receiver =~ regexp)
- #
- # See Spec::Matchers for more information about matchers
- #
- # == Warning
- #
- # NOTE that this does NOT support receiver.should != expected.
- # Instead, use receiver.should_not == expected
- def should(matcher = :default_parameter, &block)
- if :default_parameter == matcher
- Spec::Matchers::PositiveOperatorMatcher.new(self)
- else
- ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
- end
- end
-
- # :call-seq:
- # should_not(matcher)
- # should_not == expected
- # should_not === expected
- # should_not =~ expected
- #
- # receiver.should_not(matcher)
- # => Passes unless matcher.matches?(receiver)
- #
- # receiver.should_not == expected
- # => Passes unless (receiver == expected)
- #
- # receiver.should_not === expected
- # => Passes unless (receiver === expected)
- #
- # receiver.should_not =~ regexp
- # => Passes unless (receiver =~ regexp)
- #
- # See Spec::Matchers for more information about matchers
- def should_not(matcher = :default_parameter, &block)
- if :default_parameter == matcher
- Spec::Matchers::NegativeOperatorMatcher.new(self)
- else
- NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
- end
- end
-
- end
- end
-end
-
-class Object
- include Spec::Expectations::ObjectExpectations
-end
+++ /dev/null
-module Spec
- module Expectations
- module StringHelpers
- def starts_with?(prefix)
- to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
- end
- end
- end
-end
-
-class String
- include Spec::Expectations::StringHelpers
-end
-
-class Symbol
- include Spec::Expectations::StringHelpers
-end
+++ /dev/null
-module Spec
- module Expectations
- class InvalidMatcherError < ArgumentError; end
-
- module MatcherHandlerHelper
- def describe_matcher(matcher)
- matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
- end
- end
-
- class ExpectationMatcherHandler
- class << self
- include MatcherHandlerHelper
- def handle_matcher(actual, matcher, &block)
- unless matcher.respond_to?(:matches?)
- raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
- end
-
- match = matcher.matches?(actual, &block)
- ::Spec::Matchers.generated_description = "should #{describe_matcher(matcher)}"
- Spec::Expectations.fail_with(matcher.failure_message) unless match
- end
- end
- end
-
- class NegativeExpectationMatcherHandler
- class << self
- include MatcherHandlerHelper
- def handle_matcher(actual, matcher, &block)
- unless matcher.respond_to?(:matches?)
- raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
- end
-
- unless matcher.respond_to?(:negative_failure_message)
- Spec::Expectations.fail_with(
-<<-EOF
-Matcher does not support should_not.
-See Spec::Matchers for more information
-about matchers.
-EOF
-)
- end
- match = matcher.matches?(actual, &block)
- ::Spec::Matchers.generated_description = "should not #{describe_matcher(matcher)}"
- Spec::Expectations.fail_with(matcher.negative_failure_message) if match
- end
- end
- end
-
- end
-end
-
+++ /dev/null
-require 'spec/extensions/object'
-require 'spec/extensions/class'
-require 'spec/extensions/main'
+++ /dev/null
-class Class
- # Creates a new subclass of self, with a name "under" our own name.
- # Example:
- #
- # x = Foo::Bar.subclass('Zap'){}
- # x.name # => Foo::Bar::Zap_1
- # x.superclass.name # => Foo::Bar
- def subclass(base_name, &body)
- klass = Class.new(self)
- class_name = "#{base_name}_#{class_count!}"
- instance_eval do
- const_set(class_name, klass)
- end
- klass.instance_eval(&body)
- klass
- end
-
- private
- def class_count!
- @class_count ||= 0
- @class_count += 1
- @class_count
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Extensions
- module Main
- # Creates and returns a class that includes the ExampleGroupMethods
- # module. Which ExampleGroup type is created depends on the directory of the file
- # calling this method. For example, Spec::Rails will use different
- # classes for specs living in <tt>spec/models</tt>,
- # <tt>spec/helpers</tt>, <tt>spec/views</tt> and
- # <tt>spec/controllers</tt>.
- #
- # It is also possible to override autodiscovery of the example group
- # type with an options Hash as the last argument:
- #
- # describe "name", :type => :something_special do ...
- #
- # The reason for using different behaviour classes is to have different
- # matcher methods available from within the <tt>describe</tt> block.
- #
- # See Spec::Example::ExampleFactory#register for details about how to
- # register special implementations.
- #
- def describe(*args, &block)
- raise ArgumentError if args.empty?
- raise ArgumentError unless block
- args << {} unless Hash === args.last
- args.last[:spec_path] = caller(0)[1]
- Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
- end
- alias :context :describe
-
- # Creates an example group that can be shared by other example groups
- #
- # == Examples
- #
- # share_examples_for "All Editions" do
- # it "all editions behaviour" ...
- # end
- #
- # describe SmallEdition do
- # it_should_behave_like "All Editions"
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- def share_examples_for(name, &block)
- describe(name, :shared => true, &block)
- end
-
- alias :shared_examples_for :share_examples_for
-
- # Creates a Shared Example Group and assigns it to a constant
- #
- # share_as :AllEditions do
- # it "should do all editions stuff" ...
- # end
- #
- # describe SmallEdition do
- # it_should_behave_like AllEditions
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- #
- # And, for those of you who prefer to use something more like Ruby, you
- # can just include the module directly
- #
- # describe SmallEdition do
- # include AllEditions
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- def share_as(name, &block)
- begin
- Object.const_set(name, share_examples_for(name, &block))
- rescue NameError => e
- raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
- end
- end
-
- private
-
- def rspec_options
- $rspec_options ||= begin; \
- parser = ::Spec::Runner::OptionParser.new(STDERR, STDOUT); \
- parser.order!(ARGV); \
- $rspec_options = parser.options; \
- end
- $rspec_options
- end
-
- def init_rspec_options(options)
- $rspec_options = options if $rspec_options.nil?
- end
- end
- end
-end
-
-include Spec::Extensions::Main
\ No newline at end of file
+++ /dev/null
-class Object
- def args_and_options(*args)
- options = Hash === args.last ? args.pop : {}
- return args, options
- end
-
- def metaclass
- class << self; self; end
- end
-end
+++ /dev/null
-require 'test/unit'
-require 'test/unit/testresult'
-
-require 'spec/interop/test/unit/testcase'
-require 'spec/interop/test/unit/testsuite_adapter'
-require 'spec/interop/test/unit/autorunner'
-require 'spec/interop/test/unit/testresult'
-require 'spec/interop/test/unit/ui/console/testrunner'
-
-Spec::Example::ExampleGroupFactory.default(Test::Unit::TestCase)
\ No newline at end of file
+++ /dev/null
-class Test::Unit::AutoRunner
- remove_method :process_args
- def process_args(argv)
- true
- end
-end
+++ /dev/null
-require 'test/unit/testcase'
-
-module Test
- module Unit
- # This extension of the standard Test::Unit::TestCase makes RSpec
- # available from within, so that you can do things like:
- #
- # require 'test/unit'
- # require 'spec'
- #
- # class MyTest < Test::Unit::TestCase
- # it "should work with Test::Unit assertions" do
- # assert_equal 4, 2+1
- # end
- #
- # def test_should_work_with_rspec_expectations
- # (3+1).should == 5
- # end
- # end
- #
- # See also Spec::Example::ExampleGroup
- class TestCase
- extend Spec::Example::ExampleGroupMethods
- include Spec::Example::ExampleMethods
-
- before(:each) {setup}
- after(:each) {teardown}
-
- class << self
- def suite
- Test::Unit::TestSuiteAdapter.new(self)
- end
-
- def example_method?(method_name)
- should_method?(method_name) || test_method?(method_name)
- end
-
- def test_method?(method_name)
- method_name =~ /^test[_A-Z]./ && (
- instance_method(method_name).arity == 0 ||
- instance_method(method_name).arity == -1
- )
- end
- end
-
- def initialize(defined_description, &implementation)
- @_defined_description = defined_description
- @_implementation = implementation
-
- @_result = ::Test::Unit::TestResult.new
- # @method_name is important to set here because it "complies" with Test::Unit's interface.
- # Some Test::Unit extensions depend on @method_name being present.
- @method_name = @_defined_description
- end
-
- def run(ignore_this_argument=nil)
- super()
- end
- end
- end
-end
+++ /dev/null
-class Test::Unit::TestResult
- alias_method :tu_passed?, :passed?
- def passed?
- return tu_passed? & ::Spec.run
- end
-end
\ No newline at end of file
+++ /dev/null
-module Test
- module Unit
- class TestSuiteAdapter < TestSuite
- attr_reader :example_group, :examples
- alias_method :tests, :examples
- def initialize(example_group)
- @example_group = example_group
- @examples = example_group.examples
- end
-
- def name
- example_group.description
- end
-
- def run(*args)
- return true unless args.empty?
- example_group.run
- end
-
- def size
- example_group.number_of_examples
- end
-
- def delete(example)
- examples.delete example
- end
-
- def empty?
- examples.empty?
- end
- end
- end
-end
-
+++ /dev/null
-require 'test/unit/ui/console/testrunner'
-
-module Test
- module Unit
- module UI
- module Console
- class TestRunner
-
- alias_method :started_without_rspec, :started
- def started_with_rspec(result)
- @result = result
- @need_to_output_started = true
- end
- alias_method :started, :started_with_rspec
-
- alias_method :test_started_without_rspec, :test_started
- def test_started_with_rspec(name)
- if @need_to_output_started
- if @rspec_io
- @rspec_io.rewind
- output(@rspec_io.read)
- end
- output("Started")
- @need_to_output_started = false
- end
- test_started_without_rspec(name)
- end
- alias_method :test_started, :test_started_with_rspec
-
- alias_method :test_finished_without_rspec, :test_finished
- def test_finished_with_rspec(name)
- test_finished_without_rspec(name)
- @ran_test = true
- end
- alias_method :test_finished, :test_finished_with_rspec
-
- alias_method :finished_without_rspec, :finished
- def finished_with_rspec(elapsed_time)
- if @ran_test
- finished_without_rspec(elapsed_time)
- end
- end
- alias_method :finished, :finished_with_rspec
-
- alias_method :setup_mediator_without_rspec, :setup_mediator
- def setup_mediator_with_rspec
- orig_io = @io
- @io = StringIO.new
- setup_mediator_without_rspec
- ensure
- @rspec_io = @io
- @io = orig_io
- end
- alias_method :setup_mediator, :setup_mediator_with_rspec
-
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/matchers/simple_matcher'
-require 'spec/matchers/be'
-require 'spec/matchers/be_close'
-require 'spec/matchers/change'
-require 'spec/matchers/eql'
-require 'spec/matchers/equal'
-require 'spec/matchers/exist'
-require 'spec/matchers/has'
-require 'spec/matchers/have'
-require 'spec/matchers/include'
-require 'spec/matchers/match'
-require 'spec/matchers/raise_error'
-require 'spec/matchers/respond_to'
-require 'spec/matchers/satisfy'
-require 'spec/matchers/throw_symbol'
-require 'spec/matchers/operator_matcher'
-
-module Spec
-
- # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
- # is any object that responds to the following methods:
- #
- # matches?(actual)
- # failure_message
- # negative_failure_message #optional
- # description #optional
- #
- # See Spec::Expectations to learn how to use these as Expectation Matchers.
- # See Spec::Mocks to learn how to use them as Mock Argument Constraints.
- #
- # == Predicates
- #
- # In addition to those Expression Matchers that are defined explicitly, RSpec will
- # create custom Matchers on the fly for any arbitrary predicate, giving your specs
- # a much more natural language feel.
- #
- # A Ruby predicate is a method that ends with a "?" and returns true or false.
- # Common examples are +empty?+, +nil?+, and +instance_of?+.
- #
- # All you need to do is write +should be_+ followed by the predicate without
- # the question mark, and RSpec will figure it out from there. For example:
- #
- # [].should be_empty => [].empty? #passes
- # [].should_not be_empty => [].empty? #fails
- #
- # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
- # and "be_an_", making your specs read much more naturally:
- #
- # "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
- #
- # 3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
- # 3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
- # 3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
- # 3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
- #
- # RSpec will also create custom matchers for predicates like +has_key?+. To
- # use this feature, just state that the object should have_key(:key) and RSpec will
- # call has_key?(:key) on the target. For example:
- #
- # {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
- # {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
- #
- # You can use this feature to invoke any predicate that begins with "has_", whether it is
- # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
- #
- # == Custom Expectation Matchers
- #
- # When you find that none of the stock Expectation Matchers provide a natural
- # feeling expectation, you can very easily write your own.
- #
- # For example, imagine that you are writing a game in which players can
- # be in various zones on a virtual board. To specify that bob should
- # be in zone 4, you could say:
- #
- # bob.current_zone.should eql(Zone.new("4"))
- #
- # But you might find it more expressive to say:
- #
- # bob.should be_in_zone("4")
- #
- # and/or
- #
- # bob.should_not be_in_zone("3")
- #
- # To do this, you would need to write a class like this:
- #
- # class BeInZone
- # def initialize(expected)
- # @expected = expected
- # end
- # def matches?(target)
- # @target = target
- # @target.current_zone.eql?(Zone.new(@expected))
- # end
- # def failure_message
- # "expected #{@target.inspect} to be in Zone #{@expected}"
- # end
- # def negative_failure_message
- # "expected #{@target.inspect} not to be in Zone #{@expected}"
- # end
- # end
- #
- # ... and a method like this:
- #
- # def be_in_zone(expected)
- # BeInZone.new(expected)
- # end
- #
- # And then expose the method to your specs. This is normally done
- # by including the method and the class in a module, which is then
- # included in your spec:
- #
- # module CustomGameMatchers
- # class BeInZone
- # ...
- # end
- #
- # def be_in_zone(expected)
- # ...
- # end
- # end
- #
- # describe "Player behaviour" do
- # include CustomGameMatchers
- # ...
- # end
- #
- # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
- # from your spec file(s):
- #
- # Spec::Runner.configure do |config|
- # config.include(CustomGameMatchers)
- # end
- #
- module Matchers
- module ModuleMethods
- attr_accessor :generated_description
-
- def clear_generated_description
- self.generated_description = nil
- end
- end
-
- extend ModuleMethods
-
- def method_missing(sym, *args, &block) # :nodoc:
- return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
- return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
- super
- end
-
- class MatcherError < StandardError
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Be #:nodoc:
- def initialize(*args)
- if args.empty?
- @expected = :satisfy_if
- else
- @expected = parse_expected(args.shift)
- end
- @args = args
- @comparison = ""
- end
-
- def matches?(actual)
- @actual = actual
- if handling_predicate?
- begin
- return @result = actual.__send__(predicate, *@args)
- rescue => predicate_error
- # This clause should be empty, but rcov will not report it as covered
- # unless something (anything) is executed within the clause
- rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
- end
-
- # This supports should_exist > target.exists? in the old world.
- # We should consider deprecating that ability as in the new world
- # you can't write "should exist" unless you have your own custom matcher.
- begin
- return @result = actual.__send__(present_tense_predicate, *@args)
- rescue
- raise predicate_error
- end
- else
- return match_or_compare
- end
- end
-
- def failure_message
- return "expected #{@comparison}#{expected}, got #{@actual.inspect}" unless handling_predicate?
- return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
- end
-
- def negative_failure_message
- return "expected not #{expected}, got #{@actual.inspect}" unless handling_predicate?
- return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
- end
-
- def expected
- return "if to be satisfied" if @expected == :satisfy_if
- return true if @expected == :true
- return false if @expected == :false
- return "nil" if @expected == :nil
- return @expected.inspect
- end
-
- def match_or_compare
- return @actual ? true : false if @expected == :satisfy_if
- return @actual == true if @expected == :true
- return @actual == false if @expected == :false
- return @actual.nil? if @expected == :nil
- return @actual < @expected if @less_than
- return @actual <= @expected if @less_than_or_equal
- return @actual >= @expected if @greater_than_or_equal
- return @actual > @expected if @greater_than
- return @actual == @expected if @double_equal
- return @actual === @expected if @triple_equal
- return @actual.equal?(@expected)
- end
-
- def ==(expected)
- @prefix = "be "
- @double_equal = true
- @comparison = "== "
- @expected = expected
- self
- end
-
- def ===(expected)
- @prefix = "be "
- @triple_equal = true
- @comparison = "=== "
- @expected = expected
- self
- end
-
- def <(expected)
- @prefix = "be "
- @less_than = true
- @comparison = "< "
- @expected = expected
- self
- end
-
- def <=(expected)
- @prefix = "be "
- @less_than_or_equal = true
- @comparison = "<= "
- @expected = expected
- self
- end
-
- def >=(expected)
- @prefix = "be "
- @greater_than_or_equal = true
- @comparison = ">= "
- @expected = expected
- self
- end
-
- def >(expected)
- @prefix = "be "
- @greater_than = true
- @comparison = "> "
- @expected = expected
- self
- end
-
- def description
- "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}"
- end
-
- private
- def parse_expected(expected)
- if Symbol === expected
- @handling_predicate = true
- ["be_an_","be_a_","be_"].each do |prefix|
- if expected.starts_with?(prefix)
- @prefix = prefix
- return "#{expected.to_s.sub(@prefix,"")}".to_sym
- end
- end
- end
- @prefix = ""
- return expected
- end
-
- def handling_predicate?
- return false if [:true, :false, :nil].include?(@expected)
- return @handling_predicate
- end
-
- def predicate
- "#{@expected.to_s}?".to_sym
- end
-
- def present_tense_predicate
- "#{@expected.to_s}s?".to_sym
- end
-
- def args_to_s
- return "" if @args.empty?
- inspected_args = @args.collect{|a| a.inspect}
- return "(#{inspected_args.join(', ')})"
- end
-
- def comparison
- @comparison
- end
-
- def expected_to_sentence
- split_words(@expected)
- end
-
- def prefix_to_sentence
- split_words(@prefix)
- end
-
- def split_words(sym)
- sym.to_s.gsub(/_/,' ')
- end
-
- def args_to_sentence
- case @args.length
- when 0
- ""
- when 1
- " #{@args[0]}"
- else
- " #{@args[0...-1].join(', ')} and #{@args[-1]}"
- end
- end
-
- end
-
- # :call-seq:
- # should be
- # should be_true
- # should be_false
- # should be_nil
- # should be_arbitrary_predicate(*args)
- # should_not be_nil
- # should_not be_arbitrary_predicate(*args)
- #
- # Given true, false, or nil, will pass if actual is
- # true, false or nil (respectively). Given no args means
- # the caller should satisfy an if condition (to be or not to be).
- #
- # Predicates are any Ruby method that ends in a "?" and returns true or false.
- # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
- # convert that into a query against the target object.
- #
- # The arbitrary_predicate feature will handle any predicate
- # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
- # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
- #
- # == Examples
- #
- # target.should be
- # target.should be_true
- # target.should be_false
- # target.should be_nil
- # target.should_not be_nil
- #
- # collection.should be_empty #passes if target.empty?
- # "this string".should be_an_intance_of(String)
- #
- # target.should_not be_empty #passes unless target.empty?
- # target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
- def be(*args)
- Matchers::Be.new(*args)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class BeClose #:nodoc:
- def initialize(expected, delta)
- @expected = expected
- @delta = delta
- end
-
- def matches?(actual)
- @actual = actual
- (@actual - @expected).abs < @delta
- end
-
- def failure_message
- "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
- end
-
- def description
- "be close to #{@expected} (within +- #{@delta})"
- end
- end
-
- # :call-seq:
- # should be_close(expected, delta)
- # should_not be_close(expected, delta)
- #
- # Passes if actual == expected +/- delta
- #
- # == Example
- #
- # result.should be_close(3.0, 0.5)
- def be_close(expected, delta)
- Matchers::BeClose.new(expected, delta)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- #Based on patch from Wilson Bilkovich
- class Change #:nodoc:
- def initialize(receiver=nil, message=nil, &block)
- @receiver = receiver
- @message = message
- @block = block
- end
-
- def matches?(target, &block)
- if block
- raise MatcherError.new(<<-EOF
-block passed to should or should_not change must use {} instead of do/end
-EOF
-)
- end
- @target = target
- execute_change
- return false if @from && (@from != @before)
- return false if @to && (@to != @after)
- return (@before + @amount == @after) if @amount
- return ((@after - @before) >= @minimum) if @minimum
- return ((@after - @before) <= @maximum) if @maximum
- return @before != @after
- end
-
- def execute_change
- @before = @block.nil? ? @receiver.send(@message) : @block.call
- @target.call
- @after = @block.nil? ? @receiver.send(@message) : @block.call
- end
-
- def failure_message
- if @to
- "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
- elsif @from
- "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}"
- elsif @amount
- "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
- elsif @minimum
- "#{result} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
- elsif @maximum
- "#{result} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
- else
- "#{result} should have changed, but is still #{@before.inspect}"
- end
- end
-
- def result
- @message || "result"
- end
-
- def actual_delta
- @after - @before
- end
-
- def negative_failure_message
- "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
- end
-
- def by(amount)
- @amount = amount
- self
- end
-
- def by_at_least(minimum)
- @minimum = minimum
- self
- end
-
- def by_at_most(maximum)
- @maximum = maximum
- self
- end
-
- def to(to)
- @to = to
- self
- end
-
- def from (from)
- @from = from
- self
- end
- end
-
- # :call-seq:
- # should change(receiver, message, &block)
- # should change(receiver, message, &block).by(value)
- # should change(receiver, message, &block).from(old).to(new)
- # should_not change(receiver, message, &block)
- #
- # Allows you to specify that a Proc will cause some value to change.
- #
- # == Examples
- #
- # lambda {
- # team.add_player(player)
- # }.should change(roster, :count)
- #
- # lambda {
- # team.add_player(player)
- # }.should change(roster, :count).by(1)
- #
- # lambda {
- # team.add_player(player)
- # }.should change(roster, :count).by_at_least(1)
- #
- # lambda {
- # team.add_player(player)
- # }.should change(roster, :count).by_at_most(1)
- #
- # string = "string"
- # lambda {
- # string.reverse
- # }.should change { string }.from("string").to("gnirts")
- #
- # lambda {
- # person.happy_birthday
- # }.should change(person, :birthday).from(32).to(33)
- #
- # lambda {
- # employee.develop_great_new_social_networking_app
- # }.should change(employee, :title).from("Mail Clerk").to("CEO")
- #
- # Evaluates +receiver.message+ or +block+ before and
- # after it evaluates the c object (generated by the lambdas in the examples above).
- #
- # Then compares the values before and after the +receiver.message+ and
- # evaluates the difference compared to the expected difference.
- #
- # == Warning
- # +should_not+ +change+ only supports the form with no subsequent calls to
- # +by+, +by_at_least+, +by_at_most+, +to+ or +from+.
- #
- # blocks passed to +should+ +change+ and +should_not+ +change+
- # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported)
- def change(target=nil, message=nil, &block)
- Matchers::Change.new(target, message, &block)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Eql #:nodoc:
- def initialize(expected)
- @expected = expected
- end
-
- def matches?(actual)
- @actual = actual
- @actual.eql?(@expected)
- end
-
- def failure_message
- return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
- end
-
- def negative_failure_message
- return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual
- end
-
- def description
- "eql #{@expected.inspect}"
- end
- end
-
- # :call-seq:
- # should eql(expected)
- # should_not eql(expected)
- #
- # Passes if actual and expected are of equal value, but not necessarily the same object.
- #
- # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
- #
- # == Examples
- #
- # 5.should eql(5)
- # 5.should_not eql(3)
- def eql(expected)
- Matchers::Eql.new(expected)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Equal #:nodoc:
- def initialize(expected)
- @expected = expected
- end
-
- def matches?(actual)
- @actual = actual
- @actual.equal?(@expected)
- end
-
- def failure_message
- return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
- end
-
- def negative_failure_message
- return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual
- end
-
- def description
- "equal #{@expected.inspect}"
- end
- end
-
- # :call-seq:
- # should equal(expected)
- # should_not equal(expected)
- #
- # Passes if actual and expected are the same object (object identity).
- #
- # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
- #
- # == Examples
- #
- # 5.should equal(5) #Fixnums are equal
- # "5".should_not equal("5") #Strings that look the same are not the same object
- def equal(expected)
- Matchers::Equal.new(expected)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
- class Exist
- def matches? actual
- @actual = actual
- @actual.exist?
- end
- def failure_message
- "expected #{@actual.inspect} to exist, but it doesn't."
- end
- def negative_failure_message
- "expected #{@actual.inspect} to not exist, but it does."
- end
- end
- def exist; Exist.new; end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Has #:nodoc:
- def initialize(sym, *args)
- @sym = sym
- @args = args
- end
-
- def matches?(target)
- @target = target
- begin
- return target.send(predicate, *@args)
- rescue => @error
- # This clause should be empty, but rcov will not report it as covered
- # unless something (anything) is executed within the clause
- rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
- end
- return false
- end
-
- def failure_message
- raise @error if @error
- "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
- end
-
- def negative_failure_message
- raise @error if @error
- "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
- end
-
- def description
- "have key #{@args[0].inspect}"
- end
-
- private
- def predicate
- "#{@sym.to_s.sub("have_","has_")}?".to_sym
- end
-
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Have #:nodoc:
- def initialize(expected, relativity=:exactly)
- @expected = (expected == :no ? 0 : expected)
- @relativity = relativity
- end
-
- def relativities
- @relativities ||= {
- :exactly => "",
- :at_least => "at least ",
- :at_most => "at most "
- }
- end
-
- def method_missing(sym, *args, &block)
- @collection_name = sym
- @plural_collection_name = Inflector.pluralize(sym.to_s) if Object.const_defined?(:Inflector)
- @args = args
- @block = block
- self
- end
-
- def matches?(collection_owner)
- if collection_owner.respond_to?(@collection_name)
- collection = collection_owner.send(@collection_name, *@args, &@block)
- elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
- collection = collection_owner.send(@plural_collection_name, *@args, &@block)
- elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
- collection = collection_owner
- else
- collection_owner.send(@collection_name, *@args, &@block)
- end
- @actual = collection.size if collection.respond_to?(:size)
- @actual = collection.length if collection.respond_to?(:length)
- raise not_a_collection if @actual.nil?
- return @actual >= @expected if @relativity == :at_least
- return @actual <= @expected if @relativity == :at_most
- return @actual == @expected
- end
-
- def not_a_collection
- "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
- end
-
- def failure_message
- "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
- end
-
- def negative_failure_message
- if @relativity == :exactly
- return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
- elsif @relativity == :at_most
- return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_most(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
- should have_at_least(#{@expected + 1}).#{@collection_name}
-EOF
- elsif @relativity == :at_least
- return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_least(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
- should have_at_most(#{@expected - 1}).#{@collection_name}
-EOF
- end
- end
-
- def description
- "have #{relative_expectation} #{@collection_name}"
- end
-
- private
-
- def relative_expectation
- "#{relativities[@relativity]}#{@expected}"
- end
- end
-
- # :call-seq:
- # should have(number).named_collection__or__sugar
- # should_not have(number).named_collection__or__sugar
- #
- # Passes if receiver is a collection with the submitted
- # number of items OR if the receiver OWNS a collection
- # with the submitted number of items.
- #
- # If the receiver OWNS the collection, you must use the name
- # of the collection. So if a <tt>Team</tt> instance has a
- # collection named <tt>#players</tt>, you must use that name
- # to set the expectation.
- #
- # If the receiver IS the collection, you can use any name
- # you like for <tt>named_collection</tt>. We'd recommend using
- # either "elements", "members", or "items" as these are all
- # standard ways of describing the things IN a collection.
- #
- # This also works for Strings, letting you set an expectation
- # about its length
- #
- # == Examples
- #
- # # Passes if team.players.size == 11
- # team.should have(11).players
- #
- # # Passes if [1,2,3].length == 3
- # [1,2,3].should have(3).items #"items" is pure sugar
- #
- # # Passes if "this string".length == 11
- # "this string".should have(11).characters #"characters" is pure sugar
- def have(n)
- Matchers::Have.new(n)
- end
- alias :have_exactly :have
-
- # :call-seq:
- # should have_at_least(number).items
- #
- # Exactly like have() with >=.
- #
- # == Warning
- #
- # +should_not+ +have_at_least+ is not supported
- def have_at_least(n)
- Matchers::Have.new(n, :at_least)
- end
-
- # :call-seq:
- # should have_at_most(number).items
- #
- # Exactly like have() with <=.
- #
- # == Warning
- #
- # +should_not+ +have_at_most+ is not supported
- def have_at_most(n)
- Matchers::Have.new(n, :at_most)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Include #:nodoc:
-
- def initialize(*expecteds)
- @expecteds = expecteds
- end
-
- def matches?(actual)
- @actual = actual
- @expecteds.each do |expected|
- return false unless actual.include?(expected)
- end
- true
- end
-
- def failure_message
- _message
- end
-
- def negative_failure_message
- _message("not ")
- end
-
- def description
- "include #{_pretty_print(@expecteds)}"
- end
-
- private
- def _message(maybe_not="")
- "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
- end
-
- def _pretty_print(array)
- result = ""
- array.each_with_index do |item, index|
- if index < (array.length - 2)
- result << "#{item.inspect}, "
- elsif index < (array.length - 1)
- result << "#{item.inspect} and "
- else
- result << "#{item.inspect}"
- end
- end
- result
- end
- end
-
- # :call-seq:
- # should include(expected)
- # should_not include(expected)
- #
- # Passes if actual includes expected. This works for
- # collections and Strings. You can also pass in multiple args
- # and it will only pass if all args are found in collection.
- #
- # == Examples
- #
- # [1,2,3].should include(3)
- # [1,2,3].should include(2,3) #would pass
- # [1,2,3].should include(2,3,4) #would fail
- # [1,2,3].should_not include(4)
- # "spread".should include("read")
- # "spread".should_not include("red")
- def include(*expected)
- Matchers::Include.new(*expected)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Match #:nodoc:
- def initialize(expected)
- @expected = expected
- end
-
- def matches?(actual)
- @actual = actual
- return true if actual =~ @expected
- return false
- end
-
- def failure_message
- return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
- end
-
- def negative_failure_message
- return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
- end
-
- def description
- "match #{@expected.inspect}"
- end
- end
-
- # :call-seq:
- # should match(regexp)
- # should_not match(regexp)
- #
- # Given a Regexp, passes if actual =~ regexp
- #
- # == Examples
- #
- # email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
- def match(regexp)
- Matchers::Match.new(regexp)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
- class BaseOperatorMatcher
- attr_reader :generated_description
-
- def initialize(target)
- @target = target
- end
-
- def ==(expected)
- @expected = expected
- __delegate_method_missing_to_target("==", expected)
- end
-
- def ===(expected)
- @expected = expected
- __delegate_method_missing_to_target("===", expected)
- end
-
- def =~(expected)
- @expected = expected
- __delegate_method_missing_to_target("=~", expected)
- end
-
- def >(expected)
- @expected = expected
- __delegate_method_missing_to_target(">", expected)
- end
-
- def >=(expected)
- @expected = expected
- __delegate_method_missing_to_target(">=", expected)
- end
-
- def <(expected)
- @expected = expected
- __delegate_method_missing_to_target("<", expected)
- end
-
- def <=(expected)
- @expected = expected
- __delegate_method_missing_to_target("<=", expected)
- end
-
- def fail_with_message(message)
- Spec::Expectations.fail_with(message, @expected, @target)
- end
-
- end
-
- class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc:
-
- def __delegate_method_missing_to_target(operator, expected)
- ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}"
- return if @target.send(operator, expected)
- return fail_with_message("expected: #{expected.inspect},\n got: #{@target.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator)
- return fail_with_message("expected: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
- end
-
- end
-
- class NegativeOperatorMatcher < BaseOperatorMatcher #:nodoc:
-
- def __delegate_method_missing_to_target(operator, expected)
- ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}"
- return unless @target.send(operator, expected)
- return fail_with_message("expected not: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
- end
-
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class RaiseError #:nodoc:
- def initialize(error_or_message=Exception, message=nil)
- if String === error_or_message
- @expected_error = Exception
- @expected_message = error_or_message
- else
- @expected_error = error_or_message
- @expected_message = message
- end
- end
-
- def matches?(proc)
- @raised_expected_error = false
- @raised_other = false
- begin
- proc.call
- rescue @expected_error => @actual_error
- if @expected_message.nil?
- @raised_expected_error = true
- else
- case @expected_message
- when Regexp
- if @expected_message =~ @actual_error.message
- @raised_expected_error = true
- else
- @raised_other = true
- end
- else
- if @expected_message == @actual_error.message
- @raised_expected_error = true
- else
- @raised_other = true
- end
- end
- end
- rescue => @actual_error
- @raised_other = true
- ensure
- return @raised_expected_error
- end
- end
-
- def failure_message
- return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
- end
-
- def negative_failure_message
- "expected no #{expected_error}#{actual_error}"
- end
-
- def description
- "raise #{expected_error}"
- end
-
- private
- def expected_error
- case @expected_message
- when nil
- @expected_error
- when Regexp
- "#{@expected_error} with message matching #{@expected_message.inspect}"
- else
- "#{@expected_error} with #{@expected_message.inspect}"
- end
- end
-
- def actual_error
- @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
- end
- end
-
- # :call-seq:
- # should raise_error()
- # should raise_error(NamedError)
- # should raise_error(NamedError, String)
- # should raise_error(NamedError, Regexp)
- # should_not raise_error()
- # should_not raise_error(NamedError)
- # should_not raise_error(NamedError, String)
- # should_not raise_error(NamedError, Regexp)
- #
- # With no args, matches if any error is raised.
- # With a named error, matches only if that specific error is raised.
- # With a named error and messsage specified as a String, matches only if both match.
- # With a named error and messsage specified as a Regexp, matches only if both match.
- #
- # == Examples
- #
- # lambda { do_something_risky }.should raise_error
- # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
- # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
- # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
- #
- # lambda { do_something_risky }.should_not raise_error
- # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
- # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
- # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
- def raise_error(error=Exception, message=nil)
- Matchers::RaiseError.new(error, message)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class RespondTo #:nodoc:
- def initialize(*names)
- @names = names
- @names_not_responded_to = []
- end
-
- def matches?(target)
- @names.each do |name|
- unless target.respond_to?(name)
- @names_not_responded_to << name
- end
- end
- return @names_not_responded_to.empty?
- end
-
- def failure_message
- "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
- end
-
- def negative_failure_message
- "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
- end
-
- def description
- "respond to ##{@names.to_s}"
- end
- end
-
- # :call-seq:
- # should respond_to(*names)
- # should_not respond_to(*names)
- #
- # Matches if the target object responds to all of the names
- # provided. Names can be Strings or Symbols.
- #
- # == Examples
- #
- def respond_to(*names)
- Matchers::RespondTo.new(*names)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
-
- class Satisfy #:nodoc:
- def initialize(&block)
- @block = block
- end
-
- def matches?(actual, &block)
- @block = block if block
- @actual = actual
- @block.call(actual)
- end
-
- def failure_message
- "expected #{@actual} to satisfy block"
- end
-
- def negative_failure_message
- "expected #{@actual} not to satisfy block"
- end
- end
-
- # :call-seq:
- # should satisfy {}
- # should_not satisfy {}
- #
- # Passes if the submitted block returns true. Yields target to the
- # block.
- #
- # Generally speaking, this should be thought of as a last resort when
- # you can't find any other way to specify the behaviour you wish to
- # specify.
- #
- # If you do find yourself in such a situation, you could always write
- # a custom matcher, which would likely make your specs more expressive.
- #
- # == Examples
- #
- # 5.should satisfy { |n|
- # n > 3
- # }
- def satisfy(&block)
- Matchers::Satisfy.new(&block)
- end
- end
-end
+++ /dev/null
-module Spec
- module Matchers
- class SimpleMatcher
- attr_reader :description
-
- def initialize(description, &match_block)
- @description = description
- @match_block = match_block
- end
-
- def matches?(actual)
- @actual = actual
- return @match_block.call(@actual)
- end
-
- def failure_message()
- return %[expected #{@description.inspect} but got #{@actual.inspect}]
- end
-
- def negative_failure_message()
- return %[expected not to get #{@description.inspect}, but got #{@actual.inspect}]
- end
- end
-
- def simple_matcher(message, &match_block)
- SimpleMatcher.new(message, &match_block)
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Matchers
-
- class ThrowSymbol #:nodoc:
- def initialize(expected=nil)
- @expected = expected
- @actual = nil
- end
-
- def matches?(proc)
- begin
- proc.call
- rescue NameError => e
- raise e unless e.message =~ /uncaught throw/
- @actual = e.name.to_sym
- ensure
- if @expected.nil?
- return @actual.nil? ? false : true
- else
- return @actual == @expected
- end
- end
- end
-
- def failure_message
- if @actual
- "expected #{expected}, got #{@actual.inspect}"
- else
- "expected #{expected} but nothing was thrown"
- end
- end
-
- def negative_failure_message
- if @expected
- "expected #{expected} not to be thrown"
- else
- "expected no Symbol, got :#{@actual}"
- end
- end
-
- def description
- "throw #{expected}"
- end
-
- private
-
- def expected
- @expected.nil? ? "a Symbol" : @expected.inspect
- end
-
- end
-
- # :call-seq:
- # should throw_symbol()
- # should throw_symbol(:sym)
- # should_not throw_symbol()
- # should_not throw_symbol(:sym)
- #
- # Given a Symbol argument, matches if a proc throws the specified Symbol.
- #
- # Given no argument, matches if a proc throws any Symbol.
- #
- # == Examples
- #
- # lambda { do_something_risky }.should throw_symbol
- # lambda { do_something_risky }.should throw_symbol(:that_was_risky)
- #
- # lambda { do_something_risky }.should_not throw_symbol
- # lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
- def throw_symbol(sym=nil)
- Matchers::ThrowSymbol.new(sym)
- end
- end
-end
+++ /dev/null
-require 'spec/mocks/methods'
-require 'spec/mocks/argument_constraint_matchers'
-require 'spec/mocks/spec_methods'
-require 'spec/mocks/proxy'
-require 'spec/mocks/mock'
-require 'spec/mocks/argument_expectation'
-require 'spec/mocks/message_expectation'
-require 'spec/mocks/order_group'
-require 'spec/mocks/errors'
-require 'spec/mocks/error_generator'
-require 'spec/mocks/extensions/object'
-require 'spec/mocks/space'
-
-
-module Spec
- # == Mocks and Stubs
- #
- # RSpec will create Mock Objects and Stubs for you at runtime, or attach stub/mock behaviour
- # to any of your real objects (Partial Mock/Stub). Because the underlying implementation
- # for mocks and stubs is the same, you can intermingle mock and stub
- # behaviour in either dynamically generated mocks or your pre-existing classes.
- # There is a semantic difference in how they are created, however,
- # which can help clarify the role it is playing within a given spec.
- #
- # == Mock Objects
- #
- # Mocks are objects that allow you to set and verify expectations that they will
- # receive specific messages during run time. They are very useful for specifying how the subject of
- # the spec interacts with its collaborators. This approach is widely known as "interaction
- # testing".
- #
- # Mocks are also very powerful as a design tool. As you are
- # driving the implementation of a given class, Mocks provide an anonymous
- # collaborator that can change in behaviour as quickly as you can write an expectation in your
- # spec. This flexibility allows you to design the interface of a collaborator that often
- # does not yet exist. As the shape of the class being specified becomes more clear, so do the
- # requirements for its collaborators - often leading to the discovery of new types that are
- # needed in your system.
- #
- # Read Endo-Testing[http://www.mockobjects.com/files/endotesting.pdf] for a much
- # more in depth description of this process.
- #
- # == Stubs
- #
- # Stubs are objects that allow you to set "stub" responses to
- # messages. As Martin Fowler points out on his site,
- # mocks_arent_stubs[http://www.martinfowler.com/articles/mocksArentStubs.html].
- # Paraphrasing Fowler's paraphrasing
- # of Gerard Meszaros: Stubs provide canned responses to messages they might receive in a test, while
- # mocks allow you to specify and, subsquently, verify that certain messages should be received during
- # the execution of a test.
- #
- # == Partial Mocks/Stubs
- #
- # RSpec also supports partial mocking/stubbing, allowing you to add stub/mock behaviour
- # to instances of your existing classes. This is generally
- # something to be avoided, because changes to the class can have ripple effects on
- # seemingly unrelated specs. When specs fail due to these ripple effects, the fact
- # that some methods are being mocked can make it difficult to understand why a
- # failure is occurring.
- #
- # That said, partials do allow you to expect and
- # verify interactions with class methods such as +#find+ and +#create+
- # on Ruby on Rails model classes.
- #
- # == Further Reading
- #
- # There are many different viewpoints about the meaning of mocks and stubs. If you are interested
- # in learning more, here is some recommended reading:
- #
- # * Mock Objects: http://www.mockobjects.com/
- # * Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf
- # * Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf
- # * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
- # * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
- #
- # == Creating a Mock
- #
- # You can create a mock in any specification (or setup) using:
- #
- # mock(name, options={})
- #
- # The optional +options+ argument is a +Hash+. Currently the only supported
- # option is +:null_object+. Setting this to true instructs the mock to ignore
- # any messages it hasn’t been told to expect – and quietly return itself. For example:
- #
- # mock("person", :null_object => true)
- #
- # == Creating a Stub
- #
- # You can create a stub in any specification (or setup) using:
- #
- # stub(name, stub_methods_and_values_hash)
- #
- # For example, if you wanted to create an object that always returns
- # "More?!?!?!" to "please_sir_may_i_have_some_more" you would do this:
- #
- # stub("Mr Sykes", :please_sir_may_i_have_some_more => "More?!?!?!")
- #
- # == Creating a Partial Mock
- #
- # You don't really "create" a partial mock, you simply add method stubs and/or
- # mock expectations to existing classes and objects:
- #
- # Factory.should_receive(:find).with(id).and_return(value)
- # obj.stub!(:to_i).and_return(3)
- # etc ...
- #
- # == Expecting Messages
- #
- # my_mock.should_receive(:sym)
- # my_mock.should_not_receive(:sym)
- #
- # == Expecting Arguments
- #
- # my_mock.should_receive(:sym).with(*args)
- # my_mock.should_not_receive(:sym).with(*args)
- #
- # == Argument Constraints using Expression Matchers
- #
- # Arguments that are passed to #with are compared with actual arguments received
- # using == by default. In cases in which you want to specify things about the arguments
- # rather than the arguments themselves, you can use any of the Expression Matchers.
- # They don't all make syntactic sense (they were primarily designed for use with
- # Spec::Expectations), but you are free to create your own custom Spec::Matchers.
- #
- # Spec::Mocks does provide one additional Matcher method named #ducktype.
- #
- # In addition, Spec::Mocks adds some keyword Symbols that you can use to
- # specify certain kinds of arguments:
- #
- # my_mock.should_receive(:sym).with(no_args())
- # my_mock.should_receive(:sym).with(any_args())
- # my_mock.should_receive(:sym).with(1, an_instance_of(Numeric), "b") #2nd argument can any type of Numeric
- # my_mock.should_receive(:sym).with(1, boolean(), "b") #2nd argument can true or false
- # my_mock.should_receive(:sym).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
- # my_mock.should_receive(:sym).with(1, anything(), "b") #2nd argument can be anything at all
- # my_mock.should_receive(:sym).with(1, ducktype(:abs, :div), "b")
- # #2nd argument can be object that responds to #abs and #div
- #
- # == Receive Counts
- #
- # my_mock.should_receive(:sym).once
- # my_mock.should_receive(:sym).twice
- # my_mock.should_receive(:sym).exactly(n).times
- # my_mock.should_receive(:sym).at_least(:once)
- # my_mock.should_receive(:sym).at_least(:twice)
- # my_mock.should_receive(:sym).at_least(n).times
- # my_mock.should_receive(:sym).at_most(:once)
- # my_mock.should_receive(:sym).at_most(:twice)
- # my_mock.should_receive(:sym).at_most(n).times
- # my_mock.should_receive(:sym).any_number_of_times
- #
- # == Ordering
- #
- # my_mock.should_receive(:sym).ordered
- # my_mock.should_receive(:other_sym).ordered
- # #This will fail if the messages are received out of order
- #
- # == Setting Reponses
- #
- # Whether you are setting a mock expectation or a simple stub, you can tell the
- # object precisely how to respond:
- #
- # my_mock.should_receive(:sym).and_return(value)
- # my_mock.should_receive(:sym).exactly(3).times.and_return(value1, value2, value3)
- # # returns value1 the first time, value2 the second, etc
- # my_mock.should_receive(:sym).and_return { ... } #returns value returned by the block
- # my_mock.should_receive(:sym).and_raise(error)
- # #error can be an instantiated object or a class
- # #if it is a class, it must be instantiable with no args
- # my_mock.should_receive(:sym).and_throw(:sym)
- # my_mock.should_receive(:sym).and_yield(values,to,yield)
- # my_mock.should_receive(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time)
- # # for methods that yield to a block multiple times
- #
- # Any of these responses can be applied to a stub as well, but stubs do
- # not support any qualifiers about the message received (i.e. you can't specify arguments
- # or receive counts):
- #
- # my_mock.stub!(:sym).and_return(value)
- # my_mock.stub!(:sym).and_return(value1, value2, value3)
- # my_mock.stub!(:sym).and_raise(error)
- # my_mock.stub!(:sym).and_throw(:sym)
- # my_mock.stub!(:sym).and_yield(values,to,yield)
- # my_mock.stub!(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time)
- #
- # == Arbitrary Handling
- #
- # Once in a while you'll find that the available expectations don't solve the
- # particular problem you are trying to solve. Imagine that you expect the message
- # to come with an Array argument that has a specific length, but you don't care
- # what is in it. You could do this:
- #
- # my_mock.should_receive(:sym) do |arg|
- # arg.should be_an_istance_of(Array)
- # arg.length.should == 7
- # end
- #
- # Note that this would fail if the number of arguments received was different from
- # the number of block arguments (in this case 1).
- #
- # == Combining Expectation Details
- #
- # Combining the message name with specific arguments, receive counts and responses
- # you can get quite a bit of detail in your expectations:
- #
- # my_mock.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
- module Mocks
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- module ArgumentConstraintMatchers
-
- # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
- def duck_type(*args)
- DuckTypeArgConstraint.new(*args)
- end
-
- def any_args
- AnyArgsConstraint.new
- end
-
- def anything
- AnyArgConstraint.new(nil)
- end
-
- def boolean
- BooleanArgConstraint.new(nil)
- end
-
- def no_args
- NoArgsConstraint.new
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
-
- class MatcherConstraint
- def initialize(matcher)
- @matcher = matcher
- end
-
- def matches?(value)
- @matcher.matches?(value)
- end
- end
-
- class LiteralArgConstraint
- def initialize(literal)
- @literal_value = literal
- end
-
- def matches?(value)
- @literal_value == value
- end
- end
-
- class RegexpArgConstraint
- def initialize(regexp)
- @regexp = regexp
- end
-
- def matches?(value)
- return value =~ @regexp unless value.is_a?(Regexp)
- value == @regexp
- end
- end
-
- class AnyArgConstraint
- def initialize(ignore)
- end
-
- def ==(other)
- true
- end
-
- # TODO - need this?
- def matches?(value)
- true
- end
- end
-
- class AnyArgsConstraint
- def description
- "any args"
- end
- end
-
- class NoArgsConstraint
- def description
- "no args"
- end
-
- def ==(args)
- args == []
- end
- end
-
- class NumericArgConstraint
- def initialize(ignore)
- end
-
- def matches?(value)
- value.is_a?(Numeric)
- end
- end
-
- class BooleanArgConstraint
- def initialize(ignore)
- end
-
- def ==(value)
- matches?(value)
- end
-
- def matches?(value)
- return true if value.is_a?(TrueClass)
- return true if value.is_a?(FalseClass)
- false
- end
- end
-
- class StringArgConstraint
- def initialize(ignore)
- end
-
- def matches?(value)
- value.is_a?(String)
- end
- end
-
- class DuckTypeArgConstraint
- def initialize(*methods_to_respond_to)
- @methods_to_respond_to = methods_to_respond_to
- end
-
- def matches?(value)
- @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
- end
-
- def description
- "duck_type"
- end
- end
-
- class ArgumentExpectation
- attr_reader :args
- @@constraint_classes = Hash.new { |hash, key| LiteralArgConstraint}
- @@constraint_classes[:anything] = AnyArgConstraint
- @@constraint_classes[:numeric] = NumericArgConstraint
- @@constraint_classes[:boolean] = BooleanArgConstraint
- @@constraint_classes[:string] = StringArgConstraint
-
- def initialize(args)
- @args = args
- if [:any_args] == args
- @expected_params = nil
- warn_deprecated(:any_args.inspect, "any_args()")
- elsif args.length == 1 && args[0].is_a?(AnyArgsConstraint) then @expected_params = nil
- elsif [:no_args] == args
- @expected_params = []
- warn_deprecated(:no_args.inspect, "no_args()")
- elsif args.length == 1 && args[0].is_a?(NoArgsConstraint) then @expected_params = []
- else @expected_params = process_arg_constraints(args)
- end
- end
-
- def process_arg_constraints(constraints)
- constraints.collect do |constraint|
- convert_constraint(constraint)
- end
- end
-
- def warn_deprecated(deprecated_method, instead)
- Kernel.warn "The #{deprecated_method} constraint is deprecated. Use #{instead} instead."
- end
-
- def convert_constraint(constraint)
- if [:anything, :numeric, :boolean, :string].include?(constraint)
- case constraint
- when :anything
- instead = "anything()"
- when :boolean
- instead = "boolean()"
- when :numeric
- instead = "an_instance_of(Numeric)"
- when :string
- instead = "an_instance_of(String)"
- end
- warn_deprecated(constraint.inspect, instead)
- return @@constraint_classes[constraint].new(constraint)
- end
- return MatcherConstraint.new(constraint) if is_matcher?(constraint)
- return RegexpArgConstraint.new(constraint) if constraint.is_a?(Regexp)
- return LiteralArgConstraint.new(constraint)
- end
-
- def is_matcher?(obj)
- return obj.respond_to?(:matches?) && obj.respond_to?(:description)
- end
-
- def check_args(args)
- return true if @expected_params.nil?
- return true if @expected_params == args
- return constraints_match?(args)
- end
-
- def constraints_match?(args)
- return false if args.length != @expected_params.length
- @expected_params.each_index { |i| return false unless @expected_params[i].matches?(args[i]) }
- return true
- end
-
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class ErrorGenerator
- attr_writer :opts
-
- def initialize(target, name)
- @target = target
- @name = name
- end
-
- def opts
- @opts ||= {}
- end
-
- def raise_unexpected_message_error(sym, *args)
- __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
- end
-
- def raise_unexpected_message_args_error(expectation, *args)
- expected_args = format_args(*expectation.expected_args)
- actual_args = args.empty? ? "(no args)" : format_args(*args)
- __raise "#{intro} expected #{expectation.sym.inspect} with #{expected_args} but received it with #{actual_args}"
- end
-
- def raise_expectation_error(sym, expected_received_count, actual_received_count, *args)
- __raise "#{intro} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{count_message(actual_received_count)}"
- end
-
- def raise_out_of_order_error(sym)
- __raise "#{intro} received :#{sym} out of order"
- end
-
- def raise_block_failed_error(sym, detail)
- __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
- end
-
- def raise_missing_block_error(args_to_yield)
- __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
- end
-
- def raise_wrong_arity_error(args_to_yield, arity)
- __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
- end
-
- private
- def intro
- @name ? "Mock '#{@name}'" : @target.inspect
- end
-
- def __raise(message)
- message = opts[:message] unless opts[:message].nil?
- Kernel::raise(Spec::Mocks::MockExpectationError, message)
- end
-
- def arg_message(*args)
- " with " + format_args(*args)
- end
-
- def format_args(*args)
- return "(no args)" if args.empty? || args == [:no_args]
- return "(any args)" if args == [:any_args]
- "(" + arg_list(*args) + ")"
- end
-
- def arg_list(*args)
- args.collect do |arg|
- arg.respond_to?(:description) ? arg.description : arg.inspect
- end.join(", ")
- end
-
- def count_message(count)
- return "at least #{pretty_print(count.abs)}" if count < 0
- return pretty_print(count)
- end
-
- def pretty_print(count)
- return "once" if count == 1
- return "twice" if count == 2
- return "#{count} times"
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class MockExpectationError < StandardError
- end
-
- class AmbiguousReturnError < StandardError
- end
- end
-end
-
+++ /dev/null
-class Object
- include Spec::Mocks::Methods
-end
+++ /dev/null
-module Spec
- module Mocks
-
- class BaseExpectation
- attr_reader :sym
-
- def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
- @error_generator = error_generator
- @error_generator.opts = opts
- @expected_from = expected_from
- @sym = sym
- @method_block = method_block
- @return_block = nil
- @actual_received_count = 0
- @expected_received_count = expected_received_count
- @args_expectation = ArgumentExpectation.new([AnyArgsConstraint.new])
- @consecutive = false
- @exception_to_raise = nil
- @symbol_to_throw = nil
- @order_group = expectation_ordering
- @at_least = nil
- @at_most = nil
- @args_to_yield = []
- end
-
- def expected_args
- @args_expectation.args
- end
-
- def and_return(*values, &return_block)
- Kernel::raise AmbiguousReturnError unless @method_block.nil?
- case values.size
- when 0 then value = nil
- when 1 then value = values[0]
- else
- value = values
- @consecutive = true
- @expected_received_count = values.size if !ignoring_args? &&
- @expected_received_count < values.size
- end
- @return_block = block_given? ? return_block : lambda { value }
- # Ruby 1.9 - see where this is used below
- @ignore_args = !block_given?
- end
-
- # :call-seq:
- # and_raise()
- # and_raise(Exception) #any exception class
- # and_raise(exception) #any exception object
- #
- # == Warning
- #
- # When you pass an exception class, the MessageExpectation will
- # raise an instance of it, creating it with +new+. If the exception
- # class initializer requires any parameters, you must pass in an
- # instance and not the class.
- def and_raise(exception=Exception)
- @exception_to_raise = exception
- end
-
- def and_throw(symbol)
- @symbol_to_throw = symbol
- end
-
- def and_yield(*args)
- @args_to_yield << args
- self
- end
-
- def matches(sym, args)
- @sym == sym and @args_expectation.check_args(args)
- end
-
- def invoke(args, block)
- @order_group.handle_order_constraint self
-
- begin
- Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
- Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
-
- if !@method_block.nil?
- default_return_val = invoke_method_block(args)
- elsif @args_to_yield.size > 0
- default_return_val = invoke_with_yield(block)
- else
- default_return_val = nil
- end
-
- if @consecutive
- return invoke_consecutive_return_block(args, block)
- elsif @return_block
- return invoke_return_block(args, block)
- else
- return default_return_val
- end
- ensure
- @actual_received_count += 1
- end
- end
-
- protected
-
- def invoke_method_block(args)
- begin
- @method_block.call(*args)
- rescue => detail
- @error_generator.raise_block_failed_error @sym, detail.message
- end
- end
-
- def invoke_with_yield(block)
- if block.nil?
- @error_generator.raise_missing_block_error @args_to_yield
- end
- @args_to_yield.each do |args_to_yield_this_time|
- if block.arity > -1 && args_to_yield_this_time.length != block.arity
- @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
- end
- block.call(*args_to_yield_this_time)
- end
- end
-
- def invoke_consecutive_return_block(args, block)
- args << block unless block.nil?
- value = @return_block.call(*args)
-
- index = [@actual_received_count, value.size-1].min
- value[index]
- end
-
- def invoke_return_block(args, block)
- args << block unless block.nil?
- # Ruby 1.9 - when we set @return_block to return values
- # regardless of arguments, any arguments will result in
- # a "wrong number of arguments" error
- if @ignore_args
- @return_block.call()
- else
- @return_block.call(*args)
- end
- end
- end
-
- class MessageExpectation < BaseExpectation
-
- def matches_name_but_not_args(sym, args)
- @sym == sym and not @args_expectation.check_args(args)
- end
-
- def verify_messages_received
- return if ignoring_args? || matches_exact_count? ||
- matches_at_least_count? || matches_at_most_count?
-
- generate_error
- rescue Spec::Mocks::MockExpectationError => error
- error.backtrace.insert(0, @expected_from)
- Kernel::raise error
- end
-
- def ignoring_args?
- @expected_received_count == :any
- end
-
- def matches_at_least_count?
- @at_least && @actual_received_count >= @expected_received_count
- end
-
- def matches_at_most_count?
- @at_most && @actual_received_count <= @expected_received_count
- end
-
- def matches_exact_count?
- @expected_received_count == @actual_received_count
- end
-
- def generate_error
- @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *@args_expectation.args)
- end
-
- def with(*args, &block)
- @method_block = block if block
- @args_expectation = ArgumentExpectation.new(args)
- self
- end
-
- def exactly(n)
- set_expected_received_count :exactly, n
- self
- end
-
- def at_least(n)
- set_expected_received_count :at_least, n
- self
- end
-
- def at_most(n)
- set_expected_received_count :at_most, n
- self
- end
-
- def times(&block)
- @method_block = block if block
- self
- end
-
- def any_number_of_times(&block)
- @method_block = block if block
- @expected_received_count = :any
- self
- end
-
- def never
- @expected_received_count = 0
- self
- end
-
- def once(&block)
- @method_block = block if block
- @expected_received_count = 1
- self
- end
-
- def twice(&block)
- @method_block = block if block
- @expected_received_count = 2
- self
- end
-
- def ordered(&block)
- @method_block = block if block
- @order_group.register(self)
- @ordered = true
- self
- end
-
- def negative_expectation_for?(sym)
- return false
- end
-
- protected
- def set_expected_received_count(relativity, n)
- @at_least = (relativity == :at_least)
- @at_most = (relativity == :at_most)
- @expected_received_count = case n
- when Numeric
- n
- when :once
- 1
- when :twice
- 2
- end
- end
-
- end
-
- class NegativeMessageExpectation < MessageExpectation
- def initialize(message, expectation_ordering, expected_from, sym, method_block)
- super(message, expectation_ordering, expected_from, sym, method_block, 0)
- end
-
- def negative_expectation_for?(sym)
- return @sym == sym
- end
- end
-
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- module Methods
- def should_receive(sym, opts={}, &block)
- __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym.to_sym, opts, &block)
- end
-
- def should_not_receive(sym, &block)
- __mock_proxy.add_negative_message_expectation(caller(1)[0], sym.to_sym, &block)
- end
-
- def stub!(sym, opts={})
- __mock_proxy.add_stub(caller(1)[0], sym.to_sym, opts)
- end
-
- def received_message?(sym, *args, &block) #:nodoc:
- __mock_proxy.received_message?(sym.to_sym, *args, &block)
- end
-
- def rspec_verify #:nodoc:
- __mock_proxy.verify
- end
-
- def rspec_reset #:nodoc:
- __mock_proxy.reset
- end
-
- private
-
- def __mock_proxy
- if Mock === self
- @mock_proxy ||= Proxy.new(self, @name, @options)
- else
- @mock_proxy ||= Proxy.new(self, self.class.name)
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class Mock
- include Methods
-
- # Creates a new mock with a +name+ (that will be used in error messages only)
- # == Options:
- # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
- def initialize(name, stubs_and_options={})
- @name = name
- @options = parse_options(stubs_and_options)
- assign_stubs(stubs_and_options)
- end
-
- # This allows for comparing the mock to other objects that proxy
- # such as ActiveRecords belongs_to proxy objects
- # By making the other object run the comparison, we're sure the call gets delegated to the proxy target
- # This is an unfortunate side effect from ActiveRecord, but this should be safe unless the RHS redefines == in a nonsensical manner
- def ==(other)
- other == __mock_proxy
- end
-
- def method_missing(sym, *args, &block)
- __mock_proxy.instance_eval {@messages_received << [sym, args, block]}
- begin
- return self if __mock_proxy.null_object?
- super(sym, *args, &block)
- rescue NameError
- __mock_proxy.raise_unexpected_message_error sym, *args
- end
- end
-
- def inspect
- "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
- end
-
- private
-
- def parse_options(options)
- options.has_key?(:null_object) ? {:null_object => options.delete(:null_object)} : {}
- end
-
- def assign_stubs(stubs)
- stubs.each_pair do |message, response|
- stub!(message).and_return(response)
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class OrderGroup
- def initialize error_generator
- @error_generator = error_generator
- @ordering = Array.new
- end
-
- def register(expectation)
- @ordering << expectation
- end
-
- def ready_for?(expectation)
- return @ordering.first == expectation
- end
-
- def consume
- @ordering.shift
- end
-
- def handle_order_constraint expectation
- return unless @ordering.include? expectation
- return consume if ready_for?(expectation)
- @error_generator.raise_out_of_order_error expectation.sym
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class Proxy
- DEFAULT_OPTIONS = {
- :null_object => false,
- }
-
- def initialize(target, name, options={})
- @target = target
- @name = name
- @error_generator = ErrorGenerator.new target, name
- @expectation_ordering = OrderGroup.new @error_generator
- @expectations = []
- @messages_received = []
- @stubs = []
- @proxied_methods = []
- @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
- end
-
- def null_object?
- @options[:null_object]
- end
-
- def add_message_expectation(expected_from, sym, opts={}, &block)
- __add sym
- @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
- @expectations.last
- end
-
- def add_negative_message_expectation(expected_from, sym, &block)
- __add sym
- @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
- @expectations.last
- end
-
- def add_stub(expected_from, sym, opts={})
- __add sym
- @stubs.unshift MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, nil, :any, opts)
- @stubs.first
- end
-
- def verify #:nodoc:
- verify_expectations
- ensure
- reset
- end
-
- def reset
- clear_expectations
- clear_stubs
- reset_proxied_methods
- clear_proxied_methods
- end
-
- def received_message?(sym, *args, &block)
- @messages_received.any? {|array| array == [sym, args, block]}
- end
-
- def has_negative_expectation?(sym)
- @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
- end
-
- def message_received(sym, *args, &block)
- if expectation = find_matching_expectation(sym, *args)
- expectation.invoke(args, block)
- elsif stub = find_matching_method_stub(sym, *args)
- stub.invoke([], block)
- elsif expectation = find_almost_matching_expectation(sym, *args)
- raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
- else
- @target.send :method_missing, sym, *args, &block
- end
- end
-
- def raise_unexpected_message_args_error(expectation, *args)
- @error_generator.raise_unexpected_message_args_error expectation, *args
- end
-
- def raise_unexpected_message_error(sym, *args)
- @error_generator.raise_unexpected_message_error sym, *args
- end
-
- private
-
- def __add(sym)
- $rspec_mocks.add(@target) unless $rspec_mocks.nil?
- define_expected_method(sym)
- end
-
- def define_expected_method(sym)
- if target_responds_to?(sym) && !metaclass.method_defined?(munge(sym))
- munged_sym = munge(sym)
- metaclass.instance_eval do
- alias_method munged_sym, sym if method_defined?(sym.to_s)
- end
- @proxied_methods << sym
- end
-
- metaclass_eval(<<-EOF, __FILE__, __LINE__)
- def #{sym}(*args, &block)
- __mock_proxy.message_received :#{sym}, *args, &block
- end
- EOF
- end
-
- def target_responds_to?(sym)
- return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
- return @already_proxied_respond_to = true if sym == :respond_to?
- return @target.respond_to?(sym)
- end
-
- def munge(sym)
- "proxied_by_rspec__#{sym.to_s}".to_sym
- end
-
- def clear_expectations
- @expectations.clear
- end
-
- def clear_stubs
- @stubs.clear
- end
-
- def clear_proxied_methods
- @proxied_methods.clear
- end
-
- def metaclass_eval(str, filename, lineno)
- metaclass.class_eval(str, filename, lineno)
- end
-
- def metaclass
- (class << @target; self; end)
- end
-
- def verify_expectations
- @expectations.each do |expectation|
- expectation.verify_messages_received
- end
- end
-
- def reset_proxied_methods
- @proxied_methods.each do |sym|
- munged_sym = munge(sym)
- metaclass.instance_eval do
- if method_defined?(munged_sym.to_s)
- alias_method sym, munged_sym
- undef_method munged_sym
- else
- undef_method sym
- end
- end
- end
- end
-
- def find_matching_expectation(sym, *args)
- @expectations.find {|expectation| expectation.matches(sym, args)}
- end
-
- def find_almost_matching_expectation(sym, *args)
- @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
- end
-
- def find_matching_method_stub(sym, *args)
- @stubs.find {|stub| stub.matches(sym, args)}
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- class Space
- def add(obj)
- mocks << obj unless mocks.detect {|m| m.equal? obj}
- end
-
- def verify_all
- mocks.each do |mock|
- mock.rspec_verify
- end
- end
-
- def reset_all
- mocks.each do |mock|
- mock.rspec_reset
- end
- mocks.clear
- end
-
- private
-
- def mocks
- @mocks ||= []
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Mocks
- module ExampleMethods
- include Spec::Mocks::ArgumentConstraintMatchers
-
- # Shortcut for creating an instance of Spec::Mocks::Mock.
- #
- # +name+ is used for failure reporting, so you should use the
- # role that the mock is playing in the example.
- #
- # +stubs_and_options+ lets you assign options and stub values
- # at the same time. The only option available is :null_object.
- # Anything else is treated as a stub value.
- #
- # == Examples
- #
- # stub_thing = mock("thing", :a => "A")
- # stub_thing.a == "A" => true
- #
- # stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com")
- # stub_person.name => "Joe"
- # stub_person.email => "joe@domain.com"
- def mock(name, stubs_and_options={})
- Spec::Mocks::Mock.new(name, stubs_and_options)
- end
-
- alias :stub :mock
-
- # Shortcut for creating a mock object that will return itself in response
- # to any message it receives that it hasn't been explicitly instructed
- # to respond to.
- def stub_everything(name = 'stub')
- mock(name, :null_object => true)
- end
-
- end
- end
-end
+++ /dev/null
-#!/usr/bin/env ruby
-
-# Define a task library for running RSpec contexts.
-
-require 'rake'
-require 'rake/tasklib'
-
-module Spec
- module Rake
-
- # A Rake task that runs a set of specs.
- #
- # Example:
- #
- # Spec::Rake::SpecTask.new do |t|
- # t.warning = true
- # t.rcov = true
- # end
- #
- # This will create a task that can be run with:
- #
- # rake spec
- #
- # If rake is invoked with a "SPEC=filename" command line option,
- # then the list of spec files will be overridden to include only the
- # filename specified on the command line. This provides an easy way
- # to run just one spec.
- #
- # If rake is invoked with a "SPEC_OPTS=options" command line option,
- # then the given options will override the value of the +spec_opts+
- # attribute.
- #
- # If rake is invoked with a "RCOV_OPTS=options" command line option,
- # then the given options will override the value of the +rcov_opts+
- # attribute.
- #
- # Examples:
- #
- # rake spec # run specs normally
- # rake spec SPEC=just_one_file.rb # run just one spec file.
- # rake spec SPEC_OPTS="--diff" # enable diffing
- # rake spec RCOV_OPTS="--aggregate myfile.txt" # see rcov --help for details
- #
- # Each attribute of this task may be a proc. This allows for lazy evaluation,
- # which is sometimes handy if you want to defer the evaluation of an attribute value
- # until the task is run (as opposed to when it is defined).
- #
- # This task can also be used to run existing Test::Unit tests and get RSpec
- # output, for example like this:
- #
- # require 'rubygems'
- # require 'spec/rake/spectask'
- # Spec::Rake::SpecTask.new do |t|
- # t.ruby_opts = ['-rtest/unit']
- # t.spec_files = FileList['test/**/*_test.rb']
- # end
- #
- class SpecTask < ::Rake::TaskLib
- class << self
- def attr_accessor(*names)
- super(*names)
- names.each do |name|
- module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
- end
- end
- end
-
- # Name of spec task. (default is :spec)
- attr_accessor :name
-
- # Array of directories to be added to $LOAD_PATH before running the
- # specs. Defaults to ['<the absolute path to RSpec's lib directory>']
- attr_accessor :libs
-
- # If true, requests that the specs be run with the warning flag set.
- # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false.
- attr_accessor :warning
-
- # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
- # Setting the SPEC environment variable overrides this.
- attr_accessor :pattern
-
- # Array of commandline options to pass to RSpec. Defaults to [].
- # Setting the SPEC_OPTS environment variable overrides this.
- attr_accessor :spec_opts
-
- # Whether or not to use RCov (default is false)
- # See http://eigenclass.org/hiki.rb?rcov
- attr_accessor :rcov
-
- # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec'].
- # Ignored if rcov=false
- # Setting the RCOV_OPTS environment variable overrides this.
- attr_accessor :rcov_opts
-
- # Directory where the RCov report is written. Defaults to "coverage"
- # Ignored if rcov=false
- attr_accessor :rcov_dir
-
- # Array of commandline options to pass to ruby. Defaults to [].
- attr_accessor :ruby_opts
-
- # Whether or not to fail Rake when an error occurs (typically when specs fail).
- # Defaults to true.
- attr_accessor :fail_on_error
-
- # A message to print to stderr when there are failures.
- attr_accessor :failure_message
-
- # Where RSpec's output is written. Defaults to STDOUT.
- # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
- attr_accessor :out
-
- # Explicitly define the list of spec files to be included in a
- # spec. +spec_files+ is expected to be an array of file names (a
- # FileList is acceptable). If both +pattern+ and +spec_files+ are
- # used, then the list of spec files is the union of the two.
- # Setting the SPEC environment variable overrides this.
- attr_accessor :spec_files
-
- # Use verbose output. If this is set to true, the task will print
- # the executed spec command to stdout. Defaults to false.
- attr_accessor :verbose
-
- # Defines a new task, using the name +name+.
- def initialize(name=:spec)
- @name = name
- @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
- @pattern = nil
- @spec_files = nil
- @spec_opts = []
- @warning = false
- @ruby_opts = []
- @fail_on_error = true
- @rcov = false
- @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb']
- @rcov_dir = "coverage"
-
- yield self if block_given?
- @pattern = 'spec/**/*_spec.rb' if pattern.nil? && spec_files.nil?
- define
- end
-
- def define # :nodoc:
- spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spec')
-
- lib_path = libs.join(File::PATH_SEPARATOR)
- actual_name = Hash === name ? name.keys.first : name
- unless ::Rake.application.last_comment
- desc "Run specs" + (rcov ? " using RCov" : "")
- end
- task name do
- RakeFileUtils.verbose(verbose) do
- unless spec_file_list.empty?
- # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts]
- # or
- # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts]
- cmd = "ruby "
-
- rb_opts = ruby_opts.clone
- rb_opts << "-I\"#{lib_path}\""
- rb_opts << "-S rcov" if rcov
- rb_opts << "-w" if warning
- cmd << rb_opts.join(" ")
- cmd << " "
- cmd << rcov_option_list
- cmd << %[ -o "#{rcov_dir}" ] if rcov
- cmd << %Q|"#{spec_script}"|
- cmd << " "
- cmd << "-- " if rcov
- cmd << spec_file_list.collect { |fn| %["#{fn}"] }.join(' ')
- cmd << " "
- cmd << spec_option_list
- if out
- cmd << " "
- cmd << %Q| > "#{out}"|
- STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead."
- end
- if verbose
- puts cmd
- end
- unless system(cmd)
- STDERR.puts failure_message if failure_message
- raise("Command #{cmd} failed") if fail_on_error
- end
- end
- end
- end
-
- if rcov
- desc "Remove rcov products for #{actual_name}"
- task paste("clobber_", actual_name) do
- rm_r rcov_dir rescue nil
- end
-
- clobber_task = paste("clobber_", actual_name)
- task :clobber => [clobber_task]
-
- task actual_name => clobber_task
- end
- self
- end
-
- def rcov_option_list # :nodoc:
- return "" unless rcov
- ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
- end
-
- def spec_option_list # :nodoc:
- STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS']
- ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || ""
- end
-
- def evaluate(o) # :nodoc:
- case o
- when Proc then o.call
- else o
- end
- end
-
- def spec_file_list # :nodoc:
- if ENV['SPEC']
- FileList[ ENV['SPEC'] ]
- else
- result = []
- result += spec_files.to_a if spec_files
- result += FileList[ pattern ].to_a if pattern
- FileList[result]
- end
- end
-
- end
- end
-end
-
+++ /dev/null
-module RCov
- # A task that can verify that the RCov coverage doesn't
- # drop below a certain threshold. It should be run after
- # running Spec::Rake::SpecTask.
- class VerifyTask < Rake::TaskLib
- # Name of the task. Defaults to :verify_rcov
- attr_accessor :name
-
- # Path to the index.html file generated by RCov, which
- # is the file containing the total coverage.
- # Defaults to 'coverage/index.html'
- attr_accessor :index_html
-
- # Whether or not to output details. Defaults to true.
- attr_accessor :verbose
-
- # The threshold value (in percent) for coverage. If the
- # actual coverage is not equal to this value, the task will raise an
- # exception.
- attr_accessor :threshold
-
- # Require the threshold value be met exactly. This is the default.
- attr_accessor :require_exact_threshold
-
- def initialize(name=:verify_rcov)
- @name = name
- @index_html = 'coverage/index.html'
- @verbose = true
- @require_exact_threshold = true
- yield self if block_given?
- raise "Threshold must be set" if @threshold.nil?
- define
- end
-
- def define
- desc "Verify that rcov coverage is at least #{threshold}%"
- task @name do
- total_coverage = nil
-
- File.open(index_html).each_line do |line|
- if line =~ /<tt class='coverage_total'>(\d+\.\d+)%<\/tt>/
- total_coverage = eval($1)
- break
- end
- end
- puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
- raise "Coverage must be at least #{threshold}% but was #{total_coverage}%" if total_coverage < threshold
- raise "Coverage has increased above the threshold of #{threshold}% to #{total_coverage}%. You should update your threshold value." if (total_coverage > threshold) and require_exact_threshold
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/options'
-require 'spec/runner/option_parser'
-require 'spec/runner/example_group_runner'
-require 'spec/runner/command_line'
-require 'spec/runner/drb_command_line'
-require 'spec/runner/backtrace_tweaker'
-require 'spec/runner/reporter'
-require 'spec/runner/spec_parser'
-require 'spec/runner/class_and_arguments_parser'
-
-module Spec
- # == ExampleGroups and Examples
- #
- # Rather than expressing examples in classes, RSpec uses a custom DSLL (DSL light) to
- # describe groups of examples.
- #
- # A ExampleGroup is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
- # in which you will run your executable example - a set of known objects in a known starting state.
- # We begin be describing
- #
- # describe Account do
- #
- # before do
- # @account = Account.new
- # end
- #
- # it "should have a balance of $0" do
- # @account.balance.should == Money.new(0, :dollars)
- # end
- #
- # end
- #
- # We use the before block to set up the Example (given), and then the #it method to
- # hold the example code that expresses the event (when) and the expected outcome (then).
- #
- # == Helper Methods
- #
- # A primary goal of RSpec is to keep the examples clear. We therefore prefer
- # less indirection than you might see in xUnit examples and in well factored, DRY production code. We feel
- # that duplication is OK if removing it makes it harder to understand an example without
- # having to look elsewhere to understand its context.
- #
- # That said, RSpec does support some level of encapsulating common code in helper
- # methods that can exist within a context or within an included module.
- #
- # == Setup and Teardown
- #
- # You can use before and after within a Example. Both methods take an optional
- # scope argument so you can run the block before :each example or before :all examples
- #
- # describe "..." do
- # before :all do
- # ...
- # end
- #
- # before :each do
- # ...
- # end
- #
- # it "should do something" do
- # ...
- # end
- #
- # it "should do something else" do
- # ...
- # end
- #
- # after :each do
- # ...
- # end
- #
- # after :all do
- # ...
- # end
- #
- # end
- #
- # The <tt>before :each</tt> block will run before each of the examples, once for each example. Likewise,
- # the <tt>after :each</tt> block will run after each of the examples.
- #
- # It is also possible to specify a <tt>before :all</tt> and <tt>after :all</tt>
- # block that will run only once for each behaviour, respectively before the first <code>before :each</code>
- # and after the last <code>after :each</code>. The use of these is generally discouraged, because it
- # introduces dependencies between the examples. Still, it might prove useful for very expensive operations
- # if you know what you are doing.
- #
- # == Local helper methods
- #
- # You can include local helper methods by simply expressing them within a context:
- #
- # describe "..." do
- #
- # it "..." do
- # helper_method
- # end
- #
- # def helper_method
- # ...
- # end
- #
- # end
- #
- # == Included helper methods
- #
- # You can include helper methods in multiple contexts by expressing them within
- # a module, and then including that module in your context:
- #
- # module AccountExampleHelperMethods
- # def helper_method
- # ...
- # end
- # end
- #
- # describe "A new account" do
- # include AccountExampleHelperMethods
- # before do
- # @account = Account.new
- # end
- #
- # it "should have a balance of $0" do
- # helper_method
- # @account.balance.should eql(Money.new(0, :dollars))
- # end
- # end
- #
- # == Shared Example Groups
- #
- # You can define a shared Example Group, that may be used on other groups
- #
- # share_examples_for "All Editions" do
- # it "all editions behaviour" ...
- # end
- #
- # describe SmallEdition do
- # it_should_behave_like "All Editions"
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- #
- # You can also assign the shared group to a module and include that
- #
- # share_as :AllEditions do
- # it "should do all editions stuff" ...
- # end
- #
- # describe SmallEdition do
- # it_should_behave_like AllEditions
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- #
- # And, for those of you who prefer to use something more like Ruby, you
- # can just include the module directly
- #
- # describe SmallEdition do
- # include AllEditions
- #
- # it "should do small edition stuff" do
- # ...
- # end
- # end
- module Runner
- class << self
- def configuration # :nodoc:
- @configuration ||= Spec::Example::Configuration.new
- end
-
- # Use this to configure various configurable aspects of
- # RSpec:
- #
- # Spec::Runner.configure do |configuration|
- # # Configure RSpec here
- # end
- #
- # The yielded <tt>configuration</tt> object is a
- # Spec::Example::Configuration instance. See its RDoc
- # for details about what you can do with it.
- #
- def configure
- yield configuration
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- class BacktraceTweaker
- def clean_up_double_slashes(line)
- line.gsub!('//','/')
- end
- end
-
- class NoisyBacktraceTweaker < BacktraceTweaker
- def tweak_backtrace(error)
- return if error.backtrace.nil?
- error.backtrace.each do |line|
- clean_up_double_slashes(line)
- end
- end
- end
-
- # Tweaks raised Exceptions to mask noisy (unneeded) parts of the backtrace
- class QuietBacktraceTweaker < BacktraceTweaker
- unless defined?(IGNORE_PATTERNS)
- root_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', '..'))
- spec_files = Dir["#{root_dir}/lib/*"].map do |path|
- subpath = path[root_dir.length..-1]
- /#{subpath}/
- end
- IGNORE_PATTERNS = spec_files + [
- /\/lib\/ruby\//,
- /bin\/spec:/,
- /bin\/rcov:/,
- /lib\/rspec_on_rails/,
- /vendor\/rails/,
- # TextMate's Ruby and RSpec plugins
- /Ruby\.tmbundle\/Support\/tmruby.rb:/,
- /RSpec\.tmbundle\/Support\/lib/,
- /temp_textmate\./,
- /mock_frameworks\/rspec/,
- /spec_server/
- ]
- end
-
- def tweak_backtrace(error)
- return if error.backtrace.nil?
- error.backtrace.collect! do |line|
- clean_up_double_slashes(line)
- IGNORE_PATTERNS.each do |ignore|
- if line =~ ignore
- line = nil
- break
- end
- end
- line
- end
- error.backtrace.compact!
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- class ClassAndArgumentsParser
- class << self
- def parse(s)
- if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/
- arg = $2 == "" ? nil : $2
- [$1, arg]
- else
- raise "Couldn't parse #{s.inspect}"
- end
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require 'spec/runner/option_parser'
-
-module Spec
- module Runner
- # Facade to run specs without having to fork a new ruby process (using `spec ...`)
- class CommandLine
- class << self
- # Runs specs. +argv+ is the commandline args as per the spec commandline API, +err+
- # and +out+ are the streams output will be written to.
- def run(instance_rspec_options)
- # NOTE - this call to init_rspec_options is not spec'd, but neither is any of this
- # swapping of $rspec_options. That is all here to enable rspec to run against itself
- # and maintain coverage in a single process. Therefore, DO NOT mess with this stuff
- # unless you know what you are doing!
- init_rspec_options(instance_rspec_options)
- orig_rspec_options = rspec_options
- begin
- $rspec_options = instance_rspec_options
- return $rspec_options.run_examples
- ensure
- ::Spec.run = true
- $rspec_options = orig_rspec_options
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require "drb/drb"
-
-module Spec
- module Runner
- # Facade to run specs by connecting to a DRB server
- class DrbCommandLine
- # Runs specs on a DRB server. Note that this API is similar to that of
- # CommandLine - making it possible for clients to use both interchangeably.
- def self.run(options)
- begin
- DRb.start_service
- spec_server = DRbObject.new_with_uri("druby://localhost:8989")
- spec_server.run(options.argv, options.error_stream, options.output_stream)
- rescue DRb::DRbConnError => e
- options.error_stream.puts "No server is running"
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- class ExampleGroupRunner
- def initialize(options)
- @options = options
- end
-
- def load_files(files)
- # It's important that loading files (or choosing not to) stays the
- # responsibility of the ExampleGroupRunner. Some implementations (like)
- # the one using DRb may choose *not* to load files, but instead tell
- # someone else to do it over the wire.
- files.each do |file|
- load file
- end
- end
-
- def run
- prepare
- success = true
- example_groups.each do |example_group|
- success = success & example_group.run
- end
- return success
- ensure
- finish
- end
-
- protected
- def prepare
- reporter.start(number_of_examples)
- example_groups.reverse! if reverse
- end
-
- def finish
- reporter.end
- reporter.dump
- end
-
- def reporter
- @options.reporter
- end
-
- def reverse
- @options.reverse
- end
-
- def example_groups
- @options.example_groups
- end
-
- def number_of_examples
- @options.number_of_examples
- end
- end
- # TODO: BT - Deprecate BehaviourRunner?
- BehaviourRunner = ExampleGroupRunner
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Runner
- module Formatter
- # Baseclass for formatters that implements all required methods as no-ops.
- class BaseFormatter
- attr_accessor :example_group, :options, :where
- def initialize(options, where)
- @options = options
- @where = where
- end
-
- # This method is invoked before any examples are run, right after
- # they have all been collected. This can be useful for special
- # formatters that need to provide progress on feedback (graphical ones)
- #
- # This method will only be invoked once, and the next one to be invoked
- # is #add_example_group
- def start(example_count)
- end
-
- # This method is invoked at the beginning of the execution of each example_group.
- # +name+ is the name of the example_group and +first+ is true if it is the
- # first example_group - otherwise it's false.
- #
- # The next method to be invoked after this is #example_failed or #example_finished
- def add_example_group(example_group)
- @example_group = example_group
- end
-
- # This method is invoked when an +example+ starts.
- def example_started(example)
- end
-
- # This method is invoked when an +example+ passes.
- def example_passed(example)
- end
-
- # This method is invoked when an +example+ fails, i.e. an exception occurred
- # inside it (such as a failed should or other exception). +counter+ is the
- # sequence number of the failure (starting at 1) and +failure+ is the associated
- # Failure object.
- def example_failed(example, counter, failure)
- end
-
- # This method is invoked when an example is not yet implemented (i.e. has not
- # been provided a block), or when an ExamplePendingError is raised.
- # +message+ is the message from the ExamplePendingError, if it exists, or the
- # default value of "Not Yet Implemented"
- def example_pending(example_group_description, example, message)
- end
-
- # This method is invoked after all of the examples have executed. The next method
- # to be invoked after this one is #dump_failure (once for each failed example),
- def start_dump
- end
-
- # Dumps detailed information about an example failure.
- # This method is invoked for each failed example after all examples have run. +counter+ is the sequence number
- # of the associated example. +failure+ is a Failure object, which contains detailed
- # information about the failure.
- def dump_failure(counter, failure)
- end
-
- # This method is invoked after the dumping of examples and failures.
- def dump_summary(duration, example_count, failure_count, pending_count)
- end
-
- # This gets invoked after the summary if option is set to do so.
- def dump_pending
- end
-
- # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
- def close
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/base_formatter'
-
-module Spec
- module Runner
- module Formatter
- # Baseclass for text-based formatters. Can in fact be used for
- # non-text based ones too - just ignore the +output+ constructor
- # argument.
- class BaseTextFormatter < BaseFormatter
- attr_reader :output, :pending_examples
- # Creates a new instance that will write to +where+. If +where+ is a
- # String, output will be written to the File with that name, otherwise
- # +where+ is exected to be an IO (or an object that responds to #puts and #write).
- def initialize(options, where)
- super
- if where.is_a?(String)
- @output = File.open(where, 'w')
- elsif where == STDOUT
- @output = Kernel
- def @output.flush
- STDOUT.flush
- end
- else
- @output = where
- end
- @pending_examples = []
- end
-
- def example_pending(example_group_description, example, message)
- @pending_examples << ["#{example_group_description} #{example.description}", message]
- end
-
- def dump_failure(counter, failure)
- @output.puts
- @output.puts "#{counter.to_s})"
- @output.puts colourise("#{failure.header}\n#{failure.exception.message}", failure)
- @output.puts format_backtrace(failure.exception.backtrace)
- @output.flush
- end
-
- def colourise(s, failure)
- if(failure.expectation_not_met?)
- red(s)
- elsif(failure.pending_fixed?)
- blue(s)
- else
- magenta(s)
- end
- end
-
- def dump_summary(duration, example_count, failure_count, pending_count)
- return if dry_run?
- @output.puts
- @output.puts "Finished in #{duration} seconds"
- @output.puts
-
- summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
- summary << ", #{pending_count} pending" if pending_count > 0
-
- if failure_count == 0
- if pending_count > 0
- @output.puts yellow(summary)
- else
- @output.puts green(summary)
- end
- else
- @output.puts red(summary)
- end
- @output.flush
- end
-
- def dump_pending
- unless @pending_examples.empty?
- @output.puts
- @output.puts "Pending:"
- @pending_examples.each do |pending_example|
- @output.puts "#{pending_example[0]} (#{pending_example[1]})"
- end
- end
- @output.flush
- end
-
- def close
- if IO === @output
- @output.close
- end
- end
-
- def format_backtrace(backtrace)
- return "" if backtrace.nil?
- backtrace.map { |line| backtrace_line(line) }.join("\n")
- end
-
- protected
-
- def colour?
- @options.colour ? true : false
- end
-
- def dry_run?
- @options.dry_run ? true : false
- end
-
- def backtrace_line(line)
- line.sub(/\A([^:]+:\d+)$/, '\\1:')
- end
-
- def colour(text, colour_code)
- return text unless colour? && output_to_tty?
- "#{colour_code}#{text}\e[0m"
- end
-
- def output_to_tty?
- begin
- @output == Kernel || @output.tty?
- rescue NoMethodError
- false
- end
- end
-
- def green(text); colour(text, "\e[32m"); end
- def red(text); colour(text, "\e[31m"); end
- def magenta(text); colour(text, "\e[35m"); end
- def yellow(text); colour(text, "\e[33m"); end
- def blue(text); colour(text, "\e[34m"); end
-
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- class FailingExampleGroupsFormatter < BaseTextFormatter
- def add_example_group(example_group)
- super
- @example_group_description_parts = example_group.description_parts
- end
-
- def example_failed(example, counter, failure)
- if @example_group_description_parts
- description_parts = @example_group_description_parts.collect do |description|
- description =~ /(.*) \(druby.*\)$/ ? $1 : description
- end
- @output.puts ::Spec::Example::ExampleGroupMethods.description_text(*description_parts)
- @output.flush
- @example_group_description_parts = nil
- end
- end
-
- def dump_failure(counter, failure)
- end
-
- def dump_summary(duration, example_count, failure_count, pending_count)
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- class FailingExamplesFormatter < BaseTextFormatter
- def example_failed(example, counter, failure)
- @output.puts "#{example_group.description} #{example.description}"
- @output.flush
- end
-
- def dump_failure(counter, failure)
- end
-
- def dump_summary(duration, example_count, failure_count, pending_count)
- end
- end
- end
- end
-end
+++ /dev/null
-require 'erb'
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- class HtmlFormatter < BaseTextFormatter
- include ERB::Util # for the #h method
-
- def initialize(options, output)
- super
- @current_example_group_number = 0
- @current_example_number = 0
- end
-
- # The number of the currently running example_group
- def current_example_group_number
- @current_example_group_number
- end
-
- # The number of the currently running example (a global counter)
- def current_example_number
- @current_example_number
- end
-
- def start(example_count)
- @example_count = example_count
-
- @output.puts html_header
- @output.puts report_header
- @output.flush
- end
-
- def add_example_group(example_group)
- super
- @example_group_red = false
- @example_group_red = false
- @current_example_group_number += 1
- unless current_example_group_number == 1
- @output.puts " </dl>"
- @output.puts "</div>"
- end
- @output.puts "<div class=\"example_group\">"
- @output.puts " <dl>"
- @output.puts " <dt id=\"example_group_#{current_example_group_number}\">#{h(example_group.description)}</dt>"
- @output.flush
- end
-
- def start_dump
- @output.puts " </dl>"
- @output.puts "</div>"
- @output.flush
- end
-
- def example_started(example)
- @current_example_number += 1
- end
-
- def example_passed(example)
- move_progress
- @output.puts " <dd class=\"spec passed\"><span class=\"passed_spec_name\">#{h(example.description)}</span></dd>"
- @output.flush
- end
-
- def example_failed(example, counter, failure)
- extra = extra_failure_content(failure)
- failure_style = failure.pending_fixed? ? 'pending_fixed' : 'failed'
- @output.puts " <script type=\"text/javascript\">makeRed('rspec-header');</script>" unless @header_red
- @header_red = true
- @output.puts " <script type=\"text/javascript\">makeRed('example_group_#{current_example_group_number}');</script>" unless @example_group_red
- @example_group_red = true
- move_progress
- @output.puts " <dd class=\"spec #{failure_style}\">"
- @output.puts " <span class=\"failed_spec_name\">#{h(example.description)}</span>"
- @output.puts " <div class=\"failure\" id=\"failure_#{counter}\">"
- @output.puts " <div class=\"message\"><pre>#{h(failure.exception.message)}</pre></div>" unless failure.exception.nil?
- @output.puts " <div class=\"backtrace\"><pre>#{format_backtrace(failure.exception.backtrace)}</pre></div>" unless failure.exception.nil?
- @output.puts extra unless extra == ""
- @output.puts " </div>"
- @output.puts " </dd>"
- @output.flush
- end
-
- def example_pending(example_group_description, example, message)
- @output.puts " <script type=\"text/javascript\">makeYellow('rspec-header');</script>" unless @header_red
- @output.puts " <script type=\"text/javascript\">makeYellow('example_group_#{current_example_group_number}');</script>" unless @example_group_red
- move_progress
- @output.puts " <dd class=\"spec not_implemented\"><span class=\"not_implemented_spec_name\">#{h(example.description)} (PENDING: #{h(message)})</span></dd>"
- @output.flush
- end
-
- # Override this method if you wish to output extra HTML for a failed spec. For example, you
- # could output links to images or other files produced during the specs.
- #
- def extra_failure_content(failure)
- require 'spec/runner/formatter/snippet_extractor'
- @snippet_extractor ||= SnippetExtractor.new
- " <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(failure.exception)}</code></pre>"
- end
-
- def move_progress
- @output.puts " <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
- @output.flush
- end
-
- def percent_done
- result = 100.0
- if @example_count != 0
- result = ((current_example_number).to_f / @example_count.to_f * 1000).to_i / 10.0
- end
- result
- end
-
- def dump_failure(counter, failure)
- end
-
- def dump_summary(duration, example_count, failure_count, pending_count)
- if dry_run?
- totals = "This was a dry-run"
- else
- totals = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
- totals << ", #{pending_count} pending" if pending_count > 0
- end
- @output.puts "<script type=\"text/javascript\">document.getElementById('duration').innerHTML = \"Finished in <strong>#{duration} seconds</strong>\";</script>"
- @output.puts "<script type=\"text/javascript\">document.getElementById('totals').innerHTML = \"#{totals}\";</script>"
- @output.puts "</div>"
- @output.puts "</div>"
- @output.puts "</body>"
- @output.puts "</html>"
- @output.flush
- end
-
- def html_header
- <<-EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html
- PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
- <title>RSpec results</title>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
- <meta http-equiv="Expires" content="-1" />
- <meta http-equiv="Pragma" content="no-cache" />
- <style type="text/css">
- body {
- margin: 0;
- padding: 0;
- background: #fff;
- font-size: 80%;
- }
- </style>
-</head>
-<body>
-EOF
- end
-
- def report_header
- <<-EOF
-<div class="rspec-report">
- <script type="text/javascript">
- // <![CDATA[
-#{global_scripts}
- // ]]>
- </script>
- <style type="text/css">
-#{global_styles}
- </style>
-
-<div id="rspec-header">
- <h1>RSpec Results</h1>
-
- <div id="summary">
- <p id="totals"> </p>
- <p id="duration"> </p>
- </div>
-</div>
-
-<div class="results">
-EOF
- end
-
- def global_scripts
- <<-EOF
-function moveProgressBar(percentDone) {
- document.getElementById("rspec-header").style.width = percentDone +"%";
-}
-function makeRed(element_id) {
- document.getElementById(element_id).style.background = '#C40D0D';
- document.getElementById(element_id).style.color = '#FFFFFF';
-}
-
-function makeYellow(element_id) {
- if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D')
- {
- document.getElementById(element_id).style.background = '#FAF834';
- document.getElementById(element_id).style.color = '#000000';
- }
- else
- {
- document.getElementById(element_id).style.background = '#FAF834';
- document.getElementById(element_id).style.color = '#000000';
- }
-}
-EOF
- end
-
- def global_styles
- <<-EOF
-#rspec-header {
- background: #65C400; color: #fff;
-}
-
-.rspec-report h1 {
- margin: 0px 10px 0px 10px;
- padding: 10px;
- font-family: "Lucida Grande", Helvetica, sans-serif;
- font-size: 1.8em;
-}
-
-#summary {
- margin: 0; padding: 5px 10px;
- font-family: "Lucida Grande", Helvetica, sans-serif;
- text-align: right;
- position: absolute;
- top: 0px;
- right: 0px;
-}
-
-#summary p {
- margin: 0 0 0 2px;
-}
-
-#summary #totals {
- font-size: 1.2em;
-}
-
-.example_group {
- margin: 0 10px 5px;
- background: #fff;
-}
-
-dl {
- margin: 0; padding: 0 0 5px;
- font: normal 11px "Lucida Grande", Helvetica, sans-serif;
-}
-
-dt {
- padding: 3px;
- background: #65C400;
- color: #fff;
- font-weight: bold;
-}
-
-dd {
- margin: 5px 0 5px 5px;
- padding: 3px 3px 3px 18px;
-}
-
-dd.spec.passed {
- border-left: 5px solid #65C400;
- border-bottom: 1px solid #65C400;
- background: #DBFFB4; color: #3D7700;
-}
-
-dd.spec.failed {
- border-left: 5px solid #C20000;
- border-bottom: 1px solid #C20000;
- color: #C20000; background: #FFFBD3;
-}
-
-dd.spec.not_implemented {
- border-left: 5px solid #FAF834;
- border-bottom: 1px solid #FAF834;
- background: #FCFB98; color: #131313;
-}
-
-dd.spec.pending_fixed {
- border-left: 5px solid #0000C2;
- border-bottom: 1px solid #0000C2;
- color: #0000C2; background: #D3FBFF;
-}
-
-.backtrace {
- color: #000;
- font-size: 12px;
-}
-
-a {
- color: #BE5C00;
-}
-
-/* Ruby code, style similar to vibrant ink */
-.ruby {
- font-size: 12px;
- font-family: monospace;
- color: white;
- background-color: black;
- padding: 0.1em 0 0.2em 0;
-}
-
-.ruby .keyword { color: #FF6600; }
-.ruby .constant { color: #339999; }
-.ruby .attribute { color: white; }
-.ruby .global { color: white; }
-.ruby .module { color: white; }
-.ruby .class { color: white; }
-.ruby .string { color: #66FF00; }
-.ruby .ident { color: white; }
-.ruby .method { color: #FFCC00; }
-.ruby .number { color: white; }
-.ruby .char { color: white; }
-.ruby .comment { color: #9933CC; }
-.ruby .symbol { color: white; }
-.ruby .regex { color: #44B4CC; }
-.ruby .punct { color: white; }
-.ruby .escape { color: white; }
-.ruby .interp { color: white; }
-.ruby .expr { color: white; }
-
-.ruby .offending { background-color: gray; }
-.ruby .linenum {
- width: 75px;
- padding: 0.1em 1em 0.2em 0;
- color: #000000;
- background-color: #FFFBD3;
-}
-EOF
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/progress_bar_formatter'
-
-module Spec
- module Runner
- module Formatter
- class ProfileFormatter < ProgressBarFormatter
-
- def initialize(options, where)
- super
- @example_times = []
- end
-
- def start(count)
- @output.puts "Profiling enabled."
- end
-
- def example_started(example)
- @time = Time.now
- end
-
- def example_passed(example)
- super
- @example_times << [
- example_group.description,
- example.description,
- Time.now - @time
- ]
- end
-
- def start_dump
- super
- @output.puts "\n\nTop 10 slowest examples:\n"
-
- @example_times = @example_times.sort_by do |description, example, time|
- time
- end.reverse
-
- @example_times[0..9].each do |description, example, time|
- @output.print red(sprintf("%.7f", time))
- @output.puts " #{description} #{example}"
- end
- @output.flush
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- class ProgressBarFormatter < BaseTextFormatter
- def example_failed(example, counter, failure)
- @output.print colourise('F', failure)
- @output.flush
- end
-
- def example_passed(example)
- @output.print green('.')
- @output.flush
- end
-
- def example_pending(example_group_description, example, message)
- super
- @output.print yellow('P')
- @output.flush
- end
-
- def start_dump
- @output.puts
- @output.flush
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- module Formatter
- # This class extracts code snippets by looking at the backtrace of the passed error
- class SnippetExtractor #:nodoc:
- class NullConverter; def convert(code, pre); code; end; end #:nodoc:
- begin; require 'rubygems'; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end
-
- def snippet(error)
- raw_code, line = snippet_for(error.backtrace[0])
- highlighted = @@converter.convert(raw_code, false)
- highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
- post_process(highlighted, line)
- end
-
- def snippet_for(error_line)
- if error_line =~ /(.*):(\d+)/
- file = $1
- line = $2.to_i
- [lines_around(file, line), line]
- else
- ["# Couldn't get snippet for #{error_line}", 1]
- end
- end
-
- def lines_around(file, line)
- if File.file?(file)
- lines = File.open(file).read.split("\n")
- min = [0, line-3].max
- max = [line+1, lines.length-1].min
- selected_lines = []
- selected_lines.join("\n")
- lines[min..max].join("\n")
- else
- "# Couldn't get snippet for #{file}"
- end
- end
-
- def post_process(highlighted, offending_line)
- new_lines = []
- highlighted.split("\n").each_with_index do |line, i|
- new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
- new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
- new_lines << new_line
- end
- new_lines.join("\n")
- end
-
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- class SpecdocFormatter < BaseTextFormatter
- def add_example_group(example_group)
- super
- output.puts
- output.puts example_group.description
- output.flush
- end
-
- def example_failed(example, counter, failure)
- message = if failure.expectation_not_met?
- "- #{example.description} (FAILED - #{counter})"
- else
- "- #{example.description} (ERROR - #{counter})"
- end
-
- output.puts(failure.expectation_not_met? ? red(message) : magenta(message))
- output.flush
- end
-
- def example_passed(example)
- message = "- #{example.description}"
- output.puts green(message)
- output.flush
- end
-
- def example_pending(example_group_description, example, message)
- super
- output.puts yellow("- #{example.description} (PENDING: #{message})")
- output.flush
- end
- end
- end
- end
-end
+++ /dev/null
-require 'erb'
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- module Story
- class HtmlFormatter < BaseTextFormatter
- include ERB::Util
-
- def run_started(count)
- @output.puts <<-EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html
- PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
- <head>
- <title>Stories</title>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
- <meta http-equiv="Expires" content="-1" />
- <meta http-equiv="Pragma" content="no-cache" />
- <script src="javascripts/prototype.js" type="text/javascript"></script>
- <script src="javascripts/scriptaculous.js" type="text/javascript"></script>
- <script src="javascripts/rspec.js" type="text/javascript"></script>
- <link href="stylesheets/rspec.css" rel="stylesheet" type="text/css" />
- </head>
- <body>
- <div id="container">
-EOF
- end
-
- def collected_steps(steps)
- unless steps.empty?
- @output.puts " <ul id=\"stock_steps\" style=\"display: none;\">"
- steps.each do |step|
- @output.puts " <li>#{step}</li>"
- end
- @output.puts " </ul>"
- end
- end
-
- def run_ended
- @output.puts <<-EOF
- </div>
- </body>
-</head>
-EOF
- end
-
- def story_started(title, narrative)
- @output.puts <<-EOF
- <dl class="story passed">
- <dt>Story: #{h title}</dt>
- <dd>
- <p>
- #{h(narrative).split("\n").join("<br />")}
- </p>
-EOF
- end
-
- def story_ended(title, narrative)
- @output.puts <<-EOF
- </dd>
- </dl>
-EOF
- end
-
- def scenario_started(story_title, scenario_name)
- @output.puts <<-EOF
- <dl class="passed">
- <dt>Scenario: #{h scenario_name}</dt>
- <dd>
- <ul class="steps">
-EOF
- end
-
- def scenario_ended
- @output.puts <<-EOF
- </ul>
- </dd>
- </dl>
-EOF
- end
-
- def found_scenario(type, description)
- end
-
- def scenario_succeeded(story_title, scenario_name)
- scenario_ended
- end
-
- def scenario_pending(story_title, scenario_name, reason)
- scenario_ended
- end
-
- def scenario_failed(story_title, scenario_name, err)
- scenario_ended
- end
-
- def step_succeeded(type, description, *args)
- print_step('passed', type, description, *args) # TODO: uses succeeded CSS class
- end
-
- def step_pending(type, description, *args)
- print_step('pending', type, description, *args)
- end
-
- def step_failed(type, description, *args)
- print_step('failed', type, description, *args)
- end
-
- def print_step(klass, type, description, *args)
- spans = args.map { |arg| "<span class=\"param\">#{arg}</span>" }
- desc_string = description.step_name
- arg_regexp = description.arg_regexp
- i = -1
- inner = type.to_s.capitalize + ' ' + desc_string.gsub(arg_regexp) { |param| spans[i+=1] }
- @output.puts " <li class=\"#{klass}\">#{inner}</li>"
- end
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- module Story
- class PlainTextFormatter < BaseTextFormatter
- def initialize(options, where)
- super
- @successful_scenario_count = 0
- @pending_scenario_count = 0
- @failed_scenarios = []
- @pending_steps = []
- @previous_type = nil
- end
-
- def run_started(count)
- @count = count
- @output.puts "Running #@count scenarios\n\n"
- end
-
- def story_started(title, narrative)
- @current_story_title = title
- @output.puts "Story: #{title}\n\n"
- narrative.each_line do |line|
- @output.print " "
- @output.print line
- end
- end
-
- def story_ended(title, narrative)
- @output.puts
- @output.puts
- end
-
- def scenario_started(story_title, scenario_name)
- @current_scenario_name = scenario_name
- @scenario_already_failed = false
- @output.print "\n\n Scenario: #{scenario_name}"
- @scenario_ok = true
- end
-
- def scenario_succeeded(story_title, scenario_name)
- @successful_scenario_count += 1
- end
-
- def scenario_failed(story_title, scenario_name, err)
- @options.backtrace_tweaker.tweak_backtrace(err)
- @failed_scenarios << [story_title, scenario_name, err] unless @scenario_already_failed
- @scenario_already_failed = true
- end
-
- def scenario_pending(story_title, scenario_name, msg)
- @pending_scenario_count += 1 unless @scenario_already_failed
- @scenario_already_failed = true
- end
-
- def run_ended
- @output.puts "#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending"
- unless @pending_steps.empty?
- @output.puts "\nPending Steps:"
- @pending_steps.each_with_index do |pending, i|
- story_name, scenario_name, msg = pending
- @output.puts "#{i+1}) #{story_name} (#{scenario_name}): #{msg}"
- end
- end
- unless @failed_scenarios.empty?
- @output.print "\nFAILURES:"
- @failed_scenarios.each_with_index do |failure, i|
- title, scenario_name, err = failure
- @output.print %[
- #{i+1}) #{title} (#{scenario_name}) FAILED
- #{err.class}: #{err.message}
- #{err.backtrace.join("\n")}
-]
- end
- end
- end
-
- def step_succeeded(type, description, *args)
- found_step(type, description, false, *args)
- end
-
- def step_pending(type, description, *args)
- found_step(type, description, false, *args)
- @pending_steps << [@current_story_title, @current_scenario_name, description]
- @output.print " (PENDING)"
- @scenario_ok = false
- end
-
- def step_failed(type, description, *args)
- found_step(type, description, true, *args)
- @output.print red(@scenario_ok ? " (FAILED)" : " (SKIPPED)")
- @scenario_ok = false
- end
-
- def collected_steps(steps)
- end
-
- def method_missing(sym, *args, &block) #:nodoc:
- # noop - ignore unknown messages
- end
-
- private
-
- def found_step(type, description, failed, *args)
- desc_string = description.step_name
- arg_regexp = description.arg_regexp
- text = if(type == @previous_type)
- "\n And "
- else
- "\n\n #{type.to_s.capitalize} "
- end
- i = -1
- text << desc_string.gsub(arg_regexp) { |param| args[i+=1] }
- @output.print(failed ? red(text) : green(text))
-
- if type == :'given scenario'
- @previous_type = :given
- else
- @previous_type = type
- end
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require 'spec/runner/formatter/html_formatter'
-
-module Spec
- module Runner
- module Formatter
- # Formats backtraces so they're clickable by TextMate
- class TextMateFormatter < HtmlFormatter
- def backtrace_line(line)
- line.gsub(/([^:]*\.rb):(\d*)/) do
- "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
- end
- end
- end
- end
- end
-end
+++ /dev/null
-begin
- require 'rubygems'
- require 'heckle'
-rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
-
-module Spec
- module Runner
- # Creates a new Heckler configured to heckle all methods in the classes
- # whose name matches +filter+
- class HeckleRunner
- def initialize(filter, heckle_class=Heckler)
- @filter = filter
- @heckle_class = heckle_class
- end
-
- # Runs all the example groups held by +rspec_options+ once for each of the
- # methods in the matched classes.
- def heckle_with
- if @filter =~ /(.*)[#\.](.*)/
- heckle_method($1, $2)
- else
- heckle_class_or_module(@filter)
- end
- end
-
- def heckle_method(class_name, method_name)
- verify_constant(class_name)
- heckle = @heckle_class.new(class_name, method_name, rspec_options)
- heckle.validate
- end
-
- def heckle_class_or_module(class_or_module_name)
- verify_constant(class_or_module_name)
- pattern = /^#{class_or_module_name}/
- classes = []
- ObjectSpace.each_object(Class) do |klass|
- classes << klass if klass.name =~ pattern
- end
-
- classes.each do |klass|
- klass.instance_methods(false).each do |method_name|
- heckle = @heckle_class.new(klass.name, method_name, rspec_options)
- heckle.validate
- end
- end
- end
-
- def verify_constant(name)
- begin
- # This is defined in Heckle
- name.to_class
- rescue
- raise "Heckling failed - \"#{name}\" is not a known class or module"
- end
- end
- end
-
- #Supports Heckle 1.2 and prior (earlier versions used Heckle::Base)
- class Heckler < (Heckle.const_defined?(:Base) ? Heckle::Base : Heckle)
- def initialize(klass_name, method_name, rspec_options)
- super(klass_name, method_name)
- @rspec_options = rspec_options
- end
-
- def tests_pass?
- success = @rspec_options.run_examples
- success
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
- class HeckleRunner
- def initialize(filter)
- raise "Heckle not supported on Windows"
- end
- end
- end
-end
+++ /dev/null
-require 'optparse'
-require 'stringio'
-
-module Spec
- module Runner
- class OptionParser < ::OptionParser
- class << self
- def parse(args, err, out)
- parser = new(err, out)
- parser.parse(args)
- parser.options
- end
- end
-
- attr_reader :options
-
- OPTIONS = {
- :diff => ["-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
- "Builtin formats: unified|u|context|c",
- "You can also specify a custom differ class",
- "(in which case you should also specify --require)"],
- :colour => ["-c", "--colour", "--color", "Show coloured (red/green) output"],
- :example => ["-e", "--example [NAME|FILE_NAME]", "Execute example(s) with matching name(s). If the argument is",
- "the path to an existing file (typically generated by a previous",
- "run using --format failing_examples:file.txt), then the examples",
- "on each line of thatfile will be executed. If the file is empty,",
- "all examples will be run (as if --example was not specified).",
- " ",
- "If the argument is not an existing file, then it is treated as",
- "an example name directly, causing RSpec to run just the example",
- "matching that name"],
- :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"],
- :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviout or specification at given line.",
- "(does not work for dynamically generated specs)"],
- :format => ["-f", "--format FORMAT[:WHERE]", "Specifies what format to use for output. Specify WHERE to tell",
- "the formatter where to write the output. All built-in formats",
- "expect WHERE to be a file name, and will write to STDOUT if it's",
- "not specified. The --format option may be specified several times",
- "if you want several outputs",
- " ",
- "Builtin formats for examples: ",
- "progress|p : Text progress",
- "profile|o : Text progress with profiling of 10 slowest examples",
- "specdoc|s : Example doc as text",
- "html|h : A nice HTML report",
- "failing_examples|e : Write all failing examples - input for --example",
- "failing_example_groups|g : Write all failing example groups - input for --example",
- " ",
- "Builtin formats for stories: ",
- "plain|p : Plain Text",
- "html|h : A nice HTML report",
- " ",
- "FORMAT can also be the name of a custom formatter class",
- "(in which case you should also specify --require to load it)"],
- :require => ["-r", "--require FILE", "Require FILE before running specs",
- "Useful for loading custom formatters or other extensions.",
- "If this option is used it must come before the others"],
- :backtrace => ["-b", "--backtrace", "Output full backtrace"],
- :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.",
- "STRATEGY can currently only be 'mtime' (File modification time)",
- "By default, spec files are loaded in alphabetical order if --loadby",
- "is not specified."],
- :reverse => ["-R", "--reverse", "Run examples in reverse order"],
- :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
- "specified time"],
- :heckle => ["-H", "--heckle CODE", "If all examples pass, this will mutate the classes and methods",
- "identified by CODE little by little and run all the examples again",
- "for each mutation. The intent is that for each mutation, at least",
- "one example *should* fail, and RSpec will tell you if this is not the",
- "case. CODE should be either Some::Module, Some::Class or",
- "Some::Fabulous#method}"],
- :dry_run => ["-d", "--dry-run", "Invokes formatters without executing the examples."],
- :options_file => ["-O", "--options PATH", "Read options from a file"],
- :generate_options => ["-G", "--generate-options PATH", "Generate an options file for --options"],
- :runner => ["-U", "--runner RUNNER", "Use a custom Runner."],
- :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
- :version => ["-v", "--version", "Show version"],
- :help => ["-h", "--help", "You're looking at it"]
- }
-
- def initialize(err, out)
- super()
- @error_stream = err
- @out_stream = out
- @options = Options.new(@error_stream, @out_stream)
-
- @spec_parser = SpecParser.new
- @file_factory = File
-
- self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
- self.separator ""
- on(*OPTIONS[:diff]) {|diff| @options.parse_diff(diff)}
- on(*OPTIONS[:colour]) {@options.colour = true}
- on(*OPTIONS[:example]) {|example| @options.parse_example(example)}
- on(*OPTIONS[:specification]) {|example| @options.parse_example(example)}
- on(*OPTIONS[:line]) {|line_number| @options.line_number = line_number.to_i}
- on(*OPTIONS[:format]) {|format| @options.parse_format(format)}
- on(*OPTIONS[:require]) {|requires| invoke_requires(requires)}
- on(*OPTIONS[:backtrace]) {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
- on(*OPTIONS[:loadby]) {|loadby| @options.loadby = loadby}
- on(*OPTIONS[:reverse]) {@options.reverse = true}
- on(*OPTIONS[:timeout]) {|timeout| @options.timeout = timeout.to_f}
- on(*OPTIONS[:heckle]) {|heckle| @options.load_heckle_runner(heckle)}
- on(*OPTIONS[:dry_run]) {@options.dry_run = true}
- on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)}
- on(*OPTIONS[:generate_options]) do |options_file|
- end
- on(*OPTIONS[:runner]) do |runner|
- @options.user_input_for_runner = runner
- end
- on(*OPTIONS[:drb]) {}
- on(*OPTIONS[:version]) {parse_version}
- on_tail(*OPTIONS[:help]) {parse_help}
- end
-
- def order!(argv, &blk)
- @argv = argv
- @options.argv = @argv.dup
- return if parse_generate_options
- return if parse_drb
-
- super(@argv) do |file|
- @options.files << file
- blk.call(file) if blk
- end
-
- if @options.line_number
- set_spec_from_line_number
- end
-
- @options
- end
-
- protected
- def invoke_requires(requires)
- requires.split(",").each do |file|
- require file
- end
- end
-
- def parse_options_file(options_file)
- option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
- @argv.push(*option_file_args)
- end
-
- def parse_generate_options
- # Remove the --generate-options option and the argument before writing to file
- options_file = nil
- ['-G', '--generate-options'].each do |option|
- if index = @argv.index(option)
- @argv.delete_at(index)
- options_file = @argv.delete_at(index)
- end
- end
-
- if options_file
- write_generated_options(options_file)
- return true
- else
- return false
- end
- end
-
- def write_generated_options(options_file)
- File.open(options_file, 'w') do |io|
- io.puts @argv.join("\n")
- end
- @out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:"
- @out_stream.puts "spec --options #{options_file}"
- @options.examples_should_not_be_run
- end
-
- def parse_drb
- is_drb = false
- argv = @options.argv
- is_drb ||= argv.delete(OPTIONS[:drb][0])
- is_drb ||= argv.delete(OPTIONS[:drb][1])
- return nil unless is_drb
- @options.examples_should_not_be_run
- DrbCommandLine.run(
- self.class.parse(argv, @error_stream, @out_stream)
- )
- true
- end
-
- def parse_version
- @out_stream.puts ::Spec::VERSION::DESCRIPTION
- exit if stdout?
- end
-
- def parse_help
- @out_stream.puts self
- exit if stdout?
- end
-
- def set_spec_from_line_number
- if @options.examples.empty?
- if @options.files.length == 1
- if @file_factory.file?(@options.files[0])
- source = @file_factory.open(@options.files[0])
- example = @spec_parser.spec_name_for(source, @options.line_number)
- @options.parse_example(example)
- elsif @file_factory.directory?(@options.files[0])
- @error_stream.puts "You must specify one file, not a directory when using the --line option"
- exit(1) if stderr?
- else
- @error_stream.puts "#{@options.files[0]} does not exist"
- exit(2) if stderr?
- end
- else
- @error_stream.puts "Only one file can be specified when using the --line option: #{@options.files.inspect}"
- exit(3) if stderr?
- end
- else
- @error_stream.puts "You cannot use both --line and --example"
- exit(4) if stderr?
- end
- end
-
- def stdout?
- @out_stream == $stdout
- end
-
- def stderr?
- @error_stream == $stderr
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- class Options
- FILE_SORTERS = {
- 'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
- }
-
- EXAMPLE_FORMATTERS = { # Load these lazily for better speed
- 'specdoc' => ['spec/runner/formatter/specdoc_formatter', 'Formatter::SpecdocFormatter'],
- 's' => ['spec/runner/formatter/specdoc_formatter', 'Formatter::SpecdocFormatter'],
- 'html' => ['spec/runner/formatter/html_formatter', 'Formatter::HtmlFormatter'],
- 'h' => ['spec/runner/formatter/html_formatter', 'Formatter::HtmlFormatter'],
- 'progress' => ['spec/runner/formatter/progress_bar_formatter', 'Formatter::ProgressBarFormatter'],
- 'p' => ['spec/runner/formatter/progress_bar_formatter', 'Formatter::ProgressBarFormatter'],
- 'failing_examples' => ['spec/runner/formatter/failing_examples_formatter', 'Formatter::FailingExamplesFormatter'],
- 'e' => ['spec/runner/formatter/failing_examples_formatter', 'Formatter::FailingExamplesFormatter'],
-'failing_example_groups' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
- 'g' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
- 'profile' => ['spec/runner/formatter/profile_formatter', 'Formatter::ProfileFormatter'],
- 'o' => ['spec/runner/formatter/profile_formatter', 'Formatter::ProfileFormatter'],
- 'textmate' => ['spec/runner/formatter/text_mate_formatter', 'Formatter::TextMateFormatter']
- }
-
- STORY_FORMATTERS = {
- 'plain' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
- 'p' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
- 'html' => ['spec/runner/formatter/story/html_formatter', 'Formatter::Story::HtmlFormatter'],
- 'h' => ['spec/runner/formatter/story/html_formatter', 'Formatter::Story::HtmlFormatter']
- }
-
- attr_accessor(
- :backtrace_tweaker,
- :context_lines,
- :diff_format,
- :dry_run,
- :profile,
- :examples,
- :heckle_runner,
- :line_number,
- :loadby,
- :reporter,
- :reverse,
- :timeout,
- :verbose,
- :user_input_for_runner,
- :error_stream,
- :output_stream,
- # TODO: BT - Figure out a better name
- :argv
- )
- attr_reader :colour, :differ_class, :files, :example_groups
-
- def initialize(error_stream, output_stream)
- @error_stream = error_stream
- @output_stream = output_stream
- @backtrace_tweaker = QuietBacktraceTweaker.new
- @examples = []
- @colour = false
- @profile = false
- @dry_run = false
- @reporter = Reporter.new(self)
- @context_lines = 3
- @diff_format = :unified
- @files = []
- @example_groups = []
- @examples_run = false
- @examples_should_be_run = nil
- @user_input_for_runner = nil
- end
-
- def add_example_group(example_group)
- @example_groups << example_group
- end
-
- def remove_example_group(example_group)
- @example_groups.delete(example_group)
- end
-
- def run_examples
- return true unless examples_should_be_run?
- runner = custom_runner || ExampleGroupRunner.new(self)
-
- runner.load_files(files_to_load)
- if example_groups.empty?
- true
- else
- success = runner.run
- @examples_run = true
- heckle if heckle_runner
- success
- end
- end
-
- def examples_run?
- @examples_run
- end
-
- def examples_should_not_be_run
- @examples_should_be_run = false
- end
-
- def colour=(colour)
- @colour = colour
- begin; \
- require 'Win32/Console/ANSI' if @colour && PLATFORM =~ /win32/; \
- rescue LoadError ; \
- raise "You must gem install win32console to use colour on Windows" ; \
- end
- end
-
- def parse_diff(format)
- case format
- when :context, 'context', 'c'
- @diff_format = :context
- default_differ
- when :unified, 'unified', 'u', '', nil
- @diff_format = :unified
- default_differ
- else
- @diff_format = :custom
- self.differ_class = load_class(format, 'differ', '--diff')
- end
- end
-
- def parse_example(example)
- if(File.file?(example))
- @examples = File.open(example).read.split("\n")
- else
- @examples = [example]
- end
- end
-
- def parse_format(format_arg)
- format, where = ClassAndArgumentsParser.parse(format_arg)
- unless where
- raise "When using several --format options only one of them can be without a file" if @out_used
- where = @output_stream
- @out_used = true
- end
- @format_options ||= []
- @format_options << [format, where]
- end
-
- def formatters
- @format_options ||= [['progress', @output_stream]]
- @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS)
- end
-
- def story_formatters
- @format_options ||= [['plain', @output_stream]]
- @formatters ||= load_formatters(@format_options, STORY_FORMATTERS)
- end
-
- def load_formatters(format_options, formatters)
- format_options.map do |format, where|
- formatter_type = if formatters[format]
- require formatters[format][0]
- eval(formatters[format][1], binding, __FILE__, __LINE__)
- else
- load_class(format, 'formatter', '--format')
- end
- formatter_type.new(self, where)
- end
- end
-
- def load_heckle_runner(heckle)
- suffix = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? '_unsupported' : ''
- require "spec/runner/heckle_runner#{suffix}"
- @heckle_runner = HeckleRunner.new(heckle)
- end
-
- def number_of_examples
- @example_groups.inject(0) do |sum, example_group|
- sum + example_group.number_of_examples
- end
- end
-
- protected
- def examples_should_be_run?
- return @examples_should_be_run unless @examples_should_be_run.nil?
- @examples_should_be_run = true
- end
-
- def differ_class=(klass)
- return unless klass
- @differ_class = klass
- Spec::Expectations.differ = self.differ_class.new(self)
- end
-
- def load_class(name, kind, option)
- if name =~ /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
- arg = $2 == "" ? nil : $2
- [$1, arg]
- else
- m = "#{name.inspect} is not a valid class name"
- @error_stream.puts m
- raise m
- end
- begin
- eval(name, binding, __FILE__, __LINE__)
- rescue NameError => e
- @error_stream.puts "Couldn't find #{kind} class #{name}"
- @error_stream.puts "Make sure the --require option is specified *before* #{option}"
- if $_spec_spec ; raise e ; else exit(1) ; end
- end
- end
-
- def files_to_load
- result = []
- sorted_files.each do |file|
- if test ?d, file
- result += Dir[File.expand_path("#{file}/**/*.rb")]
- elsif test ?f, file
- result << file
- else
- raise "File or directory not found: #{file}"
- end
- end
- result
- end
-
- def custom_runner
- return nil unless custom_runner?
- klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner)
- runner_type = load_class(klass_name, 'behaviour runner', '--runner')
- return runner_type.new(self, arg)
- end
-
- def custom_runner?
- return user_input_for_runner ? true : false
- end
-
- def heckle
- returns = self.heckle_runner.heckle_with
- self.heckle_runner = nil
- returns
- end
-
- def sorted_files
- return sorter ? files.sort(&sorter) : files
- end
-
- def sorter
- FILE_SORTERS[loadby]
- end
-
- def default_differ
- require 'spec/expectations/differs/default'
- self.differ_class = Spec::Expectations::Differs::Default
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- class Reporter
- attr_reader :options, :example_groups
-
- def initialize(options)
- @options = options
- @options.reporter = self
- clear
- end
-
- def add_example_group(example_group)
- formatters.each do |f|
- f.add_example_group(example_group)
- end
- example_groups << example_group
- end
-
- def example_started(example)
- formatters.each{|f| f.example_started(example)}
- end
-
- def example_finished(example, error=nil)
- @examples << example
-
- if error.nil?
- example_passed(example)
- elsif Spec::Example::ExamplePendingError === error
- example_pending(example_groups.last, example, error.message)
- else
- example_failed(example, error)
- end
- end
-
- def failure(example, error)
- backtrace_tweaker.tweak_backtrace(error)
- example_name = "#{example_groups.last.description} #{example.description}"
- failure = Failure.new(example_name, error)
- @failures << failure
- formatters.each do |f|
- f.example_failed(example, @failures.length, failure)
- end
- end
- alias_method :example_failed, :failure
-
- def start(number_of_examples)
- clear
- @start_time = Time.new
- formatters.each{|f| f.start(number_of_examples)}
- end
-
- def end
- @end_time = Time.new
- end
-
- # Dumps the summary and returns the total number of failures
- def dump
- formatters.each{|f| f.start_dump}
- dump_pending
- dump_failures
- formatters.each do |f|
- f.dump_summary(duration, @examples.length, @failures.length, @pending_count)
- f.close
- end
- @failures.length
- end
-
- private
-
- def formatters
- @options.formatters
- end
-
- def backtrace_tweaker
- @options.backtrace_tweaker
- end
-
- def clear
- @example_groups = []
- @failures = []
- @pending_count = 0
- @examples = []
- @start_time = nil
- @end_time = nil
- end
-
- def dump_failures
- return if @failures.empty?
- @failures.inject(1) do |index, failure|
- formatters.each{|f| f.dump_failure(index, failure)}
- index + 1
- end
- end
- def dump_pending
- formatters.each{|f| f.dump_pending}
- end
-
- def duration
- return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
- return "0.0"
- end
-
- def example_passed(example)
- formatters.each{|f| f.example_passed(example)}
- end
-
- def example_pending(example_group, example, message="Not Yet Implemented")
- @pending_count += 1
- formatters.each do |f|
- f.example_pending(example_group.description, example, message)
- end
- end
-
- class Failure
- attr_reader :exception
-
- def initialize(example_name, exception)
- @example_name = example_name
- @exception = exception
- end
-
- def header
- if expectation_not_met?
- "'#{@example_name}' FAILED"
- elsif pending_fixed?
- "'#{@example_name}' FIXED"
- else
- "#{@exception.class.name} in '#{@example_name}'"
- end
- end
-
- def pending_fixed?
- @exception.is_a?(Spec::Example::PendingExampleFixedError)
- end
-
- def expectation_not_met?
- @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
- end
-
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Runner
- # Parses a spec file and finds the nearest example for a given line number.
- class SpecParser
- def spec_name_for(io, line_number)
- source = io.read
- example_group, example_group_line = example_group_at_line(source, line_number)
- example, example_line = example_at_line(source, line_number)
- if example_group && example && (example_group_line < example_line)
- "#{example_group} #{example}"
- elsif example_group
- example_group
- else
- nil
- end
- end
-
- protected
-
- def example_group_at_line(source, line_number)
- find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
- end
-
- def example_at_line(source, line_number)
- find_above(source, line_number, /^\s*(specify|it)\s+(.*)\s+do/)
- end
-
- # Returns the context/describe or specify/it name and the line number
- def find_above(source, line_number, pattern)
- lines_above_reversed(source, line_number).each_with_index do |line, n|
- return [parse_description($2), line_number-n] if line =~ pattern
- end
- nil
- end
-
- def lines_above_reversed(source, line_number)
- lines = source.split("\n")
- lines[0...line_number].reverse
- end
-
- def parse_description(str)
- return str[1..-2] if str =~ /^['"].*['"]$/
- if matches = /^['"](.*)['"](,.*)?$/.match(str)
- return ::Spec::Example::ExampleGroupMethods.description_text(matches[1])
- end
- if matches = /^(.*)\s*,\s*['"](.*)['"](,.*)?$/.match(str)
- return ::Spec::Example::ExampleGroupMethods.description_text(matches[1], matches[2])
- end
- return str
- end
- end
- end
-end
+++ /dev/null
-require 'spec'
-require 'spec/story/extensions'
-require 'spec/story/given_scenario'
-require 'spec/story/runner'
-require 'spec/story/scenario'
-require 'spec/story/step'
-require 'spec/story/step_group'
-require 'spec/story/step_mother'
-require 'spec/story/story'
-require 'spec/story/world'
+++ /dev/null
-require 'spec/story/extensions/main'
-require 'spec/story/extensions/string'
-require 'spec/story/extensions/regexp'
+++ /dev/null
-module Spec
- module Story
- module Extensions
- module Main
- def Story(title, narrative, params = {}, &body)
- ::Spec::Story::Runner.story_runner.Story(title, narrative, params, &body)
- end
-
- # Calling this deprecated is silly, since it hasn't been released yet. But, for
- # those who are reading this - this will be deleted before the 1.1 release.
- def run_story(*args, &block)
- runner = Spec::Story::Runner::PlainTextStoryRunner.new(*args)
- runner.instance_eval(&block) if block
- runner.run
- end
-
- # Creates (or appends to an existing) a namespaced group of steps for use in Stories
- #
- # == Examples
- #
- # # Creating a new group
- # steps_for :forms do
- # When("user enters $value in the $field field") do ... end
- # When("user submits the $form form") do ... end
- # end
- def steps_for(tag, &block)
- steps = rspec_story_steps[tag]
- steps.instance_eval(&block) if block
- steps
- end
-
- # Creates a context for running a Plain Text Story with specific groups of Steps.
- # Also supports adding arbitrary steps that will only be accessible to
- # the Story being run.
- #
- # == Examples
- #
- # # Run a Story with one group of steps
- # with_steps_for :checking_accounts do
- # run File.dirname(__FILE__) + "/withdraw_cash"
- # end
- #
- # # Run a Story, adding steps that are only available for this Story
- # with_steps_for :accounts do
- # Given "user is logged in as account administrator"
- # run File.dirname(__FILE__) + "/reconcile_accounts"
- # end
- #
- # # Run a Story with steps from two groups
- # with_steps_for :checking_accounts, :savings_accounts do
- # run File.dirname(__FILE__) + "/transfer_money"
- # end
- #
- # # Run a Story with a specific Story extension
- # with_steps_for :login, :navigation do
- # run File.dirname(__FILE__) + "/user_changes_password", :type => RailsStory
- # end
- def with_steps_for(*tags, &block)
- steps = Spec::Story::StepGroup.new do
- extend StoryRunnerStepGroupAdapter
- end
- tags.each {|tag| steps << rspec_story_steps[tag]}
- steps.instance_eval(&block) if block
- steps
- end
-
- private
-
- module StoryRunnerStepGroupAdapter
- def run(path, options={})
- runner = Spec::Story::Runner::PlainTextStoryRunner.new(path, options)
- runner.steps << self
- runner.run
- end
- end
-
- def rspec_story_steps # :nodoc:
- $rspec_story_steps ||= Spec::Story::StepGroupHash.new
- end
-
- end
- end
- end
-end
-
-include Spec::Story::Extensions::Main
\ No newline at end of file
+++ /dev/null
-class Regexp
- def step_name
- self.source
- end
-
- def arg_regexp
- ::Spec::Story::Step::PARAM_OR_GROUP_PATTERN
- end
-end
\ No newline at end of file
+++ /dev/null
-class String
- def step_name
- self
- end
-
- def arg_regexp
- ::Spec::Story::Step::PARAM_PATTERN
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Story
- class GivenScenario
- def initialize(name)
- @name = name
- end
-
- def perform(instance, ignore_name)
- scenario = Runner::StoryRunner.scenario_from_current_story(@name)
- Runner::ScenarioRunner.new.run(scenario, instance)
- end
- end
- end
-end
+++ /dev/null
-require 'spec/story/runner/scenario_collector.rb'
-require 'spec/story/runner/scenario_runner.rb'
-require 'spec/story/runner/story_runner.rb'
-require 'spec/story/runner/story_parser.rb'
-require 'spec/story/runner/story_mediator.rb'
-require 'spec/story/runner/plain_text_story_runner.rb'
-
-module Spec
- module Story
- module Runner
- class << self
- def run_options # :nodoc:
- @run_options ||= ::Spec::Runner::OptionParser.parse(ARGV, $stderr, $stdout)
- end
-
- def story_runner # :nodoc:
- unless @story_runner
- @story_runner = StoryRunner.new(scenario_runner, world_creator)
- run_options.story_formatters.each do |formatter|
- register_listener(formatter)
- end
- Runner.register_exit_hook
- end
- @story_runner
- end
-
- def scenario_runner # :nodoc:
- @scenario_runner ||= ScenarioRunner.new
- end
-
- def world_creator # :nodoc:
- @world_creator ||= World
- end
-
- # Use this to register a customer output formatter.
- def register_listener(listener)
- story_runner.add_listener(listener) # run_started, story_started, story_ended, #run_ended
- world_creator.add_listener(listener) # found_scenario, step_succeeded, step_failed, step_failed
- scenario_runner.add_listener(listener) # scenario_started, scenario_succeeded, scenario_pending, scenario_failed
- end
-
- def register_exit_hook # :nodoc:
- # TODO - when story runner uses test/unit runners like example runner does we can kill
- # this and also the assorted Kernel.stub!(:at_exit) in examples
- at_exit do
- Runner.story_runner.run_stories unless $!
- end
- # TODO exit with non-zero status if run fails
- end
-
- def dry_run
- run_options.dry_run
- end
-
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- module Runner
- class PlainTextStoryRunner
- # You can initialize a PlainTextStoryRunner with the path to the
- # story file or a block, in which you can define the path using load.
- #
- # == Examples
- #
- # PlainTextStoryRunner.new('path/to/file')
- #
- # PlainTextStoryRunner.new do |runner|
- # runner.load 'path/to/file'
- # end
- def initialize(*args)
- @options = Hash === args.last ? args.pop : {}
- @story_file = args.empty? ? nil : args.shift
- yield self if block_given?
- end
-
- def []=(key, value)
- @options[key] = value
- end
-
- def load(path)
- @story_file = path
- end
-
- def run
- raise "You must set a path to the file with the story. See the RDoc." if @story_file.nil?
- mediator = Spec::Story::Runner::StoryMediator.new(steps, Spec::Story::Runner.story_runner, @options)
- parser = Spec::Story::Runner::StoryParser.new(mediator)
-
- story_text = File.read(@story_file)
- parser.parse(story_text.split("\n"))
-
- mediator.run_stories
- end
-
- def steps
- @step_group ||= Spec::Story::StepGroup.new
- yield @step_group if block_given?
- @step_group
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- module Runner
- class ScenarioCollector
- attr_accessor :scenarios
-
- def initialize(story)
- @story = story
- @scenarios = []
- end
-
- def Scenario(name, &body)
- @scenarios << Scenario.new(@story, name, &body)
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- module Runner
- class ScenarioRunner
- def initialize
- @listeners = []
- end
-
- def run(scenario, world)
- @listeners.each { |l| l.scenario_started(scenario.story.title, scenario.name) }
- run_story_ignoring_scenarios(scenario.story, world)
-
- world.start_collecting_errors
- world.instance_eval(&scenario.body)
- if world.errors.empty?
- @listeners.each { |l| l.scenario_succeeded(scenario.story.title, scenario.name) }
- else
- if Spec::Example::ExamplePendingError === (e = world.errors.first)
- @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, e.message) }
- else
- @listeners.each { |l| l.scenario_failed(scenario.story.title, scenario.name, e) }
- end
- end
- end
-
- def add_listener(listener)
- @listeners << listener
- end
-
- private
-
- def run_story_ignoring_scenarios(story, world)
- class << world
- def Scenario(name, &block)
- # do nothing
- end
- end
- story.run_in(world)
- class << world
- remove_method(:Scenario)
- end
- end
- end
- end
- end
-end
+++ /dev/null
- module Spec
- module Story
- module Runner
-
- class StoryMediator
- def initialize(step_group, runner, options={})
- @step_group = step_group
- @stories = []
- @runner = runner
- @options = options
- end
-
- def stories
- @stories.collect { |p| p.to_proc }
- end
-
- def create_story(title, narrative)
- @stories << Story.new(title, narrative, @step_group, @options)
- end
-
- def create_scenario(title)
- current_story.add_scenario Scenario.new(title)
- end
-
- def create_given(name)
- current_scenario.add_step Step.new('Given', name)
- end
-
- def create_given_scenario(name)
- current_scenario.add_step Step.new('GivenScenario', name)
- end
-
- def create_when(name)
- current_scenario.add_step Step.new('When', name)
- end
-
- def create_then(name)
- current_scenario.add_step Step.new('Then', name)
- end
-
- def run_stories
- stories.each { |story| @runner.instance_eval(&story) }
- end
-
- private
- def current_story
- @stories.last
- end
-
- def current_scenario
- current_story.current_scenario
- end
-
- class Story
- def initialize(title, narrative, step_group, options)
- @title = title
- @narrative = narrative
- @scenarios = []
- @step_group = step_group
- @options = options
- end
-
- def to_proc
- title = @title
- narrative = @narrative
- scenarios = @scenarios.collect { |scenario| scenario.to_proc }
- options = @options.merge(:steps => @step_group)
- lambda do
- Story title, narrative, options do
- scenarios.each { |scenario| instance_eval(&scenario) }
- end
- end
- end
-
- def add_scenario(scenario)
- @scenarios << scenario
- end
-
- def current_scenario
- @scenarios.last
- end
- end
-
- class Scenario
- def initialize(name)
- @name = name
- @steps = []
- end
-
- def to_proc
- name = @name
- steps = @steps.collect { |step| step.to_proc }
- lambda do
- Scenario name do
- steps.each { |step| instance_eval(&step) }
- end
- end
- end
-
- def add_step(step)
- @steps << step
- end
- end
-
- class Step
- def initialize(type, name)
- @type = type
- @name = name
- end
-
- def to_proc
- type = @type
- name = @name
- lambda do
- send(type, name)
- end
- end
- end
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- module Runner
-
- class IllegalStepError < StandardError
- def initialize(state, event)
- super("Illegal attempt to create a #{event} after a #{state}")
- end
- end
-
- class StoryParser
- def initialize(story_mediator)
- @story_mediator = story_mediator
- @current_story_lines = []
- transition_to(:starting_state)
- end
-
- def parse(lines)
- lines.reject! {|line| line == ""}
- until lines.empty?
- process_line(lines.shift)
- end
- @state.eof
- end
-
- def process_line(line)
- line.strip!
- case line
- when /^Story: / then @state.story(line)
- when /^Scenario: / then @state.scenario(line)
- when /^Given:? / then @state.given(line)
- when /^GivenScenario:? / then @state.given_scenario(line)
- when /^When:? / then @state.event(line)
- when /^Then:? / then @state.outcome(line)
- when /^And:? / then @state.one_more_of_the_same(line)
- else @state.other(line)
- end
- end
-
- def init_story(title)
- @current_story_lines.clear
- add_story_line(title)
- end
-
- def add_story_line(line)
- @current_story_lines << line
- end
-
- def create_story()
- unless @current_story_lines.empty?
- @story_mediator.create_story(@current_story_lines[0].gsub("Story: ",""), @current_story_lines[1..-1].join("\n"))
- @current_story_lines.clear
- end
- end
-
- def create_scenario(title)
- @story_mediator.create_scenario(title.gsub("Scenario: ",""))
- end
-
- def create_given(name)
- @story_mediator.create_given(name)
- end
-
- def create_given_scenario(name)
- @story_mediator.create_given_scenario(name)
- end
-
- def create_when(name)
- @story_mediator.create_when(name)
- end
-
- def create_then(name)
- @story_mediator.create_then(name)
- end
-
- def transition_to(key)
- @state = states[key]
- end
-
- def states
- @states ||= {
- :starting_state => StartingState.new(self),
- :story_state => StoryState.new(self),
- :scenario_state => ScenarioState.new(self),
- :given_state => GivenState.new(self),
- :when_state => WhenState.new(self),
- :then_state => ThenState.new(self)
- }
- end
-
- class State
- def initialize(parser)
- @parser = parser
- end
-
- def story(line)
- @parser.init_story(line)
- @parser.transition_to(:story_state)
- end
-
- def scenario(line)
- @parser.create_scenario(line)
- @parser.transition_to(:scenario_state)
- end
-
- def given(line)
- @parser.create_given(remove_tag_from(:given, line))
- @parser.transition_to(:given_state)
- end
-
- def given_scenario(line)
- @parser.create_given_scenario(remove_tag_from(:givenscenario, line))
- @parser.transition_to(:given_state)
- end
-
- def event(line)
- @parser.create_when(remove_tag_from(:when, line))
- @parser.transition_to(:when_state)
- end
-
- def outcome(line)
- @parser.create_then(remove_tag_from(:then, line))
- @parser.transition_to(:then_state)
- end
-
- def remove_tag_from(tag, line)
- tokens = line.split
- # validation of tag can go here
- tokens[0].downcase.match(/#{tag.to_s}:?/) ?
- (tokens[1..-1].join(' ')) : line
- end
-
- def eof
- end
-
- def other(line)
- # no-op - supports header text before the first story in a file
- end
- end
-
- class StartingState < State
- def initialize(parser)
- @parser = parser
- end
- end
-
- class StoryState < State
- def one_more_of_the_same(line)
- other(line)
- end
-
- def story(line)
- @parser.create_story
- @parser.add_story_line(line)
- end
-
- def scenario(line)
- @parser.create_story
- @parser.create_scenario(line)
- @parser.transition_to(:scenario_state)
- end
-
- def given(line)
- other(line)
- end
-
- def event(line)
- other(line)
- end
-
- def outcome(line)
- other(line)
- end
-
- def other(line)
- @parser.add_story_line(line)
- end
-
- def eof
- @parser.create_story
- end
- end
-
- class ScenarioState < State
- def one_more_of_the_same(line)
- raise IllegalStepError.new("Scenario", "And")
- end
-
- def scenario(line)
- @parser.create_scenario(line)
- end
- end
-
- class GivenState < State
- def one_more_of_the_same(line)
- @parser.create_given(remove_tag_from(:and, line))
- end
-
- def given(line)
- @parser.create_given(remove_tag_from(:given, line))
- end
- end
-
- class WhenState < State
- def one_more_of_the_same(line)
- @parser.create_when(remove_tag_from(:and ,line))
- end
-
- def event(line)
- @parser.create_when(remove_tag_from(:when ,line))
- end
- end
-
- class ThenState < State
- def one_more_of_the_same(line)
- @parser.create_then(remove_tag_from(:and ,line))
- end
-
- def outcome(line)
- @parser.create_then(remove_tag_from(:then ,line))
- end
- end
-
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- module Runner
- class StoryRunner
- class << self
- attr_accessor :current_story_runner
-
- def scenario_from_current_story(scenario_name)
- current_story_runner.scenario_from_current_story(scenario_name)
- end
- end
-
- attr_accessor :stories, :scenarios, :current_story
-
- def initialize(scenario_runner, world_creator = World)
- StoryRunner.current_story_runner = self
- @scenario_runner = scenario_runner
- @world_creator = world_creator
- @stories = []
- @scenarios_by_story = {}
- @scenarios = []
- @listeners = []
- end
-
- def Story(title, narrative, params = {}, &body)
- story = Story.new(title, narrative, params, &body)
- @stories << story
-
- # collect scenarios
- collector = ScenarioCollector.new(story)
- story.run_in(collector)
- @scenarios += collector.scenarios
- @scenarios_by_story[story.title] = collector.scenarios
- end
-
- def run_stories
- return if @stories.empty?
- @listeners.each { |l| l.run_started(scenarios.size) }
- @stories.each do |story|
- story.assign_steps_to(World)
- @current_story = story
- @listeners.each { |l| l.story_started(story.title, story.narrative) }
- scenarios = @scenarios_by_story[story.title]
- scenarios.each do |scenario|
- type = story[:type] || Object
- args = story[:args] || []
- world = @world_creator.create(type, *args)
- @scenario_runner.run(scenario, world)
- end
- @listeners.each { |l| l.story_ended(story.title, story.narrative) }
- World.step_mother.clear
- end
- unique_steps = (World.step_names.collect {|n| Regexp === n ? n.source : n.to_s}).uniq.sort
- @listeners.each { |l| l.collected_steps(unique_steps) }
- @listeners.each { |l| l.run_ended }
- end
-
- def add_listener(listener)
- @listeners << listener
- end
-
- def scenario_from_current_story(scenario_name)
- @scenarios_by_story[@current_story.title].find {|s| s.name == scenario_name }
- end
- end
- end
- end
-end
+++ /dev/null
-
-module Spec
- module Story
- class Scenario
- attr_accessor :name, :body, :story
-
- def initialize(story, name, &body)
- @story = story
- @name = name
- @body = body
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- class Step
- PARAM_PATTERN = /(\$\w*)/
- PARAM_OR_GROUP_PATTERN = /(\$\w*)|\(.*?\)/
-
- attr_reader :name
- def initialize(name, &block)
- @name = name
- assign_expression(name)
- init_module(name, &block)
- end
-
- def perform(instance, *args)
- instance.extend(@mod)
- instance.__send__(sanitize(@name), *args)
- end
-
- def init_module(name, &block)
- sanitized_name = sanitize(name)
- @mod = Module.new do
- define_method(sanitized_name, &block)
- end
- end
-
- def sanitize(a_string_or_regexp)
- return a_string_or_regexp.source if Regexp == a_string_or_regexp
- a_string_or_regexp.to_s
- end
-
-
- def matches?(name)
- !(matches = name.match(@expression)).nil?
- end
-
- def parse_args(name)
- name.match(@expression)[1..-1]
- end
-
- private
-
- def assign_expression(name)
- expression = name.dup
- if String === expression
- expression.gsub! '(', '\('
- expression.gsub! ')', '\)'
- while expression =~ PARAM_PATTERN
- expression.gsub!($1, "(.*?)")
- end
- end
- @expression = Regexp.new("^#{expression}$")
- end
-
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-module Spec
- module Story
-
- class StepGroupHash < Hash
- def initialize
- super do |h,k|
- h[k] = Spec::Story::StepGroup.new
- end
- end
- end
-
- class StepGroup
- def self.steps(&block)
- @step_group ||= StepGroup.new(false)
- @step_group.instance_eval(&block) if block
- @step_group
- end
-
- def initialize(init_defaults=true, &block)
- @hash_of_lists_of_steps = Hash.new {|h, k| h[k] = []}
- if init_defaults
- self.class.steps.add_to(self)
- end
- instance_eval(&block) if block
- end
-
- def find(type, name)
- @hash_of_lists_of_steps[type].each do |step|
- return step if step.matches?(name)
- end
- return nil
- end
-
- def GivenScenario(name, &block)
- create_matcher(:given_scenario, name, &block)
- end
-
- def Given(name, &block)
- create_matcher(:given, name, &block)
- end
-
- def When(name, &block)
- create_matcher(:when, name, &block)
- end
-
- def Then(name, &block)
- create_matcher(:then, name, &block)
- end
-
- alias :given_scenario :GivenScenario
- alias :given :Given
- alias :when :When
- alias :then :Then
-
- def add(type, steps)
- (@hash_of_lists_of_steps[type] << steps).flatten!
- end
-
- def clear
- @hash_of_lists_of_steps.clear
- end
-
- def empty?
- [:given_scenario, :given, :when, :then].each do |type|
- return false unless @hash_of_lists_of_steps[type].empty?
- end
- return true
- end
-
- def add_to(other_step_matchers)
- [:given_scenario, :given, :when, :then].each do |type|
- other_step_matchers.add(type, @hash_of_lists_of_steps[type])
- end
- end
-
- def <<(other_step_matchers)
- other_step_matchers.add_to(self) if other_step_matchers.respond_to?(:add_to)
- end
-
- # TODO - make me private
- def create_matcher(type, name, &block)
- matcher = Step.new(name, &block)
- @hash_of_lists_of_steps[type] << matcher
- matcher
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- class StepMother
- def initialize
- @steps = StepGroup.new
- end
-
- def use(new_step_group)
- @steps << new_step_group
- end
-
- def store(type, step)
- @steps.add(type, step)
- end
-
- def find(type, name)
- if @steps.find(type, name).nil?
- @steps.add(type,
- Step.new(name) do
- raise Spec::Example::ExamplePendingError.new("Unimplemented step: #{name}")
- end
- )
- end
- @steps.find(type, name)
- end
-
- def clear
- @steps.clear
- end
-
- def empty?
- @steps.empty?
- end
-
- end
- end
-end
+++ /dev/null
-module Spec
- module Story
- class Story
- attr_reader :title, :narrative
-
- def initialize(title, narrative, params = {}, &body)
- @body = body
- @title = title
- @narrative = narrative
- @params = params
- end
-
- def [](key)
- @params[key]
- end
-
- def run_in(obj)
- obj.instance_eval(&@body)
- end
-
- def assign_steps_to(assignee)
- if @params[:steps]
- assignee.use(@params[:steps])
- else
- case keys = @params[:steps_for]
- when Symbol
- keys = [keys]
- when nil
- keys = []
- end
- keys.each do |key|
- assignee.use(steps_for(key))
- end
- end
- end
-
- def steps_for(key)
- $rspec_story_steps[key]
- end
- end
- end
-end
+++ /dev/null
-require 'rubygems'
-require 'spec/expectations'
-require 'spec/matchers'
-require 'spec/example/pending'
-
-module Spec
- module Story
-=begin
- A World represents the actual instance a scenario will run in.
-
- The runner ensures any instance variables and methods defined anywhere
- in a story block are available to all the scenarios. This includes
- variables that are created or referenced inside Given, When and Then
- blocks.
-=end
- module World
- include ::Spec::Example::Pending
- include ::Spec::Matchers
- # store steps and listeners in the singleton metaclass.
- # This serves both to keep them out of the way of runtime Worlds
- # and to make them available to all instances.
- class << self
- def create(cls = Object, *args)
- cls.new(*args).extend(World)
- end
-
- def listeners
- @listeners ||= []
- end
-
- def add_listener(listener)
- listeners() << listener
- end
-
- def step_mother
- @step_mother ||= StepMother.new
- end
-
- def use(steps)
- step_mother.use(steps)
- end
-
- def step_names
- @step_names ||= []
- end
-
- def run_given_scenario_with_suspended_listeners(world, type, name, scenario)
- current_listeners = Array.new(listeners)
- begin
- listeners.each { |l| l.found_scenario(type, name) }
- @listeners.clear
- scenario.perform(world, name) unless ::Spec::Story::Runner.dry_run
- ensure
- @listeners.replace(current_listeners)
- end
- end
-
- def store_and_call(world, type, name, *args, &block)
- if block_given?
- step_mother.store(type, Step.new(name, &block))
- end
- step = step_mother.find(type, name)
-
- step_name = step.name
- step_names << step_name
-
- # It's important to have access to the parsed args here, so
- # we can give them to the listeners. The HTML reporter needs
- # the args so it can style them. See the generated output in
- # story_server/prototype/rspec_stories.html (generated by rake stories)
- args = step.parse_args(name) if args.empty?
- begin
- step.perform(world, *args) unless ::Spec::Story::Runner.dry_run
- listeners.each { |l| l.step_succeeded(type, step_name, *args) }
- rescue Exception => e
- case e
- when Spec::Example::ExamplePendingError
- @listeners.each { |l| l.step_pending(type, step_name, *args) }
- else
- @listeners.each { |l| l.step_failed(type, step_name, *args) }
- end
- errors << e
- end
- end
-
- def errors
- @errors ||= []
- end
- end # end of class << self
-
- def start_collecting_errors
- errors.clear
- end
-
- def errors
- World.errors
- end
-
- def GivenScenario(name)
- World.run_given_scenario_with_suspended_listeners(self, :'given scenario', name, GivenScenario.new(name))
- @__previous_step = :given
- end
-
- def Given(name, *args, &block)
- World.store_and_call self, :given, name, *args, &block
- @__previous_step = :given
- end
-
- def When(name, *args, &block)
- World.store_and_call self, :when, name, *args, &block
- @__previous_step = :when
- end
-
- def Then(name, *args, &block)
- World.store_and_call self, :then, name, *args, &block
- @__previous_step = :then
- end
-
- def And(name, *args, &block)
- World.store_and_call self, @__previous_step, name, *args, &block
- end
- end
- end
-end
+++ /dev/null
-require 'fileutils'
-
-module Spec
- class Translator
- def translate(from, to)
- from = File.expand_path(from)
- to = File.expand_path(to)
- if File.directory?(from)
- translate_dir(from, to)
- elsif(from =~ /\.rb$/)
- translate_file(from, to)
- end
- end
-
- def translate_dir(from, to)
- FileUtils.mkdir_p(to) unless File.directory?(to)
- Dir["#{from}/*"].each do |sub_from|
- path = sub_from[from.length+1..-1]
- sub_to = File.join(to, path)
- translate(sub_from, sub_to)
- end
- end
-
- def translate_file(from, to)
- translation = ""
- File.open(from) do |io|
- io.each_line do |line|
- translation << translate_line(line)
- end
- end
- File.open(to, "w") do |io|
- io.write(translation)
- end
- end
-
- def translate_line(line)
- # Translate deprecated mock constraints
- line.gsub!(/:any_args/, 'any_args')
- line.gsub!(/:anything/, 'anything')
- line.gsub!(/:boolean/, 'boolean')
- line.gsub!(/:no_args/, 'no_args')
- line.gsub!(/:numeric/, 'an_instance_of(Numeric)')
- line.gsub!(/:string/, 'an_instance_of(String)')
-
- return line if line =~ /(should_not|should)_receive/
-
- line.gsub!(/(^\s*)context([\s*|\(]['|"|A-Z])/, '\1describe\2')
- line.gsub!(/(^\s*)specify([\s*|\(]['|"|A-Z])/, '\1it\2')
- line.gsub!(/(^\s*)context_setup(\s*[do|\{])/, '\1before(:all)\2')
- line.gsub!(/(^\s*)context_teardown(\s*[do|\{])/, '\1after(:all)\2')
- line.gsub!(/(^\s*)setup(\s*[do|\{])/, '\1before(:each)\2')
- line.gsub!(/(^\s*)teardown(\s*[do|\{])/, '\1after(:each)\2')
-
- if line =~ /(.*\.)(should_not|should)(?:_be)(?!_)(.*)/m
- pre = $1
- should = $2
- post = $3
- be_or_equal = post =~ /(<|>)/ ? "be" : "equal"
-
- return "#{pre}#{should} #{be_or_equal}#{post}"
- end
-
- if line =~ /(.*\.)(should_not|should)_(?!not)\s*(.*)/m
- pre = $1
- should = $2
- post = $3
-
- post.gsub!(/^raise/, 'raise_error')
- post.gsub!(/^throw/, 'throw_symbol')
-
- unless standard_matcher?(post)
- post = "be_#{post}"
- end
-
- # Add parenthesis
- post.gsub!(/^(\w+)\s+([\w|\.|\,|\(.*\)|\'|\"|\:|@| ]+)(\})/, '\1(\2)\3') # inside a block
- post.gsub!(/^(redirect_to)\s+(.*)/, '\1(\2)') # redirect_to, which often has http:
- post.gsub!(/^(\w+)\s+([\w|\.|\,|\(.*\)|\{.*\}|\'|\"|\:|@| ]+)/, '\1(\2)')
- post.gsub!(/(\s+\))/, ')')
- post.gsub!(/\)\}/, ') }')
- post.gsub!(/^(\w+)\s+(\/.*\/)/, '\1(\2)') #regexps
- line = "#{pre}#{should} #{post}"
- end
-
- line
- end
-
- def standard_matcher?(matcher)
- patterns = [
- /^be/,
- /^be_close/,
- /^eql/,
- /^equal/,
- /^has/,
- /^have/,
- /^change/,
- /^include/,
- /^match/,
- /^raise_error/,
- /^respond_to/,
- /^redirect_to/,
- /^satisfy/,
- /^throw_symbol/,
- # Extra ones that we use in spec_helper
- /^pass/,
- /^fail/,
- /^fail_with/,
- ]
- matched = patterns.detect{ |p| matcher =~ p }
- !matched.nil?
- end
-
- end
-end
+++ /dev/null
-module Spec
- module VERSION
- unless defined? MAJOR
- MAJOR = 1
- MINOR = 1
- TINY = 2
- RELEASE_CANDIDATE = nil
-
- BUILD_TIME_UTC = 20080114022430
-
- STRING = [MAJOR, MINOR, TINY].join('.')
- TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_')
- FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (build #{BUILD_TIME_UTC})"
-
- NAME = "RSpec"
- URL = "http://rspec.rubyforge.org/"
-
- DESCRIPTION = "#{NAME}-#{FULL_VERSION} - BDD for Ruby\n#{URL}"
- end
- end
-end
-
+++ /dev/null
-#!/usr/bin/env ruby
-#
-# Created by Jim Weirich on 2007-04-10.
-# Copyright (c) 2007. All rights reserved.
-
-require 'flexmock/rspec'
-
-module Spec
- module Plugins
- module MockFramework
- include FlexMock::MockContainer
- def setup_mocks_for_rspec
- # No setup required
- end
- def verify_mocks_for_rspec
- flexmock_verify
- end
- def teardown_mocks_for_rspec
- flexmock_close
- end
- end
- end
-end
+++ /dev/null
-require 'mocha/standalone'
-require 'mocha/object'
-
-module Spec
- module Plugins
- module MockFramework
- include Mocha::Standalone
- def setup_mocks_for_rspec
- mocha_setup
- end
- def verify_mocks_for_rspec
- mocha_verify
- end
- def teardown_mocks_for_rspec
- mocha_teardown
- end
- end
- end
-end
+++ /dev/null
-require 'rr'
-
-patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
-patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-
-module Spec
- module Plugins
- module MockFramework
- include RR::Extensions::InstanceMethods
- def setup_mocks_for_rspec
- RR::Space.instance.reset
- end
- def verify_mocks_for_rspec
- RR::Space.instance.verify_doubles
- end
- def teardown_mocks_for_rspec
- RR::Space.instance.reset
- end
- end
- end
-end
+++ /dev/null
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "spec", "mocks"))
-
-module Spec
- module Plugins
- module MockFramework
- include Spec::Mocks::ExampleMethods
- def setup_mocks_for_rspec
- $rspec_mocks ||= Spec::Mocks::Space.new
- end
- def verify_mocks_for_rspec
- $rspec_mocks.verify_all
- end
- def teardown_mocks_for_rspec
- $rspec_mocks.reset_all
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + "/../autotest_helper"
-
-module DiscoveryHelper
- def load_discovery
- require File.dirname(__FILE__) + "/../../lib/autotest/discover"
- end
-end
-
-
-class Autotest
- describe Rspec, "discovery" do
- include DiscoveryHelper
-
- it "should add the rspec autotest plugin" do
- Autotest.should_receive(:add_discovery).and_yield
- load_discovery
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + "/../autotest_helper"
-
-class Autotest
-
- module AutotestHelper
- def rspec_output
- <<-HERE
-.............PPF
-
-1)
-'false should be false' FAILED
-expected: true,
- got: false (using ==)
-./spec/autotest/rspec_spec.rb:203:
-
-Finished in 0.158674 seconds
-
-16 examples, 1 failure, 2 pending
-
-Pending:
-Autotest::Rspec handling failed results should return an array of failed examples and errors (TODO)
-Autotest::Rspec tests/specs for a given file should find all the specs for a given file (TODO)
-HERE
- end
-
-
- def common_setup
- @proc = mock Proc
- @kernel = mock Kernel
- @kernel.stub!(:proc).and_return @proc
-
- File.stub!(:exists).and_return true
- @windows_alt_separator = "\\"
- @posix_separator = '/'
-
- @rspec_output = rspec_output
- end
- end
-
- describe Rspec, "rspec_commands" do
- it "should contain the various commands, ordered by preference" do
- Rspec.new.spec_commands.should == [
- File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec"),
- "#{Config::CONFIG['bindir']}/spec"
- ]
- end
- end
-
- describe Rspec, "selection of rspec command" do
- include AutotestHelper
-
- before :each do
- common_setup
- @rspec_autotest = Rspec.new
- end
-
- it "should try to find the spec command if it exists in ./bin and use it above everything else" do
- File.stub!(:exists?).and_return true
-
- spec_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
- File.should_receive(:exists?).with(spec_path).and_return true
- @rspec_autotest.spec_command.should == spec_path
- end
-
- it "should otherwise select the default spec command in gem_dir/bin/spec" do
- @rspec_autotest.stub!(:spec_commands).and_return ["/foo/spec"]
- Config::CONFIG.stub!(:[]).and_return "/foo"
- File.should_receive(:exists?).with("/foo/spec").and_return(true)
-
- @rspec_autotest.spec_command.should == "/foo/spec"
- end
-
- it "should raise an error if no spec command is found at all" do
- File.stub!(:exists?).and_return false
-
- lambda {
- @rspec_autotest.spec_command
- }.should raise_error(RspecCommandError, "No spec command could be found!")
- end
-
- end
-
- describe Rspec, "selection of rspec command (windows compatibility issues)" do
- include AutotestHelper
-
- before :each do
- common_setup
- end
-
- it "should use the ALT_SEPARATOR if it is non-nil" do
- pending("autotest got re-worked so this is failing for the moment")
- @rspec_autotest = Rspec.new
- spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
- @rspec_autotest.stub!(:spec_commands).and_return [spec_command]
- @rspec_autotest.spec_command.should == spec_command.gsub('/', '\\')
- end
-
- it "should not use the ALT_SEPATOR if it is nil" do
- @windows_alt_separator = nil
- @rspec_autotest = Rspec.new
- spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
- @rspec_autotest.stub!(:spec_commands).and_return [spec_command]
- @rspec_autotest.spec_command.should == spec_command
- end
- end
-
- describe Rspec, "adding spec.opts --options" do
- before :each do
- @rspec_autotest = Rspec.new
- end
-
- it "should return the command line option to add spec.opts if the options file exists" do
- File.stub!(:exist?).and_return true
- @rspec_autotest.add_options_if_present.should == "-O spec/spec.opts "
- end
-
- it "should return an empty string if no spec.opts exists" do
- File.stub!(:exist?).and_return false
- Rspec.new.add_options_if_present.should == ""
- end
- end
-
- describe Rspec do
- before :each do
- @rspec_autotest = Rspec.new
- @rspec_autotest.stub!(:ruby).and_return "ruby"
- @rspec_autotest.stub!(:add_options_if_present).and_return "-O spec/spec.opts"
-
- @ruby = @rspec_autotest.ruby
- @spec_command = @rspec_autotest.spec_command
- @options = @rspec_autotest.add_options_if_present
- @files_to_test = {
- :spec => ["file_one", "file_two"]
- }
- # this is not the inner representation of Autotest!
- @rspec_autotest.stub!(:files_to_test).and_return @files_to_test
- @files_to_test.stub!(:keys).and_return @files_to_test[:spec]
- @to_test = @files_to_test.keys.flatten.join ' '
- end
-
- it "should make the apropriate test command" do
- @rspec_autotest.make_test_cmd(@files_to_test).should == "#{@ruby} -S #{@spec_command} #{@options} #{@to_test}"
- end
- end
-
- describe Rspec, "test mappings" do
- before :each do
- @rspec_autotest = Rspec.new
- @rspec_autotest.hook :initialize
- end
-
- it "should map all filenames in spec/ which end in .rb" do
- @rspec_autotest.instance_eval{@test_mappings}.should have_key(%r%^spec/.*\.rb$%)
- end
-
- it "should map all names in lib which end in .rb to the corresponding ones in spec/" do
- @rspec_autotest.instance_eval{@test_mappings}.should have_key(%r%^lib/(.*)\.rb$%)
- end
-
- it "should find all files in spec/shares/* and the spec helper in spec/spec_helper" do
- @rspec_autotest.instance_eval{@test_mappings}.should have_key(%r%^spec/(spec_helper|shared/.*)\.rb$%)
- end
- end
-
- describe Rspec, "handling results" do
- include AutotestHelper
-
- before :each do
- common_setup
- @rspec_autotest = Rspec.new
- @rspec_autotest.stub!(:hook)
-
- @results = mock String
- @results.stub!(:scan).and_return ""
- end
-
- it "should call hook(:red) if there are failures" do
- @rspec_autotest.stub!(:consolidate_failures).and_return ["spec/some_spec.rb"]
-
- @rspec_autotest.should_receive(:hook).with(:red)
- @rspec_autotest.handle_results(@results)
- end
-
- it "should call hook(:green) if there are no failures" do
- @rspec_autotest.stub!(:consolidate_failures).and_return []
- @rspec_autotest.should_receive(:hook).with(:green)
- @rspec_autotest.handle_results(@results)
- end
- end
-
- describe Rspec, "handling failed results" do
- include AutotestHelper
-
- before :each do
- common_setup
- end
-
- it %(should scan the output into a multi-dimensional array,
- consisting of the failing spec's name as the first element,
- and the failure as the second) do
- @rspec_autotest = Rspec.new
- @rspec_autotest.failed_results(@rspec_output).should == [
- [
- "false should be false",
- "expected: true,\n got: false (using ==)\n./spec/autotest/rspec_spec.rb:203:"
- ]
- ]
- end
- end
-
- describe Rspec, "specs for a given file" do
- before :each do
- @lib_file = "lib/something.rb"
- @spec_file = "spec/something_spec.rb"
- @rspec_autotest = Rspec.new
- @rspec_autotest.hook :initialize
-
- @rspec_autotest.instance_variable_set("@files", {@lib_file => Time.now, @spec_file => Time.now})
- @rspec_autotest.stub!(:find_files_to_test).and_return true
- end
-
- it "should find the spec file for a given lib file" do
- @rspec_autotest.specs_for_file(@lib_file).should == [@spec_file]
- end
-
- it "should find the spec file if given a spec file" do
- @rspec_autotest.specs_for_file(@spec_file).should == [@spec_file]
- end
-
- it "should only find the file if the file is being tracked (in @file)" do
- @other_file = "lib/some_non_tracked_file"
- @rspec_autotest.specs_for_file(@other_file).should == []
- end
- end
-
- describe Rspec, "consolidating failures" do
- include AutotestHelper
-
- before :each do
- common_setup
- @rspec_autotest = Rspec.new
-
- @spec_file = "./spec/autotest/rspec_spec.rb"
- @rspec_autotest.instance_variable_set("@files", {@spec_file => Time.now})
- @rspec_autotest.stub!(:find_files_to_test).and_return true
- end
-
- it "should return no failures if no failures were given in the output" do
- @rspec_autotest.stub!(:failed_results).and_return [[]]
- @rspec_autotest.consolidate_failures(@rspec_autotest.failed_results).should == {}
- end
-
- it "should return a hash with the spec filename => spec name for each failure or error" do
- @rspec_autotest.stub!(:failed_results).and_return([
- [
- "false should be false",
- "expected: true,\n got: false (using ==)\n./spec/autotest/rspec_spec.rb:203:"
- ]
- ])
- @rspec_autotest.consolidate_failures(@rspec_autotest.failed_results).should == {@spec_file => ["false should be false"]}
- end
-
- end
-end
+++ /dev/null
-require "rubygems"
-require 'autotest'
-dir = File.dirname(__FILE__)
-require "#{dir}/spec_helper"
-require File.expand_path("#{dir}/../lib/autotest/rspec")
\ No newline at end of file
+++ /dev/null
-if __FILE__ == $0
- dir = File.dirname(__FILE__)
- Dir["#{dir}/**/*_spec.rb"].each do |file|
-# puts "require '#{file}'"
- require file
- end
-end
+++ /dev/null
-require 'rbconfig'
-
-module RubyForker
- # Forks a ruby interpreter with same type as ourself.
- # juby will fork jruby, ruby will fork ruby etc.
- def ruby(args, stderr=nil)
- config = ::Config::CONFIG
- interpreter = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
- cmd = "#{interpreter} #{args}"
- cmd << " 2> #{stderr}" unless stderr.nil?
- `#{cmd}`
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Example
-
- describe Configuration do
- before(:each) do
- @config = Configuration.new
- @example_group = mock("example_group")
- end
-
- describe "#mock_with" do
-
- it "should default mock framework to rspec" do
- @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
- end
-
- it "should let you set rspec mocking explicitly" do
- @config.mock_with(:rspec)
- @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
- end
-
- it "should let you set mocha" do
- @config.mock_with(:mocha)
- @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/
- end
-
- it "should let you set flexmock" do
- @config.mock_with(:flexmock)
- @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/
- end
-
- it "should let you set rr" do
- @config.mock_with(:rr)
- @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/
- end
-
- it "should let you set an arbitrary adapter module" do
- adapter = Module.new
- @config.mock_with(adapter)
- @config.mock_framework.should == adapter
- end
- end
-
- describe "#include" do
-
- before do
- @original_configuration = Spec::Runner.configuration
- spec_configuration = @config
- Spec::Runner.instance_eval {@configuration = spec_configuration}
- @example_group_class = Class.new(ExampleGroup) do
- class << self
- def this_class_has_special_methods
- end
- end
- end
- ExampleGroupFactory.register(:foobar, @example_group_class)
- end
-
- after do
- original_configuration = @original_configuration
- Spec::Runner.instance_eval {@configuration = original_configuration}
- ExampleGroupFactory.reset
- end
-
- it "should include the submitted module in ExampleGroup subclasses" do
- mod = Module.new
- @config.include mod
- Class.new(@example_group_class).included_modules.should include(mod)
- end
-
- it "should let you define modules to be included for a specific type" do
- mod = Module.new
- @config.include mod, :type => :foobar
- Class.new(@example_group_class).included_modules.should include(mod)
- end
-
- it "should not include modules in a type they are not intended for" do
- mod = Module.new
- @other_example_group_class = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:baz, @other_example_group_class)
-
- @config.include mod, :type => :foobar
-
- Class.new(@other_example_group_class).included_modules.should_not include(mod)
- end
-
- end
-
- end
-
- describe Configuration do
-
- before(:each) do
- @config = Configuration.new
- @special_example_group = Class.new(ExampleGroup)
- @special_child_example_group = Class.new(@special_example_group)
- @nonspecial_example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:special, @special_example_group)
- ExampleGroupFactory.register(:special_child, @special_child_example_group)
- ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
- @example_group = @special_child_example_group.describe "Special Example Group"
- @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
- end
-
- after(:each) do
- ExampleGroupFactory.reset
- end
-
- describe "#prepend_before" do
- it "prepends the before block on all instances of the passed in type" do
- order = []
- @config.prepend_before(:all) do
- order << :prepend__before_all
- end
- @config.prepend_before(:all, :type => :special) do
- order << :special_prepend__before_all
- end
- @config.prepend_before(:all, :type => :special_child) do
- order << :special_child_prepend__before_all
- end
- @config.prepend_before(:each) do
- order << :prepend__before_each
- end
- @config.prepend_before(:each, :type => :special) do
- order << :special_prepend__before_each
- end
- @config.prepend_before(:each, :type => :special_child) do
- order << :special_child_prepend__before_each
- end
- @config.prepend_before(:all, :type => :non_special) do
- order << :special_prepend__before_all
- end
- @config.prepend_before(:each, :type => :non_special) do
- order << :special_prepend__before_each
- end
- @example_group.it "calls prepend_before" do
- end
-
- @example_group.run
- order.should == [
- :prepend__before_all,
- :special_prepend__before_all,
- :special_child_prepend__before_all,
- :prepend__before_each,
- :special_prepend__before_each,
- :special_child_prepend__before_each
- ]
- end
- end
-
- describe "#append_before" do
-
- it "calls append_before on the type" do
- order = []
- @config.append_before(:all) do
- order << :append_before_all
- end
- @config.append_before(:all, :type => :special) do
- order << :special_append_before_all
- end
- @config.append_before(:all, :type => :special_child) do
- order << :special_child_append_before_all
- end
- @config.append_before(:each) do
- order << :append_before_each
- end
- @config.append_before(:each, :type => :special) do
- order << :special_append_before_each
- end
- @config.append_before(:each, :type => :special_child) do
- order << :special_child_append_before_each
- end
- @config.append_before(:all, :type => :non_special) do
- order << :special_append_before_all
- end
- @config.append_before(:each, :type => :non_special) do
- order << :special_append_before_each
- end
- @example_group.it "calls append_before" do
- end
-
- @example_group.run
- order.should == [
- :append_before_all,
- :special_append_before_all,
- :special_child_append_before_all,
- :append_before_each,
- :special_append_before_each,
- :special_child_append_before_each
- ]
- end
- end
-
- describe "#prepend_after" do
-
- it "prepends the after block on all instances of the passed in type" do
- order = []
- @config.prepend_after(:all) do
- order << :prepend__after_all
- end
- @config.prepend_after(:all, :type => :special) do
- order << :special_prepend__after_all
- end
- @config.prepend_after(:all, :type => :special) do
- order << :special_child_prepend__after_all
- end
- @config.prepend_after(:each) do
- order << :prepend__after_each
- end
- @config.prepend_after(:each, :type => :special) do
- order << :special_prepend__after_each
- end
- @config.prepend_after(:each, :type => :special) do
- order << :special_child_prepend__after_each
- end
- @config.prepend_after(:all, :type => :non_special) do
- order << :special_prepend__after_all
- end
- @config.prepend_after(:each, :type => :non_special) do
- order << :special_prepend__after_each
- end
- @example_group.it "calls prepend_after" do
- end
-
- @example_group.run
- order.should == [
- :special_child_prepend__after_each,
- :special_prepend__after_each,
- :prepend__after_each,
- :special_child_prepend__after_all,
- :special_prepend__after_all,
- :prepend__after_all
- ]
- end
- end
-
- describe "#append_after" do
-
- it "calls append_after on the type" do
- order = []
- @config.append_after(:all) do
- order << :append__after_all
- end
- @config.append_after(:all, :type => :special) do
- order << :special_append__after_all
- end
- @config.append_after(:all, :type => :special_child) do
- order << :special_child_append__after_all
- end
- @config.append_after(:each) do
- order << :append__after_each
- end
- @config.append_after(:each, :type => :special) do
- order << :special_append__after_each
- end
- @config.append_after(:each, :type => :special_child) do
- order << :special_child_append__after_each
- end
- @config.append_after(:all, :type => :non_special) do
- order << :non_special_append_after_all
- end
- @config.append_after(:each, :type => :non_special) do
- order << :non_special_append_after_each
- end
- @example_group.it "calls append_after" do
- end
-
- @example_group.run
- order.should == [
- :special_child_append__after_each,
- :special_append__after_each,
- :append__after_each,
- :special_child_append__after_all,
- :special_append__after_all,
- :append__after_all
- ]
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- class ExampleGroupSubclass < ExampleGroup
- class << self
- attr_accessor :examples_ran
- end
-
- @@klass_variable_set = true
- CONSTANT = :foobar
-
- before do
- @instance_variable = :hello
- end
-
- it "should run" do
- self.class.examples_ran = true
- end
-
- it "should have access to instance variables" do
- @instance_variable.should == :hello
- end
-
- it "should have access to class variables" do
- @@klass_variable_set.should == true
- end
-
- it "should have access to constants" do
- CONSTANT.should == :foobar
- end
-
- it "should have access to methods defined in the Example Group" do
- a_method.should == 22
- end
-
- def a_method
- 22
- end
- end
-
- describe ExampleGroupSubclass do
- it "should run" do
- ExampleGroupSubclass.examples_ran.should be_true
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- describe ExampleGroupFactory, "with :foobar registered as custom type" do
-
- before do
- @example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:foobar, @example_group)
- end
-
- after do
- ExampleGroupFactory.reset
- end
-
- it "should #get the default ExampleGroup type when passed nil" do
- ExampleGroupFactory.get(nil).should == ExampleGroup
- end
-
- it "should #get the default ExampleGroup for unregistered non-nil values" do
- ExampleGroupFactory.get(:does_not_exist).should == ExampleGroup
- end
-
- it "should #get custom type for :foobar" do
- ExampleGroupFactory.get(:foobar).should == @example_group
- end
-
- it "should #get the actual type when that is passed in" do
- ExampleGroupFactory.get(@example_group).should == @example_group
- end
-
- end
-
- describe ExampleGroupFactory, "#create_example_group" do
- it "should create a uniquely named class" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
- example_group.name.should =~ /Spec::Example::ExampleGroup::Subclass_\d+/
- end
-
- it "should create a Spec::Example::Example subclass by default" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
- example_group.superclass.should == Spec::Example::ExampleGroup
- end
-
- it "should create a Spec::Example::Example when :type => :default" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "example_group", :type => :default
- ) {}
- example_group.superclass.should == Spec::Example::ExampleGroup
- end
-
- it "should create a Spec::Example::Example when :type => :default" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "example_group", :type => :default
- ) {}
- example_group.superclass.should == Spec::Example::ExampleGroup
- end
-
- it "should create specified type when :type => :something_other_than_default" do
- klass = Class.new(ExampleGroup) do
- def initialize(*args, &block); end
- end
- Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass)
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "example_group", :type => :something_other_than_default
- ) {}
- example_group.superclass.should == klass
- end
-
- it "should create a type indicated by :spec_path" do
- klass = Class.new(ExampleGroup) do
- def initialize(*args, &block); end
- end
- Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass)
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "example_group", :spec_path => "./spec/something_other_than_default/some_spec.rb"
- ) {}
- example_group.superclass.should == klass
- end
-
- it "should create a type indicated by :spec_path (with spec_path generated by caller on windows)" do
- klass = Class.new(ExampleGroup) do
- def initialize(*args, &block); end
- end
- Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass)
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "example_group", :spec_path => "./spec\\something_other_than_default\\some_spec.rb"
- ) {}
- example_group.superclass.should == klass
- end
-
- it "should create and register a Spec::Example::Example if :shared => true" do
- shared_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "name", :spec_path => '/blah/spec/models/blah.rb', :type => :controller, :shared => true
- ) {}
- shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
- SharedExampleGroup.shared_example_groups.should include(shared_example_group)
- end
-
- it "should favor the :type over the :spec_path" do
- klass = Class.new(ExampleGroup) do
- def initialize(*args, &block); end
- end
- Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass)
- example_group = Spec::Example::ExampleGroupFactory.create_example_group(
- "name", :spec_path => '/blah/spec/models/blah.rb', :type => :something_other_than_default
- ) {}
- example_group.superclass.should == klass
- end
-
- it "should register ExampleGroup by default" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
- end
- rspec_options.example_groups.should include(example_group)
- end
-
- it "should enable unregistering of ExampleGroups" do
- example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
- unregister
- end
- rspec_options.example_groups.should_not include(example_group)
- end
-
- after(:each) do
- Spec::Example::ExampleGroupFactory.reset
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- describe 'ExampleGroupMethods' do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :example_group, :result, :reporter
- before(:each) do
- options.formatters << mock("formatter", :null_object => true)
- options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
- @reporter = FakeReporter.new(@options)
- options.reporter = reporter
- @example_group = Class.new(ExampleGroup) do
- describe("ExampleGroup")
- it "does nothing"
- end
- class << example_group
- public :include
- end
- @result = nil
- end
-
- after(:each) do
- ExampleGroup.reset
- end
-
- describe "#describe" do
- attr_reader :child_example_group
- before do
- @child_example_group = @example_group.describe("Another ExampleGroup") do
- it "should pass" do
- true.should be_true
- end
- end
- end
-
- it "should create a subclass of the ExampleGroup when passed a block" do
- child_example_group.superclass.should == @example_group
- @options.example_groups.should include(child_example_group)
- end
-
- it "should not inherit examples" do
- child_example_group.examples.length.should == 1
- end
- end
-
- describe "#it" do
- it "should should create an example instance" do
- lambda {
- @example_group.it("")
- }.should change { @example_group.examples.length }.by(1)
- end
- end
-
- describe "#xit" do
- before(:each) do
- Kernel.stub!(:warn)
- end
-
- it "should NOT should create an example instance" do
- lambda {
- @example_group.xit("")
- }.should_not change(@example_group.examples, :length)
- end
-
- it "should warn that it is disabled" do
- Kernel.should_receive(:warn).with("Example disabled: foo")
- @example_group.xit("foo")
- end
- end
-
- describe "#examples" do
- it "should have Examples" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- it "should pass" do
- 1.should == 1
- end
- end
- example_group.examples.length.should == 1
- example_group.examples.first.description.should == "should pass"
- end
-
- it "should not include methods that begin with test (only when TU interop is loaded)" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- def test_any_args(*args)
- true.should be_true
- end
- def test_something
- 1.should == 1
- end
- def test
- raise "This is not a real test"
- end
- def testify
- raise "This is not a real test"
- end
- end
- example_group.examples.length.should == 0
- example_group.run.should be_true
- end
-
- it "should include methods that begin with should and has an arity of 0 in suite" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- def shouldCamelCase
- true.should be_true
- end
- def should_any_args(*args)
- true.should be_true
- end
- def should_something
- 1.should == 1
- end
- def should_not_something
- 1.should_not == 2
- end
- def should
- raise "This is not a real example"
- end
- def should_not
- raise "This is not a real example"
- end
- end
- example_group = example_group.dup
- example_group.examples.length.should == 4
- descriptions = example_group.examples.collect {|example| example.description}.sort
- descriptions.should include("shouldCamelCase")
- descriptions.should include("should_any_args")
- descriptions.should include("should_something")
- descriptions.should include("should_not_something")
- end
-
- it "should not include methods that begin with test_ and has an arity > 0 in suite" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- def test_invalid(foo)
- 1.should == 1
- end
- def testInvalidCamelCase(foo)
- 1.should == 1
- end
- end
- example_group.examples.length.should == 0
- end
-
- it "should not include methods that begin with should_ and has an arity > 0 in suite" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- def should_invalid(foo)
- 1.should == 2
- end
- def shouldInvalidCamelCase(foo)
- 1.should == 3
- end
- def should_not_invalid(foo)
- 1.should == 4
- end
- def should_valid
- 1.should == 1
- end
- end
- example_group.examples.length.should == 1
- example_group.run.should be_true
- end
-
- it "should run should_methods" do
- example_group = Class.new(ExampleGroup) do
- def should_valid
- 1.should == 2
- end
- end
- example_group.examples.length.should == 1
- example_group.run.should be_false
- end
- end
-
- describe "#set_description" do
- attr_reader :example_group
- before do
- class << example_group
- public :set_description
- end
- end
-
- describe "#set_description(String)" do
- before(:each) do
- example_group.set_description("abc")
- end
-
- specify ".description should return the String passed into .set_description" do
- example_group.description.should == "abc"
- end
-
- specify ".described_type should provide nil as its type" do
- example_group.described_type.should be_nil
- end
- end
-
- describe "#set_description(Type)" do
- before(:each) do
- example_group.set_description(ExampleGroup)
- end
-
- specify ".description should return a String representation of that type (fully qualified) as its name" do
- example_group.description.should == "Spec::Example::ExampleGroup"
- end
-
- specify ".described_type should return the passed in type" do
- example_group.described_type.should == Spec::Example::ExampleGroup
- end
- end
-
- describe "#set_description(String, Type)" do
- before(:each) do
- example_group.set_description("behaving", ExampleGroup)
- end
-
- specify ".description should return String then space then Type" do
- example_group.description.should == "behaving Spec::Example::ExampleGroup"
- end
-
- specify ".described_type should return the passed in type" do
- example_group.described_type.should == Spec::Example::ExampleGroup
- end
- end
-
- describe "#set_description(Type, String not starting with a space)" do
- before(:each) do
- example_group.set_description(ExampleGroup, "behaving")
- end
-
- specify ".description should return the Type then space then String" do
- example_group.description.should == "Spec::Example::ExampleGroup behaving"
- end
- end
-
- describe "#set_description(Type, String starting with .)" do
- before(:each) do
- example_group.set_description(ExampleGroup, ".behaving")
- end
-
- specify ".description should return the Type then String" do
- example_group.description.should == "Spec::Example::ExampleGroup.behaving"
- end
- end
-
- describe "#set_description(Type, String containing .)" do
- before(:each) do
- example_group.set_description(ExampleGroup, "calling a.b")
- end
-
- specify ".description should return the Type then space then String" do
- example_group.description.should == "Spec::Example::ExampleGroup calling a.b"
- end
- end
-
- describe "#set_description(Type, String starting with .)" do
- before(:each) do
- example_group.set_description(ExampleGroup, ".behaving")
- end
-
- specify "should return the Type then String" do
- example_group.description.should == "Spec::Example::ExampleGroup.behaving"
- end
- end
-
- describe "#set_description(Type, String containing .)" do
- before(:each) do
- example_group.set_description(ExampleGroup, "is #1")
- end
-
- specify ".description should return the Type then space then String" do
- example_group.description.should == "Spec::Example::ExampleGroup is #1"
- end
- end
-
- describe "#set_description(String, Type, String)" do
- before(:each) do
- example_group.set_description("A", Hash, "with one entry")
- end
-
- specify ".description should return the first String then space then Type then second String" do
- example_group.description.should == "A Hash with one entry"
- end
- end
-
- describe "#set_description(Hash representing options)" do
- before(:each) do
- example_group.set_description(:a => "b", :spec_path => "blah")
- end
-
- it ".spec_path should expand the passed in :spec_path option passed into the constructor" do
- example_group.spec_path.should == File.expand_path("blah")
- end
-
- it ".description_options should return all the options passed in" do
- example_group.description_options.should == {:a => "b", :spec_path => "blah"}
- end
-
- end
- end
-
- describe "#description" do
- it "should return the same description instance for each call" do
- example_group.description.should eql(example_group.description)
- end
-
- it "should not add a space when description_text begins with #" do
- child_example_group = Class.new(example_group) do
- describe("#foobar", "Does something")
- end
- child_example_group.description.should == "ExampleGroup#foobar Does something"
- end
-
- it "should not add a space when description_text begins with ." do
- child_example_group = Class.new(example_group) do
- describe(".foobar", "Does something")
- end
- child_example_group.description.should == "ExampleGroup.foobar Does something"
- end
-
- it "should return the class name if nil" do
- example_group.set_description(nil)
- example_group.description.should =~ /Class:/
- end
-
- it "should return the class name if nil" do
- example_group.set_description("")
- example_group.description.should =~ /Class:/
- end
- end
-
- describe "#description_parts" do
- it "should return an Array of the current class description args" do
- example_group.description_parts.should == [example_group.description]
- end
-
- it "should return an Array of the description args from each class in the hierarchy" do
- child_example_group = Class.new(example_group)
- child_example_group.describe("Child", ExampleGroup)
- child_example_group.description.should_not be_empty
-
- grand_child_example_group = Class.new(child_example_group)
- grand_child_example_group.describe("GrandChild", ExampleGroup)
- grand_child_example_group.description.should_not be_empty
-
- grand_child_example_group.description_parts.should == [
- "ExampleGroup",
- "Child",
- Spec::Example::ExampleGroup,
- "GrandChild",
- Spec::Example::ExampleGroup
- ]
- end
- end
-
- describe "#described_type" do
- it "should return passed in type" do
- child_example_group = Class.new(example_group) do
- describe Object
- end
- child_example_group.described_type.should == Object
- end
-
- it "should return #described_type of superclass when no passed in type" do
- parent_example_group = Class.new(ExampleGroup) do
- describe Object, "#foobar"
- end
- child_example_group = Class.new(parent_example_group) do
- describe "not a type"
- end
- child_example_group.described_type.should == Object
- end
- end
-
- describe "#remove_after" do
- it "should unregister a given after(:each) block" do
- after_all_ran = false
- @example_group.it("example") {}
- proc = Proc.new { after_all_ran = true }
- ExampleGroup.after(:each, &proc)
- @example_group.run
- after_all_ran.should be_true
-
- after_all_ran = false
- ExampleGroup.remove_after(:each, &proc)
- @example_group.run
- after_all_ran.should be_false
- end
- end
-
- describe "#include" do
- it "should have accessible class methods from included module" do
- mod1_method_called = false
- mod1 = Module.new do
- class_methods = Module.new do
- define_method :mod1_method do
- mod1_method_called = true
- end
- end
-
- metaclass.class_eval do
- define_method(:included) do |receiver|
- receiver.extend class_methods
- end
- end
- end
-
- mod2_method_called = false
- mod2 = Module.new do
- class_methods = Module.new do
- define_method :mod2_method do
- mod2_method_called = true
- end
- end
-
- metaclass.class_eval do
- define_method(:included) do |receiver|
- receiver.extend class_methods
- end
- end
- end
-
- @example_group.include mod1, mod2
-
- @example_group.mod1_method
- @example_group.mod2_method
- mod1_method_called.should be_true
- mod2_method_called.should be_true
- end
- end
-
- describe "#number_of_examples" do
- it "should count number of specs" do
- proc do
- @example_group.it("one") {}
- @example_group.it("two") {}
- @example_group.it("three") {}
- @example_group.it("four") {}
- end.should change {@example_group.number_of_examples}.by(4)
- end
- end
-
- describe "#class_eval" do
- it "should allow constants to be defined" do
- example_group = Class.new(ExampleGroup) do
- describe('example')
- FOO = 1
- it "should reference FOO" do
- FOO.should == 1
- end
- end
- example_group.run
- Object.const_defined?(:FOO).should == false
- end
- end
-
- describe '#register' do
- it "should add ExampleGroup to set of ExampleGroups to be run" do
- example_group.register
- options.example_groups.should include(example_group)
- end
- end
-
- describe '#unregister' do
- before do
- example_group.register
- options.example_groups.should include(example_group)
- end
-
- it "should remove ExampleGroup from set of ExampleGroups to be run" do
- example_group.unregister
- options.example_groups.should_not include(example_group)
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- class ExampleModuleScopingSpec < ExampleGroup
- describe ExampleGroup, "via a class definition"
-
- module Foo
- module Bar
- def self.loaded?
- true
- end
- end
- end
- include Foo
-
- it "should understand module scoping" do
- Bar.should be_loaded
- end
-
- @@foo = 1
-
- it "should allow class variables to be defined" do
- @@foo.should == 1
- end
- end
-
- class ExampleClassVariablePollutionSpec < ExampleGroup
- describe ExampleGroup, "via a class definition without a class variable"
-
- it "should not retain class variables from other Example classes" do
- proc do
- @@foo
- end.should raise_error
- end
- end
-
- describe ExampleGroup, "#pending" do
- it "should raise a Pending error when its block fails" do
- block_ran = false
- lambda {
- pending("something") do
- block_ran = true
- raise "something wrong with my example"
- end
- }.should raise_error(Spec::Example::ExamplePendingError, "something")
- block_ran.should == true
- end
-
- it "should raise Spec::Example::PendingExampleFixedError when its block does not fail" do
- block_ran = false
- lambda {
- pending("something") do
- block_ran = true
- end
- }.should raise_error(Spec::Example::PendingExampleFixedError, "Expected pending 'something' to fail. No Error was raised.")
- block_ran.should == true
- end
- end
-
- describe ExampleGroup, "#run with failure in example", :shared => true do
- it "should add an example failure to the TestResult" do
- example_group.run.should be_false
- end
- end
-
- describe ExampleGroup, "#run" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :example_group, :formatter, :reporter
- before :each do
- @formatter = mock("formatter", :null_object => true)
- options.formatters << formatter
- options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
- @reporter = FakeReporter.new(options)
- options.reporter = reporter
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it "does nothing" do
- end
- end
- class << example_group
- public :include
- end
- end
-
- after :each do
- ExampleGroup.reset
- end
-
- it "should not run when there are no examples" do
- example_group = Class.new(ExampleGroup) do
- describe("Foobar")
- end
- example_group.examples.should be_empty
-
- reporter = mock("Reporter")
- reporter.should_not_receive(:add_example_group)
- example_group.run
- end
-
- describe "when before_each fails" do
- before(:each) do
- $example_ran = $after_each_ran = false
- @example_group = describe("Foobar") do
- before(:each) {raise}
- it "should not be run" do
- $example_ran = true
- end
- after(:each) do
- $after_each_ran = true
- end
- end
- end
-
- it "should not run example block" do
- example_group.run
- $example_ran.should be_false
- end
-
- it "should run after_each" do
- example_group.run
- $after_each_ran.should be_true
- end
-
- it "should report failure location when in before_each" do
- reporter.should_receive(:example_finished) do |example_group, error|
- error.message.should eql("in before_each")
- end
- example_group.run
- end
- end
-
- describe ExampleGroup, "#run on dry run" do
- before do
- @options.dry_run = true
- end
-
- it "should not run before(:all) or after(:all)" do
- before_all_ran = false
- after_all_ran = false
- ExampleGroup.before(:all) { before_all_ran = true }
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.it("should") {}
- example_group.run
- before_all_ran.should be_false
- after_all_ran.should be_false
- end
-
- it "should not run example" do
- example_ran = false
- example_group.it("should") {example_ran = true}
- example_group.run
- example_ran.should be_false
- end
- end
-
- describe ExampleGroup, "#run with specified examples" do
- attr_reader :examples_that_were_run
- before do
- @examples_that_were_run = []
- end
-
- describe "when specified_examples matches entire ExampleGroup" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("the ExampleGroup")
- it("should be run") do
- examples_that_were_run << 'should be run'
- end
-
- it("should also be run") do
- examples_that_were_run << 'should also be run'
- end
- end
- options.examples = ["the ExampleGroup"]
- end
-
- it "should not run the Examples in the ExampleGroup" do
- example_group.run
- examples_that_were_run.should == ['should be run', 'should also be run']
- end
- end
-
- describe ExampleGroup, "#run when specified_examples matches only Example description" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be run") do
- examples_that_were_run << 'should be run'
- end
- end
- options.examples = ["should be run"]
- end
-
- it "should not run the example" do
- example_group.run
- examples_that_were_run.should == ['should be run']
- end
- end
-
- describe ExampleGroup, "#run when specified_examples does not match an Example description" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be something else") do
- examples_that_were_run << 'should be something else'
- end
- end
- options.examples = ["does not match anything"]
- end
-
- it "should not run the example" do
- example_group.run
- examples_that_were_run.should == []
- end
- end
-
- describe ExampleGroup, "#run when specified_examples matches an Example description" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be run") do
- examples_that_were_run << 'should be run'
- end
- it("should not be run") do
- examples_that_were_run << 'should not be run'
- end
- end
- options.examples = ["should be run"]
- end
-
- it "should run only the example, when there in only one" do
- example_group.run
- examples_that_were_run.should == ["should be run"]
- end
-
- it "should run only the one example" do
- example_group.run
- examples_that_were_run.should == ["should be run"] end
- end
- end
-
- describe ExampleGroup, "#run with success" do
- before do
- @special_example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:special, @special_example_group)
- @not_special_example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:not_special, @not_special_example_group)
- end
-
- after do
- ExampleGroupFactory.reset
- end
-
- it "should send reporter add_example_group" do
- example_group.run
- reporter.example_groups.should == [example_group]
- end
-
- it "should run example on run" do
- example_ran = false
- example_group.it("should") {example_ran = true}
- example_group.run
- example_ran.should be_true
- end
-
- it "should run before(:all) block only once" do
- before_all_run_count_run_count = 0
- example_group.before(:all) {before_all_run_count_run_count += 1}
- example_group.it("test") {true}
- example_group.it("test2") {true}
- example_group.run
- before_all_run_count_run_count.should == 1
- end
-
- it "should run after(:all) block only once" do
- after_all_run_count = 0
- example_group.after(:all) {after_all_run_count += 1}
- example_group.it("test") {true}
- example_group.it("test2") {true}
- example_group.run
- after_all_run_count.should == 1
- @reporter.rspec_verify
- end
-
- it "after(:all) should have access to all instance variables defined in before(:all)" do
- context_instance_value_in = "Hello there"
- context_instance_value_out = ""
- example_group.before(:all) { @instance_var = context_instance_value_in }
- example_group.after(:all) { context_instance_value_out = @instance_var }
- example_group.it("test") {true}
- example_group.run
- context_instance_value_in.should == context_instance_value_out
- end
-
- it "should copy instance variables from before(:all)'s execution context into spec's execution context" do
- context_instance_value_in = "Hello there"
- context_instance_value_out = ""
- example_group.before(:all) { @instance_var = context_instance_value_in }
- example_group.it("test") {context_instance_value_out = @instance_var}
- example_group.run
- context_instance_value_in.should == context_instance_value_out
- end
-
- it "should not add global before callbacks for untargetted example_group" do
- fiddle = []
-
- ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
- ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
- @special_example_group.before(:each) { fiddle << "Example.before(:each, :type => :special)" }
- @special_example_group.prepend_before(:each) { fiddle << "Example.prepend_before(:each, :type => :special)" }
- @special_example_group.before(:all) { fiddle << "Example.before(:all, :type => :special)" }
- @special_example_group.prepend_before(:all) { fiddle << "Example.prepend_before(:all, :type => :special)" }
-
- example_group = Class.new(ExampleGroup) do
- describe("I'm not special", :type => :not_special)
- it "does nothing"
- end
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- ]
- end
-
- it "should add global before callbacks for targetted example_groups" do
- fiddle = []
-
- ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
- ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
- @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" }
- @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" }
- @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" }
- @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" }
- @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" }
-
- example_group = Class.new(@special_example_group).describe("I'm a special example_group") {}
- example_group.it("test") {true}
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- 'special.prepend_before(:all, :type => :special)',
- 'special.before(:all, :type => :special)',
- 'special.prepend_before(:each, :type => :special)',
- 'special.before(:each, :type => :special)',
- 'special.append_before(:each, :type => :special)',
- ]
- end
-
- it "should order before callbacks from global to local" do
- fiddle = []
- ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
- ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
- example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" }
- example_group.before(:all) { fiddle << "before(:all)" }
- example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" }
- example_group.before(:each) { fiddle << "before(:each)" }
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- 'prepend_before(:all)',
- 'before(:all)',
- 'prepend_before(:each)',
- 'before(:each)'
- ]
- end
-
- it "should order after callbacks from local to global" do
- fiddle = []
- example_group.after(:each) { fiddle << "after(:each)" }
- example_group.append_after(:each) { fiddle << "append_after(:each)" }
- example_group.after(:all) { fiddle << "after(:all)" }
- example_group.append_after(:all) { fiddle << "append_after(:all)" }
- ExampleGroup.after(:all) { fiddle << "Example.after(:all)" }
- ExampleGroup.append_after(:all) { fiddle << "Example.append_after(:all)" }
- example_group.run
- fiddle.should == [
- 'after(:each)',
- 'append_after(:each)',
- 'after(:all)',
- 'append_after(:all)',
- 'Example.after(:all)',
- 'Example.append_after(:all)'
- ]
- end
-
- it "should have accessible instance methods from included module" do
- mod1_method_called = false
- mod1 = Module.new do
- define_method :mod1_method do
- mod1_method_called = true
- end
- end
-
- mod2_method_called = false
- mod2 = Module.new do
- define_method :mod2_method do
- mod2_method_called = true
- end
- end
-
- example_group.include mod1, mod2
-
- example_group.it("test") do
- mod1_method
- mod2_method
- end
- example_group.run
- mod1_method_called.should be_true
- mod2_method_called.should be_true
- end
-
- it "should include targetted modules included using configuration" do
- mod1 = Module.new
- mod2 = Module.new
- mod3 = Module.new
- Spec::Runner.configuration.include(mod1, mod2)
- Spec::Runner.configuration.include(mod3, :type => :not_special)
-
- example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do
- it "does nothing"
- end
- example_group.run
-
- example_group.included_modules.should include(mod1)
- example_group.included_modules.should include(mod2)
- example_group.included_modules.should_not include(mod3)
- end
-
- it "should include any predicate_matchers included using configuration" do
- $included_predicate_matcher_found = false
- Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something?
- example_group = Class.new(ExampleGroup) do
- describe('example')
- it "should respond to do_something" do
- $included_predicate_matcher_found = respond_to?(:do_something)
- end
- end
- example_group.run
- $included_predicate_matcher_found.should be(true)
- end
-
- it "should use a mock framework set up in config" do
- mod = Module.new do
- class << self
- def included(mod)
- $included_module = mod
- end
- end
-
- def teardown_mocks_for_rspec
- $torn_down = true
- end
- end
-
- begin
- $included_module = nil
- $torn_down = true
- Spec::Runner.configuration.mock_with mod
-
- example_group = Class.new(ExampleGroup) do
- describe('example')
- it "does nothing"
- end
- example_group.run
-
- $included_module.should_not be_nil
- $torn_down.should == true
- ensure
- Spec::Runner.configuration.mock_with :rspec
- end
- end
- end
-
- describe ExampleGroup, "#run with pending example that has a failing assertion" do
- before do
- example_group.it("should be pending") do
- pending("Example fails") {false.should be_true}
- end
- end
-
- it "should send example_pending to formatter" do
- @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails")
- example_group.run
- end
- end
-
- describe ExampleGroup, "#run with pending example that does not have a failing assertion" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- example_group.it("should be pending") do
- pending("Example passes") {true.should be_true}
- end
- end
-
- it "should send example_pending to formatter" do
- @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes")
- example_group.run
- end
- end
-
- describe ExampleGroup, "#run when before(:all) fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" }
- end
-
- it "should not run any example" do
- spec_ran = false
- example_group.it("test") {spec_ran = true}
- example_group.run
- spec_ran.should be_false
- end
-
- it "should run ExampleGroup after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
-
- it "should run example_group after(:all)" do
- after_all_ran = false
- example_group.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
-
- it "should supply before(:all) as description" do
- @reporter.should_receive(:failure) do |example, error|
- example.description.should eql("before(:all)")
- error.message.should eql("before(:all) failure")
- end
-
- example_group.it("test") {true}
- example_group.run
- end
- end
-
- describe ExampleGroup, "#run when before(:each) fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- ExampleGroup.before(:each) { raise NonStandardError }
- end
-
- it "should run after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
- end
-
- describe ExampleGroup, "#run when any example fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- example_group.it("should") { raise NonStandardError }
- end
-
- it "should run after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
- end
-
- describe ExampleGroup, "#run when first after(:each) block fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- class << example_group
- attr_accessor :first_after_ran, :second_after_ran
- end
- example_group.first_after_ran = false
- example_group.second_after_ran = false
-
- example_group.after(:each) do
- self.class.second_after_ran = true
- end
- example_group.after(:each) do
- self.class.first_after_ran = true
- raise "first"
- end
- end
-
- it "should run second after(:each) block" do
- reporter.should_receive(:example_finished) do |example, error|
- example.should equal(example)
- error.message.should eql("first")
- end
- example_group.run
- example_group.first_after_ran.should be_true
- example_group.second_after_ran.should be_true
- end
- end
-
- describe ExampleGroup, "#run when first before(:each) block fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- class << example_group
- attr_accessor :first_before_ran, :second_before_ran
- end
- example_group.first_before_ran = false
- example_group.second_before_ran = false
-
- example_group.before(:each) do
- self.class.first_before_ran = true
- raise "first"
- end
- example_group.before(:each) do
- self.class.second_before_ran = true
- end
- end
-
- it "should not run second before(:each)" do
- reporter.should_receive(:example_finished) do |name, error|
- error.message.should eql("first")
- end
- example_group.run
- example_group.first_before_ran.should be_true
- example_group.second_before_ran.should be_false
- end
- end
-
- describe ExampleGroup, "#run when failure in after(:all)" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
-
- before do
- ExampleGroup.after(:all) { raise NonStandardError, "in after(:all)" }
- end
-
- it "should return false" do
- example_group.run.should be_false
- end
- end
- end
-
- class ExampleSubclass < ExampleGroup
- end
-
- describe ExampleGroup, "subclasses" do
- after do
- ExampleGroupFactory.reset
- end
-
- it "should have access to the described_type" do
- example_group = Class.new(ExampleSubclass) do
- describe(Array)
- end
- example_group.send(:described_type).should == Array
- end
-
- it "should concat descriptions when nested" do
- example_group = Class.new(ExampleSubclass) do
- describe(Array)
- $nested_group = describe("when empty") do
- end
- end
- $nested_group.description.to_s.should == "Array when empty"
- end
- end
-
- describe Enumerable do
- def each(&block)
- ["4", "2", "1"].each(&block)
- end
-
- it "should be included in examples because it is a module" do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
-
- describe "An", Enumerable, "as a second argument" do
- def each(&block)
- ["4", "2", "1"].each(&block)
- end
-
- it "should be included in examples because it is a module" do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
-
- describe Enumerable do
- describe "as the parent of nested example groups" do
- it "should be included in examples because it is a module" do
- pending("need to make sure nested groups know the described type") do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
- end
- end
-
- describe String do
- it"should not be included in examples because it is not a module" do
- lambda{self.map}.should raise_error(NoMethodError, /undefined method `map' for/)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Example
- module ExampleMatcherSpecHelper
- class MatchDescription
- def initialize(description)
- @description = description
- end
-
- def matches?(matcher)
- matcher.matches?(@description)
- end
-
- def failure_message
- "expected matcher.matches?(#{@description.inspect}) to return true, got false"
- end
-
- def negative_failure_message
- "expected matcher.matches?(#{@description.inspect}) to return false, got true"
- end
- end
- def match_description(description)
- MatchDescription.new(description)
- end
- end
-
- describe ExampleMatcher, "#matches?" do
- include ExampleMatcherSpecHelper
-
- it "should match correct example_group and example" do
- matcher = ExampleMatcher.new("example_group", "example")
- matcher.should match_description("example_group example")
- end
-
- it "should not match wrong example" do
- matcher = ExampleMatcher.new("example_group", "other example")
- matcher.should_not match_description("example_group example")
- end
-
- it "should not match wrong example_group" do
- matcher = ExampleMatcher.new("other example_group", "example")
- matcher.should_not match_description("example_group example")
- end
-
- it "should match example only" do
- matcher = ExampleMatcher.new("example_group", "example")
- matcher.should match_description("example")
- end
-
- it "should match example_group only" do
- matcher = ExampleMatcher.new("example_group", "example")
- matcher.should match_description("example_group")
- end
-
- it "should match example_group ending with before(:all)" do
- matcher = ExampleMatcher.new("example_group", "example")
- matcher.should match_description("example_group before(:all)")
- end
-
- it "should escape regexp chars" do
- matcher = ExampleMatcher.new("(con|text)", "[example]")
- matcher.should_not match_description("con p")
- end
-
- it "should match when example_group is modularized" do
- matcher = ExampleMatcher.new("MyModule::MyClass", "example")
- matcher.should match_description("MyClass example")
- end
- end
-
- describe ExampleMatcher, "#matches? normal case" do
- it "matches when passed in example matches" do
- matcher = ExampleMatcher.new("Foo", "bar")
- matcher.matches?(["no match", "Foo bar"]).should == true
- end
-
- it "does not match when no passed in examples match" do
- matcher = ExampleMatcher.new("Foo", "bar")
- matcher.matches?(["no match1", "no match2"]).should == false
- end
- end
-
- describe ExampleMatcher, "#matches? where description has '::' in it" do
- it "matches when passed in example matches" do
- matcher = ExampleMatcher.new("Foo::Bar", "baz")
- matcher.matches?(["no match", "Foo::Bar baz"]).should == true
- end
-
- it "does not match when no passed in examples match" do
- matcher = ExampleMatcher.new("Foo::Bar", "baz")
- matcher.matches?(["no match1", "no match2"]).should == false
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- module ModuleThatIsReopened
- end
-
- module ExampleMethods
- include ModuleThatIsReopened
- end
-
- module ModuleThatIsReopened
- def module_that_is_reopened_method
- end
- end
-
- describe "ExampleMethods with an included module that is reopened" do
- it "should have repoened methods" do
- method(:module_that_is_reopened_method).should_not be_nil
- end
- end
-
- describe ExampleMethods, "lifecycle" do
- before do
- @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
- @options.formatters << mock("formatter", :null_object => true)
- @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
- @reporter = FakeReporter.new(@options)
- @options.reporter = @reporter
-
- ExampleMethods.before_all_parts.should == []
- ExampleMethods.before_each_parts.should == []
- ExampleMethods.after_each_parts.should == []
- ExampleMethods.after_all_parts.should == []
- def ExampleMethods.count
- @count ||= 0
- @count = @count + 1
- @count
- end
- end
-
- after do
- ExampleMethods.instance_variable_set("@before_all_parts", [])
- ExampleMethods.instance_variable_set("@before_each_parts", [])
- ExampleMethods.instance_variable_set("@after_each_parts", [])
- ExampleMethods.instance_variable_set("@after_all_parts", [])
- end
-
- it "should pass before and after callbacks to all ExampleGroup subclasses" do
- ExampleMethods.before(:all) do
- ExampleMethods.count.should == 1
- end
-
- ExampleMethods.before(:each) do
- ExampleMethods.count.should == 2
- end
-
- ExampleMethods.after(:each) do
- ExampleMethods.count.should == 3
- end
-
- ExampleMethods.after(:all) do
- ExampleMethods.count.should == 4
- end
-
- @example_group = Class.new(ExampleGroup) do
- it "should use ExampleMethods callbacks" do
- end
- end
- @example_group.run
- ExampleMethods.count.should == 5
- end
-
- describe "run_with_description_capturing" do
- before(:each) do
- @example_group = Class.new(ExampleGroup) do end
- @example = @example_group.new("foo", &(lambda { 2.should == 2 }))
- @example.run_with_description_capturing
- end
-
- it "should provide the generated description" do
- @example.instance_eval { @_matcher_description }.should == "should == 2"
- end
-
- it "should clear the global generated_description" do
- Spec::Matchers.generated_description.should == nil
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Example
- # describe "Spec::Example::ExampleRunner", "#run", :shared => true do
- # before(:each) do
- # @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
- # @reporter = ::Spec::Runner::Reporter.new(@options)
- # @options.reporter = @reporter
- # @example_group_class = Class.new(ExampleGroup) do
- # plugin_mock_framework
- # describe("Some Examples")
- # end
- # end
- #
- # def create_runner(example_definition)
- # example = @example_group_class.new(example_definition)
- # runner = ExampleGroup.new(@options, example)
- # runner.stub!(:verify_mocks)
- # runner.stub!(:teardown_mocks)
- # runner
- # end
- # end
- #
- # describe ExampleRunner, "#run with blank passing example" do
- # it_should_behave_like "Spec::Example::ExampleRunner#run"
- #
- # before do
- # @e = @example_group_class.it("example") {}
- # @runner = create_runner(@e)
- # end
- #
- # it "should send reporter example_started" do
- # @reporter.should_receive(:example_started).with(equal(@e))
- # @runner.run
- # end
- #
- # it "should report its name for dry run" do
- # @options.dry_run = true
- # @reporter.should_receive(:example_finished).with(equal(@e), nil)
- # @runner.run
- # end
- #
- # it "should report success" do
- # @reporter.should_receive(:example_finished).with(equal(@e), nil)
- # @runner.run
- # end
- # end
- #
- # describe ExampleRunner, "#run with a failing example" do
- # predicate_matchers[:is_a] = [:is_a?]
- # it_should_behave_like "Spec::Example::ExampleRunner#run"
- #
- # before do
- # @e = @example_group_class.it("example") do
- # (2+2).should == 5
- # end
- # @runner = create_runner(@e)
- # end
- #
- # it "should report failure due to failure" do
- # @reporter.should_receive(:example_finished).with(
- # equal(@e),
- # is_a(Spec::Expectations::ExpectationNotMetError)
- # )
- # @runner.run
- # end
- # end
- #
- # describe ExampleRunner, "#run with a erroring example" do
- # it_should_behave_like "Spec::Example::ExampleRunner#run"
- #
- # before do
- # @error = error = NonStandardError.new("in body")
- # @example_definition = @example_group_class.it("example") do
- # raise(error)
- # end
- # @runner = create_runner(@example_definition)
- # end
- #
- # it "should report failure due to error" do
- # @reporter.should_receive(:example_finished).with(
- # equal(@example_definition),
- # @error
- # )
- # @runner.run
- # end
- #
- # it "should run after_each block" do
- # @example_group_class.after(:each) do
- # raise("in after_each")
- # end
- # @reporter.should_receive(:example_finished) do |example_definition, error|
- # example_definition.should equal(@example_definition)
- # error.message.should eql("in body")
- # end
- # @runner.run
- # end
- # end
- #
- # describe ExampleRunner, "#run where after_each fails" do
- # it_should_behave_like "Spec::Example::ExampleRunner#run"
- #
- # before do
- # @example_ran = example_ran = false
- # @example_definition = @example_group_class.it("should not run") do
- # example_ran = true
- # end
- # @runner = create_runner(@example_definition)
- # @example_group_class.after(:each) { raise(NonStandardError.new("in after_each")) }
- # end
- #
- # it "should report failure location when in after_each" do
- # @reporter.should_receive(:example_finished) do |example_definition, error|
- # example_definition.should equal(@example_definition)
- # error.message.should eql("in after_each")
- # end
- # @runner.run
- # end
- # end
- #
- # describe ExampleRunner, "#run with use cases" do
- # predicate_matchers[:is_a] = [:is_a?]
- # it_should_behave_like "Spec::Example::ExampleRunner#run"
- #
- # it "should report NO NAME when told to use generated description with --dry-run" do
- # @options.dry_run = true
- # example_definition = @example_group_class.it() do
- # 5.should == 5
- # end
- # runner = create_runner(example_definition)
- #
- # @reporter.should_receive(:example_finished) do |example_definition, error|
- # example_definition.description.should == "NO NAME (Because of --dry-run)"
- # end
- # runner.run
- # end
- #
- # it "should report given name if present with --dry-run" do
- # @options.dry_run = true
- # example_definition = @example_group_class.it("example name") do
- # 5.should == 5
- # end
- # runner = create_runner(example_definition)
- #
- # @reporter.should_receive(:example_finished) do |example_definition, error|
- # example_definition.description.should == "example name"
- # end
- # runner.run
- # end
- #
- # it "should report NO NAME when told to use generated description with no expectations" do
- # example_definition = @example_group_class.it() {}
- # runner = create_runner(example_definition)
- # @reporter.should_receive(:example_finished) do |example, error|
- # example.description.should == "NO NAME (Because there were no expectations)"
- # end
- # runner.run
- # end
- #
- # it "should report NO NAME when told to use generated description and matcher fails" do
- # example_definition = @example_group_class.it() do
- # 5.should "" # Has no matches? method..
- # end
- # runner = create_runner(example_definition)
- #
- # @reporter.should_receive(:example_finished) do |example, error|
- # example_definition.description.should == "NO NAME (Because of Error raised in matcher)"
- # end
- # runner.run
- # end
- #
- # it "should report generated description when told to and it is available" do
- # example_definition = @example_group_class.it() {
- # 5.should == 5
- # }
- # runner = create_runner(example_definition)
- #
- # @reporter.should_receive(:example_finished) do |example_definition, error|
- # example_definition.description.should == "should == 5"
- # end
- # runner.run
- # end
- #
- # it "should unregister description_generated callback (lest a memory leak should build up)" do
- # example_definition = @example_group_class.it("something")
- # runner = create_runner(example_definition)
- #
- # Spec::Matchers.should_receive(:example_finished)
- # runner.run
- # end
- # end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- # describe Example do
- # before(:each) do
- # @example = Example.new "example" do
- # foo
- # end
- # end
- #
- # it "should tell you its docstring" do
- # @example.description.should == "example"
- # end
- #
- # it "should execute its block in the context provided" do
- # context = Class.new do
- # def foo
- # "foo"
- # end
- # end.new
- # @example.run_in(context).should == "foo"
- # end
- # end
- #
- # describe Example, "#description" do
- # it "should default to NO NAME when not passed anything when there are no matchers" do
- # example = Example.new {}
- # example.run_in(Object.new)
- # example.description.should == "NO NAME"
- # end
- #
- # it "should default to NO NAME description (Because of --dry-run) when passed nil and there are no matchers" do
- # example = Example.new(nil) {}
- # example.run_in(Object.new)
- # example.description.should == "NO NAME"
- # end
- #
- # it "should allow description to be overridden" do
- # example = Example.new("Test description")
- # example.description.should == "Test description"
- # end
- #
- # it "should use description generated from matcher when there is no passed in description" do
- # example = Example.new(nil) do
- # 1.should == 1
- # end
- # example.run_in(Object.new)
- # example.description.should == "should == 1"
- # end
- # end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- describe 'Nested Example Groups' do
- parent = self
-
- def count
- @count ||= 0
- @count = @count + 1
- @count
- end
-
- before(:all) do
- count.should == 1
- end
-
- before(:all) do
- count.should == 2
- end
-
- before(:each) do
- count.should == 3
- end
-
- before(:each) do
- count.should == 4
- end
-
- it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do
- count.should == 5
- end
-
- after(:each) do
- count.should == 7
- end
-
- after(:each) do
- count.should == 6
- end
-
- after(:all) do
- count.should == 9
- end
-
- after(:all) do
- count.should == 8
- end
-
- describe 'nested example group' do
- self.superclass.should == parent
-
- it "should run all before and after callbacks" do
- count.should == 5
- end
- end
- end
- end
-end
+++ /dev/null
-module Spec
- module Example
- describe Pending do
-
- it 'should raise an ExamplePendingError if no block is supplied' do
- lambda {
- include Pending
- pending "TODO"
- }.should raise_error(ExamplePendingError, /TODO/)
- end
-
- it 'should raise an ExamplePendingError if a supplied block fails as expected' do
- lambda {
- include Pending
- pending "TODO" do
- raise "oops"
- end
- }.should raise_error(ExamplePendingError, /TODO/)
- end
-
- it 'should raise a PendingExampleFixedError if a supplied block starts working' do
- lambda {
- include Pending
- pending "TODO" do
- # success!
- end
- }.should raise_error(PendingExampleFixedError, /TODO/)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- class Fish
- def can_swim?(distance_in_yards)
- distance_in_yards < 1000
- end
- end
-
- describe "predicate_matcher[method_on_object] = matcher_method" do
- predicate_matchers[:swim] = :can_swim?
- it "should match matcher_method if method_on_object returns true" do
- swim(100).matches?(Fish.new).should be_true
- end
- it "should not match matcher_method if method_on_object returns false" do
- swim(10000).matches?(Fish.new).should be_false
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- describe ExampleGroup, "with :shared => true" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :formatter, :example_group
- before(:each) do
- @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
- options.formatters << formatter
- @example_group = Class.new(ExampleGroup).describe("example_group")
- class << example_group
- public :include
- end
- end
-
- after(:each) do
- @formatter.rspec_verify
- @example_group = nil
- $shared_example_groups.clear unless $shared_example_groups.nil?
- end
-
- def make_shared_example_group(name, opts=nil, &block)
- example_group = SharedExampleGroup.new(name, :shared => true, &block)
- SharedExampleGroup.add_shared_example_group(example_group)
- example_group
- end
-
- def non_shared_example_group()
- @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
- end
-
- it "should accept an optional options hash" do
- lambda { Class.new(ExampleGroup).describe("context") }.should_not raise_error(Exception)
- lambda { Class.new(ExampleGroup).describe("context", :shared => true) }.should_not raise_error(Exception)
- end
-
- it "should return all shared example_groups" do
- b1 = make_shared_example_group("b1", :shared => true) {}
- b2 = make_shared_example_group("b2", :shared => true) {}
-
- b1.should_not be(nil)
- b2.should_not be(nil)
-
- SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
- SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
- end
-
- it "should register as shared example_group" do
- example_group = make_shared_example_group("example_group") {}
- SharedExampleGroup.shared_example_groups.should include(example_group)
- end
-
- it "should not be shared when not configured as shared" do
- example_group = non_shared_example_group
- SharedExampleGroup.shared_example_groups.should_not include(example_group)
- end
-
- it "should complain when adding a second shared example_group with the same description" do
- describe "shared example_group", :shared => true do
- end
- lambda do
- describe "shared example_group", :shared => true do
- end
- end.should raise_error(ArgumentError)
- end
-
- it "should NOT complain when adding the same shared example_group instance again" do
- shared_example_group = Class.new(ExampleGroup).describe("shared example_group", :shared => true)
- SharedExampleGroup.add_shared_example_group(shared_example_group)
- SharedExampleGroup.add_shared_example_group(shared_example_group)
- end
-
- it "should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
- lambda do
- 2.times do
- describe "shared example_group which gets loaded twice", :shared => true do
- end
- end
- end.should_not raise_error(ArgumentError)
- end
-
- it "should NOT complain when adding the same shared example_group in same file with different absolute path" do
- shared_example_group_1 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/a/../shared.rb"
- )
- shared_example_group_2 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/b/../shared.rb"
- )
-
- SharedExampleGroup.add_shared_example_group(shared_example_group_1)
- SharedExampleGroup.add_shared_example_group(shared_example_group_2)
- end
-
- it "should complain when adding a different shared example_group with the same name in a different file with the same basename" do
- shared_example_group_1 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/a/shared.rb"
- )
- shared_example_group_2 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/b/shared.rb"
- )
-
- SharedExampleGroup.add_shared_example_group(shared_example_group_1)
- lambda do
- SharedExampleGroup.add_shared_example_group(shared_example_group_2)
- end.should raise_error(ArgumentError, /already exists/)
- end
-
- it "should add examples to current example_group using it_should_behave_like" do
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") {}
- it("shared example 2") {}
- end
-
- example_group.it("example") {}
- example_group.number_of_examples.should == 1
- example_group.it_should_behave_like("shared example_group")
- example_group.number_of_examples.should == 3
- end
-
- it "should add examples to current example_group using include" do
- shared_example_group = describe "all things", :shared => true do
- it "should do stuff" do end
- end
-
- example_group = describe "one thing" do
- include shared_example_group
- end
-
- example_group.number_of_examples.should == 1
- end
-
- it "should add examples to current example_group using it_should_behave_like with a module" do
- AllThings = describe "all things", :shared => true do
- it "should do stuff" do end
- end
-
- example_group = describe "one thing" do
- it_should_behave_like AllThings
- end
-
- example_group.number_of_examples.should == 1
- end
-
- it "should run shared examples" do
- shared_example_ran = false
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") { shared_example_ran = true }
- end
-
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_example_ran.should be_true
- end
-
- it "should run setup and teardown from shared example_group" do
- shared_setup_ran = false
- shared_teardown_ran = false
- shared_example_group = make_shared_example_group("shared example_group") do
- before { shared_setup_ran = true }
- after { shared_teardown_ran = true }
- it("shared example") { shared_example_ran = true }
- end
-
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_setup_ran.should be_true
- shared_teardown_ran.should be_true
- end
-
- it "should run before(:all) and after(:all) only once from shared example_group" do
- shared_before_all_run_count = 0
- shared_after_all_run_count = 0
- shared_example_group = make_shared_example_group("shared example_group") do
- before(:all) { shared_before_all_run_count += 1}
- after(:all) { shared_after_all_run_count += 1}
- it("shared example") { shared_example_ran = true }
- end
-
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_before_all_run_count.should == 1
- shared_after_all_run_count.should == 1
- end
-
- it "should include modules, included into shared example_group, into current example_group" do
- @formatter.should_receive(:add_example_group).with(any_args)
-
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") { shared_example_ran = true }
- end
-
- mod1_method_called = false
- mod1 = Module.new do
- define_method :mod1_method do
- mod1_method_called = true
- end
- end
-
- mod2_method_called = false
- mod2 = Module.new do
- define_method :mod2_method do
- mod2_method_called = true
- end
- end
-
- shared_example_group.include mod2
-
- example_group.it_should_behave_like("shared example_group")
- example_group.include mod1
-
- example_group.it("test") do
- mod1_method
- mod2_method
- end
- example_group.run
- mod1_method_called.should be_true
- mod2_method_called.should be_true
- end
-
- it "should make methods defined in the shared example_group available in consuming example_group" do
- shared_example_group = make_shared_example_group("shared example_group xyz") do
- def a_shared_helper_method
- "this got defined in a shared example_group"
- end
- end
- example_group.it_should_behave_like("shared example_group xyz")
- success = false
- example_group.it("should access a_shared_helper_method") do
- a_shared_helper_method
- success = true
- end
- example_group.run
- success.should be_true
- end
-
- it "should raise when named shared example_group can not be found" do
- lambda {
- example_group.it_should_behave_like("non-existent shared example group")
- violated
- }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Example
- class GrandParentExampleGroup < Spec::Example::ExampleGroup
- describe "Grandparent ExampleGroup"
- end
-
- class ParentExampleGroup < GrandParentExampleGroup
- describe "Parent ExampleGroup"
- it "should bar" do
- end
- end
-
- class ChildExampleGroup < ParentExampleGroup
- describe "Child ExampleGroup"
- it "should bam" do
- end
- end
-
- describe ChildExampleGroup do
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-module Spec
- module Fixtures
- class Animal
- def initialize(name,species)
- @name,@species = name,species
- end
-
- def inspect
- <<-EOA
-<Animal
- name=#{@name},
- species=#{@species}
->
- EOA
- end
- end
- end
-end
-
-describe "Diff" do
- before(:each) do
- @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
- @differ = Spec::Expectations::Differs::Default.new(@options)
- end
-
- it "should output unified diff of two strings" do
- expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
- actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
- expected_diff="\n\n@@ -1,6 +1,6 @@\n foo\n-bar\n zap\n+bar\n this\n is\n soo\n@@ -9,5 +9,6 @@\n equal\n insert\n a\n+another\n line\n"
- diff = @differ.diff_as_string(expected, actual)
- diff.should eql(expected_diff)
- end
-
- it "should output unified diff message of two arrays" do
- expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
- actual = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango' , :width, 'very wide' ]
-
- expected_diff = <<'EOD'
-
-
-@@ -5,7 +5,7 @@
- :metasyntactic,
- "variable",
- :delta,
-- "charlie",
-+ "tango",
- :width,
-- "quite wide"]
-+ "very wide"]
-EOD
-
-
- diff = @differ.diff_as_object(expected,actual)
- diff.should == expected_diff
- end
-
- it "should output unified diff message of two objects" do
- expected = Spec::Fixtures::Animal.new "bob", "giraffe"
- actual = Spec::Fixtures::Animal.new "bob", "tortoise"
-
- expected_diff = <<'EOD'
-
-@@ -1,5 +1,5 @@
- <Animal
- name=bob,
-- species=giraffe
-+ species=tortoise
- >
-EOD
-
- diff = @differ.diff_as_object(expected,actual)
- diff.should == expected_diff
- end
-
-end
-
-
-describe "Diff in context format" do
- before(:each) do
- @options = Spec::Runner::Options.new(StringIO.new, StringIO.new)
- @options.diff_format = :context
- @differ = Spec::Expectations::Differs::Default.new(@options)
- end
-
- it "should output unified diff message of two objects" do
- expected = Spec::Fixtures::Animal.new "bob", "giraffe"
- actual = Spec::Fixtures::Animal.new "bob", "tortoise"
-
- expected_diff = <<'EOD'
-
-***************
-*** 1,5 ****
- <Animal
- name=bob,
-! species=giraffe
- >
---- 1,5 ----
- <Animal
- name=bob,
-! species=tortoise
- >
-EOD
-
- diff = @differ.diff_as_object(expected,actual)
- diff.should == expected_diff
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-describe Object, "#should" do
- before(:each) do
- @target = "target"
- @matcher = mock("matcher")
- @matcher.stub!(:matches?).and_return(true)
- @matcher.stub!(:failure_message)
- end
-
- it "should accept and interact with a matcher" do
- @matcher.should_receive(:matches?).with(@target).and_return(true)
- @target.should @matcher
- end
-
- it "should ask for a failure_message when matches? returns false" do
- @matcher.should_receive(:matches?).with(@target).and_return(false)
- @matcher.should_receive(:failure_message).and_return("the failure message")
- lambda {
- @target.should @matcher
- }.should fail_with("the failure message")
- end
-
- it "should raise error if it receives false directly" do
- lambda {
- @target.should false
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives false (evaluated)" do
- lambda {
- @target.should eql?("foo")
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives true" do
- lambda {
- @target.should true
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives nil" do
- lambda {
- @target.should nil
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives no argument and it is not used as a left side of an operator" do
- pending "Is it even possible to catch this?"
- lambda {
- @target.should
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-end
-
-describe Object, "#should_not" do
- before(:each) do
- @target = "target"
- @matcher = mock("matcher")
- end
-
- it "should accept and interact with a matcher" do
- @matcher.should_receive(:matches?).with(@target).and_return(false)
- @matcher.stub!(:negative_failure_message)
-
- @target.should_not @matcher
- end
-
- it "should ask for a negative_failure_message when matches? returns true" do
- @matcher.should_receive(:matches?).with(@target).and_return(true)
- @matcher.should_receive(:negative_failure_message).and_return("the negative failure message")
- lambda {
- @target.should_not @matcher
- }.should fail_with("the negative failure message")
- end
-
- it "should raise error if it receives false directly" do
- lambda {
- @target.should_not false
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives false (evaluated)" do
- lambda {
- @target.should_not eql?("foo")
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives true" do
- lambda {
- @target.should_not true
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives nil" do
- lambda {
- @target.should_not nil
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
- it "should raise error if it receives no argument and it is not used as a left side of an operator" do
- pending "Is it even possible to catch this?"
- lambda {
- @target.should_not
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe Spec::Expectations, "#fail_with with no diff" do
- before(:each) do
- @old_differ = Spec::Expectations.differ
- Spec::Expectations.differ = nil
- end
-
- it "should handle just a message" do
- lambda {
- Spec::Expectations.fail_with "the message"
- }.should fail_with("the message")
- end
-
- it "should handle an Array" do
- lambda {
- Spec::Expectations.fail_with ["the message","expected","actual"]
- }.should fail_with("the message")
- end
-
- after(:each) do
- Spec::Expectations.differ = @old_differ
- end
-end
-
-describe Spec::Expectations, "#fail_with with diff" do
- before(:each) do
- @old_differ = Spec::Expectations.differ
- @differ = mock("differ")
- Spec::Expectations.differ = @differ
- end
-
- it "should not call differ if no expected/actual" do
- lambda {
- Spec::Expectations.fail_with "the message"
- }.should fail_with("the message")
- end
-
- it "should call differ if expected/actual are presented separately" do
- @differ.should_receive(:diff_as_string).and_return("diff")
- lambda {
- Spec::Expectations.fail_with "the message", "expected", "actual"
- }.should fail_with("the message\nDiff:diff")
- end
-
- it "should call differ if expected/actual are not strings" do
- @differ.should_receive(:diff_as_object).and_return("diff")
- lambda {
- Spec::Expectations.fail_with "the message", :expected, :actual
- }.should fail_with("the message\nDiff:diff")
- end
-
- it "should not call differ if expected or actual are procs" do
- @differ.should_not_receive(:diff_as_string)
- @differ.should_not_receive(:diff_as_object)
- lambda {
- Spec::Expectations.fail_with "the message", lambda {}, lambda {}
- }.should fail_with("the message")
- end
-
- it "should call differ if expected/actual are presented in an Array with message" do
- @differ.should_receive(:diff_as_string).with("actual","expected").and_return("diff")
- lambda {
- Spec::Expectations.fail_with(["the message", "expected", "actual"])
- }.should fail_with(/the message\nDiff:diff/)
- end
-
- after(:each) do
- Spec::Expectations.differ = @old_differ
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Extensions
- describe Main do
- it_should_behave_like "sandboxed rspec_options"
- before(:each) do
- @main = Class.new do; include Main; end
- end
-
- after(:each) do
- $rspec_story_steps = @original_rspec_story_steps
- end
-
- it "should create an Options object" do
- @main.send(:rspec_options).should be_instance_of(Spec::Runner::Options)
- @main.send(:rspec_options).should === $rspec_options
- end
-
- specify {@main.should respond_to(:describe)}
- specify {@main.should respond_to(:context)}
-
- it "should raise when no block given to describe" do
- lambda { @main.describe "foo" }.should raise_error(ArgumentError)
- end
-
- it "should raise when no description given to describe" do
- lambda { @main.describe do; end }.should raise_error(ArgumentError)
- end
-
- it "should registered ExampleGroups by default" do
- example_group = @main.describe("The ExampleGroup") do end
- rspec_options.example_groups.should include(example_group)
- end
-
- it "should not run unregistered ExampleGroups" do
- example_group = @main.describe("The ExampleGroup") do
- unregister
- end
-
- rspec_options.example_groups.should_not include(example_group)
- end
-
- it "should create a shared ExampleGroup with share_examples_for" do
- group = @main.share_examples_for "all things" do end
- group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
- end
-
- describe "#share_as" do
- before(:each) do
- $share_as_examples_example_module_number ||= 1
- $share_as_examples_example_module_number += 1
- t = Time.new.to_i
- @group_name = "Group#{$share_as_examples_example_module_number}"
- end
-
- it "should create a shared ExampleGroup" do
- group = @main.share_as @group_name do end
- group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
- end
-
- it "should create a constant that points to a Module" do
- group = @main.share_as @group_name do end
- Object.const_get(@group_name).should equal(group)
- end
-
- it "should bark if you pass it something not-constantizable" do
- lambda do
- @group = @main.share_as "Non Constant" do end
- end.should raise_error(NameError, /The first argument to share_as must be a legal name for a constant/)
- end
-
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../../spec_helper'
-require File.dirname(__FILE__) + '/../../../../ruby_forker'
-
-module TestUnitSpecHelper
- include RubyForker
-
- def run_script(file_name)
- output = ruby(file_name)
- if !$?.success? || output.include?("FAILED") || output.include?("Error")
- raise output
- end
- output
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/test_unit_spec_helper'
-
-describe "Test::Unit::TestCase" do
- include TestUnitSpecHelper
- it "should pass" do
- dir = File.dirname(__FILE__)
- output = run_script("#{dir}/testcase_spec_with_test_unit.rb")
- output.should include("3 examples, 0 failures")
- end
-end
\ No newline at end of file
+++ /dev/null
-require "test/unit"
-require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
-
-describe "TestCase#method_name" do
- it "should equal the description of the example" do
- @method_name.should == "should equal the description of the example"
- end
-
- def test_this
- true.should be_true
- end
-
- def testThis
- true.should be_true
- end
-
- def testament
- raise "testament is not a test"
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/test_unit_spec_helper'
-
-describe "TestSuiteAdapter" do
- include TestUnitSpecHelper
- it "should pass" do
- dir = File.dirname(__FILE__)
- run_script "#{dir}/testsuite_adapter_spec_with_test_unit.rb"
- end
-end
\ No newline at end of file
+++ /dev/null
-require "test/unit"
-require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
-
-module TestSuiteAdapterSpecHelper
- def create_adapter(group)
- Test::Unit::TestSuiteAdapter.new(group)
- end
-end
-
-describe "TestSuiteAdapter#size" do
- include TestSuiteAdapterSpecHelper
- it "should return the number of examples in the example group" do
- group = Class.new(Spec::ExampleGroup) do
- describe("some examples")
- it("bar") {}
- it("baz") {}
- end
- adapter = create_adapter(group)
- adapter.size.should == 2
- end
-end
-
-describe "TestSuiteAdapter#delete" do
- include TestSuiteAdapterSpecHelper
- it "should do nothing" do
- group = Class.new(Spec::ExampleGroup) do
- describe("Some Examples")
- it("does something") {}
- end
- adapter = create_adapter(group)
- adapter.delete(adapter.examples.first)
- adapter.should be_empty
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-module Spec
- module Matchers
- describe BeClose do
- it "should match when value == target" do
- BeClose.new(5.0, 0.5).matches?(5.0).should be_true
- end
- it "should match when value < (target + delta)" do
- BeClose.new(5.0, 0.5).matches?(5.49).should be_true
- end
- it "should match when value > (target - delta)" do
- BeClose.new(5.0, 0.5).matches?(4.51).should be_true
- end
- it "should not match when value == (target - delta)" do
- BeClose.new(5.0, 0.5).matches?(4.5).should be_false
- end
- it "should not match when value < (target - delta)" do
- BeClose.new(5.0, 0.5).matches?(4.49).should be_false
- end
- it "should not match when value == (target + delta)" do
- BeClose.new(5.0, 0.5).matches?(5.5).should be_false
- end
- it "should not match when value > (target + delta)" do
- BeClose.new(5.0, 0.5).matches?(5.51).should be_false
- end
- it "should provide a useful failure message" do
- #given
- matcher = BeClose.new(5.0, 0.5)
- #when
- matcher.matches?(5.51)
- #then
- matcher.failure_message.should == "expected 5.0 +/- (< 0.5), got 5.51"
- end
- it "should describe itself" do
- BeClose.new(5.0, 0.5).description.should == "be close to 5.0 (within +- 0.5)"
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should be_predicate" do
- it "should pass when actual returns true for :predicate?" do
- actual = stub("actual", :happy? => true)
- actual.should be_happy
- end
-
- it "should pass when actual returns true for :predicates? (present tense)" do
- actual = stub("actual", :exists? => true)
- actual.should be_exist
- end
-
- it "should fail when actual returns false for :predicate?" do
- actual = stub("actual", :happy? => false)
- lambda {
- actual.should be_happy
- }.should fail_with("expected happy? to return true, got false")
- end
-
- it "should fail when actual does not respond to :predicate?" do
- lambda {
- Object.new.should be_happy
- }.should raise_error(NameError)
- end
-end
-
-describe "should_not be_predicate" do
- it "should pass when actual returns false for :sym?" do
- actual = stub("actual", :happy? => false)
- actual.should_not be_happy
- end
-
- it "should fail when actual returns true for :sym?" do
- actual = stub("actual", :happy? => true)
- lambda {
- actual.should_not be_happy
- }.should fail_with("expected happy? to return false, got true")
- end
-
- it "should fail when actual does not respond to :sym?" do
- lambda {
- Object.new.should_not be_happy
- }.should raise_error(NameError)
- end
-end
-
-describe "should be_predicate(*args)" do
- it "should pass when actual returns true for :predicate?(*args)" do
- actual = mock("actual")
- actual.should_receive(:older_than?).with(3).and_return(true)
- actual.should be_older_than(3)
- end
-
- it "should fail when actual returns false for :predicate?(*args)" do
- actual = mock("actual")
- actual.should_receive(:older_than?).with(3).and_return(false)
- lambda {
- actual.should be_older_than(3)
- }.should fail_with("expected older_than?(3) to return true, got false")
- end
-
- it "should fail when actual does not respond to :predicate?" do
- lambda {
- Object.new.should be_older_than(3)
- }.should raise_error(NameError)
- end
-end
-
-describe "should_not be_predicate(*args)" do
- it "should pass when actual returns false for :predicate?(*args)" do
- actual = mock("actual")
- actual.should_receive(:older_than?).with(3).and_return(false)
- actual.should_not be_older_than(3)
- end
-
- it "should fail when actual returns true for :predicate?(*args)" do
- actual = mock("actual")
- actual.should_receive(:older_than?).with(3).and_return(true)
- lambda {
- actual.should_not be_older_than(3)
- }.should fail_with("expected older_than?(3) to return false, got true")
- end
-
- it "should fail when actual does not respond to :predicate?" do
- lambda {
- Object.new.should_not be_older_than(3)
- }.should raise_error(NameError)
- end
-end
-
-describe "should be_true" do
- it "should pass when actual equal(true)" do
- true.should be_true
- end
-
- it "should fail when actual equal(false)" do
- lambda {
- false.should be_true
- }.should fail_with("expected true, got false")
- end
-end
-
-describe "should be_false" do
- it "should pass when actual equal(false)" do
- false.should be_false
- end
-
- it "should fail when actual equal(true)" do
- lambda {
- true.should be_false
- }.should fail_with("expected false, got true")
- end
-end
-
-describe "should be_nil" do
- it "should pass when actual is nil" do
- nil.should be_nil
- end
-
- it "should fail when actual is not nil" do
- lambda {
- :not_nil.should be_nil
- }.should fail_with("expected nil, got :not_nil")
- end
-end
-
-describe "should_not be_nil" do
- it "should pass when actual is not nil" do
- :not_nil.should_not be_nil
- end
-
- it "should fail when actual is nil" do
- lambda {
- nil.should_not be_nil
- }.should fail_with("expected not nil, got nil")
- end
-end
-
-describe "should be <" do
- it "should pass when < operator returns true" do
- 3.should be < 4
- end
-
- it "should fail when < operator returns false" do
- lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3")
- end
-end
-
-describe "should be <=" do
- it "should pass when <= operator returns true" do
- 3.should be <= 4
- 4.should be <= 4
- end
-
- it "should fail when <= operator returns false" do
- lambda { 3.should be <= 2 }.should fail_with("expected <= 2, got 3")
- end
-end
-
-describe "should be >=" do
- it "should pass when >= operator returns true" do
- 4.should be >= 4
- 5.should be >= 4
- end
-
- it "should fail when >= operator returns false" do
- lambda { 3.should be >= 4 }.should fail_with("expected >= 4, got 3")
- end
-end
-
-describe "should be >" do
- it "should pass when > operator returns true" do
- 5.should be > 4
- end
-
- it "should fail when > operator returns false" do
- lambda { 3.should be > 4 }.should fail_with("expected > 4, got 3")
- end
-end
-
-describe "should be ==" do
- it "should pass when == operator returns true" do
- 5.should be == 5
- end
-
- it "should fail when == operator returns false" do
- lambda { 3.should be == 4 }.should fail_with("expected == 4, got 3")
- end
-end
-
-describe "should be ===" do
- it "should pass when === operator returns true" do
- Hash.should be === Hash.new
- end
-
- it "should fail when === operator returns false" do
- lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === "not a hash", got Hash])
- end
-end
-
-describe "should be" do
- it "should pass if actual is true or a set value" do
- true.should be
- 1.should be
- end
-
- it "should fail if actual is false" do
- lambda {false.should be}.should fail_with("expected if to be satisfied, got false")
- end
-
- it "should fail if actual is nil" do
- lambda {nil.should be}.should fail_with("expected if to be satisfied, got nil")
- end
-end
-
-describe "should be(value)" do
- it "should pass if actual.equal?(value)" do
- 5.should be(5)
- end
- it "should fail if !actual.equal?(value)" do
- lambda { 5.should be(6) }.should fail_with("expected 6, got 5")
- end
-end
+++ /dev/null
-#Based on patch from Wilson Bilkovich
-
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-class SomethingExpected
- attr_accessor :some_value
-end
-
-describe "should change(actual, message)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when actual is modified by the block" do
- lambda {@instance.some_value = 6}.should change(@instance, :some_value)
- end
-
- it "should fail when actual is not modified by the block" do
- lambda do
- lambda {}.should change(@instance, :some_value)
- end.should fail_with("some_value should have changed, but is still 5")
- end
-end
-
-describe "should_not change(actual, message)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when actual is not modified by the block" do
- lambda { }.should_not change(@instance, :some_value)
- end
-
- it "should fail when actual is not modified by the block" do
- lambda do
- lambda {@instance.some_value = 6}.should_not change(@instance, :some_value)
- end.should fail_with("some_value should not have changed, but did change from 5 to 6")
- end
-end
-
-describe "should change { block }" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when actual is modified by the block" do
- lambda {@instance.some_value = 6}.should change { @instance.some_value }
- end
-
- it "should fail when actual is not modified by the block" do
- lambda do
- lambda {}.should change{ @instance.some_value }
- end.should fail_with("result should have changed, but is still 5")
- end
-
- it "should warn if passed a block using do/end" do
- lambda do
- lambda {}.should change do
- end
- end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
- end
-end
-
-describe "should_not change { block }" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when actual is modified by the block" do
- lambda {}.should_not change{ @instance.some_value }
- end
-
- it "should fail when actual is not modified by the block" do
- lambda do
- lambda {@instance.some_value = 6}.should_not change { @instance.some_value }
- end.should fail_with("result should not have changed, but did change from 5 to 6")
- end
-
- it "should warn if passed a block using do/end" do
- lambda do
- lambda {}.should_not change do
- end
- end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
- end
-end
-
-describe "should change(actual, message).by(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by expected amount" do
- lambda { @instance.some_value += 1 }.should change(@instance, :some_value).by(1)
- end
-
- it "should fail when the attribute is changed by unexpected amount" do
- lambda do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by(1)
- end.should fail_with("some_value should have been changed by 1, but was changed by 2")
- end
-
- it "should fail when the attribute is changed by unexpected amount in the opposite direction" do
- lambda do
- lambda { @instance.some_value -= 1 }.should change(@instance, :some_value).by(1)
- end.should fail_with("some_value should have been changed by 1, but was changed by -1")
- end
-end
-
-describe "should change{ block }.by(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by expected amount" do
- lambda { @instance.some_value += 1 }.should change{@instance.some_value}.by(1)
- end
-
- it "should fail when the attribute is changed by unexpected amount" do
- lambda do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by(1)
- end.should fail_with("result should have been changed by 1, but was changed by 2")
- end
-
- it "should fail when the attribute is changed by unexpected amount in the opposite direction" do
- lambda do
- lambda { @instance.some_value -= 1 }.should change{@instance.some_value}.by(1)
- end.should fail_with("result should have been changed by 1, but was changed by -1")
- end
-end
-
-describe "should change(actual, message).by_at_least(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by greater than the expected amount" do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_least(1)
- end
-
- it "should pass when attribute is changed by the expected amount" do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_least(2)
- end
-
- it "should fail when the attribute is changed by less than the expected amount" do
- lambda do
- lambda { @instance.some_value += 1 }.should change(@instance, :some_value).by_at_least(2)
- end.should fail_with("some_value should have been changed by at least 2, but was changed by 1")
- end
-
-end
-
-describe "should change{ block }.by_at_least(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by greater than expected amount" do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_least(1)
- end
-
- it "should pass when attribute is changed by the expected amount" do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_least(2)
- end
-
- it "should fail when the attribute is changed by less than the unexpected amount" do
- lambda do
- lambda { @instance.some_value += 1 }.should change{@instance.some_value}.by_at_least(2)
- end.should fail_with("result should have been changed by at least 2, but was changed by 1")
- end
-end
-
-
-describe "should change(actual, message).by_at_most(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by less than the expected amount" do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(3)
- end
-
- it "should pass when attribute is changed by the expected amount" do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(2)
- end
-
- it "should fail when the attribute is changed by greater than the expected amount" do
- lambda do
- lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(1)
- end.should fail_with("some_value should have been changed by at most 1, but was changed by 2")
- end
-
-end
-
-describe "should change{ block }.by_at_most(expected)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 5
- end
-
- it "should pass when attribute is changed by less than expected amount" do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(3)
- end
-
- it "should pass when attribute is changed by the expected amount" do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(2)
- end
-
- it "should fail when the attribute is changed by greater than the unexpected amount" do
- lambda do
- lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(1)
- end.should fail_with("result should have been changed by at most 1, but was changed by 2")
- end
-end
-
-describe "should change(actual, message).from(old)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when attribute is == to expected value before executing block" do
- lambda { @instance.some_value = "astring" }.should change(@instance, :some_value).from("string")
- end
-
- it "should fail when attribute is not == to expected value before executing block" do
- lambda do
- lambda { @instance.some_value = "knot" }.should change(@instance, :some_value).from("cat")
- end.should fail_with("some_value should have initially been \"cat\", but was \"string\"")
- end
-end
-
-describe "should change{ block }.from(old)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when attribute is == to expected value before executing block" do
- lambda { @instance.some_value = "astring" }.should change{@instance.some_value}.from("string")
- end
-
- it "should fail when attribute is not == to expected value before executing block" do
- lambda do
- lambda { @instance.some_value = "knot" }.should change{@instance.some_value}.from("cat")
- end.should fail_with("result should have initially been \"cat\", but was \"string\"")
- end
-end
-
-describe "should change(actual, message).to(new)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when attribute is == to expected value after executing block" do
- lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).to("cat")
- end
-
- it "should fail when attribute is not == to expected value after executing block" do
- lambda do
- lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("string").to("dog")
- end.should fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
- end
-end
-
-describe "should change{ block }.to(new)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when attribute is == to expected value after executing block" do
- lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.to("cat")
- end
-
- it "should fail when attribute is not == to expected value after executing block" do
- lambda do
- lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("dog")
- end.should fail_with("result should have been changed to \"dog\", but is now \"cat\"")
- end
-end
-
-describe "should change(actual, message).from(old).to(new)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when #to comes before #from" do
- lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).to("cat").from("string")
- end
-
- it "should pass when #from comes before #to" do
- lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("string").to("cat")
- end
-end
-
-describe "should change{ block }.from(old).to(new)" do
- before(:each) do
- @instance = SomethingExpected.new
- @instance.some_value = 'string'
- end
-
- it "should pass when #to comes before #from" do
- lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.to("cat").from("string")
- end
-
- it "should pass when #from comes before #to" do
- lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("cat")
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "Matchers should be able to generate their own descriptions" do
- after(:each) do
- Spec::Matchers.clear_generated_description
- end
-
- it "should == expected" do
- "this".should == "this"
- Spec::Matchers.generated_description.should == "should == \"this\""
- end
-
- it "should not == expected" do
- "this".should_not == "that"
- Spec::Matchers.generated_description.should == "should not == \"that\""
- end
-
- it "should be empty (arbitrary predicate)" do
- [].should be_empty
- Spec::Matchers.generated_description.should == "should be empty"
- end
-
- it "should not be empty (arbitrary predicate)" do
- [1].should_not be_empty
- Spec::Matchers.generated_description.should == "should not be empty"
- end
-
- it "should be true" do
- true.should be_true
- Spec::Matchers.generated_description.should == "should be true"
- end
-
- it "should be false" do
- false.should be_false
- Spec::Matchers.generated_description.should == "should be false"
- end
-
- it "should be nil" do
- nil.should be_nil
- Spec::Matchers.generated_description.should == "should be nil"
- end
-
- it "should be > n" do
- 5.should be > 3
- Spec::Matchers.generated_description.should == "should be > 3"
- end
-
- it "should be predicate arg1, arg2 and arg3" do
- 5.0.should be_between(0,10)
- Spec::Matchers.generated_description.should == "should be between 0 and 10"
- end
-
- it "should be_few_words predicate should be transformed to 'be few words'" do
- 5.should be_kind_of(Fixnum)
- Spec::Matchers.generated_description.should == "should be kind of Fixnum"
- end
-
- it "should preserve a proper prefix for be predicate" do
- 5.should be_a_kind_of(Fixnum)
- Spec::Matchers.generated_description.should == "should be a kind of Fixnum"
- 5.should be_an_instance_of(Fixnum)
- Spec::Matchers.generated_description.should == "should be an instance of Fixnum"
- end
-
- it "should equal" do
- expected = "expected"
- expected.should equal(expected)
- Spec::Matchers.generated_description.should == "should equal \"expected\""
- end
-
- it "should_not equal" do
- 5.should_not equal(37)
- Spec::Matchers.generated_description.should == "should not equal 37"
- end
-
- it "should eql" do
- "string".should eql("string")
- Spec::Matchers.generated_description.should == "should eql \"string\""
- end
-
- it "should not eql" do
- "a".should_not eql(:a)
- Spec::Matchers.generated_description.should == "should not eql :a"
- end
-
- it "should have_key" do
- {:a => "a"}.should have_key(:a)
- Spec::Matchers.generated_description.should == "should have key :a"
- end
-
- it "should have n items" do
- team.should have(3).players
- Spec::Matchers.generated_description.should == "should have 3 players"
- end
-
- it "should have at least n items" do
- team.should have_at_least(2).players
- Spec::Matchers.generated_description.should == "should have at least 2 players"
- end
-
- it "should have at most n items" do
- team.should have_at_most(4).players
- Spec::Matchers.generated_description.should == "should have at most 4 players"
- end
-
- it "should include" do
- [1,2,3].should include(3)
- Spec::Matchers.generated_description.should == "should include 3"
- end
-
- it "should match" do
- "this string".should match(/this string/)
- Spec::Matchers.generated_description.should == "should match /this string/"
- end
-
- it "should raise_error" do
- lambda { raise }.should raise_error
- Spec::Matchers.generated_description.should == "should raise Exception"
- end
-
- it "should raise_error with type" do
- lambda { raise }.should raise_error(RuntimeError)
- Spec::Matchers.generated_description.should == "should raise RuntimeError"
- end
-
- it "should raise_error with type and message" do
- lambda { raise "there was an error" }.should raise_error(RuntimeError, "there was an error")
- Spec::Matchers.generated_description.should == "should raise RuntimeError with \"there was an error\""
- end
-
- it "should respond_to" do
- [].should respond_to(:insert)
- Spec::Matchers.generated_description.should == "should respond to #insert"
- end
-
- it "should throw symbol" do
- lambda { throw :what_a_mess }.should throw_symbol
- Spec::Matchers.generated_description.should == "should throw a Symbol"
- end
-
- it "should throw symbol (with named symbol)" do
- lambda { throw :what_a_mess }.should throw_symbol(:what_a_mess)
- Spec::Matchers.generated_description.should == "should throw :what_a_mess"
- end
-
- def team
- Class.new do
- def players
- [1,2,3]
- end
- end.new
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Matchers
- describe Eql do
- it "should match when actual.eql?(expected)" do
- Eql.new(1).matches?(1).should be_true
- end
- it "should not match when !actual.eql?(expected)" do
- Eql.new(1).matches?(2).should be_false
- end
- it "should describe itself" do
- matcher = Eql.new(1)
- matcher.description.should == "eql 1"
- end
- it "should provide message, expected and actual on #failure_message" do
- matcher = Eql.new("1")
- matcher.matches?(1)
- matcher.failure_message.should == ["expected \"1\", got 1 (using .eql?)", "1", 1]
- end
- it "should provide message, expected and actual on #negative_failure_message" do
- matcher = Eql.new(1)
- matcher.matches?(1)
- matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .eql?)", 1, 1]
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Matchers
- describe Equal do
- it "should match when actual.equal?(expected)" do
- Equal.new(1).matches?(1).should be_true
- end
- it "should not match when !actual.equal?(expected)" do
- Equal.new("1").matches?("1").should be_false
- end
- it "should describe itself" do
- matcher = Equal.new(1)
- matcher.description.should == "equal 1"
- end
- it "should provide message, expected and actual on #failure_message" do
- matcher = Equal.new("1")
- matcher.matches?(1)
- matcher.failure_message.should == ["expected \"1\", got 1 (using .equal?)", "1", 1]
- end
- it "should provide message, expected and actual on #negative_failure_message" do
- matcher = Equal.new(1)
- matcher.matches?(1)
- matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .equal?)", 1, 1]
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-class Substance
- def initialize exists, description
- @exists = exists
- @description = description
- end
- def exist?
- @exists
- end
- def inspect
- @description
- end
-end
-
-class SubstanceTester
- include Spec::Matchers
- def initialize substance
- @substance = substance
- end
- def should_exist
- @substance.should exist
- end
-end
-
-describe "should exist," do
-
- before(:each) do
- @real = Substance.new true, 'something real'
- @imaginary = Substance.new false, 'something imaginary'
- end
-
- describe "within an example group" do
-
- it "should pass if target exists" do
- @real.should exist
- end
-
- it "should fail if target does not exist" do
- lambda { @imaginary.should exist }.should fail
- end
-
- it "should pass if target doesn't exist" do
- lambda { @real.should_not exist }.should fail
- end
- end
-
- describe "outside of an example group" do
-
- it "should pass if target exists" do
- real_tester = SubstanceTester.new @real
- real_tester.should_exist
- end
-
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module ExampleExpectations
-
- class ArbitraryMatcher
- def initialize(*args, &block)
- if args.last.is_a? Hash
- @expected = args.last[:expected]
- end
- if block_given?
- @expected = block.call
- end
- @block = block
- end
-
- def matches?(target)
- @target = target
- return @expected == target
- end
-
- def with(new_value)
- @expected = new_value
- self
- end
-
- def failure_message
- "expected #{@expected}, got #{@target}"
- end
-
- def negative_failure_message
- "expected not #{@expected}, got #{@target}"
- end
- end
-
- class PositiveOnlyMatcher < ArbitraryMatcher
- undef negative_failure_message rescue nil
- end
-
- def arbitrary_matcher(*args, &block)
- ArbitraryMatcher.new(*args, &block)
- end
-
- def positive_only_matcher(*args, &block)
- PositiveOnlyMatcher.new(*args, &block)
- end
-
-end
-
-module Spec
- module Expectations
- describe ExpectationMatcherHandler, ".handle_matcher" do
- it "should ask the matcher if it matches" do
- matcher = mock("matcher")
- actual = Object.new
- matcher.should_receive(:matches?).with(actual).and_return(true)
- ExpectationMatcherHandler.handle_matcher(actual, matcher)
- end
-
- it "should explain when the matcher parameter is not a matcher" do
- begin
- nonmatcher = mock("nonmatcher")
- actual = Object.new
- ExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
- rescue Spec::Expectations::InvalidMatcherError => e
- end
-
- e.message.should =~ /^Expected a matcher, got /
- end
- end
-
- describe NegativeExpectationMatcherHandler, ".handle_matcher" do
- it "should explain when matcher does not support should_not" do
- matcher = mock("matcher")
- matcher.stub!(:matches?)
- actual = Object.new
- lambda {
- NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
- }.should fail_with(/Matcher does not support should_not.\n/)
- end
-
- it "should ask the matcher if it matches" do
- matcher = mock("matcher")
- actual = Object.new
- matcher.stub!(:negative_failure_message)
- matcher.should_receive(:matches?).with(actual).and_return(false)
- NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
- end
-
- it "should explain when the matcher parameter is not a matcher" do
- begin
- nonmatcher = mock("nonmatcher")
- actual = Object.new
- NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
- rescue Spec::Expectations::InvalidMatcherError => e
- end
-
- e.message.should =~ /^Expected a matcher, got /
- end
- end
-
- describe ExpectationMatcherHandler do
- include ExampleExpectations
-
- it "should handle submitted args" do
- 5.should arbitrary_matcher(:expected => 5)
- 5.should arbitrary_matcher(:expected => "wrong").with(5)
- lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
- lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
- 5.should_not arbitrary_matcher(:expected => 4)
- 5.should_not arbitrary_matcher(:expected => 5).with(4)
- lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
- lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
- end
-
- it "should handle the submitted block" do
- 5.should arbitrary_matcher { 5 }
- 5.should arbitrary_matcher(:expected => 4) { 5 }
- 5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
- end
-
- it "should explain when matcher does not support should_not" do
- lambda {
- 5.should_not positive_only_matcher(:expected => 5)
- }.should fail_with(/Matcher does not support should_not.\n/)
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should have_sym(*args)" do
- it "should pass if #has_sym?(*args) returns true" do
- {:a => "A"}.should have_key(:a)
- end
-
- it "should fail if #has_sym?(*args) returns false" do
- lambda {
- {:b => "B"}.should have_key(:a)
- }.should fail_with("expected #has_key?(:a) to return true, got false")
- end
-
- it "should fail if target does not respond to #has_sym?" do
- lambda {
- Object.new.should have_key(:a)
- }.should raise_error(NoMethodError)
- end
-end
-
-describe "should_not have_sym(*args)" do
- it "should pass if #has_sym?(*args) returns false" do
- {:a => "A"}.should_not have_key(:b)
- end
-
- it "should fail if #has_sym?(*args) returns true" do
- lambda {
- {:a => "A"}.should_not have_key(:a)
- }.should fail_with("expected #has_key?(:a) to return false, got true")
- end
-
- it "should fail if target does not respond to #has_sym?" do
- lambda {
- Object.new.should have_key(:a)
- }.should raise_error(NoMethodError)
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module HaveSpecHelper
- def create_collection_owner_with(n)
- owner = Spec::Expectations::Helper::CollectionOwner.new
- (1..n).each do |n|
- owner.add_to_collection_with_length_method(n)
- owner.add_to_collection_with_size_method(n)
- end
- owner
- end
-end
-
-describe "should have(n).items" do
- include HaveSpecHelper
-
- it "should pass if target has a collection of items with n members" do
- owner = create_collection_owner_with(3)
- owner.should have(3).items_in_collection_with_length_method
- owner.should have(3).items_in_collection_with_size_method
- end
-
- it "should convert :no to 0" do
- owner = create_collection_owner_with(0)
- owner.should have(:no).items_in_collection_with_length_method
- owner.should have(:no).items_in_collection_with_size_method
- end
-
- it "should fail if target has a collection of items with < n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have(4).items_in_collection_with_length_method
- }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have(4).items_in_collection_with_size_method
- }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
- end
-
- it "should fail if target has a collection of items with > n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have(2).items_in_collection_with_length_method
- }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have(2).items_in_collection_with_size_method
- }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
- end
-end
-
-describe 'should have(1).item when Inflector is defined' do
- include HaveSpecHelper
-
- before do
- unless Object.const_defined?(:Inflector)
- class Inflector
- def self.pluralize(string)
- string.to_s + 's'
- end
- end
- end
- end
-
- it 'should pluralize the collection name' do
- owner = create_collection_owner_with(1)
- owner.should have(1).item
- end
-end
-
-describe "should have(n).items where result responds to items but returns something other than a collection" do
- it "should provide a meaningful error" do
- owner = Class.new do
- def items
- Object.new
- end
- end.new
- lambda do
- owner.should have(3).items
- end.should raise_error("expected items to be a collection but it does not respond to #length or #size")
- end
-end
-
-describe "should_not have(n).items" do
- include HaveSpecHelper
-
- it "should pass if target has a collection of items with < n members" do
- owner = create_collection_owner_with(3)
- owner.should_not have(4).items_in_collection_with_length_method
- owner.should_not have(4).items_in_collection_with_size_method
- end
-
- it "should pass if target has a collection of items with > n members" do
- owner = create_collection_owner_with(3)
- owner.should_not have(2).items_in_collection_with_length_method
- owner.should_not have(2).items_in_collection_with_size_method
- end
-
- it "should fail if target has a collection of items with n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should_not have(3).items_in_collection_with_length_method
- }.should fail_with("expected target not to have 3 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should_not have(3).items_in_collection_with_size_method
- }.should fail_with("expected target not to have 3 items_in_collection_with_size_method, got 3")
- end
-end
-
-describe "should have_exactly(n).items" do
- include HaveSpecHelper
-
- it "should pass if target has a collection of items with n members" do
- owner = create_collection_owner_with(3)
- owner.should have_exactly(3).items_in_collection_with_length_method
- owner.should have_exactly(3).items_in_collection_with_size_method
- end
-
- it "should convert :no to 0" do
- owner = create_collection_owner_with(0)
- owner.should have_exactly(:no).items_in_collection_with_length_method
- owner.should have_exactly(:no).items_in_collection_with_size_method
- end
-
- it "should fail if target has a collection of items with < n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have_exactly(4).items_in_collection_with_length_method
- }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have_exactly(4).items_in_collection_with_size_method
- }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
- end
-
- it "should fail if target has a collection of items with > n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have_exactly(2).items_in_collection_with_length_method
- }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have_exactly(2).items_in_collection_with_size_method
- }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
- end
-end
-
-describe "should have_at_least(n).items" do
- include HaveSpecHelper
-
- it "should pass if target has a collection of items with n members" do
- owner = create_collection_owner_with(3)
- owner.should have_at_least(3).items_in_collection_with_length_method
- owner.should have_at_least(3).items_in_collection_with_size_method
- end
-
- it "should pass if target has a collection of items with > n members" do
- owner = create_collection_owner_with(3)
- owner.should have_at_least(2).items_in_collection_with_length_method
- owner.should have_at_least(2).items_in_collection_with_size_method
- end
-
- it "should fail if target has a collection of items with < n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have_at_least(4).items_in_collection_with_length_method
- }.should fail_with("expected at least 4 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have_at_least(4).items_in_collection_with_size_method
- }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
- end
-
- it "should provide educational negative failure messages" do
- #given
- owner = create_collection_owner_with(3)
- length_matcher = have_at_least(3).items_in_collection_with_length_method
- size_matcher = have_at_least(3).items_in_collection_with_size_method
-
- #when
- length_matcher.matches?(owner)
- size_matcher.matches?(owner)
-
- #then
- length_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_least(3).items_in_collection_with_length_method
-We recommend that you use this instead:
- should have_at_most(2).items_in_collection_with_length_method
-EOF
-
- size_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_least(3).items_in_collection_with_size_method
-We recommend that you use this instead:
- should have_at_most(2).items_in_collection_with_size_method
-EOF
- end
-end
-
-describe "should have_at_most(n).items" do
- include HaveSpecHelper
-
- it "should pass if target has a collection of items with n members" do
- owner = create_collection_owner_with(3)
- owner.should have_at_most(3).items_in_collection_with_length_method
- owner.should have_at_most(3).items_in_collection_with_size_method
- end
-
- it "should fail if target has a collection of items with > n members" do
- owner = create_collection_owner_with(3)
- lambda {
- owner.should have_at_most(2).items_in_collection_with_length_method
- }.should fail_with("expected at most 2 items_in_collection_with_length_method, got 3")
- lambda {
- owner.should have_at_most(2).items_in_collection_with_size_method
- }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
- end
-
- it "should pass if target has a collection of items with < n members" do
- owner = create_collection_owner_with(3)
- owner.should have_at_most(4).items_in_collection_with_length_method
- owner.should have_at_most(4).items_in_collection_with_size_method
- end
-
- it "should provide educational negative failure messages" do
- #given
- owner = create_collection_owner_with(3)
- length_matcher = have_at_most(3).items_in_collection_with_length_method
- size_matcher = have_at_most(3).items_in_collection_with_size_method
-
- #when
- length_matcher.matches?(owner)
- size_matcher.matches?(owner)
-
- #then
- length_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_most(3).items_in_collection_with_length_method
-We recommend that you use this instead:
- should have_at_least(4).items_in_collection_with_length_method
-EOF
-
- size_matcher.negative_failure_message.should == <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
- should_not have_at_most(3).items_in_collection_with_size_method
-We recommend that you use this instead:
- should have_at_least(4).items_in_collection_with_size_method
-EOF
- end
-end
-
-describe "have(n).items(args, block)" do
- it "should pass args to target" do
- target = mock("target")
- target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
- target.should have(3).items("arg1","arg2")
- end
-
- it "should pass block to target" do
- target = mock("target")
- block = lambda { 5 }
- target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
- target.should have(3).items("arg1","arg2", block)
- end
-end
-
-describe "have(n).items where target IS a collection" do
- it "should reference the number of items IN the collection" do
- [1,2,3].should have(3).items
- end
-
- it "should fail when the number of items IN the collection is not as expected" do
- lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3")
- end
-end
-
-describe "have(n).characters where target IS a String" do
- it "should pass if the length is correct" do
- "this string".should have(11).characters
- end
-
- it "should fail if the length is incorrect" do
- lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11")
- end
-end
-
-describe "have(n).things on an object which is not a collection nor contains one" do
- it "should fail" do
- lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should include(expected)" do
- it "should pass if target includes expected" do
- [1,2,3].should include(3)
- "abc".should include("a")
- end
-
- it "should fail if target does not include expected" do
- lambda {
- [1,2,3].should include(4)
- }.should fail_with("expected [1, 2, 3] to include 4")
- lambda {
- "abc".should include("d")
- }.should fail_with("expected \"abc\" to include \"d\"")
- end
-end
-
-describe "should include(with, multiple, args)" do
- it "should pass if target includes all items" do
- [1,2,3].should include(1,2,3)
- end
-
- it "should fail if target does not include any one of the items" do
- lambda {
- [1,2,3].should include(1,2,4)
- }.should fail_with("expected [1, 2, 3] to include 1, 2 and 4")
- end
-end
-
-describe "should_not include(expected)" do
- it "should pass if target does not include expected" do
- [1,2,3].should_not include(4)
- "abc".should_not include("d")
- end
-
- it "should fail if target includes expected" do
- lambda {
- [1,2,3].should_not include(3)
- }.should fail_with("expected [1, 2, 3] not to include 3")
- lambda {
- "abc".should_not include("c")
- }.should fail_with("expected \"abc\" not to include \"c\"")
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should match(expected)" do
- it "should pass when target (String) matches expected (Regexp)" do
- "string".should match(/tri/)
- end
-
- it "should fail when target (String) does not match expected (Regexp)" do
- lambda {
- "string".should match(/rings/)
- }.should fail
- end
-
- it "should provide message, expected and actual on failure" do
- matcher = match(/rings/)
- matcher.matches?("string")
- matcher.failure_message.should == ["expected \"string\" to match /rings/", /rings/, "string"]
- end
-end
-
-describe "should_not match(expected)" do
- it "should pass when target (String) matches does not match (Regexp)" do
- "string".should_not match(/rings/)
- end
-
- it "should fail when target (String) matches expected (Regexp)" do
- lambda {
- "string".should_not match(/tri/)
- }.should fail
- end
-
- it "should provide message, expected and actual on failure" do
- matcher = match(/tri/)
- matcher.matches?("string")
- matcher.negative_failure_message.should == ["expected \"string\" not to match /tri/", /tri/, "string"]
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Matchers
- context %Q{The Spec::Matchers module gets included in the execution context of every spec.
-This module should provide the following methods, each of which returns a Matcher object.} do
- it "be_true" do
- be_true.should be_an_instance_of(Be)
- end
- it "be_false" do
- be_false.should be_an_instance_of(Be)
- end
- it "be_nil" do
- be_nil.should be_an_instance_of(Be)
- end
- it "be_arbitrary_predicate" do
- be_arbitrary_predicate.should be_an_instance_of(Be)
- end
- it "be_close" do
- be_close(1,2).should be_an_instance_of(BeClose)
- end
- it "change" do
- change("target", :message).should be_an_instance_of(Change)
- end
- it "eql" do
- eql(:expected).should be_an_instance_of(Eql)
- end
- it "equal" do
- equal(:expected).should be_an_instance_of(Equal)
- end
- it "have" do
- have(0).should be_an_instance_of(Have)
- end
- it "have_exactly" do
- have_exactly(0).should be_an_instance_of(Have)
- end
- it "have_at_least" do
- have_at_least(0).should be_an_instance_of(Have)
- end
- it "have_at_most" do
- have_at_most(0).should be_an_instance_of(Have)
- end
- it "include" do
- include(:value).should be_an_instance_of(Include)
- end
- it "match" do
- match(:value).should be_an_instance_of(Match)
- end
- it "raise_error" do
- raise_error.should be_an_instance_of(RaiseError)
- raise_error(NoMethodError).should be_an_instance_of(RaiseError)
- raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
- end
- it "satisfy" do
- satisfy{}.should be_an_instance_of(Satisfy)
- end
- it "throw_symbol" do
- throw_symbol.should be_an_instance_of(ThrowSymbol)
- throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
- end
- it "respond_to" do
- respond_to(:sym).should be_an_instance_of(RespondTo)
- end
- end
-
- describe "Spec::Matchers#method_missing" do
- it "should convert be_xyz to Be(:be_xyz)" do
- Be.should_receive(:new).with(:be_whatever)
- be_whatever
- end
-
- it "should convert have_xyz to Has(:have_xyz)" do
- Has.should_receive(:new).with(:have_whatever)
- have_whatever
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "The anything() mock argument constraint matcher" do
- specify { anything.should == Object.new }
- specify { anything.should == Class }
- specify { anything.should == 1 }
- specify { anything.should == "a string" }
- specify { anything.should == :a_symbol }
-end
-
-describe "The boolean() mock argument constraint matcher" do
- specify { boolean.should == true }
- specify { boolean.should == false }
- specify { boolean.should_not == Object.new }
- specify { boolean.should_not == Class }
- specify { boolean.should_not == 1 }
- specify { boolean.should_not == "a string" }
- specify { boolean.should_not == :a_symbol }
-end
-
-describe "The an_instance_of() mock argument constraint matcher" do
- # NOTE - this is implemented as a predicate_matcher - see example_group_methods.rb
- specify { an_instance_of(String).should == "string" }
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'spec/expectations/differs/default'
-
-describe "should ==" do
-
- it "should delegate message to target" do
- subject = "apple"
- subject.should_receive(:==).with("apple").and_return(true)
- subject.should == "apple"
- end
-
- it "should fail when target.==(actual) returns false" do
- subject = "apple"
- Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n got: "apple" (using ==)], "orange", "apple")
- subject.should == "orange"
- end
-
-end
-
-describe "should_not ==" do
-
- it "should delegate message to target" do
- subject = "orange"
- subject.should_receive(:==).with("apple").and_return(false)
- subject.should_not == "apple"
- end
-
- it "should fail when target.==(actual) returns false" do
- subject = "apple"
- Spec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n got: "apple"], "apple", "apple")
- subject.should_not == "apple"
- end
-
-end
-
-describe "should ===" do
-
- it "should delegate message to target" do
- subject = "apple"
- subject.should_receive(:===).with("apple").and_return(true)
- subject.should === "apple"
- end
-
- it "should fail when target.===(actual) returns false" do
- subject = "apple"
- subject.should_receive(:===).with("orange").and_return(false)
- Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n got: "apple" (using ===)], "orange", "apple")
- subject.should === "orange"
- end
-
-end
-
-describe "should_not ===" do
-
- it "should delegate message to target" do
- subject = "orange"
- subject.should_receive(:===).with("apple").and_return(false)
- subject.should_not === "apple"
- end
-
- it "should fail when target.===(actual) returns false" do
- subject = "apple"
- subject.should_receive(:===).with("apple").and_return(true)
- Spec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple",\n got: "apple"], "apple", "apple")
- subject.should_not === "apple"
- end
-
-end
-
-describe "should =~" do
-
- it "should delegate message to target" do
- subject = "foo"
- subject.should_receive(:=~).with(/oo/).and_return(true)
- subject.should =~ /oo/
- end
-
- it "should fail when target.=~(actual) returns false" do
- subject = "fu"
- subject.should_receive(:=~).with(/oo/).and_return(false)
- Spec::Expectations.should_receive(:fail_with).with(%[expected: /oo/,\n got: "fu" (using =~)], /oo/, "fu")
- subject.should =~ /oo/
- end
-
-end
-
-describe "should_not =~" do
-
- it "should delegate message to target" do
- subject = "fu"
- subject.should_receive(:=~).with(/oo/).and_return(false)
- subject.should_not =~ /oo/
- end
-
- it "should fail when target.=~(actual) returns false" do
- subject = "foo"
- subject.should_receive(:=~).with(/oo/).and_return(true)
- Spec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/,\n got: "foo"], /oo/, "foo")
- subject.should_not =~ /oo/
- end
-
-end
-
-describe "should >" do
-
- it "should pass if > passes" do
- 4.should > 3
- end
-
- it "should fail if > fails" do
- Spec::Expectations.should_receive(:fail_with).with(%[expected: > 5,\n got: 4], 5, 4)
- 4.should > 5
- end
-
-end
-
-describe "should >=" do
-
- it "should pass if >= passes" do
- 4.should > 3
- 4.should >= 4
- end
-
- it "should fail if > fails" do
- Spec::Expectations.should_receive(:fail_with).with(%[expected: >= 5,\n got: 4], 5, 4)
- 4.should >= 5
- end
-
-end
-
-describe "should <" do
-
- it "should pass if < passes" do
- 4.should < 5
- end
-
- it "should fail if > fails" do
- Spec::Expectations.should_receive(:fail_with).with(%[expected: < 3,\n got: 4], 3, 4)
- 4.should < 3
- end
-
-end
-
-describe "should <=" do
-
- it "should pass if <= passes" do
- 4.should <= 5
- 4.should <= 4
- end
-
- it "should fail if > fails" do
- Spec::Expectations.should_receive(:fail_with).with(%[expected: <= 3,\n got: 4], 3, 4)
- 4.should <= 3
- end
-
-end
-
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should raise_error" do
- it "should pass if anything is raised" do
- lambda {raise}.should raise_error
- end
-
- it "should fail if nothing is raised" do
- lambda {
- lambda {}.should raise_error
- }.should fail_with("expected Exception but nothing was raised")
- end
-end
-
-describe "should_not raise_error" do
- it "should pass if nothing is raised" do
- lambda {}.should_not raise_error
- end
-
- it "should fail if anything is raised" do
- lambda {
- lambda {raise}.should_not raise_error
- }.should fail_with("expected no Exception, got RuntimeError")
- end
-end
-
-describe "should raise_error(message)" do
- it "should pass if RuntimeError is raised with the right message" do
- lambda {raise 'blah'}.should raise_error('blah')
- end
- it "should pass if any other error is raised with the right message" do
- lambda {raise NameError.new('blah')}.should raise_error('blah')
- end
- it "should fail if RuntimeError error is raised with the wrong message" do
- lambda do
- lambda {raise 'blarg'}.should raise_error('blah')
- end.should fail_with("expected Exception with \"blah\", got #<RuntimeError: blarg>")
- end
- it "should fail if any other error is raised with the wrong message" do
- lambda do
- lambda {raise NameError.new('blarg')}.should raise_error('blah')
- end.should fail_with("expected Exception with \"blah\", got #<NameError: blarg>")
- end
-end
-
-describe "should_not raise_error(message)" do
- it "should pass if RuntimeError error is raised with the different message" do
- lambda {raise 'blarg'}.should_not raise_error('blah')
- end
- it "should pass if any other error is raised with the wrong message" do
- lambda {raise NameError.new('blarg')}.should_not raise_error('blah')
- end
- it "should fail if RuntimeError is raised with message" do
- lambda do
- lambda {raise 'blah'}.should_not raise_error('blah')
- end.should fail_with(%Q|expected no Exception with "blah", got #<RuntimeError: blah>|)
- end
- it "should fail if any other error is raised with message" do
- lambda do
- lambda {raise NameError.new('blah')}.should_not raise_error('blah')
- end.should fail_with(%Q|expected no Exception with "blah", got #<NameError: blah>|)
- end
-end
-
-describe "should raise_error(NamedError)" do
- it "should pass if named error is raised" do
- lambda { non_existent_method }.should raise_error(NameError)
- end
-
- it "should fail if nothing is raised" do
- lambda {
- lambda { }.should raise_error(NameError)
- }.should fail_with("expected NameError but nothing was raised")
- end
-
- it "should fail if another error is raised" do
- lambda {
- lambda { raise }.should raise_error(NameError)
- }.should fail_with("expected NameError, got RuntimeError")
- end
-end
-
-describe "should_not raise_error(NamedError)" do
- it "should pass if nothing is raised" do
- lambda { }.should_not raise_error(NameError)
- end
-
- it "should pass if another error is raised" do
- lambda { raise }.should_not raise_error(NameError)
- end
-
- it "should fail if named error is raised" do
- lambda {
- lambda { non_existent_method }.should_not raise_error(NameError)
- }.should fail_with(/expected no NameError, got #<NameError: undefined/)
- end
-end
-
-describe "should raise_error(NamedError, error_message) with String" do
- it "should pass if named error is raised with same message" do
- lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
- end
-
- it "should fail if nothing is raised" do
- lambda {
- lambda {}.should raise_error(RuntimeError, "example message")
- }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
- end
-
- it "should fail if incorrect error is raised" do
- lambda {
- lambda { raise }.should raise_error(NameError, "example message")
- }.should fail_with("expected NameError with \"example message\", got RuntimeError")
- end
-
- it "should fail if correct error is raised with incorrect message" do
- lambda {
- lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
- }.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/)
- end
-end
-
-describe "should_not raise_error(NamedError, error_message) with String" do
- it "should pass if nothing is raised" do
- lambda {}.should_not raise_error(RuntimeError, "example message")
- end
-
- it "should pass if a different error is raised" do
- lambda { raise }.should_not raise_error(NameError, "example message")
- end
-
- it "should pass if same error is raised with different message" do
- lambda { raise RuntimeError.new("not the example message") }.should_not raise_error(RuntimeError, "example message")
- end
-
- it "should fail if named error is raised with same message" do
- lambda {
- lambda { raise "example message" }.should_not raise_error(RuntimeError, "example message")
- }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
- end
-end
-
-describe "should raise_error(NamedError, error_message) with Regexp" do
- it "should pass if named error is raised with matching message" do
- lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
- end
-
- it "should fail if nothing is raised" do
- lambda {
- lambda {}.should raise_error(RuntimeError, /ample mess/)
- }.should fail_with("expected RuntimeError with message matching /ample mess/ but nothing was raised")
- end
-
- it "should fail if incorrect error is raised" do
- lambda {
- lambda { raise }.should raise_error(NameError, /ample mess/)
- }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError")
- end
-
- it "should fail if correct error is raised with incorrect message" do
- lambda {
- lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, /less than ample mess/)
- }.should fail_with("expected RuntimeError with message matching /less than ample mess/, got #<RuntimeError: not the example message>")
- end
-end
-
-describe "should_not raise_error(NamedError, error_message) with Regexp" do
- it "should pass if nothing is raised" do
- lambda {}.should_not raise_error(RuntimeError, /ample mess/)
- end
-
- it "should pass if a different error is raised" do
- lambda { raise }.should_not raise_error(NameError, /ample mess/)
- end
-
- it "should pass if same error is raised with non-matching message" do
- lambda { raise RuntimeError.new("non matching message") }.should_not raise_error(RuntimeError, /ample mess/)
- end
-
- it "should fail if named error is raised with matching message" do
- lambda {
- lambda { raise "example message" }.should_not raise_error(RuntimeError, /ample mess/)
- }.should fail_with("expected no RuntimeError with message matching /ample mess/, got #<RuntimeError: example message>")
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should respond_to(:sym)" do
-
- it "should pass if target responds to :sym" do
- Object.new.should respond_to(:methods)
- end
-
- it "should fail target does not respond to :sym" do
- lambda {
- Object.new.should respond_to(:some_method)
- }.should fail_with("expected target to respond to :some_method")
- end
-
-end
-
-describe "should respond_to(message1, message2)" do
-
- it "should pass if target responds to both messages" do
- Object.new.should respond_to('methods', 'inspect')
- end
-
- it "should fail target does not respond to first message" do
- lambda {
- Object.new.should respond_to('method_one', 'inspect')
- }.should fail_with('expected target to respond to "method_one"')
- end
-
- it "should fail target does not respond to second message" do
- lambda {
- Object.new.should respond_to('inspect', 'method_one')
- }.should fail_with('expected target to respond to "method_one"')
- end
-
- it "should fail target does not respond to either message" do
- lambda {
- Object.new.should respond_to('method_one', 'method_two')
- }.should fail_with('expected target to respond to "method_one", "method_two"')
- end
-end
-
-describe "should_not respond_to(:sym)" do
-
- it "should pass if target does not respond to :sym" do
- Object.new.should_not respond_to(:some_method)
- end
-
- it "should fail target responds to :sym" do
- lambda {
- Object.new.should_not respond_to(:methods)
- }.should fail_with("expected target not to respond to :methods")
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should satisfy { block }" do
- it "should pass if block returns true" do
- true.should satisfy { |val| val }
- true.should satisfy do |val|
- val
- end
- end
-
- it "should fail if block returns false" do
- lambda {
- false.should satisfy { |val| val }
- }.should fail_with("expected false to satisfy block")
- lambda do
- false.should satisfy do |val|
- val
- end
- end.should fail_with("expected false to satisfy block")
- end
-end
-
-describe "should_not satisfy { block }" do
- it "should pass if block returns false" do
- false.should_not satisfy { |val| val }
- false.should_not satisfy do |val|
- val
- end
- end
-
- it "should fail if block returns true" do
- lambda {
- true.should_not satisfy { |val| val }
- }.should fail_with("expected true not to satisfy block")
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Matchers
- describe SimpleMatcher do
- it "should match pass match arg to block" do
- actual = nil
- matcher = simple_matcher("message") do |given| actual = given end
- matcher.matches?("foo")
- actual.should == "foo"
- end
-
- it "should provide a stock failure message" do
- matcher = simple_matcher("thing") do end
- matcher.matches?("other")
- matcher.failure_message.should =~ /expected \"thing\" but got \"other\"/
- end
-
- it "should provide a stock negative failure message" do
- matcher = simple_matcher("thing") do end
- matcher.matches?("other")
- matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/
- end
-
- it "should provide a description" do
- matcher = simple_matcher("thing") do end
- matcher.description.should =="thing"
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Matchers
- describe ThrowSymbol, "(constructed with no Symbol)" do
- before(:each) { @matcher = ThrowSymbol.new }
-
- it "should match if any Symbol is thrown" do
- @matcher.matches?(lambda{ throw :sym }).should be_true
- end
- it "should not match if no Symbol is thrown" do
- @matcher.matches?(lambda{ }).should be_false
- end
- it "should provide a failure message" do
- @matcher.matches?(lambda{})
- @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
- end
- it "should provide a negative failure message" do
- @matcher.matches?(lambda{ throw :sym})
- @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
- end
- end
-
- describe ThrowSymbol, "(constructed with a Symbol)" do
- before(:each) { @matcher = ThrowSymbol.new(:sym) }
-
- it "should match if correct Symbol is thrown" do
- @matcher.matches?(lambda{ throw :sym }).should be_true
- end
- it "should not match if no Symbol is thrown" do
- @matcher.matches?(lambda{ }).should be_false
- end
- it "should not match if correct Symbol is thrown" do
- @matcher.matches?(lambda{ throw :other_sym }).should be_false
- @matcher.failure_message.should == "expected :sym, got :other_sym"
- end
- it "should provide a failure message when no Symbol is thrown" do
- @matcher.matches?(lambda{})
- @matcher.failure_message.should == "expected :sym but nothing was thrown"
- end
- it "should provide a failure message when wrong Symbol is thrown" do
- @matcher.matches?(lambda{ throw :other_sym })
- @matcher.failure_message.should == "expected :sym, got :other_sym"
- end
- it "should provide a negative failure message" do
- @matcher.matches?(lambda{ throw :sym })
- @matcher.negative_failure_message.should == "expected :sym not to be thrown"
- end
- it "should only match NameErrors raised by uncaught throws" do
- @matcher.matches?(lambda{ sym }).should be_false
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
-
- describe "AnyNumberOfTimes" do
- before(:each) do
- @mock = Mock.new("test mock")
- end
-
- it "should pass if any number of times method is called many times" do
- @mock.should_receive(:random_call).any_number_of_times
- (1..10).each do
- @mock.random_call
- end
- end
-
- it "should pass if any number of times method is called once" do
- @mock.should_receive(:random_call).any_number_of_times
- @mock.random_call
- end
-
- it "should pass if any number of times method is not called" do
- @mock.should_receive(:random_call).any_number_of_times
- end
- end
-
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe ArgumentExpectation do
- it "should consider an object that responds to #matches? and #description to be a matcher" do
- argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
- obj = mock("matcher")
- obj.should_receive(:respond_to?).with(:matches?).and_return(true)
- obj.should_receive(:respond_to?).with(:description).and_return(true)
- argument_expecatation.is_matcher?(obj).should be_true
- end
-
- it "should NOT consider an object that only responds to #matches? to be a matcher" do
- argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
- obj = mock("matcher")
- obj.should_receive(:respond_to?).with(:matches?).and_return(true)
- obj.should_receive(:respond_to?).with(:description).and_return(false)
- argument_expecatation.is_matcher?(obj).should be_false
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "at_least" do
- before(:each) do
- @mock = Mock.new("test mock")
- end
-
- it "should fail if method is never called" do
- @mock.should_receive(:random_call).at_least(4).times
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when called less than n times" do
- @mock.should_receive(:random_call).at_least(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when at least once method is never called" do
- @mock.should_receive(:random_call).at_least(:once)
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when at least twice method is called once" do
- @mock.should_receive(:random_call).at_least(:twice)
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when at least twice method is never called" do
- @mock.should_receive(:random_call).at_least(:twice)
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should pass when at least n times method is called exactly n times" do
- @mock.should_receive(:random_call).at_least(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at least n times method is called n plus 1 times" do
- @mock.should_receive(:random_call).at_least(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at least once method is called once" do
- @mock.should_receive(:random_call).at_least(:once)
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at least once method is called twice" do
- @mock.should_receive(:random_call).at_least(:once)
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at least twice method is called three times" do
- @mock.should_receive(:random_call).at_least(:twice)
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at least twice method is called twice" do
- @mock.should_receive(:random_call).at_least(:twice)
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "at_most" do
- before(:each) do
- @mock = Mock.new("test mock")
- end
-
- it "should fail when at most n times method is called n plus 1 times" do
- @mock.should_receive(:random_call).at_most(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when at most once method is called twice" do
- @mock.should_receive(:random_call).at_most(:once)
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when at most twice method is called three times" do
- @mock.should_receive(:random_call).at_most(:twice)
- @mock.random_call
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should pass when at most n times method is called exactly n times" do
- @mock.should_receive(:random_call).at_most(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at most n times method is called less than n times" do
- @mock.should_receive(:random_call).at_most(4).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at most n times method is never called" do
- @mock.should_receive(:random_call).at_most(4).times
- @mock.rspec_verify
- end
-
- it "should pass when at most once method is called once" do
- @mock.should_receive(:random_call).at_most(:once)
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at most once method is never called" do
- @mock.should_receive(:random_call).at_most(:once)
- @mock.rspec_verify
- end
-
- it "should pass when at most twice method is called once" do
- @mock.should_receive(:random_call).at_most(:twice)
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at most twice method is called twice" do
- @mock.should_receive(:random_call).at_most(:twice)
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass when at most twice method is never called" do
- @mock.should_receive(:random_call).at_most(:twice)
- @mock.rspec_verify
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "An RSpec Mock" do
- it "should hide internals in its inspect representation" do
- m = mock('cup')
- m.inspect.should =~ /#<Spec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
- end
-end
+++ /dev/null
-describe "Mock" do
- before do
- @mock = mock("test mock")
- end
-
- specify "when one example has an expectation (non-mock) inside the block passed to the mock" do
- @mock.should_receive(:msg) do |b|
- b.should be_true #this call exposes the problem
- end
- @mock.msg(false) rescue nil
- end
-
- specify "then the next example should behave as expected instead of saying" do
- @mock.should_receive(:foobar)
- @mock.foobar
- @mock.rspec_verify
- begin
- @mock.foobar
- rescue => e
- e.message.should == "Mock 'test mock' received unexpected message :foobar with (no args)"
- end
- end
-end
-
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-class LiarLiarPantsOnFire
- def respond_to?(sym)
- true
- end
-
- def self.respond_to?(sym)
- true
- end
-end
-
-describe 'should_receive' do
- before(:each) do
- @liar = LiarLiarPantsOnFire.new
- end
-
- it "should work when object lies about responding to a method" do
- @liar.should_receive(:something)
- @liar.something
- end
-
- it 'should work when class lies about responding to a method' do
- LiarLiarPantsOnFire.should_receive(:something)
- LiarLiarPantsOnFire.something
- end
-
- it 'should cleanup after itself' do
- LiarLiarPantsOnFire.metaclass.instance_methods.should_not include("something")
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "mock failure" do
-
- it "should tell you when it receives the right message with the wrong args" do
- m = mock("foo")
- m.should_receive(:bar).with("message")
- lambda {
- m.bar("different message")
- }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
- m.bar("message") # allows the spec to pass
- end
-
- it "should tell you when it receives the right message with the wrong args if you stub the method" do
- pending("fix bug 15719")
- # NOTE - for whatever reason, if you use a the block style of pending here,
- # rcov gets unhappy. Don't know why yet.
- m = mock("foo")
- m.stub!(:bar)
- m.should_receive(:bar).with("message")
- lambda {
- m.bar("different message")
- }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
- m.bar("message") # allows the spec to pass
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Bug7611
- class Foo
- end
-
- class Bar < Foo
- end
-
- describe "A Partial Mock" do
- it "should respect subclasses" do
- Foo.stub!(:new).and_return(Object.new)
- end
-
- it "should" do
- Bar.new.class.should == Bar
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Bug7805
- #This is really a duplicate of 8302
-
- describe "Stubs should correctly restore module methods" do
- it "1 - stub the open method" do
- File.stub!(:open).and_return("something")
- File.open.should == "something"
- end
- it "2 - use File.open to create example.txt" do
- filename = "#{File.dirname(__FILE__)}/example-#{Time.new.to_i}.txt"
- File.exist?(filename).should be_false
- file = File.open(filename,'w')
- file.close
- File.exist?(filename).should be_true
- File.delete(filename)
- File.exist?(filename).should be_false
- end
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "An object where respond_to? is true and does not have method" do
- # When should_receive(:sym) is sent to any object, the Proxy sends
- # respond_to?(:sym) to that object to see if the method should be proxied.
- #
- # If respond_to? itself is proxied, then when the Proxy sends respond_to?
- # to the object, the proxy is invoked and responds yes (if so set in the spec).
- # When the object does NOT actually respond to :sym, an exception is thrown
- # when trying to proxy it.
- #
- # The fix was to keep track of whether :respond_to? had been proxied and, if
- # so, call the munged copy of :respond_to? on the object.
-
- it "should not raise an exception for Object" do
- obj = Object.new
- obj.should_receive(:respond_to?).with(:foobar).and_return(true)
- obj.should_receive(:foobar).and_return(:baz)
- obj.respond_to?(:foobar).should be_true
- obj.foobar.should == :baz
- end
-
- it "should not raise an exception for mock" do
- obj = mock("obj")
- obj.should_receive(:respond_to?).with(:foobar).and_return(true)
- obj.should_receive(:foobar).and_return(:baz)
- obj.respond_to?(:foobar).should be_true
- obj.foobar.should == :baz
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Bug8302
- class Foo
- def Foo.class_method(arg)
- end
-
- def instance_bar(arg)
- end
- end
-
- describe "Bug report 8302:" do
- it "class method is not restored correctly when proxied" do
- Foo.should_not_receive(:class_method).with(Array.new)
- Foo.rspec_verify
- Foo.class_method(Array.new)
- end
-
- it "instance method is not restored correctly when proxied" do
- foo = Foo.new
- foo.should_not_receive(:instance_bar).with(Array.new)
- foo.rspec_verify
- foo.instance_bar(Array.new)
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "failing MockArgumentConstraints" do
- before(:each) do
- @mock = mock("test mock")
- @reporter = Mock.new("reporter", :null_object => true)
- end
-
- after(:each) do
- @mock.rspec_reset
- end
-
- it "should reject non boolean" do
- @mock.should_receive(:random_call).with(boolean())
- lambda do
- @mock.random_call("false")
- end.should raise_error(MockExpectationError)
- end
-
- it "should reject non numeric" do
- @mock.should_receive(:random_call).with(an_instance_of(Numeric))
- lambda do
- @mock.random_call("1")
- end.should raise_error(MockExpectationError)
- end
-
- it "should reject non string" do
- @mock.should_receive(:random_call).with(an_instance_of(String))
- lambda do
- @mock.random_call(123)
- end.should raise_error(MockExpectationError)
- end
-
- it "should reject goose when expecting a duck" do
- @mock.should_receive(:random_call).with(duck_type(:abs, :div))
- lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
- end
-
- it "should fail if regexp does not match submitted string" do
- @mock.should_receive(:random_call).with(/bcd/)
- lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError)
- end
-
- it "should fail if regexp does not match submitted regexp" do
- @mock.should_receive(:random_call).with(/bcd/)
- lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError)
- end
-
- it "should fail for a hash w/ wrong values" do
- @mock.should_receive(:random_call).with(:a => "b", :c => "d")
- lambda do
- @mock.random_call(:a => "b", :c => "e")
- end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
- end
-
- it "should fail for a hash w/ wrong keys" do
- @mock.should_receive(:random_call).with(:a => "b", :c => "d")
- lambda do
- @mock.random_call("a" => "b", "c" => "d")
- end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
- end
-
- it "should match against a Matcher" do
- lambda do
- @mock.should_receive(:msg).with(equal(3))
- @mock.msg(37)
- end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (37)")
- end
-
- it "should fail no_args with one arg" do
- lambda do
- @mock.should_receive(:msg).with(no_args)
- @mock.msg(37)
- end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)")
- end
- end
-
- describe "failing deprecated MockArgumentConstraints" do
- before(:each) do
- @mock = mock("test mock")
- @reporter = Mock.new("reporter", :null_object => true)
- Kernel.stub!(:warn)
- end
-
- after(:each) do
- @mock.rspec_reset
- end
-
- it "should reject non boolean" do
- @mock.should_receive(:random_call).with(:boolean)
- lambda do
- @mock.random_call("false")
- end.should raise_error(MockExpectationError)
- end
-
- it "should reject non numeric" do
- @mock.should_receive(:random_call).with(:numeric)
- lambda do
- @mock.random_call("1")
- end.should raise_error(MockExpectationError)
- end
-
- it "should reject non string" do
- @mock.should_receive(:random_call).with(:string)
- lambda do
- @mock.random_call(123)
- end.should raise_error(MockExpectationError)
- end
-
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Mocks
-
- describe "Mock ordering" do
-
- before do
- @mock = mock("test mock")
- end
-
- after do
- @mock.rspec_reset
- end
-
- it "should pass two calls in order" do
- @mock.should_receive(:one).ordered
- @mock.should_receive(:two).ordered
- @mock.one
- @mock.two
- @mock.rspec_verify
- end
-
- it "should pass three calls in order" do
- @mock.should_receive(:one).ordered
- @mock.should_receive(:two).ordered
- @mock.should_receive(:three).ordered
- @mock.one
- @mock.two
- @mock.three
- @mock.rspec_verify
- end
-
- it "should fail if second call comes first" do
- @mock.should_receive(:one).ordered
- @mock.should_receive(:two).ordered
- lambda do
- @mock.two
- end.should raise_error(MockExpectationError, "Mock 'test mock' received :two out of order")
- end
-
- it "should fail if third call comes first" do
- @mock.should_receive(:one).ordered
- @mock.should_receive(:two).ordered
- @mock.should_receive(:three).ordered
- @mock.one
- lambda do
- @mock.three
- end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
- end
-
- it "should fail if third call comes second" do
- @mock.should_receive(:one).ordered
- @mock.should_receive(:two).ordered
- @mock.should_receive(:three).ordered
- @mock.one
- lambda do
- @mock.three
- end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
- end
-
- it "should ignore order of non ordered calls" do
- @mock.should_receive(:ignored_0)
- @mock.should_receive(:ordered_1).ordered
- @mock.should_receive(:ignored_1)
- @mock.should_receive(:ordered_2).ordered
- @mock.should_receive(:ignored_2)
- @mock.should_receive(:ignored_3)
- @mock.should_receive(:ordered_3).ordered
- @mock.should_receive(:ignored_4)
- @mock.ignored_3
- @mock.ordered_1
- @mock.ignored_0
- @mock.ordered_2
- @mock.ignored_4
- @mock.ignored_2
- @mock.ordered_3
- @mock.ignored_1
- @mock.rspec_verify
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-require 'spec/mocks'
-
-module Spec
- module Mocks
- describe Space do
- before :each do
- @space = Space.new
- klazz = Class.new do
- def rspec_verify
- @verified = true
- end
- def verified?
- @verified
- end
- def rspec_reset
- @reset = true
- end
- def reset?
- @reset
- end
- end
- @m1 = klazz.new
- @m2 = klazz.new
- end
- it "should verify all mocks within" do
- @space.add(@m1)
- @space.add(@m2)
- @space.verify_all
- @m1.should be_verified
- @m2.should be_verified
- end
- it "should reset all mocks within" do
- @space.add(m1 = mock("mock1"))
- @space.add(m2 = mock("mock2"))
- m1.should_receive(:rspec_reset)
- m2.should_receive(:rspec_reset)
- @space.reset_all
- end
- it "should clear internal mocks on reset_all" do
- @space.add(m = mock("mock"))
- @space.reset_all
- @space.instance_eval { mocks.empty? }.should be_true
- end
- it "should only add an instance once" do
- @space.add(m1 = mock("mock1"))
- @space.add(m1)
- m1.should_receive(:rspec_verify)
- @space.verify_all
- end
- end
- end
-end
-
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Mocks
- describe Mock do
-
- before(:each) do
- @mock = mock("test mock")
- end
-
- after(:each) do
- @mock.rspec_reset
- end
-
- it "should report line number of expectation of unreceived message" do
- expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3)
- begin
- @mock.rspec_verify
- violated
- rescue MockExpectationError => e
- # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
- e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
- end
- end
-
- it "should pass when not receiving message specified as not to be received" do
- @mock.should_not_receive(:not_expected)
- @mock.rspec_verify
- end
-
- it "should pass when receiving message specified as not to be received with different args" do
- @mock.should_not_receive(:message).with("unwanted text")
- @mock.should_receive(:message).with("other text")
- @mock.message "other text"
- @mock.rspec_verify
- end
-
- it "should fail when receiving message specified as not to be received" do
- @mock.should_not_receive(:not_expected)
- @mock.not_expected
- lambda {
- @mock.rspec_verify
- violated
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (any args) 0 times, but received it once")
- end
-
- it "should fail when receiving message specified as not to be received with args" do
- @mock.should_not_receive(:not_expected).with("unexpected text")
- @mock.not_expected("unexpected text")
- lambda {
- @mock.rspec_verify
- violated
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
- end
-
- it "should pass when receiving message specified as not to be received with wrong args" do
- @mock.should_not_receive(:not_expected).with("unexpected text")
- @mock.not_expected "really unexpected text"
- @mock.rspec_verify
- end
-
- it "should allow block to calculate return values" do
- @mock.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
- @mock.something("a","b","c").should == "cba"
- @mock.rspec_verify
- end
-
- it "should allow parameter as return value" do
- @mock.should_receive(:something).with("a","b","c").and_return("booh")
- @mock.something("a","b","c").should == "booh"
- @mock.rspec_verify
- end
-
- it "should return nil if no return value set" do
- @mock.should_receive(:something).with("a","b","c")
- @mock.something("a","b","c").should be_nil
- @mock.rspec_verify
- end
-
- it "should raise exception if args dont match when method called" do
- @mock.should_receive(:something).with("a","b","c").and_return("booh")
- lambda {
- @mock.something("a","d","c")
- violated
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with (\"a\", \"d\", \"c\")")
- end
-
- it "should fail if unexpected method called" do
- lambda {
- @mock.something("a","b","c")
- violated
- }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :something with (\"a\", \"b\", \"c\")")
- end
-
- it "should use block for expectation if provided" do
- @mock.should_receive(:something) do | a, b |
- a.should == "a"
- b.should == "b"
- "booh"
- end
- @mock.something("a", "b").should == "booh"
- @mock.rspec_verify
- end
-
- it "should fail if expectation block fails" do
- @mock.should_receive(:something) {| bool | bool.should be_true}
- lambda {
- @mock.something false
- }.should raise_error(MockExpectationError, /Mock 'test mock' received :something but passed block failed with: expected true, got false/)
- end
-
- it "should fail right away when method defined as never is received" do
- pending "Used to pass (false positive). Which one is wrong, the spec or the actual behavior?"
-
- @mock.should_receive(:not_expected).never
- lambda {
- @mock.not_expected
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected 0 times, but received it 1 times")
- end
-
- it "should eventually fail when method defined as never is received" do
- @mock.should_receive(:not_expected).never
- @mock.not_expected
-
- lambda {
- @mock.rspec_verify
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (any args) 0 times, but received it once")
- end
-
- it "should raise when told to" do
- @mock.should_receive(:something).and_raise(RuntimeError)
- lambda do
- @mock.something
- end.should raise_error(RuntimeError)
- end
-
- it "should raise passed an Exception instance" do
- error = RuntimeError.new("error message")
- @mock.should_receive(:something).and_raise(error)
- lambda {
- @mock.something
- }.should raise_error(RuntimeError, "error message")
- end
-
- it "should raise RuntimeError with passed message" do
- @mock.should_receive(:something).and_raise("error message")
- lambda {
- @mock.something
- }.should raise_error(RuntimeError, "error message")
- end
-
- it "should not raise when told to if args dont match" do
- @mock.should_receive(:something).with(2).and_raise(RuntimeError)
- lambda {
- @mock.something 1
- }.should raise_error(MockExpectationError)
- end
-
- it "should throw when told to" do
- @mock.should_receive(:something).and_throw(:blech)
- lambda {
- @mock.something
- }.should throw_symbol(:blech)
- end
-
- it "should raise when explicit return and block constrained" do
- lambda {
- @mock.should_receive(:fruit) do |colour|
- :strawberry
- end.and_return :apple
- }.should raise_error(AmbiguousReturnError)
- end
-
- it "should ignore args on any args" do
- @mock.should_receive(:something).at_least(:once).with(any_args)
- @mock.something
- @mock.something 1
- @mock.something "a", 2
- @mock.something [], {}, "joe", 7
- @mock.rspec_verify
- end
-
- it "should fail on no args if any args received" do
- @mock.should_receive(:something).with(no_args())
- lambda {
- @mock.something 1
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (no args) but received it with (1)")
- end
-
- it "should fail when args are expected but none are received" do
- @mock.should_receive(:something).with(1)
- lambda {
- @mock.something
- }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (1) but received it with (no args)")
- end
-
- it "should yield 0 args to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield
- a = nil
- @mock.yield_back {|*a|}
- a.should == []
- @mock.rspec_verify
- end
-
- it "should yield 0 args multiple times to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield.
- and_yield
- a = nil
- b = []
- @mock.yield_back {|*a| b << a}
- b.should == [ [], [] ]
- @mock.rspec_verify
- end
-
- it "should yield one arg to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
- a = nil
- @mock.yield_back {|*a|}
- a.should == [99]
- @mock.rspec_verify
- end
-
- it "should yield one arg 3 times consecutively to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
- and_yield(43).
- and_yield("something fruity")
- a = nil
- b = []
- @mock.yield_back {|*a| b << a}
- b.should == [[99], [43], ["something fruity"]]
- @mock.rspec_verify
- end
-
- it "should yield many args to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
- a = nil
- @mock.yield_back {|*a|}
- a.should == [99, 27, "go"]
- @mock.rspec_verify
- end
-
- it "should yield many args 3 times consecutively to blocks that take a variable number of arguments" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
- and_yield("wait", :amber).
- and_yield("stop", 12, :red)
- a = nil
- b = []
- @mock.yield_back {|*a| b << a}
- b.should == [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
- @mock.rspec_verify
- end
-
- it "should yield single value" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
- a = nil
- @mock.yield_back {|a|}
- a.should == 99
- @mock.rspec_verify
- end
-
- it "should yield single value 3 times consecutively" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
- and_yield(43).
- and_yield("something fruity")
- a = nil
- b = []
- @mock.yield_back {|a| b << a}
- b.should == [99, 43, "something fruity"]
- @mock.rspec_verify
- end
-
- it "should yield two values" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
- a, b = nil
- @mock.yield_back {|a,b|}
- a.should == 'wha'
- b.should == 'zup'
- @mock.rspec_verify
- end
-
- it "should yield two values 3 times consecutively" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
- and_yield('not', 'down').
- and_yield(14, 65)
- a, b = nil
- c = []
- @mock.yield_back {|a,b| c << [a, b]}
- c.should == [['wha', 'zup'], ['not', 'down'], [14, 65]]
- @mock.rspec_verify
- end
-
- it "should fail when calling yielding method with wrong arity" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
- lambda {
- @mock.yield_back {|a|}
- }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"wha\", \"zup\"| to block with arity of 1")
- end
-
- it "should fail when calling yielding method consecutively with wrong arity" do
- @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
- and_yield('down').
- and_yield(14, 65)
- lambda {
- a, b = nil
- c = []
- @mock.yield_back {|a,b| c << [a, b]}
- }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"down\"| to block with arity of 2")
- end
-
- it "should fail when calling yielding method without block" do
- @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
- lambda {
- @mock.yield_back
- }.should raise_error(MockExpectationError, "Mock 'test mock' asked to yield |[\"wha\", \"zup\"]| but no block was passed")
- end
-
- it "should be able to mock send" do
- @mock.should_receive(:send).with(any_args)
- @mock.send 'hi'
- @mock.rspec_verify
- end
-
- it "should be able to raise from method calling yielding mock" do
- @mock.should_receive(:yield_me).and_yield 44
-
- lambda {
- @mock.yield_me do |x|
- raise "Bang"
- end
- }.should raise_error(StandardError, "Bang")
-
- @mock.rspec_verify
- end
-
- it "should clear expectations after verify" do
- @mock.should_receive(:foobar)
- @mock.foobar
- @mock.rspec_verify
- lambda {
- @mock.foobar
- }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :foobar with (no args)")
- end
-
- it "should restore objects to their original state on rspec_reset" do
- mock = mock("this is a mock")
- mock.should_receive(:blah)
- mock.rspec_reset
- mock.rspec_verify #should throw if reset didn't work
- end
-
- it "should work even after method_missing starts raising NameErrors instead of NoMethodErrors" do
- # Object#method_missing throws either NameErrors or NoMethodErrors.
- #
- # On a fresh ruby program Object#method_missing:
- # * raises a NoMethodError when called directly
- # * raises a NameError when called indirectly
- #
- # Once Object#method_missing has been called at least once (on any object)
- # it starts behaving differently:
- # * raises a NameError when called directly
- # * raises a NameError when called indirectly
- #
- # There was a bug in Mock#method_missing that relied on the fact
- # that calling Object#method_missing directly raises a NoMethodError.
- # This example tests that the bug doesn't exist anymore.
-
-
- # Ensures that method_missing always raises NameErrors.
- a_method_that_doesnt_exist rescue
-
-
- @mock.should_receive(:foobar)
- @mock.foobar
- @mock.rspec_verify
-
- lambda { @mock.foobar }.should_not raise_error(NameError)
- lambda { @mock.foobar }.should raise_error(MockExpectationError)
- end
-
- it "should temporarily replace a method stub on a mock" do
- @mock.stub!(:msg).and_return(:stub_value)
- @mock.should_receive(:msg).with(:arg).and_return(:mock_value)
- @mock.msg(:arg).should equal(:mock_value)
- @mock.msg.should equal(:stub_value)
- @mock.msg.should equal(:stub_value)
- @mock.rspec_verify
- end
-
- it "should temporarily replace a method stub on a non-mock" do
- non_mock = Object.new
- non_mock.stub!(:msg).and_return(:stub_value)
- non_mock.should_receive(:msg).with(:arg).and_return(:mock_value)
- non_mock.msg(:arg).should equal(:mock_value)
- non_mock.msg.should equal(:stub_value)
- non_mock.msg.should equal(:stub_value)
- non_mock.rspec_verify
- end
-
- it "should assign stub return values" do
- mock = Mock.new('name', :message => :response)
- mock.message.should == :response
- end
- end
-
- describe "a mock message receiving a block" do
- before(:each) do
- @mock = mock("mock")
- @calls = 0
- end
-
- def add_call
- @calls = @calls + 1
- end
-
- it "should call the block after #should_receive" do
- @mock.should_receive(:foo) { add_call }
-
- @mock.foo
-
- @calls.should == 1
- end
-
- it "should call the block after #once" do
- @mock.should_receive(:foo).once { add_call }
-
- @mock.foo
-
- @calls.should == 1
- end
-
- it "should call the block after #twice" do
- @mock.should_receive(:foo).twice { add_call }
-
- @mock.foo
- @mock.foo
-
- @calls.should == 2
- end
-
- it "should call the block after #times" do
- @mock.should_receive(:foo).exactly(10).times { add_call }
-
- (1..10).each { @mock.foo }
-
- @calls.should == 10
- end
-
- it "should call the block after #any_number_of_times" do
- @mock.should_receive(:foo).any_number_of_times { add_call }
-
- (1..7).each { @mock.foo }
-
- @calls.should == 7
- end
-
- it "should call the block after #with" do
- @mock.should_receive(:foo).with(:arg) { add_call }
-
- @mock.foo(:arg)
-
- @calls.should == 1
- end
-
- it "should call the block after #ordered" do
- @mock.should_receive(:foo).ordered { add_call }
- @mock.should_receive(:bar).ordered { add_call }
-
- @mock.foo
- @mock.bar
-
- @calls.should == 2
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Mocks
- describe "a Mock expectation with multiple return values and no specified count" do
- before(:each) do
- @mock = Mock.new("mock")
- @return_values = ["1",2,Object.new]
- @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
- end
-
- it "should return values in order to consecutive calls" do
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- @mock.message.should == @return_values[2]
- @mock.rspec_verify
- end
-
- it "should complain when there are too few calls" do
- third = Object.new
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
- end
-
- it "should complain when there are too many calls" do
- third = Object.new
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- @mock.message.should == @return_values[2]
- @mock.message.should == @return_values[2]
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
- end
- end
-
- describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
- before(:each) do
- @mock = Mock.new("mock")
- @return_values = ["1",2,Object.new]
- @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
- end
-
- it "should return values in order to consecutive calls" do
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- @mock.message.should == @return_values[2]
- @mock.rspec_verify
- end
-
- it "should complain when there are too few calls" do
- third = Object.new
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
- end
-
- it "should complain when there are too many calls" do
- third = Object.new
- @mock.message.should == @return_values[0]
- @mock.message.should == @return_values[1]
- @mock.message.should == @return_values[2]
- @mock.message.should == @return_values[2]
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
- end
- end
-
- describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
- before(:each) do
- @mock = Mock.new("mock")
- @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
- end
-
- it "should use last return value for subsequent calls" do
- @mock.message.should equal(11)
- @mock.message.should equal(22)
- @mock.message.should equal(22)
- @mock.rspec_verify
- end
-
- it "should fail when called less than the specified number" do
- @mock.message.should equal(11)
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once")
- end
- end
- describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
- before(:each) do
- @mock = Mock.new("mock")
- @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
- end
-
- it "should use last return value for subsequent calls" do
- @mock.message.should equal(11)
- @mock.message.should equal(22)
- @mock.message.should equal(22)
- @mock.rspec_verify
- end
-
- it "should fail when called less than the specified number" do
- @mock.message.should equal(11)
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once")
- end
-
- it "should fail when called greater than the specified number" do
- @mock.message.should equal(11)
- @mock.message.should equal(22)
- @mock.message.should equal(22)
- @mock.message.should equal(22)
- lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
- end
- end
- end
-end
-
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "a mock acting as a NullObject" do
- before(:each) do
- @mock = Mock.new("null_object", :null_object => true)
- end
-
- it "should allow explicit expectation" do
- @mock.should_receive(:something)
- @mock.something
- end
-
- it "should fail verification when explicit exception not met" do
- lambda do
- @mock.should_receive(:something)
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should ignore unexpected methods" do
- @mock.random_call("a", "d", "c")
- @mock.rspec_verify
- end
-
- it "should expected message with different args first" do
- @mock.should_receive(:message).with(:expected_arg)
- @mock.message(:unexpected_arg)
- @mock.message(:expected_arg)
- end
-
- it "should expected message with different args second" do
- @mock.should_receive(:message).with(:expected_arg)
- @mock.message(:expected_arg)
- @mock.message(:unexpected_arg)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "OnceCounts" do
- before(:each) do
- @mock = mock("test mock")
- end
-
- it "once should fail when called once with wrong args" do
- @mock.should_receive(:random_call).once.with("a", "b", "c")
- lambda do
- @mock.random_call("d", "e", "f")
- end.should raise_error(MockExpectationError)
- @mock.rspec_reset
- end
-
- it "once should fail when called twice" do
- @mock.should_receive(:random_call).once
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "once should fail when not called" do
- @mock.should_receive(:random_call).once
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "once should pass when called once" do
- @mock.should_receive(:random_call).once
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "once should pass when called once with specified args" do
- @mock.should_receive(:random_call).once.with("a", "b", "c")
- @mock.random_call("a", "b", "c")
- @mock.rspec_verify
- end
-
- it "once should pass when called once with unspecified args" do
- @mock.should_receive(:random_call).once
- @mock.random_call("a", "b", "c")
- @mock.rspec_verify
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "calling :should_receive with an options hash" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :reporter, :example_group
- before do
- @reporter = ::Spec::Runner::Reporter.new(options)
- @example_group = Class.new(::Spec::Example::ExampleGroup) do
- plugin_mock_framework
- describe("Some Examples")
- end
- reporter.add_example_group example_group
- end
-
- it "should report the file and line submitted with :expected_from" do
- example_definition = example_group.it "spec" do
- mock = Spec::Mocks::Mock.new("a mock")
- mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
- mock.rspec_verify
- end
- example = example_group.new(example_definition)
-
- reporter.should_receive(:example_finished) do |spec, error|
- error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not be_nil
- end
- example.execute(options, {})
- end
-
- it "should use the message supplied with :message" do
- example_definition = @example_group.it "spec" do
- mock = Spec::Mocks::Mock.new("a mock")
- mock.should_receive(:message, :message => "recebi nada")
- mock.rspec_verify
- end
- example = @example_group.new(example_definition)
- @reporter.should_receive(:example_finished) do |spec, error|
- error.message.should == "recebi nada"
- end
- example.execute(@options, {})
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "using a Partial Mock," do
- before(:each) do
- @object = Object.new
- end
-
- it "should name the class in the failure message" do
- @object.should_receive(:foo)
- lambda do
- @object.rspec_verify
- end.should raise_error(Spec::Mocks::MockExpectationError, /Object/)
- end
-
- it "should not conflict with @options in the object" do
- @object.instance_eval { @options = Object.new }
- @object.should_receive(:blah)
- @object.blah
- end
-
- it "should_not_receive should mock out the method" do
- @object.should_not_receive(:fuhbar)
- @object.fuhbar
- lambda do
- @object.rspec_verify
- end.should raise_error(Spec::Mocks::MockExpectationError)
- end
-
- it "should_not_receive should return a negative message expectation" do
- @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
- end
-
- it "should_receive should mock out the method" do
- @object.should_receive(:foobar).with(:test_param).and_return(1)
- @object.foobar(:test_param).should equal(1)
- end
-
- it "should_receive should handle a hash" do
- @object.should_receive(:foobar).with(:key => "value").and_return(1)
- @object.foobar(:key => "value").should equal(1)
- end
-
- it "should_receive should handle an inner hash" do
- hash = {:a => {:key => "value"}}
- @object.should_receive(:foobar).with(:key => "value").and_return(1)
- @object.foobar(hash[:a]).should equal(1)
- end
-
- it "should_receive should return a message expectation" do
- @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
- @object.foobar
- end
-
- it "should_receive should verify method was called" do
- @object.should_receive(:foobar).with(:test_param).and_return(1)
- lambda do
- @object.rspec_verify
- end.should raise_error(Spec::Mocks::MockExpectationError)
- end
-
- it "should_receive should also take a String argument" do
- @object.should_receive('foobar')
- @object.foobar
- end
-
- it "should_not_receive should also take a String argument" do
- @object.should_not_receive('foobar')
- @object.foobar
- lambda do
- @object.rspec_verify
- end.should raise_error(Spec::Mocks::MockExpectationError)
- end
-
- it "should use report nil in the error message" do
- @this_will_resolve_to_nil.should_receive(:foobar)
- lambda do
- @this_will_resolve_to_nil.rspec_verify
- end.should raise_error(Spec::Mocks::MockExpectationError, /NilClass.*expected :foobar with/)
- end
- end
-
- describe "Partially mocking an object that defines ==, after another mock has been defined" do
- before(:each) do
- stub("existing mock", :foo => :foo)
- end
-
- class PartiallyMockedEquals
- attr_reader :val
- def initialize(val)
- @val = val
- end
-
- def ==(other)
- @val == other.val
- end
- end
-
- it "should not raise an error when stubbing the object" do
- o = PartiallyMockedEquals.new :foo
- lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-module Mocks
-describe "PartialMockUsingMocksDirectly" do
- before(:each) do
-
- klass=Class.new
- klass.class_eval do
- def existing_method
- :original_value
- end
- end
- @obj = klass.new
-
- end
-
- # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
- # specify "should clear expectations on verify" do
- # @obj.should_receive(:msg)
- # @obj.msg
- # @obj.rspec_verify
- # lambda do
- # @obj.msg
- # end.should raise_error(NoMethodError)
- #
- # end
- it "should fail when expected message is not received" do
- @obj.should_receive(:msg)
- lambda do
- @obj.rspec_verify
- end.should raise_error(MockExpectationError)
-
- end
- it "should fail when message is received with incorrect args" do
- @obj.should_receive(:msg).with(:correct_arg)
- lambda do
- @obj.msg(:incorrect_arg)
- end.should raise_error(MockExpectationError)
- @obj.msg(:correct_arg)
-
- end
- it "should pass when expected message is received" do
- @obj.should_receive(:msg)
- @obj.msg
- @obj.rspec_verify
-
- end
- it "should pass when message is received with correct args" do
- @obj.should_receive(:msg).with(:correct_arg)
- @obj.msg(:correct_arg)
- @obj.rspec_verify
-
- end
- it "should revert to original method if existed" do
- @obj.existing_method.should equal(:original_value)
- @obj.should_receive(:existing_method).and_return(:mock_value)
- @obj.existing_method.should equal(:mock_value)
- @obj.rspec_verify
- @obj.existing_method.should equal(:original_value)
-
- end
-
-end
-end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "mock argument constraints", :shared => true do
- before(:each) do
- @mock = Mock.new("test mock")
- Kernel.stub!(:warn)
- end
-
- after(:each) do
- @mock.rspec_verify
- end
- end
-
- describe Methods, "handling argument constraints with DEPRECATED symbols" do
- it_should_behave_like "mock argument constraints"
-
- it "should accept true as boolean" do
- @mock.should_receive(:random_call).with(:boolean)
- @mock.random_call(true)
- end
-
- it "should accept false as boolean" do
- @mock.should_receive(:random_call).with(:boolean)
- @mock.random_call(false)
- end
-
- it "should accept fixnum as numeric" do
- @mock.should_receive(:random_call).with(:numeric)
- @mock.random_call(1)
- end
-
- it "should accept float as numeric" do
- @mock.should_receive(:random_call).with(:numeric)
- @mock.random_call(1.5)
- end
-
- it "should accept string as anything" do
- @mock.should_receive(:random_call).with("a", :anything, "c")
- @mock.random_call("a", "whatever", "c")
- end
-
- it "should match string" do
- @mock.should_receive(:random_call).with(:string)
- @mock.random_call("a string")
- end
-
- it "should match no args against any_args" do
- @mock.should_receive(:random_call).with(:any_args)
- @mock.random_call("a string")
- end
-
- it "should match no args against no_args" do
- @mock.should_receive(:random_call).with(:no_args)
- @mock.random_call
- end
- end
-
- describe Methods, "handling argument constraints" do
- it_should_behave_like "mock argument constraints"
-
- it "should accept true as boolean()" do
- @mock.should_receive(:random_call).with(boolean())
- @mock.random_call(true)
- end
-
- it "should accept false as boolean()" do
- @mock.should_receive(:random_call).with(boolean())
- @mock.random_call(false)
- end
-
- it "should accept fixnum as an_instance_of(Numeric)" do
- @mock.should_receive(:random_call).with(an_instance_of(Numeric))
- @mock.random_call(1)
- end
-
- it "should accept float as an_instance_of(Numeric)" do
- @mock.should_receive(:random_call).with(an_instance_of(Numeric))
- @mock.random_call(1.5)
- end
-
- it "should accept string as anything()" do
- @mock.should_receive(:random_call).with("a", anything(), "c")
- @mock.random_call("a", "whatever", "c")
- end
-
- it "should match duck type with one method" do
- @mock.should_receive(:random_call).with(duck_type(:length))
- @mock.random_call([])
- end
-
- it "should match duck type with two methods" do
- @mock.should_receive(:random_call).with(duck_type(:abs, :div))
- @mock.random_call(1)
- end
-
- it "should match no args against any_args()" do
- @mock.should_receive(:random_call).with(any_args)
- @mock.random_call()
- end
-
- it "should match one arg against any_args()" do
- @mock.should_receive(:random_call).with(any_args)
- @mock.random_call("a string")
- end
-
- it "should match no args against no_args()" do
- @mock.should_receive(:random_call).with(no_args)
- @mock.random_call()
- end
- end
-
- describe Methods, "handling non-constraint arguments" do
-
- it "should match non special symbol (can be removed when deprecated symbols are removed)" do
- @mock.should_receive(:random_call).with(:some_symbol)
- @mock.random_call(:some_symbol)
- end
-
- it "should match string against regexp" do
- @mock.should_receive(:random_call).with(/bcd/)
- @mock.random_call("abcde")
- end
-
- it "should match regexp against regexp" do
- @mock.should_receive(:random_call).with(/bcd/)
- @mock.random_call(/bcd/)
- end
-
- it "should match against a hash submitted and received by value" do
- @mock.should_receive(:random_call).with(:a => "a", :b => "b")
- @mock.random_call(:a => "a", :b => "b")
- end
-
- it "should match against a hash submitted by reference and received by value" do
- opts = {:a => "a", :b => "b"}
- @mock.should_receive(:random_call).with(opts)
- @mock.random_call(:a => "a", :b => "b")
- end
-
- it "should match against a hash submitted by value and received by reference" do
- opts = {:a => "a", :b => "b"}
- @mock.should_receive(:random_call).with(:a => "a", :b => "b")
- @mock.random_call(opts)
- end
-
- it "should match against a Matcher" do
- @mock.should_receive(:msg).with(equal(37))
- @mock.msg(37)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "PreciseCounts" do
- before(:each) do
- @mock = mock("test mock")
- end
-
- it "should fail when exactly n times method is called less than n times" do
- @mock.should_receive(:random_call).exactly(3).times
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should fail when exactly n times method is never called" do
- @mock.should_receive(:random_call).exactly(3).times
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "should pass if exactly n times method is called exactly n times" do
- @mock.should_receive(:random_call).exactly(3).times
- @mock.random_call
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "should pass multiple calls with different args and counts" do
- @mock.should_receive(:random_call).twice.with(1)
- @mock.should_receive(:random_call).once.with(2)
- @mock.random_call(1)
- @mock.random_call(2)
- @mock.random_call(1)
- @mock.rspec_verify
- end
-
- it "should pass mutiple calls with different args" do
- @mock.should_receive(:random_call).once.with(1)
- @mock.should_receive(:random_call).once.with(2)
- @mock.random_call(1)
- @mock.random_call(2)
- @mock.rspec_verify
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
- module Mocks
- describe "a mock" do
- before(:each) do
- @mock = mock("mock", :null_object => true)
- end
- it "should answer false for received_message? when no messages received" do
- @mock.received_message?(:message).should be_false
- end
- it "should answer true for received_message? when message received" do
- @mock.message
- @mock.received_message?(:message).should be_true
- end
- it "should answer true for received_message? when message received with correct args" do
- @mock.message 1,2,3
- @mock.received_message?(:message, 1,2,3).should be_true
- end
- it "should answer false for received_message? when message received with incorrect args" do
- @mock.message 1,2,3
- @mock.received_message?(:message, 1,2).should be_false
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "A method stub" do
- before(:each) do
- @class = Class.new do
- def self.existing_class_method
- :original_value
- end
-
- def existing_instance_method
- :original_value
- end
- end
- @instance = @class.new
- end
-
- it "should return expected value when expected message is received" do
- @instance.stub!(:msg).and_return(:return_value)
- @instance.msg.should equal(:return_value)
- @instance.rspec_verify
- end
-
- it "should ignore when expected message is received" do
- @instance.stub!(:msg)
- @instance.msg
- lambda do
- @instance.rspec_verify
- end.should_not raise_error
- end
-
- it "should ignore when message is received with args" do
- @instance.stub!(:msg)
- @instance.msg(:an_arg)
- lambda do
- @instance.rspec_verify
- end.should_not raise_error
- end
-
- it "should ignore when expected message is not received" do
- @instance.stub!(:msg)
- lambda do
- @instance.rspec_verify
- end.should_not raise_error
- end
-
- it "should clear itself when verified" do
- @instance.stub!(:this_should_go).and_return(:blah)
- @instance.this_should_go.should == :blah
- @instance.rspec_verify
- lambda do
- @instance.this_should_go
- end.should raise_error(NameError)
- end
-
- it "should return values in order to consecutive calls" do
- return_values = ["1",2,Object.new]
- @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
- @instance.msg.should == return_values[0]
- @instance.msg.should == return_values[1]
- @instance.msg.should == return_values[2]
- end
-
- it "should keep returning last value in consecutive calls" do
- return_values = ["1",2,Object.new]
- @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
- @instance.msg.should == return_values[0]
- @instance.msg.should == return_values[1]
- @instance.msg.should == return_values[2]
- @instance.msg.should == return_values[2]
- @instance.msg.should == return_values[2]
- end
-
- it "should revert to original instance method if there is one" do
- @instance.existing_instance_method.should equal(:original_value)
- @instance.stub!(:existing_instance_method).and_return(:mock_value)
- @instance.existing_instance_method.should equal(:mock_value)
- @instance.rspec_verify
- @instance.existing_instance_method.should equal(:original_value)
- end
-
- it "should revert to original class method if there is one" do
- @class.existing_class_method.should equal(:original_value)
- @class.stub!(:existing_class_method).and_return(:mock_value)
- @class.existing_class_method.should equal(:mock_value)
- @class.rspec_verify
- @class.existing_class_method.should equal(:original_value)
- end
-
- it "should yield a specified object" do
- @instance.stub!(:method_that_yields).and_yield(:yielded_obj)
- current_value = :value_before
- @instance.method_that_yields {|val| current_value = val}
- current_value.should == :yielded_obj
- @instance.rspec_verify
- end
-
- it "should yield multiple times with multiple calls to and_yield" do
- @instance.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value).
- and_yield(:another_value)
- current_value = []
- @instance.method_that_yields_multiple_times {|val| current_value << val}
- current_value.should == [:yielded_value, :another_value]
- @instance.rspec_verify
- end
-
- it "should yield a specified object and return another specified object" do
- yielded_obj = mock("my mock")
- yielded_obj.should_receive(:foo).with(:bar)
- @instance.stub!(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
- @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz
- end
-
- it "should throw when told to" do
- @mock.stub!(:something).and_throw(:up)
- lambda do
- @mock.something
- end.should throw_symbol(:up)
- end
-
- it "should override a pre-existing stub" do
- @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
- @stub.existing_instance_method.should == :updated_stub_value
- end
-
- it "should limit " do
- @stub.stub!(:foo).with("bar")
- @stub.should_receive(:foo).with("baz")
- @stub.foo("bar")
- @stub.foo("baz")
- end
- end
-
- describe "A method stub with args" do
- before(:each) do
- @stub = Object.new
- @stub.stub!(:foo).with("bar")
- end
-
- it "should not complain if not called" do
- end
-
- it "should not complain if called with arg" do
- @stub.foo("bar")
- end
-
- it "should complain if called with no arg" do
- lambda do
- @stub.foo
- end.should raise_error
- end
-
- it "should complain if called with other arg" do
- lambda do
- @stub.foo("other")
- end.should raise_error
- end
-
- it "should not complain if also mocked w/ different args" do
- @stub.should_receive(:foo).with("baz")
- @stub.foo("bar")
- @stub.foo("baz")
- end
-
- it "should complain if also mocked w/ different args AND called w/ a 3rd set of args" do
- @stub.should_receive(:foo).with("baz")
- @stub.foo("bar")
- @stub.foo("baz")
- lambda do
- @stub.foo("other")
- end.should raise_error
- end
-
- it "should support options" do
- @stub.stub!(:foo, :expected_from => "bar")
- end
- end
-
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Mocks
- describe "TwiceCounts" do
- before(:each) do
- @mock = mock("test mock")
- end
-
- it "twice should fail when call count is higher than expected" do
- @mock.should_receive(:random_call).twice
- @mock.random_call
- @mock.random_call
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "twice should fail when call count is lower than expected" do
- @mock.should_receive(:random_call).twice
- @mock.random_call
- lambda do
- @mock.rspec_verify
- end.should raise_error(MockExpectationError)
- end
-
- it "twice should fail when called twice with wrong args on the first call" do
- @mock.should_receive(:random_call).twice.with("1", 1)
- lambda do
- @mock.random_call(1, "1")
- end.should raise_error(MockExpectationError)
- @mock.rspec_reset
- end
-
- it "twice should fail when called twice with wrong args on the second call" do
- @mock.should_receive(:random_call).twice.with("1", 1)
- @mock.random_call("1", 1)
- lambda do
- @mock.random_call(1, "1")
- end.should raise_error(MockExpectationError)
- @mock.rspec_reset
- end
-
- it "twice should pass when called twice" do
- @mock.should_receive(:random_call).twice
- @mock.random_call
- @mock.random_call
- @mock.rspec_verify
- end
-
- it "twice should pass when called twice with specified args" do
- @mock.should_receive(:random_call).twice.with("1", 1)
- @mock.random_call("1", 1)
- @mock.random_call("1", 1)
- @mock.rspec_verify
- end
-
- it "twice should pass when called twice with unspecified args" do
- @mock.should_receive(:random_call).twice
- @mock.random_call("1")
- @mock.random_call(1)
- @mock.rspec_verify
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../ruby_forker'
-
-describe "The bin/spec script" do
- include RubyForker
-
- it "should have no warnings" do
- pending "Hangs on JRuby" if PLATFORM =~ /java/
- spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
-
- output = ruby "-w #{spec_path} --help 2>&1"
- output.should_not =~ /warning/n
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe ClassAndArgumentsParser, ".parse" do
-
- it "should use a single : to separate class names from arguments" do
- ClassAndArgumentsParser.parse('Foo').should == ['Foo', nil]
- ClassAndArgumentsParser.parse('Foo:arg').should == ['Foo', 'arg']
- ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg').should == ['Foo::Bar::Zap', 'arg']
- ClassAndArgumentsParser.parse('Foo:arg1,arg2').should == ['Foo', 'arg1,arg2']
- ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg1,arg2').should == ['Foo::Bar::Zap', 'arg1,arg2']
- ClassAndArgumentsParser.parse('Foo::Bar::Zap:drb://foo,drb://bar').should == ['Foo::Bar::Zap', 'drb://foo,drb://bar']
- end
-
- it "should raise an error when passed an empty string" do
- lambda do
- ClassAndArgumentsParser.parse('')
- end.should raise_error("Couldn't parse \"\"")
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe CommandLine, ".run" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :options, :err, :out
- before do
- @err = options.error_stream
- @out = options.output_stream
- end
-
- it "should run directory" do
- file = File.dirname(__FILE__) + '/../../../examples/pure'
- Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
-
- @out.rewind
- @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
- end
-
- it "should run file" do
- file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
- Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
-
- @out.rewind
- @out.read.should =~ /2 examples, 1 failure/n
- end
-
- it "should raise when file does not exist" do
- file = File.dirname(__FILE__) + '/doesntexist'
-
- lambda {
- Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
- }.should raise_error
- end
-
- it "should return true when in --generate-options mode" do
- Spec::Runner::CommandLine.run(
- OptionParser.parse(['--generate-options', '/dev/null'], @err, @out)
- ).should be_true
- end
-
- it "should dump even if Interrupt exception is occurred" do
- example_group = Class.new(::Spec::Example::ExampleGroup) do
- describe("example_group")
- it "no error" do
- end
-
- it "should interrupt" do
- raise Interrupt, "I'm interrupting"
- end
- end
-
- options = ::Spec::Runner::Options.new(@err, @out)
- ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
- options.reporter.should_receive(:dump)
- options.add_example_group(example_group)
-
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
- end
-
- it "should heckle when options have heckle_runner" do
- example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
- it "no error" do
- end
- end
- options = ::Spec::Runner::Options.new(@err, @out)
- ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
- options.add_example_group example_group
-
- heckle_runner = mock("heckle_runner")
- heckle_runner.should_receive(:heckle_with)
- $rspec_mocks.__send__(:mocks).delete(heckle_runner)
-
- options.heckle_runner = heckle_runner
- options.add_example_group(example_group)
-
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
- heckle_runner.rspec_verify
- end
-
- it "should run examples backwards if options.reverse is true" do
- options = ::Spec::Runner::Options.new(@err, @out)
- ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
- options.reverse = true
-
- b1 = Class.new(Spec::Example::ExampleGroup)
- b2 = Class.new(Spec::Example::ExampleGroup)
-
- b2.should_receive(:run).ordered
- b1.should_receive(:run).ordered
-
- options.add_example_group(b1)
- options.add_example_group(b2)
-
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
- end
-
- it "should pass its ExampleGroup to the reporter" do
- example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
- it "should" do
- end
- end
- options = ::Spec::Runner::Options.new(@err, @out)
- options.add_example_group(example_group)
-
- ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
- options.reporter.should_receive(:add_example_group).with(example_group)
-
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
- end
-
- it "runs only selected Examples when options.examples is set" do
- options = ::Spec::Runner::Options.new(@err, @out)
- ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-
- options.examples << "example_group should"
- should_has_run = false
- should_not_has_run = false
- example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
- it "should" do
- should_has_run = true
- end
- it "should not" do
- should_not_has_run = true
- end
- end
-
- options.reporter.should_receive(:add_example_group).with(example_group)
-
- options.add_example_group example_group
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-
- should_has_run.should be_true
- should_not_has_run.should be_false
- end
-
- it "sets Spec.run to true" do
- ::Spec.run = false
- ::Spec.should_not be_run
- Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
- ::Spec.should be_run
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe DrbCommandLine, "without running local server" do
- unless Config::CONFIG['ruby_install_name'] == 'jruby'
- it "should print error when there is no running local server" do
- err = StringIO.new
- out = StringIO.new
- DrbCommandLine.run(OptionParser.parse(['--version'], err, out))
-
- err.rewind
- err.read.should =~ /No server is running/
- end
- end
- end
-
- class DrbCommandLineSpec < ::Spec::Example::ExampleGroup
- describe DrbCommandLine, "with local server"
-
- class CommandLineForSpec
- def self.run(argv, stderr, stdout)
- exit Spec::Runner::CommandLine.run(OptionParser.parse(argv, stderr, stdout))
- end
- end
-
- unless Config::CONFIG['ruby_install_name'] == 'jruby'
- before(:all) do
- DRb.start_service("druby://localhost:8989", CommandLineForSpec)
- @@drb_example_file_counter = 0
- end
-
- before(:each) do
- create_dummy_spec_file
- @@drb_example_file_counter = @@drb_example_file_counter + 1
- end
-
- after(:each) do
- File.delete(@dummy_spec_filename)
- end
-
- after(:all) do
- DRb.stop_service
- end
-
- it "should run against local server" do
- out = run_spec_via_druby(['--version'])
- out.should =~ /RSpec/n
- end
-
- it "should output green colorized text when running with --colour option" do
- out = run_spec_via_druby(["--colour", @dummy_spec_filename])
- out.should =~ /\e\[32m/n
- end
-
- it "should output red colorized text when running with -c option" do
- out = run_spec_via_druby(["-c", @dummy_spec_filename])
- out.should =~ /\e\[31m/n
- end
-
- def create_dummy_spec_file
- @dummy_spec_filename = File.expand_path(File.dirname(__FILE__)) + "/_dummy_spec#{@@drb_example_file_counter}.rb"
- File.open(@dummy_spec_filename, 'w') do |f|
- f.write %{
- describe "DUMMY CONTEXT for 'DrbCommandLine with -c option'" do
- it "should be output with green bar" do
- true.should be_true
- end
-
- it "should be output with red bar" do
- violated("I want to see a red bar!")
- end
- end
- }
- end
- end
-
- def run_spec_via_druby(argv)
- err, out = StringIO.new, StringIO.new
- out.instance_eval do
- def tty?; true end
- end
- options = ::Spec::Runner::Options.new(err, out)
- options.argv = argv
- Spec::Runner::DrbCommandLine.run(options)
- out.rewind; out.read
- end
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "ExecutionContext" do
-
- it "should provide duck_type()" do
- dt = duck_type(:length)
- dt.should be_an_instance_of(Spec::Mocks::DuckTypeArgConstraint)
- dt.matches?([]).should be_true
- end
-
- it "should violate when violated()" do
- lambda do
- violated
- end.should raise_error(Spec::Expectations::ExpectationNotMetError)
- end
-
- it "should provide mock()" do
- mock("thing").should be_an_instance_of(Spec::Mocks::Mock)
- end
-
- it "should provide stub()" do
- thing_stub = stub("thing").should be_an_instance_of(Spec::Mocks::Mock)
- end
-
- it "should add method stubs to stub()" do
- thing_stub = stub("thing", :a => "A", :b => "B")
- thing_stub.a.should == "A"
- thing_stub.b.should == "B"
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper'
-require 'spec/runner/formatter/failing_example_groups_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe FailingExampleGroupsFormatter do
- attr_reader :example_group, :formatter, :io
-
- before(:each) do
- @io = StringIO.new
- options = mock('options')
- @formatter = FailingExampleGroupsFormatter.new(options, io)
- @example_group = Class.new(::Spec::Example::ExampleGroup)
- end
-
- it "should add example name for each failure" do
- formatter.add_example_group(Class.new(ExampleGroup).describe("b 1"))
- formatter.example_failed("e 1", nil, Reporter::Failure.new(nil, RuntimeError.new))
- formatter.add_example_group(Class.new(ExampleGroup).describe("b 2"))
- formatter.example_failed("e 2", nil, Reporter::Failure.new(nil, RuntimeError.new))
- formatter.example_failed("e 3", nil, Reporter::Failure.new(nil, RuntimeError.new))
- io.string.should == "b 1\nb 2\n"
- end
-
- it "should delimit ExampleGroup superclass descriptions with :" do
- parent_example_group = Class.new(example_group).describe("Parent")
- child_example_group = Class.new(parent_example_group).describe("#child_method")
- grand_child_example_group = Class.new(child_example_group).describe("GrandChild")
-
- formatter.add_example_group(grand_child_example_group)
- formatter.example_failed("failure", nil, Reporter::Failure.new(nil, RuntimeError.new))
- io.string.should == "Parent#child_method GrandChild\n"
- end
-
- it "should remove druby url, which is used by Spec::Distributed" do
- @formatter.add_example_group(Class.new(ExampleGroup).describe("something something (druby://99.99.99.99:99)"))
- @formatter.example_failed("e 1", nil, Reporter::Failure.new(nil, RuntimeError.new))
- io.string.should == "something something\n"
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper'
-require 'spec/runner/formatter/failing_examples_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe FailingExamplesFormatter do
- before(:each) do
- @io = StringIO.new
- options = mock('options')
- @formatter = FailingExamplesFormatter.new(options, @io)
- end
-
- it "should add example name for each failure" do
- example_group_1 = Class.new(ExampleGroup).describe("A")
- example_group_2 = Class.new(example_group_1).describe("B")
-
- @formatter.add_example_group(example_group_1)
- @formatter.example_failed(example_group_1.it("a1"){}, nil, Reporter::Failure.new(nil, RuntimeError.new))
- @formatter.add_example_group(example_group_2)
- @formatter.example_failed(example_group_2.it("b2"){}, nil, Reporter::Failure.new(nil, RuntimeError.new))
- @formatter.example_failed(example_group_2.it("b3"){}, nil, Reporter::Failure.new(nil, RuntimeError.new))
- @io.string.should eql(<<-EOF
-A a1
-A B b2
-A B b3
-EOF
-)
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper'
-require 'hpricot' # Needed to compare generated with wanted HTML
-require 'spec/runner/formatter/html_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe HtmlFormatter do
- ['--diff', '--dry-run'].each do |opt|
- def jruby?
- PLATFORM == 'java'
- end
-
- it "should produce HTML identical to the one we designed manually with #{opt}" do
- root = File.expand_path(File.dirname(__FILE__) + '/../../../..')
- suffix = jruby? ? '-jruby' : ''
- expected_file = File.dirname(__FILE__) + "/html_formatted-#{::VERSION}#{suffix}.html"
- raise "There is no HTML file with expected content for this platform: #{expected_file}" unless File.file?(expected_file)
- expected_html = File.read(expected_file)
- unless jruby?
- raise "There should be no absolute paths in html_formatted.html!!" if (expected_html =~ /\/Users/n || expected_html =~ /\/home/n)
- end
-
- Dir.chdir(root) do
- args = ['failing_examples/mocking_example.rb', 'failing_examples/diffing_spec.rb', 'examples/pure/stubbing_example.rb', 'examples/pure/pending_example.rb', '--format', 'html', opt]
- err = StringIO.new
- out = StringIO.new
- CommandLine.run(
- OptionParser.parse(args, err, out)
- )
-
- seconds = /\d+\.\d+ seconds/
- html = out.string.gsub seconds, 'x seconds'
- expected_html.gsub! seconds, 'x seconds'
-
- if opt == '--diff'
- # Uncomment this line temporarily in order to overwrite the expected with actual.
- # Use with care!!!
- # File.open(expected_file, 'w') {|io| io.write(html)}
-
- doc = Hpricot(html)
- backtraces = doc.search("div.backtrace").collect {|e| e.at("/pre").inner_html}
- doc.search("div.backtrace").remove
-
- expected_doc = Hpricot(expected_html)
- expected_backtraces = expected_doc.search("div.backtrace").collect {|e| e.at("/pre").inner_html}
- expected_doc.search("div.backtrace").remove
-
- doc.inner_html.should == expected_doc.inner_html
-
- expected_backtraces.each_with_index do |expected_line, i|
- expected_path, expected_line_number, expected_suffix = expected_line.split(':')
- actual_path, actual_line_number, actual_suffix = backtraces[i].split(':')
- File.expand_path(actual_path).should == File.expand_path(expected_path)
- actual_line_number.should == expected_line_number
- end
- else
- html.should =~ /This was a dry-run/m
- end
- end
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-require 'spec/runner/formatter/profile_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe ProfileFormatter do
- attr_reader :io, :formatter
- before(:each) do
- @io = StringIO.new
- options = mock('options')
- options.stub!(:colour).and_return(true)
- @formatter = ProfileFormatter.new(options, io)
- end
-
- it "should print a heading" do
- formatter.start(0)
- io.string.should eql("Profiling enabled.\n")
- end
-
- it "should record the current time when starting a new example" do
- now = Time.now
- Time.stub!(:now).and_return(now)
- formatter.example_started('should foo')
- formatter.instance_variable_get("@time").should == now
- end
-
- it "should correctly record a passed example" do
- now = Time.now
- Time.stub!(:now).and_return(now)
- parent_example_group = Class.new(ExampleGroup).describe('Parent')
- child_example_group = Class.new(parent_example_group).describe('Child')
-
- formatter.add_example_group(child_example_group)
-
- formatter.example_started('when foo')
- Time.stub!(:now).and_return(now+1)
- formatter.example_passed(stub('foo', :description => 'i like ice cream'))
-
- formatter.start_dump
- io.string.should include('Parent Child')
- end
-
- it "should sort the results in descending order" do
- formatter.instance_variable_set("@example_times", [['a', 'a', 0.1], ['b', 'b', 0.3], ['c', 'c', 0.2]])
- formatter.start_dump
- formatter.instance_variable_get("@example_times").should == [ ['b', 'b', 0.3], ['c', 'c', 0.2], ['a', 'a', 0.1]]
- end
-
- it "should print the top 10 results" do
- example_group = Class.new(::Spec::Example::ExampleGroup).describe("ExampleGroup")
- formatter.add_example_group(example_group)
- formatter.instance_variable_set("@time", Time.now)
-
- 15.times do
- formatter.example_passed(stub('foo', :description => 'i like ice cream'))
- end
-
- io.should_receive(:print).exactly(10)
- formatter.start_dump
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-require 'spec/runner/formatter/progress_bar_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe ProgressBarFormatter do
- before(:each) do
- @io = StringIO.new
- @options = mock('options')
- @options.stub!(:dry_run).and_return(false)
- @options.stub!(:colour).and_return(false)
- @formatter = ProgressBarFormatter.new(@options, @io)
- end
-
- it "should produce line break on start dump" do
- @formatter.start_dump
- @io.string.should eql("\n")
- end
-
- it "should produce standard summary without pending when pending has a 0 count" do
- @formatter.dump_summary(3, 2, 1, 0)
- @io.string.should eql("\nFinished in 3 seconds\n\n2 examples, 1 failure\n")
- end
-
- it "should produce standard summary" do
- @formatter.example_pending("example_group", ExampleGroup.new("example"), "message")
- @io.rewind
- @formatter.dump_summary(3, 2, 1, 1)
- @io.string.should eql(%Q|
-Finished in 3 seconds
-
-2 examples, 1 failure, 1 pending
-|)
- end
-
- it "should push green dot for passing spec" do
- @io.should_receive(:tty?).and_return(true)
- @options.should_receive(:colour).and_return(true)
- @formatter.example_passed("spec")
- @io.string.should == "\e[32m.\e[0m"
- end
-
- it "should push red F for failure spec" do
- @io.should_receive(:tty?).and_return(true)
- @options.should_receive(:colour).and_return(true)
- @formatter.example_failed("spec", 98, Reporter::Failure.new("c s", Spec::Expectations::ExpectationNotMetError.new))
- @io.string.should eql("\e[31mF\e[0m")
- end
-
- it "should push magenta F for error spec" do
- @io.should_receive(:tty?).and_return(true)
- @options.should_receive(:colour).and_return(true)
- @formatter.example_failed("spec", 98, Reporter::Failure.new("c s", RuntimeError.new))
- @io.string.should eql("\e[35mF\e[0m")
- end
-
- it "should push blue F for fixed pending spec" do
- @io.should_receive(:tty?).and_return(true)
- @options.should_receive(:colour).and_return(true)
- @formatter.example_failed("spec", 98, Reporter::Failure.new("c s", Spec::Example::PendingExampleFixedError.new))
- @io.string.should eql("\e[34mF\e[0m")
- end
-
- it "should push nothing on start" do
- @formatter.start(4)
- @io.string.should eql("")
- end
-
- it "should ensure two ':' in the first backtrace" do
- backtrace = ["/tmp/x.rb:1", "/tmp/x.rb:2", "/tmp/x.rb:3"]
- @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip)
-/tmp/x.rb:1:
-/tmp/x.rb:2:
-/tmp/x.rb:3:
-EOE
-
- backtrace = ["/tmp/x.rb:1: message", "/tmp/x.rb:2", "/tmp/x.rb:3"]
- @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip)
-/tmp/x.rb:1: message
-/tmp/x.rb:2:
-/tmp/x.rb:3:
-EOE
- end
-
- it "should dump pending" do
- @formatter.example_pending("example_group", ExampleGroup.new("example"), "message")
- @formatter.dump_pending
- @io.string.should =~ /Pending\:\nexample_group example \(message\)\n/
- end
- end
-
- describe "ProgressBarFormatter outputting to custom out" do
- before(:each) do
- @out = mock("out")
- @options = mock('options')
- @out.stub!(:puts)
- @formatter = ProgressBarFormatter.new(@options, @out)
- @formatter.class.send :public, :output_to_tty?
- end
-
- after(:each) do
- @formatter.class.send :protected, :output_to_tty?
- end
-
- it "should not throw NoMethodError on output_to_tty?" do
- @out.should_receive(:tty?).and_raise(NoMethodError)
- @formatter.output_to_tty?.should be_false
- end
- end
-
- describe ProgressBarFormatter, "dry run" do
- before(:each) do
- @io = StringIO.new
- options = mock('options')
- options.stub!(:dry_run).and_return(true)
- @formatter = ProgressBarFormatter.new(options, @io)
- end
-
- it "should not produce summary on dry run" do
- @formatter.dump_summary(3, 2, 1, 0)
- @io.string.should eql("")
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-require 'spec/runner/formatter/snippet_extractor'
-
-module Spec
- module Runner
- module Formatter
- describe SnippetExtractor do
- it "should fall back on a default message when it doesn't understand a line" do
- SnippetExtractor.new.snippet_for("blech").should == ["# Couldn't get snippet for blech", 1]
- end
-
- it "should fall back on a default message when it doesn't find the file" do
- SnippetExtractor.new.lines_around("blech", 8).should == "# Couldn't get snippet for blech"
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper'
-require 'hpricot' # Needed to compare generated with wanted HTML
-require 'spec/runner/formatter/text_mate_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe TextMateFormatter do
- attr_reader :root, :suffix, :expected_file
- before do
- @root = File.expand_path(File.dirname(__FILE__) + '/../../../..')
- @suffix = jruby? ? '-jruby' : ''
- @expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::VERSION}#{suffix}.html"
- end
-
- def jruby?
- PLATFORM == 'java'
- end
-
- def produces_html_identical_to_manually_designed_document(opt)
- root = File.expand_path(File.dirname(__FILE__) + '/../../../..')
-
- Dir.chdir(root) do
- args = [
- 'failing_examples/mocking_example.rb',
- 'failing_examples/diffing_spec.rb',
- 'examples/pure/stubbing_example.rb',
- 'examples/pure/pending_example.rb',
- '--format',
- 'textmate',
- opt
- ]
- err = StringIO.new
- out = StringIO.new
- options = ::Spec::Runner::OptionParser.parse(args, err, out)
- Spec::Runner::CommandLine.run(options)
-
- yield(out.string)
- end
- end
-
- # # Uncomment this spec temporarily in order to overwrite the expected with actual.
- # # Use with care!!!
- # describe TextMateFormatter, "functional spec file generator" do
- # it "generates a new comparison file" do
- # Dir.chdir(root) do
- # args = ['failing_examples/mocking_example.rb', 'failing_examples/diffing_spec.rb', 'examples/pure/stubbing_example.rb', 'examples/pure/pending_example.rb', '--format', 'textmate', '--diff']
- # err = StringIO.new
- # out = StringIO.new
- # Spec::Runner::CommandLine.run(
- # ::Spec::Runner::OptionParser.parse(args, err, out)
- # )
- #
- # seconds = /\d+\.\d+ seconds/
- # html = out.string.gsub seconds, 'x seconds'
- #
- # File.open(expected_file, 'w') {|io| io.write(html)}
- # end
- # end
- # end
-
- describe "functional spec using --diff" do
- it "should produce HTML identical to the one we designed manually with --diff" do
- produces_html_identical_to_manually_designed_document("--diff") do |html|
- suffix = jruby? ? '-jruby' : ''
- expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::VERSION}#{suffix}.html"
- unless File.file?(expected_file)
- raise "There is no HTML file with expected content for this platform: #{expected_file}"
- end
- expected_html = File.read(expected_file)
-
- seconds = /\d+\.\d+ seconds/
- html.gsub! seconds, 'x seconds'
- expected_html.gsub! seconds, 'x seconds'
-
- doc = Hpricot(html)
- backtraces = doc.search("div.backtrace/a")
- doc.search("div.backtrace").remove
-
- expected_doc = Hpricot(expected_html)
- expected_doc.search("div.backtrace").remove
-
- doc.inner_html.should == expected_doc.inner_html
-
- backtraces.each do |backtrace_link|
- backtrace_link[:href].should include("txmt://open?url=")
- end
- end
- end
-
- end
-
- describe "functional spec using --dry-run" do
- it "should produce HTML identical to the one we designed manually with --dry-run" do
- produces_html_identical_to_manually_designed_document("--dry-run") do |html, expected_html|
- html.should =~ /This was a dry-run/m
- end
- end
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-require 'spec/runner/formatter/specdoc_formatter'
-
-module Spec
- module Runner
- module Formatter
- describe SpecdocFormatter do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :io, :options, :formatter, :example_group
- before(:each) do
- @io = StringIO.new
- options.stub!(:dry_run).and_return(false)
- options.stub!(:colour).and_return(false)
- @formatter = SpecdocFormatter.new(options, io)
- @example_group = Class.new(::Spec::Example::ExampleGroup).describe("ExampleGroup")
- end
-
- describe "where ExampleGroup has no superclasss with a description" do
- before do
- formatter.add_example_group(example_group)
- end
-
- it "should produce standard summary without pending when pending has a 0 count" do
- formatter.dump_summary(3, 2, 1, 0)
- io.string.should have_example_group_output("\nFinished in 3 seconds\n\n2 examples, 1 failure\n")
- end
-
- it "should produce standard summary" do
- formatter.dump_summary(3, 2, 1, 4)
- io.string.should have_example_group_output("\nFinished in 3 seconds\n\n2 examples, 1 failure, 4 pending\n")
- end
-
- it "should push ExampleGroup name" do
- io.string.should eql("\nExampleGroup\n")
- end
-
- it "when having an error, should push failing spec name and failure number" do
- formatter.example_failed(
- example_group.it("spec"),
- 98,
- Reporter::Failure.new("c s", RuntimeError.new)
- )
- io.string.should have_example_group_output("- spec (ERROR - 98)\n")
- end
-
- it "when having an expectation failure, should push failing spec name and failure number" do
- formatter.example_failed(
- example_group.it("spec"),
- 98,
- Reporter::Failure.new("c s", Spec::Expectations::ExpectationNotMetError.new)
- )
- io.string.should have_example_group_output("- spec (FAILED - 98)\n")
- end
-
- it "should push nothing on start" do
- formatter.start(5)
- io.string.should have_example_group_output("")
- end
-
- it "should push nothing on start dump" do
- formatter.start_dump
- io.string.should have_example_group_output("")
- end
-
- it "should push passing spec name" do
- formatter.example_passed(example_group.it("spec"))
- io.string.should have_example_group_output("- spec\n")
- end
-
- it "should push pending example name and message" do
- formatter.example_pending('example_group', ExampleGroup.new("example"), 'reason')
- io.string.should have_example_group_output("- example (PENDING: reason)\n")
- end
-
- it "should dump pending" do
- formatter.example_pending('example_group', ExampleGroup.new("example"), 'reason')
- io.rewind
- formatter.dump_pending
- io.string.should =~ /Pending\:\nexample_group example \(reason\)\n/
- end
-
- def have_example_group_output(expected_output)
- expected = "\nExampleGroup\n#{expected_output}"
- ::Spec::Matchers::SimpleMatcher.new(expected) do |actual|
- actual == expected
- end
- end
- end
-
- describe "where ExampleGroup has two superclasses with a description" do
- attr_reader :child_example_group, :grand_child_example_group
- before do
- @child_example_group = Class.new(example_group).describe("Child ExampleGroup")
- @grand_child_example_group = Class.new(child_example_group).describe("GrandChild ExampleGroup")
- formatter.add_example_group(grand_child_example_group)
- end
-
- specify "when having an error, should push failing spec name and failure number" do
- formatter.example_failed(
- example_group.it("spec"),
- 98,
- Reporter::Failure.new("c s", RuntimeError.new)
- )
- io.string.should have_nested_example_group_output("- spec (ERROR - 98)\n")
- end
-
- specify "when having an expectation failure, should push failing spec name and failure number" do
- formatter.example_failed(
- example_group.it("spec"),
- 98,
- Reporter::Failure.new("c s", Spec::Expectations::ExpectationNotMetError.new)
- )
- io.string.should have_nested_example_group_output("- spec (FAILED - 98)\n")
- end
-
- def have_nested_example_group_output(expected_output)
- expected_full_output = "\nExampleGroup Child ExampleGroup GrandChild ExampleGroup\n#{expected_output}"
- ::Spec::Matchers::SimpleMatcher.new(expected_full_output) do |actual|
- actual == expected_full_output
- end
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
-require 'spec/runner/formatter/story/html_formatter'
-
-module Spec
- module Runner
- module Formatter
- module Story
- describe HtmlFormatter do
- before :each do
- @out = StringIO.new
- @options = mock('options')
- @reporter = HtmlFormatter.new(@options, @out)
- end
-
- it "should just be poked at" do
- @reporter.run_started(1)
- @reporter.story_started('story_title', 'narrative')
-
- @reporter.scenario_started('story_title', 'succeeded_scenario_name')
- @reporter.step_succeeded('given', 'succeded_step', 'one', 'two')
- @reporter.scenario_succeeded('story_title', 'succeeded_scenario_name')
-
- @reporter.scenario_started('story_title', 'pending_scenario_name')
- @reporter.step_pending('when', 'pending_step', 'un', 'deux')
- @reporter.scenario_pending('story_title', 'pending_scenario_name', 'not done')
-
- @reporter.scenario_started('story_title', 'failed_scenario_name')
- @reporter.step_failed('then', 'failed_step', 'en', 'to')
- @reporter.scenario_failed('story_title', 'failed_scenario_name', NameError.new('sup'))
-
- @reporter.scenario_started('story_title', 'scenario_with_given_scenario_name')
- @reporter.found_scenario('given scenario', 'succeeded_scenario_name')
-
- @reporter.story_ended('story_title', 'narrative')
- @reporter.run_ended
- end
-
- it "should create spans for params" do
- @reporter.step_succeeded('given', 'a $coloured $animal', 'brown', 'dog')
- @out.string.should == " <li class=\"passed\">Given a <span class=\"param\">brown</span> <span class=\"param\">dog</span></li>\n"
- end
-
- it 'should create spanes for params in regexp steps' do
- @reporter.step_succeeded :given, /a (pink|blue) (.*)/, 'brown', 'dog'
- @out.string.should == " <li class=\"passed\">Given a <span class=\"param\">brown</span> <span class=\"param\">dog</span></li>\n"
- end
-
- it "should create a ul for collected_steps" do
- @reporter.collected_steps(['Given a $coloured $animal', 'Given a $n legged eel'])
- @out.string.should == (<<-EOF)
- <ul id="stock_steps" style="display: none;">
- <li>Given a $coloured $animal</li>
- <li>Given a $n legged eel</li>
- </ul>
-EOF
- end
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
-require 'spec/runner/formatter/story/plain_text_formatter'
-
-module Spec
- module Runner
- module Formatter
- module Story
- describe PlainTextFormatter do
- before :each do
- # given
- @out = StringIO.new
- @tweaker = mock('tweaker')
- @tweaker.stub!(:tweak_backtrace)
- @options = mock('options')
- @options.stub!(:colour).and_return(false)
- @options.stub!(:backtrace_tweaker).and_return(@tweaker)
- @formatter = PlainTextFormatter.new(@options, @out)
- end
-
- it 'should summarize the number of scenarios when the run ends' do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario2')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario3')
- @formatter.run_ended
-
- # then
- @out.string.should include('3 scenarios')
- end
-
- it 'should summarize the number of successful scenarios when the run ends' do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario2')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario3')
- @formatter.run_ended
-
- # then
- @out.string.should include('3 scenarios: 3 succeeded')
- end
-
- it 'should summarize the number of failed scenarios when the run ends' do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
- @formatter.run_ended
-
- # then
- @out.string.should include("3 scenarios: 1 succeeded, 2 failed")
- end
-
- it 'should end cleanly (no characters on the last line) with successes' do
- # when
- @formatter.run_started(1)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario')
- @formatter.run_ended
-
- # then
- @out.string.should =~ /\n\z/
- end
-
- it 'should end cleanly (no characters on the last line) with failures' do
- # when
- @formatter.run_started(1)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario', exception_from { raise RuntimeError, 'oops' })
- @formatter.run_ended
-
- # then
- @out.string.should =~ /\n\z/
- end
-
- it 'should end cleanly (no characters on the last line) with pending steps' do
- # when
- @formatter.run_started(1)
- @formatter.scenario_started(nil, nil)
- @formatter.step_pending(:then, 'do pend')
- @formatter.scenario_pending('story', 'scenario', exception_from { raise RuntimeError, 'oops' })
- @formatter.run_ended
-
- # then
- @out.string.should =~ /\n\z/
- end
-
- it 'should summarize the number of pending scenarios when the run ends' do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_pending('story', 'scenario2', 'message')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_pending('story', 'scenario3', 'message')
- @formatter.run_ended
-
- # then
- @out.string.should include("3 scenarios: 1 succeeded, 0 failed, 2 pending")
- end
-
- it "should only count the first failure in one scenario" do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops again' })
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
- @formatter.run_ended
-
- # then
- @out.string.should include("3 scenarios: 1 succeeded, 2 failed")
- end
-
- it "should only count the first pending in one scenario" do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_pending('story', 'scenario2', 'because ...')
- @formatter.scenario_pending('story', 'scenario2', 'because ...')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_pending('story', 'scenario3', 'because ...')
- @formatter.run_ended
-
- # then
- @out.string.should include("3 scenarios: 1 succeeded, 0 failed, 2 pending")
- end
-
- it "should only count a failure before the first pending in one scenario" do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_pending('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops again' })
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
- @formatter.run_ended
-
- # then
- @out.string.should include("3 scenarios: 1 succeeded, 1 failed, 1 pending")
- end
-
- it 'should produce details of the first failure each failed scenario when the run ends' do
- # when
- @formatter.run_started(3)
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_succeeded('story', 'scenario1')
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops2' })
- @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops2 - this one should not appear' })
- @formatter.scenario_started(nil, nil)
- @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops3' })
- @formatter.run_ended
-
- # then
- @out.string.should include("FAILURES:\n")
- @out.string.should include("1) story (scenario2) FAILED")
- @out.string.should include("RuntimeError: oops2")
- @out.string.should_not include("RuntimeError: oops2 - this one should not appear")
- @out.string.should include("2) story (scenario3) FAILED")
- @out.string.should include("RuntimeError: oops3")
- end
-
- it 'should produce details of each pending step when the run ends' do
- # when
- @formatter.run_started(2)
- @formatter.story_started('story 1', 'narrative')
- @formatter.scenario_started('story 1', 'scenario 1')
- @formatter.step_pending(:given, 'todo 1', [])
- @formatter.story_started('story 2', 'narrative')
- @formatter.scenario_started('story 2', 'scenario 2')
- @formatter.step_pending(:given, 'todo 2', [])
- @formatter.run_ended
-
- # then
- @out.string.should include("Pending Steps:\n")
- @out.string.should include("1) story 1 (scenario 1): todo 1")
- @out.string.should include("2) story 2 (scenario 2): todo 2")
- end
-
- it 'should document a story title and narrative' do
- # when
- @formatter.story_started 'story', 'narrative'
-
- # then
- @out.string.should include("Story: story\n\n narrative")
- end
-
- it 'should document a scenario name' do
- # when
- @formatter.scenario_started 'story', 'scenario'
-
- # then
- @out.string.should include("\n\n Scenario: scenario")
- end
-
- it 'should document a step by sentence-casing its name' do
- # when
- @formatter.step_succeeded :given, 'a context'
- @formatter.step_succeeded :when, 'an event'
- @formatter.step_succeeded :then, 'an outcome'
-
- # then
- @out.string.should include("\n\n Given a context\n\n When an event\n\n Then an outcome")
- end
-
- it 'should document additional givens using And' do
- # when
- @formatter.step_succeeded :given, 'step 1'
- @formatter.step_succeeded :given, 'step 2'
- @formatter.step_succeeded :given, 'step 3'
-
- # then
- @out.string.should include(" Given step 1\n And step 2\n And step 3")
- end
-
- it 'should document additional events using And' do
- # when
- @formatter.step_succeeded :when, 'step 1'
- @formatter.step_succeeded :when, 'step 2'
- @formatter.step_succeeded :when, 'step 3'
-
- # then
- @out.string.should include(" When step 1\n And step 2\n And step 3")
- end
-
- it 'should document additional outcomes using And' do
- # when
- @formatter.step_succeeded :then, 'step 1'
- @formatter.step_succeeded :then, 'step 2'
- @formatter.step_succeeded :then, 'step 3'
-
- # then
- @out.string.should include(" Then step 1\n And step 2\n And step 3")
- end
-
- it 'should document a GivenScenario followed by a Given using And' do
- # when
- @formatter.step_succeeded :'given scenario', 'a scenario'
- @formatter.step_succeeded :given, 'a context'
-
- # then
- @out.string.should include(" Given scenario a scenario\n And a context")
- end
-
- it 'should document steps with replaced params' do
- @formatter.step_succeeded :given, 'a $coloured dog with $n legs', 'pink', 21
- @out.string.should include(" Given a pink dog with 21 legs")
- end
-
- it 'should document regexp steps with replaced params' do
- @formatter.step_succeeded :given, /a (pink|blue) dog with (.*) legs/, 'pink', 21
- @out.string.should include(" Given a pink dog with 21 legs")
- end
-
- it "should append PENDING for the first pending step" do
- @formatter.scenario_started('','')
- @formatter.step_pending(:given, 'a context')
-
- @out.string.should include('Given a context (PENDING)')
- end
-
- it "should append PENDING for pending after already pending" do
- @formatter.scenario_started('','')
- @formatter.step_pending(:given, 'a context')
- @formatter.step_pending(:when, 'I say hey')
-
- @out.string.should include('When I say hey (PENDING)')
- end
-
- it "should append FAILED for the first failiure" do
- @formatter.scenario_started('','')
- @formatter.step_failed(:given, 'a context')
-
- @out.string.should include('Given a context (FAILED)')
- end
-
- it "should append SKIPPED for the second failiure" do
- @formatter.scenario_started('','')
- @formatter.step_failed(:given, 'a context')
- @formatter.step_failed(:when, 'I say hey')
-
- @out.string.should include('When I say hey (SKIPPED)')
- end
-
- it "should append SKIPPED for the a failiure after PENDING" do
- @formatter.scenario_started('','')
- @formatter.step_pending(:given, 'a context')
- @formatter.step_failed(:when, 'I say hey')
-
- @out.string.should include('When I say hey (SKIPPED)')
- end
-
- it 'should print some white space after each story' do
- # when
- @formatter.story_ended 'title', 'narrative'
-
- # then
- @out.string.should include("\n\n")
- end
-
- it "should print nothing for collected_steps" do
- @formatter.collected_steps(['Given a $coloured $animal', 'Given a $n legged eel'])
- @out.string.should == ("")
- end
-
- it "should ignore messages it doesn't care about" do
- lambda {
- @formatter.this_method_does_not_exist
- }.should_not raise_error
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM}
- require 'spec/runner/heckle_runner'
-
- module Foo
- class Bar
- def one; end
- def two; end
- end
-
- class Zap
- def three; end
- def four; end
- end
- end
-
- describe "HeckleRunner" do
- before(:each) do
- @heckle = mock("heckle", :null_object => true)
- @heckle_class = mock("heckle_class")
- end
-
- it "should heckle all methods in all classes in a module" do
- @heckle_class.should_receive(:new).with("Foo::Bar", "one", rspec_options).and_return(@heckle)
- @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
- @heckle_class.should_receive(:new).with("Foo::Zap", "three", rspec_options).and_return(@heckle)
- @heckle_class.should_receive(:new).with("Foo::Zap", "four", rspec_options).and_return(@heckle)
-
- heckle_runner = Spec::Runner::HeckleRunner.new("Foo", @heckle_class)
- heckle_runner.heckle_with
- end
-
- it "should heckle all methods in a class" do
- @heckle_class.should_receive(:new).with("Foo::Bar", "one", rspec_options).and_return(@heckle)
- @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
-
- heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar", @heckle_class)
- heckle_runner.heckle_with
- end
-
- it "should fail heckling when the class is not found" do
- lambda do
- heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bob", @heckle_class)
- heckle_runner.heckle_with
- end.should raise_error(StandardError, "Heckling failed - \"Foo::Bob\" is not a known class or module")
- end
-
- it "should heckle specific method in a class (with #)" do
- @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
-
- heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar#two", @heckle_class)
- heckle_runner.heckle_with
- end
-
- it "should heckle specific method in a class (with .)" do
- @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
-
- heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar.two", @heckle_class)
- heckle_runner.heckle_with
- end
- end
-
- describe "Heckler" do
- it "should say yes to tests_pass? if specs pass" do
- options = mock("options", :null_object => true)
- options.should_receive(:run_examples).and_return(true)
- heckler = Spec::Runner::Heckler.new("Foo", nil, options)
- heckler.tests_pass?.should be_true
- end
-
- it "should say no to tests_pass? if specs fail" do
- options = mock("options", :null_object => true)
- options.should_receive(:run_examples).and_return(false)
- heckler = Spec::Runner::Heckler.new("Foo", nil, options)
- heckler.tests_pass?.should be_false
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM}
- require 'spec/runner/heckle_runner'
-
- describe "Heckler" do
- it "should run examples on tests_pass?" do
- options = Spec::Runner::Options.new(StringIO.new, StringIO.new)
- options.should_receive(:run_examples).with().and_return(&options.method(:run_examples))
- heckler = Spec::Runner::Heckler.new('Array', 'push', options)
- heckler.tests_pass?
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe "NoisyBacktraceTweaker" do
- before(:each) do
- @error = RuntimeError.new
- @tweaker = NoisyBacktraceTweaker.new
- end
-
- it "should leave anything in lib spec dir" do
- ["expectations", "mocks", "runner", "stubs"].each do |child|
- @error.set_backtrace(["/lib/spec/#{child}/anything.rb"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should_not be_empty
- end
- end
-
- it "should leave anything in spec dir" do
- @error.set_backtrace(["/lib/spec/expectations/anything.rb"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should_not be_empty
- end
-
- it "should leave bin spec" do
- @error.set_backtrace(["bin/spec:"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should_not be_empty
- end
-
- it "should not barf on nil backtrace" do
- lambda do
- @tweaker.tweak_backtrace(@error)
- end.should_not raise_error
- end
-
- it "should clean up double slashes" do
- @error.set_backtrace(["/a//b/c//d.rb"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should include("/a/b/c/d.rb")
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-require 'fileutils'
-
-describe "OptionParser" do
- before(:each) do
- @out = StringIO.new
- @err = StringIO.new
- @parser = Spec::Runner::OptionParser.new(@err, @out)
- end
-
- def parse(args)
- @parser.parse(args)
- @parser.options
- end
-
- it "should accept dry run option" do
- options = parse(["--dry-run"])
- options.dry_run.should be_true
- end
-
- it "should eval and use custom formatter when none of the builtins" do
- options = parse(["--format", "Custom::Formatter"])
- options.formatters[0].class.should be(Custom::Formatter)
- end
-
- it "should support formatters with relative and absolute paths, even on windows" do
- options = parse([
- "--format", "Custom::Formatter:C:\\foo\\bar",
- "--format", "Custom::Formatter:foo/bar",
- "--format", "Custom::Formatter:foo\\bar",
- "--format", "Custom::Formatter:/foo/bar"
- ])
- options.formatters[0].where.should eql("C:\\foo\\bar")
- options.formatters[1].where.should eql("foo/bar")
- options.formatters[2].where.should eql("foo\\bar")
- options.formatters[3].where.should eql("/foo/bar")
- end
-
- it "should not be verbose by default" do
- options = parse([])
- options.verbose.should be_nil
- end
-
- it "should not use colour by default" do
- options = parse([])
- options.colour.should == false
- end
-
- it "should print help to stdout if no args" do
- pending 'A regression since 1.0.8' do
- options = parse([])
- @out.rewind
- @out.read.should match(/Usage: spec \(FILE\|DIRECTORY\|GLOB\)\+ \[options\]/m)
- end
- end
-
- it "should print help to stdout" do
- options = parse(["--help"])
- @out.rewind
- @out.read.should match(/Usage: spec \(FILE\|DIRECTORY\|GLOB\)\+ \[options\]/m)
- end
-
- it "should print instructions about how to require missing formatter" do
- lambda do
- options = parse(["--format", "Custom::MissingFormatter"])
- options.formatters
- end.should raise_error(NameError)
- @err.string.should match(/Couldn't find formatter class Custom::MissingFormatter/n)
- end
-
- it "should print version to stdout" do
- options = parse(["--version"])
- @out.rewind
- @out.read.should match(/RSpec-\d+\.\d+\.\d+.*\(build \d+\) - BDD for Ruby\nhttp:\/\/rspec.rubyforge.org\/\n/n)
- end
-
- it "should require file when require specified" do
- lambda do
- parse(["--require", "whatever"])
- end.should raise_error(LoadError)
- end
-
- it "should support c option" do
- options = parse(["-c"])
- options.colour.should be_true
- end
-
- it "should support queens colour option" do
- options = parse(["--colour"])
- options.colour.should be_true
- end
-
- it "should support us color option" do
- options = parse(["--color"])
- options.colour.should be_true
- end
-
- it "should support single example with -e option" do
- options = parse(["-e", "something or other"])
- options.examples.should eql(["something or other"])
- end
-
- it "should support single example with -s option (will be removed when autotest supports -e)" do
- options = parse(["-s", "something or other"])
- options.examples.should eql(["something or other"])
- end
-
- it "should support single example with --example option" do
- options = parse(["--example", "something or other"])
- options.examples.should eql(["something or other"])
- end
-
- it "should read several example names from file if --example is given an existing file name" do
- options = parse(["--example", File.dirname(__FILE__) + '/examples.txt'])
- options.examples.should eql([
- "Sir, if you were my husband, I would poison your drink.",
- "Madam, if you were my wife, I would drink it."])
- end
-
- it "should read no examples if given an empty file" do
- options = parse(["--example", File.dirname(__FILE__) + '/empty_file.txt'])
- options.examples.should eql([])
- end
-
- it "should use html formatter when format is h" do
- options = parse(["--format", "h"])
- options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
- end
-
- it "should use html story formatter when format is h" do
- options = parse(["--format", "h"])
- options.story_formatters[0].class.should equal(Spec::Runner::Formatter::Story::HtmlFormatter)
- end
-
- it "should use html formatter when format is html" do
- options = parse(["--format", "html"])
- options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
- end
-
- it "should use html story formatter when format is html" do
- options = parse(["--format", "html"])
- options.story_formatters[0].class.should equal(Spec::Runner::Formatter::Story::HtmlFormatter)
- end
-
- it "should use html formatter with explicit output when format is html:test.html" do
- FileUtils.rm 'test.html' if File.exist?('test.html')
- options = parse(["--format", "html:test.html"])
- options.formatters # creates the file
- File.should be_exist('test.html')
- options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
- options.formatters[0].close
- FileUtils.rm 'test.html'
- end
-
- it "should use noisy backtrace tweaker with b option" do
- options = parse(["-b"])
- options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
- end
-
- it "should use noisy backtrace tweaker with backtrace option" do
- options = parse(["--backtrace"])
- options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
- end
-
- it "should use quiet backtrace tweaker by default" do
- options = parse([])
- options.backtrace_tweaker.should be_instance_of(Spec::Runner::QuietBacktraceTweaker)
- end
-
- it "should use progress bar formatter by default" do
- options = parse([])
- options.formatters[0].class.should equal(Spec::Runner::Formatter::ProgressBarFormatter)
- end
-
- it "should use specdoc formatter when format is s" do
- options = parse(["--format", "s"])
- options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter)
- end
-
- it "should use specdoc formatter when format is specdoc" do
- options = parse(["--format", "specdoc"])
- options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter)
- end
-
- it "should support diff option when format is not specified" do
- options = parse(["--diff"])
- options.diff_format.should == :unified
- end
-
- it "should use unified diff format option when format is unified" do
- options = parse(["--diff", "unified"])
- options.diff_format.should == :unified
- options.differ_class.should equal(Spec::Expectations::Differs::Default)
- end
-
- it "should use context diff format option when format is context" do
- options = parse(["--diff", "context"])
- options.diff_format.should == :context
- options.differ_class.should == Spec::Expectations::Differs::Default
- end
-
- it "should use custom diff format option when format is a custom format" do
- Spec::Expectations.differ.should_not be_instance_of(Custom::Differ)
-
- options = parse(["--diff", "Custom::Differ"])
- options.parse_diff "Custom::Differ"
- options.diff_format.should == :custom
- options.differ_class.should == Custom::Differ
- Spec::Expectations.differ.should be_instance_of(Custom::Differ)
- end
-
- it "should print instructions about how to fix missing differ" do
- lambda { parse(["--diff", "Custom::MissingFormatter"]) }.should raise_error(NameError)
- @err.string.should match(/Couldn't find differ class Custom::MissingFormatter/n)
- end
-
- it "should support --line to identify spec" do
- spec_parser = mock("spec_parser")
- @parser.instance_variable_set('@spec_parser', spec_parser)
-
- file_factory = mock("File")
- file_factory.should_receive(:file?).and_return(true)
- file_factory.should_receive(:open).and_return("fake_io")
- @parser.instance_variable_set('@file_factory', file_factory)
-
- spec_parser.should_receive(:spec_name_for).with("fake_io", 169).and_return("some spec")
-
- options = parse(["some file", "--line", "169"])
- options.examples.should eql(["some spec"])
- File.rspec_verify
- end
-
- it "should fail with error message if file is dir along with --line" do
- spec_parser = mock("spec_parser")
- @parser.instance_variable_set('@spec_parser', spec_parser)
-
- file_factory = mock("File")
- file_factory.should_receive(:file?).and_return(false)
- file_factory.should_receive(:directory?).and_return(true)
- @parser.instance_variable_set('@file_factory', file_factory)
-
- options = parse(["some file", "--line", "169"])
- @err.string.should match(/You must specify one file, not a directory when using the --line option/n)
- end
-
- it "should fail with error message if file does not exist along with --line" do
- spec_parser = mock("spec_parser")
- @parser.instance_variable_set('@spec_parser', spec_parser)
-
- file_factory = mock("File")
- file_factory.should_receive(:file?).and_return(false)
- file_factory.should_receive(:directory?).and_return(false)
- @parser.instance_variable_set('@file_factory', file_factory)
-
- options = parse(["some file", "--line", "169"])
- @err.string.should match(/some file does not exist/n)
- end
-
- it "should fail with error message if more than one files are specified along with --line" do
- spec_parser = mock("spec_parser")
- @parser.instance_variable_set('@spec_parser', spec_parser)
-
- options = parse(["some file", "some other file", "--line", "169"])
- @err.string.should match(/Only one file can be specified when using the --line option/n)
- end
-
- it "should fail with error message if --example and --line are used simultaneously" do
- spec_parser = mock("spec_parser")
- @parser.instance_variable_set('@spec_parser', spec_parser)
-
- options = parse(["some file", "--example", "some example", "--line", "169"])
- @err.string.should match(/You cannot use both --line and --example/n)
- end
-
- if [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM}
- it "should barf when --heckle is specified (and platform is windows)" do
- lambda do
- options = parse(["--heckle", "Spec"])
- end.should raise_error(StandardError, "Heckle not supported on Windows")
- end
- else
- it "should heckle when --heckle is specified (and platform is not windows)" do
- options = parse(["--heckle", "Spec"])
- options.heckle_runner.should be_instance_of(Spec::Runner::HeckleRunner)
- end
- end
-
- it "should read options from file when --options is specified" do
- options = parse(["--options", File.dirname(__FILE__) + "/spec.opts"])
- options.diff_format.should_not be_nil
- options.colour.should be_true
- end
-
- it "should default the formatter to ProgressBarFormatter when using options file" do
- options = parse(["--options", File.dirname(__FILE__) + "/spec.opts"])
- options.formatters.first.should be_instance_of(::Spec::Runner::Formatter::ProgressBarFormatter)
- end
-
- it "should read spaced and multi-line options from file when --options is specified" do
- options = parse(["--options", File.dirname(__FILE__) + "/spec_spaced.opts"])
- options.diff_format.should_not be_nil
- options.colour.should be_true
- options.formatters.first.should be_instance_of(::Spec::Runner::Formatter::SpecdocFormatter)
- end
-
- it "should save config to file when --generate-options is specified" do
- FileUtils.rm 'test.spec.opts' if File.exist?('test.spec.opts')
- options = parse(["--colour", "--generate-options", "test.spec.opts", "--diff"])
- IO.read('test.spec.opts').should == "--colour\n--diff\n"
- FileUtils.rm 'test.spec.opts'
- end
-
- it "should save config to file when -G is specified" do
- FileUtils.rm 'test.spec.opts' if File.exist?('test.spec.opts')
- options = parse(["--colour", "-G", "test.spec.opts", "--diff"])
- IO.read('test.spec.opts').should == "--colour\n--diff\n"
- FileUtils.rm 'test.spec.opts'
- end
-
- it "when --drb is specified, calls DrbCommandLine all of the other ARGV arguments" do
- options = Spec::Runner::OptionParser.parse([
- "some/spec.rb", "--diff", "--colour"
- ], @err, @out)
- Spec::Runner::DrbCommandLine.should_receive(:run).and_return do |options|
- options.argv.should == ["some/spec.rb", "--diff", "--colour"]
- end
- parse(["some/spec.rb", "--diff", "--drb", "--colour"])
- end
-
- it "should reverse spec order when --reverse is specified" do
- options = parse(["some/spec.rb", "--reverse"])
- end
-
- it "should set an mtime comparator when --loadby mtime" do
- options = parse(["--loadby", 'mtime'])
- runner = Spec::Runner::ExampleGroupRunner.new(options)
- Spec::Runner::ExampleGroupRunner.should_receive(:new).
- with(options).
- and_return(runner)
- runner.should_receive(:load_files).with(["most_recent_spec.rb", "command_line_spec.rb"])
-
- Dir.chdir(File.dirname(__FILE__)) do
- options.files << 'command_line_spec.rb'
- options.files << 'most_recent_spec.rb'
- FileUtils.touch "most_recent_spec.rb"
- options.run_examples
- FileUtils.rm "most_recent_spec.rb"
- end
- end
-
- it "should use the standard runner by default" do
- runner = ::Spec::Runner::ExampleGroupRunner.new(@parser.options)
- ::Spec::Runner::ExampleGroupRunner.should_receive(:new).
- with(@parser.options).
- and_return(runner)
- options = parse([])
- options.run_examples
- end
-
- it "should use a custom runner when given" do
- runner = Custom::ExampleGroupRunner.new(@parser.options, nil)
- Custom::ExampleGroupRunner.should_receive(:new).
- with(@parser.options, nil).
- and_return(runner)
- options = parse(["--runner", "Custom::ExampleGroupRunner"])
- options.run_examples
- end
-
- it "should use a custom runner with extra options" do
- runner = Custom::ExampleGroupRunner.new(@parser.options, 'something')
- Custom::ExampleGroupRunner.should_receive(:new).
- with(@parser.options, 'something').
- and_return(runner)
- options = parse(["--runner", "Custom::ExampleGroupRunner:something"])
- options.run_examples
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe Options do
- before(:each) do
- @err = StringIO.new('')
- @out = StringIO.new('')
- @options = Options.new(@err, @out)
- end
-
- after(:each) do
- Spec::Expectations.differ = nil
- end
-
- describe "#examples" do
- it "should default to empty array" do
- @options.examples.should == []
- end
- end
-
- describe "#backtrace_tweaker" do
- it "should default to QuietBacktraceTweaker" do
- @options.backtrace_tweaker.class.should == QuietBacktraceTweaker
- end
- end
-
- describe "#dry_run" do
- it "should default to false" do
- @options.dry_run.should == false
- end
- end
-
- describe "#context_lines" do
- it "should default to 3" do
- @options.context_lines.should == 3
- end
- end
-
- describe "#parse_diff with nil" do
- before(:each) do
- @options.parse_diff nil
- end
-
- it "should make diff_format unified" do
- @options.diff_format.should == :unified
- end
-
- it "should set Spec::Expectations.differ to be a default differ" do
- Spec::Expectations.differ.class.should ==
- ::Spec::Expectations::Differs::Default
- end
- end
-
- describe "#parse_diff with 'unified'" do
- before(:each) do
- @options.parse_diff 'unified'
- end
-
- it "should make diff_format unified and uses default differ_class" do
- @options.diff_format.should == :unified
- @options.differ_class.should equal(Spec::Expectations::Differs::Default)
- end
-
- it "should set Spec::Expectations.differ to be a default differ" do
- Spec::Expectations.differ.class.should ==
- ::Spec::Expectations::Differs::Default
- end
- end
-
- describe "#parse_diff with 'context'" do
- before(:each) do
- @options.parse_diff 'context'
- end
-
- it "should make diff_format context and uses default differ_class" do
- @options.diff_format.should == :context
- @options.differ_class.should == Spec::Expectations::Differs::Default
- end
-
- it "should set Spec::Expectations.differ to be a default differ" do
- Spec::Expectations.differ.class.should ==
- ::Spec::Expectations::Differs::Default
- end
- end
-
- describe "#parse_diff with Custom::Differ" do
- before(:each) do
- @options.parse_diff 'Custom::Differ'
- end
-
- it "should use custom differ_class" do
- @options.diff_format.should == :custom
- @options.differ_class.should == Custom::Differ
- Spec::Expectations.differ.should be_instance_of(Custom::Differ)
- end
-
- it "should set Spec::Expectations.differ to be a default differ" do
- Spec::Expectations.differ.class.should ==
- ::Custom::Differ
- end
- end
-
- describe "#parse_diff with missing class name" do
- it "should raise error" do
- lambda { @options.parse_diff "Custom::MissingDiffer" }.should raise_error(NameError)
- @err.string.should match(/Couldn't find differ class Custom::MissingDiffer/n)
- end
- end
-
- describe "#parse_example" do
- it "with argument thats not a file path, sets argument as the example" do
- example = "something or other"
- File.file?(example).should == false
- @options.parse_example example
- @options.examples.should eql(["something or other"])
- end
-
- it "with argument that is a file path, sets examples to contents of the file" do
- example = "#{File.dirname(__FILE__)}/examples.txt"
- File.should_receive(:file?).with(example).and_return(true)
- file = StringIO.new("Sir, if you were my husband, I would poison your drink.\nMadam, if you were my wife, I would drink it.")
- File.should_receive(:open).with(example).and_return(file)
-
- @options.parse_example example
- @options.examples.should eql([
- "Sir, if you were my husband, I would poison your drink.",
- "Madam, if you were my wife, I would drink it."
- ])
- end
- end
-
- describe "#examples_should_not_be_run" do
- it "should cause #run_examples to return true and do nothing" do
- @options.examples_should_not_be_run
- ExampleGroupRunner.should_not_receive(:new)
-
- @options.run_examples.should be_true
- end
- end
-
- describe "#load_class" do
- it "should raise error when not class name" do
- lambda do
- @options.send(:load_class, 'foo', 'fruit', '--food')
- end.should raise_error('"foo" is not a valid class name')
- end
- end
-
- describe "#reporter" do
- it "returns a Reporter" do
- @options.reporter.should be_instance_of(Reporter)
- @options.reporter.options.should === @options
- end
- end
-
- describe "#add_example_group affecting passed in example_group" do
- it "runs all examples when options.examples is nil" do
- example_1_has_run = false
- example_2_has_run = false
- @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do
- it "runs 1" do
- example_1_has_run = true
- end
- it "runs 2" do
- example_2_has_run = true
- end
- end
-
- @options.examples = nil
-
- @options.add_example_group @example_group
- @options.run_examples
- example_1_has_run.should be_true
- example_2_has_run.should be_true
- end
-
- it "keeps all example_definitions when options.examples is empty" do
- example_1_has_run = false
- example_2_has_run = false
- @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do
- it "runs 1" do
- example_1_has_run = true
- end
- it "runs 2" do
- example_2_has_run = true
- end
- end
-
- @options.examples = []
-
- @options.add_example_group @example_group
- @options.run_examples
- example_1_has_run.should be_true
- example_2_has_run.should be_true
- end
- end
-
- describe "#add_example_group affecting example_group" do
- it "adds example_group when example_group has example_definitions and is not shared" do
- @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do
- it "uses this example_group" do
- end
- end
-
- @options.number_of_examples.should == 0
- @options.add_example_group @example_group
- @options.number_of_examples.should == 1
- @options.example_groups.length.should == 1
- end
- end
-
- describe "#remove_example_group" do
- it "should remove the ExampleGroup from the list of ExampleGroups" do
- @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do
- end
- @options.add_example_group @example_group
- @options.example_groups.should include(@example_group)
-
- @options.remove_example_group @example_group
- @options.example_groups.should_not include(@example_group)
- end
- end
-
- describe "#run_examples" do
- it "should use the standard runner by default" do
- runner = ::Spec::Runner::ExampleGroupRunner.new(@options)
- ::Spec::Runner::ExampleGroupRunner.should_receive(:new).
- with(@options).
- and_return(runner)
- @options.user_input_for_runner = nil
-
- @options.run_examples
- end
-
- it "should use a custom runner when given" do
- runner = Custom::ExampleGroupRunner.new(@options, nil)
- Custom::ExampleGroupRunner.should_receive(:new).
- with(@options, nil).
- and_return(runner)
- @options.user_input_for_runner = "Custom::ExampleGroupRunner"
-
- @options.run_examples
- end
-
- it "should use a custom runner with extra options" do
- runner = Custom::ExampleGroupRunner.new(@options, 'something')
- Custom::ExampleGroupRunner.should_receive(:new).
- with(@options, 'something').
- and_return(runner)
- @options.user_input_for_runner = "Custom::ExampleGroupRunner:something"
-
- @options.run_examples
- end
-
- describe "#run_examples when there are example_group" do
- before(:each) do
- @options.add_example_group Class.new(::Spec::Example::ExampleGroup)
- @options.formatters << Formatter::BaseTextFormatter.new(@options, @out)
- end
-
- it "runs the Examples and outputs the result" do
- @options.run_examples
- @out.string.should include("0 examples, 0 failures")
- end
-
- it "sets #examples_run? to true" do
- @options.examples_run?.should be_false
- @options.run_examples
- @options.examples_run?.should be_true
- end
- end
-
- describe "#run_examples when there are no example_group" do
- before(:each) do
- @options.formatters << Formatter::BaseTextFormatter.new(@options, @out)
- end
-
- it "does not run Examples and does not output a result" do
- @options.run_examples
- @out.string.should_not include("examples")
- @out.string.should_not include("failures")
- end
-
- it "sets #examples_run? to false" do
- @options.examples_run?.should be_false
- @options.run_examples
- @options.examples_run?.should be_false
- end
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "Running an Example" do
- it "should not output twice" do
- true.should be_true
- end
-end
\ No newline at end of file
+++ /dev/null
-dir = File.dirname(__FILE__)
-require "#{dir}/../../spec_helper"
-
-triggering_double_output = rspec_options
-options = Spec::Runner::OptionParser.parse(
- ["#{dir}/output_one_time_fixture.rb"], $stderr, $stdout
-)
-Spec::Runner::CommandLine.run(options)
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe CommandLine do
- it "should not output twice" do
- dir = File.dirname(__FILE__)
- Dir.chdir("#{dir}/../../..") do
- output =`ruby #{dir}/output_one_time_fixture_runner.rb`
- output.should include("1 example, 0 failures")
- output.should_not include("0 examples, 0 failures")
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe "QuietBacktraceTweaker" do
- before(:each) do
- @error = RuntimeError.new
- @tweaker = QuietBacktraceTweaker.new
- end
-
- it "should not barf on nil backtrace" do
- lambda do
- @tweaker.tweak_backtrace(@error)
- end.should_not raise_error
- end
-
- it "should remove anything from textmate ruby bundle" do
- @error.set_backtrace(["/Applications/TextMate.app/Contents/SharedSupport/Bundles/Ruby.tmbundle/Support/tmruby.rb:147"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should be_empty
- end
-
- it "should remove anything in lib spec dir" do
- ["expectations", "mocks", "runner"].each do |child|
- element="/lib/spec/#{child}/anything.rb"
- @error.set_backtrace([element])
- @tweaker.tweak_backtrace(@error)
- unless (@error.backtrace.empty?)
- raise("Should have tweaked away '#{element}'")
- end
- end
- end
-
- it "should remove mock_frameworks/rspec" do
- element = "mock_frameworks/rspec"
- @error.set_backtrace([element])
- @tweaker.tweak_backtrace(@error)
- unless (@error.backtrace.empty?)
- raise("Should have tweaked away '#{element}'")
- end
- end
-
- it "should remove bin spec" do
- @error.set_backtrace(["bin/spec:"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should be_empty
- end
-
- it "should clean up double slashes" do
- @error.set_backtrace(["/a//b/c//d.rb"])
- @tweaker.tweak_backtrace(@error)
- @error.backtrace.should include("/a/b/c/d.rb")
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
- module Runner
- describe Reporter do
- attr_reader :formatter_output, :options, :backtrace_tweaker, :formatter, :reporter, :example_group
- before(:each) do
- @formatter_output = StringIO.new
- @options = Options.new(StringIO.new, StringIO.new)
- @backtrace_tweaker = stub("backtrace tweaker", :tweak_backtrace => nil)
- options.backtrace_tweaker = backtrace_tweaker
- @formatter = ::Spec::Runner::Formatter::BaseTextFormatter.new(options, formatter_output)
- options.formatters << formatter
- @reporter = Reporter.new(options)
- @example_group = create_example_group("example_group")
- reporter.add_example_group example_group
- end
-
- def failure
- Mocks::DuckTypeArgConstraint.new(:header, :exception)
- end
-
- def create_example_group(description_text)
- example_group = Class.new(Spec::Example::ExampleGroup)
- example_group.describe description_text
- example_group
- end
-
- it "should assign itself as the reporter to options" do
- options.reporter.should equal(@reporter)
- end
-
- it "should tell formatter when example_group is added" do
- formatter.should_receive(:add_example_group).with(example_group)
- reporter.add_example_group(example_group)
- end
-
- it "should handle multiple example_groups with same name" do
- formatter.should_receive(:add_example_group).exactly(3).times
- formatter.should_receive(:example_started).exactly(3).times
- formatter.should_receive(:example_passed).exactly(3).times
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:close).with(no_args)
- formatter.should_receive(:dump_summary).with(anything(), 3, 0, 0)
- reporter.add_example_group(create_example_group("example_group"))
- reporter.example_started("spec 1")
- reporter.example_finished("spec 1")
- reporter.add_example_group(create_example_group("example_group"))
- reporter.example_started("spec 2")
- reporter.example_finished("spec 2")
- reporter.add_example_group(create_example_group("example_group"))
- reporter.example_started("spec 3")
- reporter.example_finished("spec 3")
- reporter.dump
- end
-
- it "should handle multiple examples with the same name" do
- error=RuntimeError.new
- passing = ExampleGroup.new("example")
- failing = ExampleGroup.new("example")
-
- formatter.should_receive(:add_example_group).exactly(2).times
- formatter.should_receive(:example_passed).with(passing).exactly(2).times
- formatter.should_receive(:example_failed).with(failing, 1, failure)
- formatter.should_receive(:example_failed).with(failing, 2, failure)
- formatter.should_receive(:dump_failure).exactly(2).times
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:close).with(no_args)
- formatter.should_receive(:dump_summary).with(anything(), 4, 2, 0)
- backtrace_tweaker.should_receive(:tweak_backtrace).twice
-
- reporter.add_example_group(create_example_group("example_group"))
- reporter.example_finished(passing)
- reporter.example_finished(failing, error)
-
- reporter.add_example_group(create_example_group("example_group"))
- reporter.example_finished(passing)
- reporter.example_finished(failing, error)
- reporter.dump
- end
-
- it "should push stats to formatter even with no data" do
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:dump_summary).with(anything(), 0, 0, 0)
- formatter.should_receive(:close).with(no_args)
- reporter.dump
- end
-
- it "should push time to formatter" do
- formatter.should_receive(:start).with(5)
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:close).with(no_args)
- formatter.should_receive(:dump_summary) do |time, a, b|
- time.to_s.should match(/[0-9].[0-9|e|-]+/)
- end
- reporter.start(5)
- reporter.end
- reporter.dump
- end
-
- describe Reporter, "reporting one passing example" do
- it "should tell formatter example passed" do
- formatter.should_receive(:example_passed)
- reporter.example_finished("example")
- end
-
- it "should not delegate to backtrace tweaker" do
- formatter.should_receive(:example_passed)
- backtrace_tweaker.should_not_receive(:tweak_backtrace)
- reporter.example_finished("example")
- end
-
- it "should account for passing example in stats" do
- formatter.should_receive(:example_passed)
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:dump_summary).with(anything(), 1, 0, 0)
- formatter.should_receive(:close).with(no_args)
- reporter.example_finished("example")
- reporter.dump
- end
- end
-
- describe Reporter, "reporting one failing example" do
- it "should tell formatter that example failed" do
- formatter.should_receive(:example_failed)
- reporter.example_finished(example_group, RuntimeError.new)
- end
-
- it "should delegate to backtrace tweaker" do
- formatter.should_receive(:example_failed)
- backtrace_tweaker.should_receive(:tweak_backtrace)
- reporter.example_finished(ExampleGroup.new("example"), RuntimeError.new)
- end
-
- it "should account for failing example in stats" do
- example = ExampleGroup.new("example")
- formatter.should_receive(:example_failed).with(example, 1, failure)
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:dump_failure).with(1, anything())
- formatter.should_receive(:dump_summary).with(anything(), 1, 1, 0)
- formatter.should_receive(:close).with(no_args)
- reporter.example_finished(example, RuntimeError.new)
- reporter.dump
- end
-
- end
-
- describe Reporter, "reporting one pending example (ExamplePendingError)" do
- it "should tell formatter example is pending" do
- example = ExampleGroup.new("example")
- formatter.should_receive(:example_pending).with(example_group.description, example, "reason")
- formatter.should_receive(:add_example_group).with(example_group)
- reporter.add_example_group(example_group)
- reporter.example_finished(example, Spec::Example::ExamplePendingError.new("reason"))
- end
-
- it "should account for pending example in stats" do
- example = ExampleGroup.new("example")
- formatter.should_receive(:example_pending).with(example_group.description, example, "reason")
- formatter.should_receive(:start_dump)
- formatter.should_receive(:dump_pending)
- formatter.should_receive(:dump_summary).with(anything(), 1, 0, 1)
- formatter.should_receive(:close).with(no_args)
- formatter.should_receive(:add_example_group).with(example_group)
- reporter.add_example_group(example_group)
- reporter.example_finished(example, Spec::Example::ExamplePendingError.new("reason"))
- reporter.dump
- end
- end
-
- describe Reporter, "reporting one pending example (PendingExampleFixedError)" do
- it "should tell formatter pending example is fixed" do
- formatter.should_receive(:example_failed) do |name, counter, failure|
- failure.header.should == "'example_group example' FIXED"
- end
- formatter.should_receive(:add_example_group).with(example_group)
- reporter.add_example_group(example_group)
- reporter.example_finished(ExampleGroup.new("example"), Spec::Example::PendingExampleFixedError.new("reason"))
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "c" do
-
- it "1" do
- end
-
- it "2" do
- end
-
-end
-
-describe "d" do
-
- it "3" do
- end
-
- it "4" do
- end
-
-end
-
-class SpecParserSubject
-end
-
-describe SpecParserSubject do
-
- it "5" do
- end
-
-end
-
-describe SpecParserSubject, "described" do
-
- it "6" do
- end
-
-end
-
-describe SpecParserSubject, "described", :something => :something_else do
-
- it "7" do
- end
-
-end
-
-describe "described", :something => :something_else do
-
- it "8" do
- end
-
-end
-
-
-describe "SpecParser" do
- before(:each) do
- @p = Spec::Runner::SpecParser.new
- end
-
- it "should find spec name for 'specify' at same line" do
- @p.spec_name_for(File.open(__FILE__), 5).should == "c 1"
- end
-
- it "should find spec name for 'specify' at end of spec line" do
- @p.spec_name_for(File.open(__FILE__), 6).should == "c 1"
- end
-
- it "should find context for 'context' above all specs" do
- @p.spec_name_for(File.open(__FILE__), 4).should == "c"
- end
-
- it "should find spec name for 'it' at same line" do
- @p.spec_name_for(File.open(__FILE__), 15).should == "d 3"
- end
-
- it "should find spec name for 'it' at end of spec line" do
- @p.spec_name_for(File.open(__FILE__), 16).should == "d 3"
- end
-
- it "should find context for 'describe' above all specs" do
- @p.spec_name_for(File.open(__FILE__), 14).should == "d"
- end
-
- it "should find nearest example name between examples" do
- @p.spec_name_for(File.open(__FILE__), 7).should == "c 1"
- end
-
- it "should find nothing outside a context" do
- @p.spec_name_for(File.open(__FILE__), 2).should be_nil
- end
-
- it "should find context name for type" do
- @p.spec_name_for(File.open(__FILE__), 26).should == "SpecParserSubject"
- end
-
- it "should find context and spec name for type" do
- @p.spec_name_for(File.open(__FILE__), 28).should == "SpecParserSubject 5"
- end
-
- it "should find context and description for type" do
- @p.spec_name_for(File.open(__FILE__), 33).should == "SpecParserSubject described"
- end
-
- it "should find context and description and example for type" do
- @p.spec_name_for(File.open(__FILE__), 36).should == "SpecParserSubject described 6"
- end
-
- it "should find context and description for type with modifications" do
- @p.spec_name_for(File.open(__FILE__), 40).should == "SpecParserSubject described"
- end
-
- it "should find context and described and example for type with modifications" do
- @p.spec_name_for(File.open(__FILE__), 43).should == "SpecParserSubject described 7"
- end
-
- it "should find example group" do
- @p.spec_name_for(File.open(__FILE__), 47).should == "described"
- end
-
- it "should find example" do
- @p.spec_name_for(File.open(__FILE__), 50).should == "described 8"
- end
-
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-module Spec
- describe Runner, ".configure" do
- it "should yield global configuration" do
- Spec::Runner.configure do |config|
- config.should equal(Spec::Runner.configuration)
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-# This file contains various classes used by the specs.
-module Spec
- module Expectations
- class Person
- attr_reader :name
- def initialize name
- @name = name
- end
- def == other
- return @name == other.name
- end
- end
-
- class ClassWithMultiWordPredicate
- def multi_word_predicate?
- true
- end
- end
-
- module Helper
- class CollectionWithSizeMethod
- def initialize; @list = []; end
- def size; @list.size; end
- def push(item); @list.push(item); end
- end
-
- class CollectionWithLengthMethod
- def initialize; @list = []; end
- def length; @list.size; end
- def push(item); @list.push(item); end
- end
-
- class CollectionOwner
- attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method
-
- def initialize
- @items_in_collection_with_size_method = CollectionWithSizeMethod.new
- @items_in_collection_with_length_method = CollectionWithLengthMethod.new
- end
-
- def add_to_collection_with_size_method(item)
- @items_in_collection_with_size_method.push(item)
- end
-
- def add_to_collection_with_length_method(item)
- @items_in_collection_with_length_method.push(item)
- end
-
- def items_for(arg)
- return [1, 2, 3] if arg == 'a'
- [1]
- end
-
- def items
- @items_in_collection_with_size_method
- end
- end
-
- class HandCodedMock
- include Spec::Matchers
- def initialize(return_val)
- @return_val = return_val
- @funny_called = false
- end
-
- def funny?
- @funny_called = true
- @return_val
- end
-
- def hungry?(a, b, c)
- a.should equal(1)
- b.should equal(2)
- c.should equal(3)
- @funny_called = true
- @return_val
- end
-
- def exists?
- @return_val
- end
-
- def multi_word_predicate?
- @return_val
- end
-
- def rspec_verify
- @funny_called.should be_true
- end
- end
- class ClassWithUnqueriedPredicate
- attr_accessor :foo
- def initialize(foo)
- @foo = foo
- end
- end
- end
- end
-end
-
-module Custom
- require 'spec/runner/formatter/base_text_formatter'
- class Formatter < Spec::Runner::Formatter::BaseTextFormatter
- attr_reader :options, :where
-
- def initialize(options, where)
- @options = options
- @where = where
- end
- end
-
- class BadFormatter < Spec::Runner::Formatter::BaseTextFormatter
- attr_reader :where
-
- def initialize(options, where)
- bad_method
- end
- end
-
- class Differ
- attr_reader :options
- def initialize(options)
- @options = options
- end
- end
-end
-
-class FakeReporter < Spec::Runner::Reporter
-end
+++ /dev/null
-module Spec
- module Story
- class StoryBuilder
- def initialize
- @title = 'a story'
- @narrative = 'narrative'
- end
-
- def title(value)
- @title = value
- self
- end
-
- def narrative(value)
- @narrative = value
- self
- end
-
- def to_story(&block)
- block = lambda {} unless block_given?
- Story.new @title, @narrative, &block
- end
- end
-
- class ScenarioBuilder
- def initialize
- @name = 'a scenario'
- @story = StoryBuilder.new.to_story
- end
-
- def name(value)
- @name = value
- self
- end
-
- def story(value)
- @story = value
- self
- end
-
- def to_scenario(&block)
- Scenario.new @story, @name, &block
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-module Spec
- module Story
- module Extensions
- describe "the main object extended with Main", :shared => true do
- before(:each) do
- @main = Class.new do; include Main; end
- @original_rspec_story_steps, $rspec_story_steps = $rspec_story_steps, nil
- end
-
- after(:each) do
- $rspec_story_steps = @original_rspec_story_steps
- end
-
- def have_step(type, name)
- return simple_matcher(%[step group containing a #{type} named #{name.inspect}]) do |actual|
- Spec::Story::Step === actual.find(type, name)
- end
- end
- end
-
- describe Main, "#run_story" do
- it_should_behave_like "the main object extended with Main"
-
- it "should create a PlainTextStoryRunner with run_story" do
- Spec::Story::Runner::PlainTextStoryRunner.should_receive(:new).and_return(mock("runner", :null_object => true))
- @main.run_story
- end
-
- it "should yield the runner if arity == 1" do
- File.should_receive(:read).with("some/path").and_return("Story: foo")
- $main_spec_runner = nil
- @main.run_story("some/path") do |runner|
- $main_spec_runner = runner
- end
- $main_spec_runner.should be_an_instance_of(Spec::Story::Runner::PlainTextStoryRunner)
- end
-
- it "should run in the runner if arity == 0" do
- File.should_receive(:read).with("some/path").and_return("Story: foo")
- $main_spec_runner = nil
- @main.run_story("some/path") do
- $main_spec_runner = self
- end
- $main_spec_runner.should be_an_instance_of(Spec::Story::Runner::PlainTextStoryRunner)
- end
-
- it "should tell the PlainTextStoryRunner to run with run_story" do
- runner = mock("runner")
- Spec::Story::Runner::PlainTextStoryRunner.should_receive(:new).and_return(runner)
- runner.should_receive(:run)
- @main.run_story
- end
- end
-
- describe Main, "#steps_for" do
- it_should_behave_like "the main object extended with Main"
-
- it "should have no steps for a non existent key" do
- @main.steps_for(:key).find(:given, "foo").should be_nil
- end
-
- it "should create steps for a key" do
- $main_spec_invoked = false
- @main.steps_for(:key) do
- Given("foo") {
- $main_spec_invoked = true
- }
- end
- @main.steps_for(:key).find(:given, "foo").perform(Object.new, "foo")
- $main_spec_invoked.should be_true
- end
-
- it "should append steps to steps_for a given key" do
- @main.steps_for(:key) do
- Given("first") {}
- end
- @main.steps_for(:key) do
- Given("second") {}
- end
- @main.steps_for(:key).should have_step(:given, "first")
- @main.steps_for(:key).should have_step(:given, "second")
- end
- end
-
- describe Main, "#with_steps_for adding new steps" do
- it_should_behave_like "the main object extended with Main"
-
- it "should result in a group containing pre-existing steps and newly defined steps" do
- first_group = @main.steps_for(:key) do
- Given("first") {}
- end
- second_group = @main.with_steps_for(:key) do
- Given("second") {}
- end
-
- second_group.should have_step(:given, "first")
- second_group.should have_step(:given, "second")
- end
-
- it "should not add its steps to the existing group" do
- first_group = @main.steps_for(:key) do
- Given("first") {}
- end
- second_group = @main.with_steps_for(:key) do
- Given("second") {}
- end
-
- first_group.should have_step(:given, "first")
- first_group.should_not have_step(:given, "second")
- end
- end
-
- describe Main, "#with_steps_for running a story" do
- it_should_behave_like "the main object extended with Main"
-
- before(:each) do
- @runner = mock("runner")
- @runner_step_group = StepGroup.new
- @runner.stub!(:steps).and_return(@runner_step_group)
- @runner.stub!(:run)
- Spec::Story::Runner::PlainTextStoryRunner.stub!(:new).and_return(@runner)
- end
-
- it "should create a PlainTextStoryRunner with a path" do
- Spec::Story::Runner::PlainTextStoryRunner.should_receive(:new).with('path/to/file',{}).and_return(@runner)
- @main.with_steps_for(:foo) do
- run 'path/to/file'
- end
- end
-
- it "should create a PlainTextStoryRunner with a path and options" do
- Spec::Story::Runner::PlainTextStoryRunner.should_receive(:new).with(anything,{:bar => :baz}).and_return(@runner)
- @main.with_steps_for(:foo) do
- run 'path/to/file', :bar => :baz
- end
- end
-
- it "should pass the group it creates to the runner's steps" do
- steps = @main.steps_for(:ice_cream) do
- Given("vanilla") {}
- end
- @main.with_steps_for(:ice_cream) do
- run 'foo'
- end
- @runner_step_group.should have_step(:given, "vanilla")
- end
-
- it "should run a story" do
- @runner.should_receive(:run)
- Spec::Story::Runner::PlainTextStoryRunner.should_receive(:new).and_return(@runner)
- @main.with_steps_for(:foo) do
- run 'path/to/file'
- end
- end
-
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-require 'spec/story'
-
-describe Kernel, "#Story" do
- before(:each) do
- Kernel.stub!(:at_exit)
- end
-
- it "should delegate to ::Spec::Story::Runner.story_runner" do
- ::Spec::Story::Runner.story_runner.should_receive(:Story)
- story = Story("title","narrative"){}
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe GivenScenario do
- it 'should execute a scenario from the current story in its world' do
- # given
- class MyWorld
- attr :scenario_ran
- end
- instance = World.create(MyWorld)
- scenario = ScenarioBuilder.new.to_scenario do
- @scenario_ran = true
- end
- Runner::StoryRunner.should_receive(:scenario_from_current_story).with('scenario name').and_return(scenario)
-
- step = GivenScenario.new 'scenario name'
-
- # when
- step.perform(instance, nil)
-
- # then
- instance.scenario_ran.should be_true
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
- describe PlainTextStoryRunner do
- before(:each) do
- StoryParser.stub!(:new).and_return(@parser = mock("parser"))
- @parser.stub!(:parse).and_return([])
- File.stub!(:read).with("path").and_return("this\nand that")
- end
-
- it "should provide access to steps" do
- runner = PlainTextStoryRunner.new("path")
-
- runner.steps do |add|
- add.given("baz") {}
- end
-
- runner.steps.find(:given, "baz").should_not be_nil
- end
-
- it "should parse a story file" do
- runner = PlainTextStoryRunner.new("path")
-
- during {
- runner.run
- }.expect {
- @parser.should_receive(:parse).with(["this", "and that"])
- }
- end
-
- it "should build up a mediator with its own steps and the singleton story_runner" do
- runner = PlainTextStoryRunner.new("path")
- Spec::Story::Runner.should_receive(:story_runner).and_return(story_runner = mock("story runner"))
- Spec::Story::Runner::StoryMediator.should_receive(:new).with(runner.steps, story_runner, {}).
- and_return(mediator = stub("mediator", :run_stories => nil))
- runner.run
- end
-
- it "should build up a parser with the mediator" do
- runner = PlainTextStoryRunner.new("path")
- Spec::Story::Runner.should_receive(:story_runner).and_return(story_runner = mock("story runner"))
- Spec::Story::Runner::StoryMediator.should_receive(:new).and_return(mediator = stub("mediator", :run_stories => nil))
- Spec::Story::Runner::StoryParser.should_receive(:new).with(mediator).and_return(@parser)
- runner.run
- end
-
- it "should tell the mediator to run the stories" do
- runner = PlainTextStoryRunner.new("path")
- mediator = mock("mediator")
- Spec::Story::Runner::StoryMediator.should_receive(:new).and_return(mediator)
- mediator.should_receive(:run_stories)
- runner.run
- end
-
- it "should accept a block instead of a path" do
- runner = PlainTextStoryRunner.new do |runner|
- runner.load("path/to/story")
- end
- File.should_receive(:read).with("path/to/story").and_return("this\nand that")
- runner.run
- end
-
- it "should tell you if you try to run with no path set" do
- runner = PlainTextStoryRunner.new
- lambda {
- runner.run
- }.should raise_error(RuntimeError, "You must set a path to the file with the story. See the RDoc.")
- end
-
- it "should pass options to the mediator" do
- runner = PlainTextStoryRunner.new("path", :foo => :bar)
- Spec::Story::Runner::StoryMediator.should_receive(:new).
- with(anything, anything, :foo => :bar).
- and_return(mediator = stub("mediator", :run_stories => nil))
- runner.run
- end
-
- it "should provide access to its options" do
- runner = PlainTextStoryRunner.new("path")
- runner[:foo] = :bar
- Spec::Story::Runner::StoryMediator.should_receive(:new).
- with(anything, anything, :foo => :bar).
- and_return(mediator = stub("mediator", :run_stories => nil))
- runner.run
- end
-
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
- describe ScenarioCollector do
- it 'should construct scenarios with the supplied story' do
- # given
- story = stub_everything('story')
- scenario_collector = ScenarioCollector.new(story)
-
- # when
- scenario_collector.Scenario 'scenario1' do end
- scenario_collector.Scenario 'scenario2' do end
- scenarios = scenario_collector.scenarios
-
- # then
- scenario_collector.should have(2).scenarios
- scenarios.first.name.should == 'scenario1'
- scenarios.first.story.should equal(story)
- scenarios.last.name.should == 'scenario2'
- scenarios.last.story.should equal(story)
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
- describe ScenarioRunner do
- it 'should run a scenario in its story' do
- # given
- world = stub_everything
- scenario_runner = ScenarioRunner.new
- $answer = nil
- story = Story.new 'story', 'narrative' do
- @answer = 42 # this should be available to the scenario
- end
- scenario = Scenario.new story, 'scenario' do
- $answer = @answer
- end
-
- # when
- scenario_runner.run(scenario, world)
-
- # then
- $answer.should == 42
- end
-
- it 'should allow scenarios to share methods' do
- # given
- world = stub_everything
- $shared_invoked = 0
- story = Story.new 'story', 'narrative' do
- def shared
- $shared_invoked += 1
- end
- end
- scenario1 = Scenario.new story, 'scenario1' do
- shared()
- end
- scenario2 = Scenario.new story, 'scenario2' do
- shared()
- end
- scenario_runner = ScenarioRunner.new
-
- # when
- scenario_runner.run(scenario1, world)
- scenario_runner.run(scenario2, world)
-
- # then
- $shared_invoked.should == 2
- end
-
- it 'should notify listeners when a scenario starts' do
- # given
- world = stub_everything
- story = Story.new 'story', 'narrative' do end
- scenario = Scenario.new story, 'scenario1' do
- # succeeds
- end
- scenario_runner = ScenarioRunner.new
- mock_listener1 = stub_everything('listener1')
- mock_listener2 = stub_everything('listener2')
- scenario_runner.add_listener(mock_listener1)
- scenario_runner.add_listener(mock_listener2)
-
- # expect
- mock_listener1.should_receive(:scenario_started).with('story', 'scenario1')
- mock_listener2.should_receive(:scenario_started).with('story', 'scenario1')
-
- # when
- scenario_runner.run(scenario, world)
-
- # then
- end
-
- it 'should notify listeners when a scenario succeeds' do
- # given
- world = stub_everything('world')
- story = Story.new 'story', 'narrative' do end
- scenario = Scenario.new story, 'scenario1' do
- # succeeds
- end
- scenario_runner = ScenarioRunner.new
- mock_listener1 = stub_everything('listener1')
- mock_listener2 = stub_everything('listener2')
- scenario_runner.add_listener(mock_listener1)
- scenario_runner.add_listener(mock_listener2)
-
- # expect
- mock_listener1.should_receive(:scenario_succeeded).with('story', 'scenario1')
- mock_listener2.should_receive(:scenario_succeeded).with('story', 'scenario1')
-
- # when
- scenario_runner.run(scenario, world)
-
- # then
- end
-
- it 'should notify listeners ONCE when a scenario raises an error' do
- # given
- error = RuntimeError.new('oops')
- story = Story.new 'title', 'narrative' do end
- scenario = Scenario.new story, 'scenario1' do
- end
- scenario_runner = ScenarioRunner.new
- mock_listener = stub_everything('listener')
- scenario_runner.add_listener(mock_listener)
- world = stub_everything
-
- # expect
- world.should_receive(:errors).twice.and_return([error, error])
- mock_listener.should_receive(:scenario_failed).with('title', 'scenario1', error).once
-
- # when
- scenario_runner.run scenario, world
-
- # then
- end
-
- it 'should notify listeners when a scenario is pending' do
- # given
- pending_error = Spec::Example::ExamplePendingError.new('todo')
- story = Story.new 'title', 'narrative' do end
- scenario = Scenario.new story, 'scenario1' do
- end
- scenario_runner = ScenarioRunner.new
- mock_listener = mock('listener')
- scenario_runner.add_listener(mock_listener)
- world = stub_everything
-
- # expect
- world.should_receive(:errors).twice.and_return([pending_error, pending_error])
- mock_listener.should_receive(:scenario_started).with('title', 'scenario1')
- mock_listener.should_receive(:scenario_pending).with('title', 'scenario1', 'todo').once
-
- # when
- scenario_runner.run scenario, world
-
- # then
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
-
- describe StoryMediator do
- before(:each) do
- $story_mediator_spec_value = nil
- @step_group = StepGroup.new
- @step_group.create_matcher(:given, "given") { $story_mediator_spec_value = "given matched" }
- @step_group.create_matcher(:when, "when") { $story_mediator_spec_value = "when matched" }
- @step_group.create_matcher(:then, "then") { $story_mediator_spec_value = "then matched" }
-
- @scenario_runner = ScenarioRunner.new
- @runner = StoryRunner.new @scenario_runner
- @mediator = StoryMediator.new @step_group, @runner
- end
-
- def run_stories
- @mediator.run_stories
- @runner.run_stories
- end
-
- it "should have no stories" do
- @mediator.stories.should be_empty
- end
-
- it "should create two stories" do
- @mediator.create_story "story title", "story narrative"
- @mediator.create_story "story title 2", "story narrative 2"
- run_stories
-
- @runner.should have(2).stories
- @runner.stories.first.title.should == "story title"
- @runner.stories.first.narrative.should == "story narrative"
- @runner.stories.last.title.should == "story title 2"
- @runner.stories.last.narrative.should == "story narrative 2"
- end
-
- it "should create a scenario" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario name"
- run_stories
-
- @runner.should have(1).scenarios
- @runner.scenarios.first.name.should == "scenario name"
- @runner.scenarios.first.story.should == @runner.stories.first
- end
-
- it "should create a given scenario step if one matches" do
- pending("need to untangle the dark mysteries of the story runner - something needs to get stubbed here") do
- story = @mediator.create_story "title", "narrative"
- @mediator.create_scenario "previous scenario"
- @mediator.create_scenario "current scenario"
- @mediator.create_given_scenario "previous scenario"
- run_stories
-
- $story_mediator_spec_value.should == "previous scenario matched"
- end
- end
-
- it "should create a given step if one matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_given "given"
- run_stories
-
- $story_mediator_spec_value.should == "given matched"
- end
-
- it "should create a pending step if no given step matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_given "no match"
- mock_listener = stub_everything("listener")
- mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
- @scenario_runner.add_listener mock_listener
- run_stories
- end
-
- it "should create a when step if one matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_when "when"
- run_stories
-
- $story_mediator_spec_value.should == "when matched"
- end
-
- it "should create a pending step if no when step matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_when "no match"
- mock_listener = stub_everything("listener")
- mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
- @scenario_runner.add_listener mock_listener
- run_stories
- end
-
- it "should create a then step if one matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_then "then"
- run_stories
-
- $story_mediator_spec_value.should == "then matched"
- end
-
- it "should create a pending step if no 'then' step matches" do
- @mediator.create_story "title", "narrative"
- @mediator.create_scenario "scenario"
- @mediator.create_then "no match"
- mock_listener = stub_everything("listener")
- mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
- @scenario_runner.add_listener mock_listener
- run_stories
- end
-
- it "should pass options to the stories it creates" do
- @mediator = StoryMediator.new @step_group, @runner, :foo => :bar
- @mediator.create_story "story title", "story narrative"
-
- run_stories
-
- @runner.stories.first[:foo].should == :bar
- end
-
- end
-
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
-
- describe StoryParser do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- end
-
- it "should parse no lines" do
- @parser.parse([])
- end
-
- it "should ignore text before the first Story: begins" do
- @story_mediator.should_not_receive(:create_scenario)
- @story_mediator.should_not_receive(:create_given)
- @story_mediator.should_not_receive(:create_when)
- @story_mediator.should_not_receive(:create_then)
- @story_mediator.should_receive(:create_story).with("simple addition", "")
- @parser.parse(["Here is a bunch of text", "about a calculator and all the things", "that it will do", "Story: simple addition"])
- end
-
- it "should create a story" do
- @story_mediator.should_receive(:create_story).with("simple addition", "")
- @parser.parse(["Story: simple addition"])
- end
-
- it "should create a story when line has leading spaces" do
- @story_mediator.should_receive(:create_story).with("simple addition", "")
- @parser.parse([" Story: simple addition"])
- end
-
- it "should add a one line narrative to the story" do
- @story_mediator.should_receive(:create_story).with("simple addition","narrative")
- @parser.parse(["Story: simple addition","narrative"])
- end
-
- it "should add a multi line narrative to the story" do
- @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2\nline 3")
- @parser.parse(["Story: simple addition","narrative line 1", "line 2", "line 3"])
- end
-
- it "should exclude blank lines from the narrative" do
- @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
- @parser.parse(["Story: simple addition","narrative line 1", "", "line 2"])
- end
-
- it "should exclude Scenario from the narrative" do
- @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
- @story_mediator.should_receive(:create_scenario)
- @parser.parse(["Story: simple addition","narrative line 1", "line 2", "Scenario: add one plus one"])
- end
-
- end
-
- describe StoryParser, "in Story state" do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- @story_mediator.stub!(:create_story)
- end
-
- it "should create a second Story for Story" do
- @story_mediator.should_receive(:create_story).with("number two","")
- @parser.parse(["Story: s", "Story: number two"])
- end
-
- it "should include And in the narrative" do
- @story_mediator.should_receive(:create_story).with("s","And foo")
- @story_mediator.should_receive(:create_scenario).with("bar")
- @parser.parse(["Story: s", "And foo", "Scenario: bar"])
- end
-
- it "should create a Scenario for Scenario" do
- @story_mediator.should_receive(:create_scenario).with("number two")
- @parser.parse(["Story: s", "Scenario: number two"])
- end
-
- it "should include Given in the narrative" do
- @story_mediator.should_receive(:create_story).with("s","Given foo")
- @story_mediator.should_receive(:create_scenario).with("bar")
- @parser.parse(["Story: s", "Given foo", "Scenario: bar"])
- end
-
- it "should include Given: in the narrative" do
- @story_mediator.should_receive(:create_story).with("s","Given: foo")
- @story_mediator.should_receive(:create_scenario).with("bar")
- @parser.parse(["Story: s", "Given: foo", "Scenario: bar"])
- end
-
- it "should include When in the narrative" do
- @story_mediator.should_receive(:create_story).with("s","When foo")
- @story_mediator.should_receive(:create_scenario).with("bar")
- @parser.parse(["Story: s", "When foo", "Scenario: bar"])
- end
-
- it "should include Then in the narrative" do
- @story_mediator.should_receive(:create_story).with("s","Then foo")
- @story_mediator.should_receive(:create_scenario).with("bar")
- @parser.parse(["Story: s", "Then foo", "Scenario: bar"])
- end
-
- it "should include other in the story" do
- @story_mediator.should_receive(:create_story).with("s","narrative")
- @parser.parse(["Story: s", "narrative"])
- end
- end
-
- describe StoryParser, "in Scenario state" do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- @story_mediator.stub!(:create_story)
- @story_mediator.stub!(:create_scenario)
- end
-
- it "should create a Story for Story" do
- @story_mediator.should_receive(:create_story).with("number two","")
- @parser.parse(["Story: s", "Scenario: s", "Story: number two"])
- end
-
- it "should create a Scenario for Scenario" do
- @story_mediator.should_receive(:create_scenario).with("number two")
- @parser.parse(["Story: s", "Scenario: s", "Scenario: number two"])
- end
-
- it "should raise for And" do
- lambda {
- @parser.parse(["Story: s", "Scenario: s", "And second"])
- }.should raise_error(IllegalStepError, /^Illegal attempt to create a And after a Scenario/)
- end
-
- it "should create a Given for Given" do
- @story_mediator.should_receive(:create_given).with("gift")
- @parser.parse(["Story: s", "Scenario: s", "Given gift"])
- end
-
- it "should create a Given for Given:" do
- @story_mediator.should_receive(:create_given).with("gift")
- @parser.parse(["Story: s", "Scenario: s", "Given: gift"])
- end
-
- it "should create a GivenScenario for GivenScenario" do
- @story_mediator.should_receive(:create_given_scenario).with("previous")
- @parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
- end
-
- it "should create a GivenScenario for GivenScenario:" do
- @story_mediator.should_receive(:create_given_scenario).with("previous")
- @parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
- end
-
- it "should transition to Given state after GivenScenario" do
- @story_mediator.stub!(:create_given_scenario)
- @parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
- @parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
- end
-
- it "should transition to Given state after GivenScenario:" do
- @story_mediator.stub!(:create_given_scenario)
- @parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
- @parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
- end
-
- it "should create a When for When" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "When ever"])
- end
-
- it "should create a When for When:" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "When: ever"])
- end
-
- it "should create a Then for Then" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Then and there"])
- end
-
- it "should create a Then for Then:" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Then: and there"])
- end
-
- it "should ignore other" do
- @parser.parse(["Story: s", "Scenario: s", "this is ignored"])
- end
- end
-
- describe StoryParser, "in Given state" do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- @story_mediator.stub!(:create_story)
- @story_mediator.stub!(:create_scenario)
- @story_mediator.should_receive(:create_given).with("first")
- end
-
- it "should create a Story for Story" do
- @story_mediator.should_receive(:create_story).with("number two","")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "Story: number two"])
- end
-
- it "should create a Scenario for Scenario" do
- @story_mediator.should_receive(:create_scenario).with("number two")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "Scenario: number two"])
- end
-
- it "should create a second Given for Given" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "Given second"])
- end
-
- it "should create a second Given for And" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "And second"])
- end
-
- it "should create a second Given for And:" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "And: second"])
- end
-
- it "should create a When for When" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When ever"])
- end
-
- it "should create a When for When:" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When: ever"])
- end
-
- it "should create a Then for Then" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "Then and there"])
- end
-
- it "should create a Then for Then:" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "Then: and there"])
- end
-
- it "should ignore other" do
- @parser.parse(["Story: s", "Scenario: s", "Given first", "this is ignored"])
- end
- end
-
- describe StoryParser, "in When state" do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- @story_mediator.stub!(:create_story)
- @story_mediator.stub!(:create_scenario)
- @story_mediator.should_receive(:create_given).with("first")
- @story_mediator.should_receive(:create_when).with("else")
- end
-
- it "should create a Story for Story" do
- @story_mediator.should_receive(:create_story).with("number two","")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When: else", "Story: number two"])
- end
-
- it "should create a Scenario for Scenario" do
- @story_mediator.should_receive(:create_scenario).with("number two")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Scenario: number two"])
- end
-
- it "should create Given for Given" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given second"])
- end
-
- it "should create Given for Given:" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given: second"])
- end
-
- it "should create a second When for When" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "When ever"])
- end
-
- it "should create a second When for When:" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "When: ever"])
- end
-
- it "should create a second When for And" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "And ever"])
- end
-
- it "should create a second When for And:" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "And: ever"])
- end
-
- it "should create a Then for Then" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then and there"])
- end
-
- it "should create a Then for Then:" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: and there"])
- end
-
- it "should ignore other" do
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "this is ignored"])
- end
- end
-
- describe StoryParser, "in Then state" do
- before(:each) do
- @story_mediator = mock("story_mediator")
- @parser = StoryParser.new(@story_mediator)
- @story_mediator.stub!(:create_story)
- @story_mediator.stub!(:create_scenario)
- @story_mediator.should_receive(:create_given).with("first")
- @story_mediator.should_receive(:create_when).with("else")
- @story_mediator.should_receive(:create_then).with("what")
- end
-
- it "should create a Story for Story" do
- @story_mediator.should_receive(:create_story).with("number two","")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Story: number two"])
- end
-
- it "should create a Scenario for Scenario" do
- @story_mediator.should_receive(:create_scenario).with("number two")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Scenario: number two"])
- end
-
- it "should create Given for Given" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Given second"])
- end
-
- it "should create Given for Given:" do
- @story_mediator.should_receive(:create_given).with("second")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Given: second"])
- end
-
- it "should create When for When" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "When ever"])
- end
-
- it "should create When for When:" do
- @story_mediator.should_receive(:create_when).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "When: ever"])
- end
-
- it "should create a Then for Then" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Then and there"])
- end
-
- it "should create a Then for Then:" do
- @story_mediator.should_receive(:create_then).with("and there")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Then: and there"])
- end
-
- it "should create a second Then for And" do
- @story_mediator.should_receive(:create_then).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "And ever"])
- end
-
- it "should create a second Then for And:" do
- @story_mediator.should_receive(:create_then).with("ever")
- @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "And: ever"])
- end
-
- it "should ignore other" do
- @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "this is ignored"])
- end
- end
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
- module Story
- module Runner
- describe StoryRunner do
- it 'should collect all the stories' do
- # given
- story_runner = StoryRunner.new(stub('scenario_runner'))
-
- # when
- story_runner.Story 'title1', 'narrative1' do end
- story_runner.Story 'title2', 'narrative2' do end
- stories = story_runner.stories
-
- # then
- story_runner.should have(2).stories
- stories.first.title.should == 'title1'
- stories.first.narrative.should == 'narrative1'
- stories.last.title.should == 'title2'
- stories.last.narrative.should == 'narrative2'
- end
-
- it 'should gather all the scenarios in the stories' do
- # given
- story_runner = StoryRunner.new(stub('scenario_runner'))
-
- # when
- story_runner.Story "story1", "narrative1" do
- Scenario "scenario1" do end
- Scenario "scenario2" do end
- end
- story_runner.Story "story2", "narrative2" do
- Scenario "scenario3" do end
- end
- scenarios = story_runner.scenarios
-
- # then
- story_runner.should have(3).scenarios
- scenarios[0].name.should == 'scenario1'
- scenarios[1].name.should == 'scenario2'
- scenarios[2].name.should == 'scenario3'
- end
-
- # captures worlds passed into a ScenarioRunner
- class ScenarioWorldCatcher
- attr_accessor :worlds
- def run(scenario, world)
- (@worlds ||= []) << world
- end
- end
-
- it 'should run each scenario in a separate object' do
- # given
- scenario_world_catcher = ScenarioWorldCatcher.new
- story_runner = StoryRunner.new(scenario_world_catcher)
- story_runner.Story 'story', 'narrative' do
- Scenario 'scenario1' do end
- Scenario 'scenario2' do end
- end
-
- # when
- story_runner.run_stories
-
- # then
- worlds = scenario_world_catcher.worlds
- scenario_world_catcher.should have(2).worlds
- worlds[0].should_not == worlds[1]
- end
-
- it 'should use the provided world creator to create worlds' do
- # given
- stub_scenario_runner = stub_everything
- mock_world_creator = mock('world creator')
- story_runner = StoryRunner.new(stub_scenario_runner, mock_world_creator)
- story_runner.Story 'story', 'narrative' do
- Scenario 'scenario1' do end
- Scenario 'scenario2' do end
- end
-
- # expect
- mock_world_creator.should_receive(:create).twice
-
- # when
- story_runner.run_stories
-
- # then
- end
-
- it 'should notify listeners of the scenario count when the run starts' do
- # given
- story_runner = StoryRunner.new(stub_everything)
- mock_listener1 = stub_everything('listener1')
- mock_listener2 = stub_everything('listener2')
- story_runner.add_listener(mock_listener1)
- story_runner.add_listener(mock_listener2)
-
- story_runner.Story 'story1', 'narrative1' do
- Scenario 'scenario1' do end
- end
- story_runner.Story 'story2', 'narrative2' do
- Scenario 'scenario2' do end
- Scenario 'scenario3' do end
- end
-
- # expect
- mock_listener1.should_receive(:run_started).with(3)
- mock_listener2.should_receive(:run_started).with(3)
-
- # when
- story_runner.run_stories
-
- # then
- end
-
- it 'should notify listeners when a story starts' do
- # given
- story_runner = StoryRunner.new(stub_everything)
- mock_listener1 = stub_everything('listener1')
- mock_listener2 = stub_everything('listener2')
- story_runner.add_listener(mock_listener1)
- story_runner.add_listener(mock_listener2)
-
- story_runner.Story 'story1', 'narrative1' do
- Scenario 'scenario1' do end
- end
- story_runner.Story 'story2', 'narrative2' do
- Scenario 'scenario2' do end
- Scenario 'scenario3' do end
- end
-
- # expect
- mock_listener1.should_receive(:story_started).with('story1', 'narrative1')
- mock_listener1.should_receive(:story_ended).with('story1', 'narrative1')
- mock_listener2.should_receive(:story_started).with('story2', 'narrative2')
- mock_listener2.should_receive(:story_ended).with('story2', 'narrative2')
-
- # when
- story_runner.run_stories
-
- # then
- end
-
- it 'should notify listeners when the run ends' do
- # given
- story_runner = StoryRunner.new(stub_everything)
- mock_listener1 = stub_everything('listener1')
- mock_listener2 = stub_everything('listener2')
- story_runner.add_listener mock_listener1
- story_runner.add_listener mock_listener2
- story_runner.Story 'story1', 'narrative1' do
- Scenario 'scenario1' do end
- end
-
- # expect
- mock_listener1.should_receive(:run_ended)
- mock_listener2.should_receive(:run_ended)
-
- # when
- story_runner.run_stories
-
- # then
- end
-
- it 'should run a story in an instance of a specified class' do
- # given
- scenario_world_catcher = ScenarioWorldCatcher.new
- story_runner = StoryRunner.new(scenario_world_catcher)
- story_runner.Story 'title', 'narrative', :type => String do
- Scenario 'scenario' do end
- end
-
- # when
- story_runner.run_stories
-
- # then
- scenario_world_catcher.worlds[0].should be_kind_of(String)
- scenario_world_catcher.worlds[0].should be_kind_of(World)
- end
-
- it 'should pass initialization params through to the constructed instance' do
- # given
- scenario_world_catcher = ScenarioWorldCatcher.new
- story_runner = StoryRunner.new(scenario_world_catcher)
- story_runner.Story 'title', 'narrative', :type => Array, :args => [3] do
- Scenario 'scenario' do end
- end
-
- # when
- story_runner.run_stories
-
- # then
- scenario_world_catcher.worlds[0].should be_kind_of(Array)
- scenario_world_catcher.worlds[0].size.should == 3
- end
-
- it 'should find a scenario in the current story by name' do
- # given
- story_runner = StoryRunner.new(ScenarioRunner.new)
- $scenario = nil
-
- story_runner.Story 'title', 'narrative' do
- Scenario 'first scenario' do
- end
- Scenario 'second scenario' do
- $scenario = StoryRunner.scenario_from_current_story 'first scenario'
- end
- end
-
- # when
- story_runner.run_stories
-
- # then
- $scenario.name.should == 'first scenario'
- end
-
- it "should clean the steps between stories" do
- #given
- story_runner = StoryRunner.new(ScenarioRunner.new)
- result = mock 'result'
-
- step1 = Step.new('step') do
- result.one
- end
- steps1 = StepGroup.new
- steps1.add :when, step1
-
- story_runner.Story 'title', 'narrative', :steps => steps1 do
- Scenario 'first scenario' do
- When 'step'
- end
- end
-
- step2 = Step.new('step') do
- result.two
- end
- steps2 = StepGroup.new
- steps2.add :when, step2
-
- story_runner.Story 'title2', 'narrative', :steps => steps2 do
- Scenario 'second scenario' do
- When 'step'
- end
- end
-
- #then
- result.should_receive(:one)
- result.should_receive(:two)
-
- #when
- story_runner.run_stories
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe Runner, "module" do
- def dev_null
- io = StringIO.new
- def io.write(str)
- str.to_s.size
- end
- return io
- end
-
- before :each do
- Kernel.stub!(:at_exit)
- @stdout, $stdout = $stdout, dev_null
- @argv = Array.new(ARGV)
- @runner_module = Runner.dup
- @world_creator = World.dup
- @runner_module.module_eval { @run_options = @story_runner = @scenario_runner = @world_creator = nil }
- end
-
- after :each do
- $stdout = @stdout
- ARGV.replace @argv
- @runner_module.module_eval { @run_options = @story_runner = @scenario_runner = @world_creator = nil }
- end
-
- it 'should wire up a singleton StoryRunner' do
- @runner_module.story_runner.should_not be_nil
- end
-
- it 'should set its options based on ARGV' do
- # given
- ARGV << '--dry-run'
-
- # when
- options = @runner_module.run_options
-
- # then
- options.dry_run.should be_true
- end
-
- it 'should add a reporter to the runner classes' do
- # given
- story_runner = mock('story runner', :null_object => true)
- scenario_runner = mock('scenario runner', :null_object => true)
- world_creator = mock('world', :null_object => true)
-
- @runner_module::class_eval { @world_creator = world_creator }
- @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
- @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
- # expect
- world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
- story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
- scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
-
- # when
- @runner_module.story_runner
- end
-
- it 'should add a documenter to the runner classes if one is specified' do
- # given
- ARGV << "--format" << "html"
- story_runner = mock('story runner', :null_object => true)
- scenario_runner = mock('scenario runner', :null_object => true)
- world_creator = mock('world', :null_object => true)
-
- @runner_module::class_eval { @world_creator = world_creator }
- @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
- @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
- # expect
- world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
- story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
- scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
-
- # when
- @runner_module.story_runner
- end
-
- it 'should add any registered listener to the runner classes' do
- # given
- ARGV << "--format" << "html"
- story_runner = mock('story runner', :null_object => true)
- scenario_runner = mock('scenario runner', :null_object => true)
- world_creator = mock('world', :null_object => true)
-
- @runner_module::class_eval { @world_creator = world_creator }
- @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
- @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
- listener = Object.new
-
- # expect
- world_creator.should_receive(:add_listener).with(listener)
- story_runner.should_receive(:add_listener).with(listener)
- scenario_runner.should_receive(:add_listener).with(listener)
-
- # when
- @runner_module.register_listener listener
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe Scenario do
- it 'should not raise an error if no body is supplied' do
- # given
- story = StoryBuilder.new.to_story
-
- # when
- error = exception_from do
- Scenario.new story, 'name'
- end
-
- # then
- error.should be_nil
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe StepGroup do
- before(:each) do
- @step_group = StepGroup.new
- end
-
- it "should not find a matcher if empty" do
- @step_group.find(:given, "this and that").should be_nil
- end
-
- it "should create a given_scenario matcher" do
- step = @step_group.given_scenario("this and that") {}
- @step_group.find(:given_scenario, "this and that").should_not be_nil
- @step_group.find(:given_scenario, "this and that").should equal(step)
- end
-
- it "should create a given matcher" do
- step = @step_group.given("this and that") {}
- @step_group.find(:given, "this and that").should equal(step)
- end
-
- it "should create a when matcher" do
- step = @step_group.when("this and that") {}
- @step_group.find(:when, "this and that").should equal(step)
- end
-
- it "should create a them matcher" do
- step = @step_group.then("this and that") {}
- @step_group.find(:then, "this and that").should equal(step)
- end
-
- it "should add a matcher object" do
- step = Step.new("this and that") {}
- @step_group.add(:given, step)
- @step_group.find(:given, "this and that").should equal(step)
- end
-
- it "should add it matchers to another StepGroup (with one given)" do
- source = StepGroup.new
- target = StepGroup.new
- step = source.given("this and that") {}
- source.add_to target
- target.find(:given, "this and that").should equal(step)
- end
-
- it "should add it matchers to another StepGroup (with some of each type)" do
- source = StepGroup.new
- target = StepGroup.new
- given_scenario = source.given_scenario("1") {}
- given = source.given("1") {}
- when1 = source.when("1") {}
- when2 = source.when("2") {}
- then1 = source.then("1") {}
- then2 = source.then("2") {}
- then3 = source.then("3") {}
- source.add_to target
- target.find(:given_scenario, "1").should equal(given_scenario)
- target.find(:given, "1").should equal(given)
- target.find(:when, "1").should equal(when1)
- target.find(:when, "2").should equal(when2)
- target.find(:then, "1").should equal(then1)
- target.find(:then, "2").should equal(then2)
- target.find(:then, "3").should equal(then3)
- end
-
- it "should append another collection" do
- matchers_to_append = StepGroup.new
- step = matchers_to_append.given("this and that") {}
- @step_group << matchers_to_append
- @step_group.find(:given, "this and that").should equal(step)
- end
-
- it "should append several other collections" do
- matchers_to_append = StepGroup.new
- more_matchers_to_append = StepGroup.new
- first_matcher = matchers_to_append.given("this and that") {}
- second_matcher = more_matchers_to_append.given("and the other") {}
- @step_group << matchers_to_append
- @step_group << more_matchers_to_append
- @step_group.find(:given, "this and that").should equal(first_matcher)
- @step_group.find(:given, "and the other").should equal(second_matcher)
- end
-
- it "should yield itself on initialization" do
- begin
- $step_group_spec_step = nil
- matchers = StepGroup.new do |matchers|
- $step_group_spec_step = matchers.given("foo") {}
- end
- $step_group_spec_step.matches?("foo").should be_true
- ensure
- $step_group_spec_step = nil
- end
- end
-
- it "should support defaults" do
- class StepGroupSubclass < StepGroup
- steps do |add|
- add.given("foo") {}
- end
- end
- StepGroupSubclass.new.find(:given, "foo").should_not be_nil
- end
-
- it "should create a Given" do
- sub = Class.new(StepGroup).new
- step = sub.Given("foo") {}
- sub.find(:given, "foo").should == step
- end
-
- it "should create a When" do
- sub = Class.new(StepGroup).new
- step = sub.When("foo") {}
- sub.find(:when, "foo").should == step
- end
-
- it "should create a Then" do
- sub = Class.new(StepGroup).new
- step = sub.Then("foo") {}
- sub.find(:then, "foo").should == step
- end
-
- it "should create steps in a block" do
- sub = Class.new(StepGroup).new do
- Given("a given") {}
- When("a when") {}
- Then("a then") {}
- end
- sub.find(:given, "a given").should_not be_nil
- sub.find(:when, "a when").should_not be_nil
- sub.find(:then, "a then").should_not be_nil
- end
-
- it "should clear itself" do
- step = @step_group.given("this and that") {}
- @step_group.clear
- @step_group.find(:given, "this and that").should be_nil
- end
-
- it "should tell you when it is empty" do
- @step_group.should be_empty
- end
-
- it "should tell you when it is not empty" do
- @step_group.given("this and that") {}
- @step_group.should_not be_empty
- end
-
- it "should handle << nil" do
- @step_group << nil
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe StepMother do
- it 'should store a step by name and type' do
- # given
- step_mother = StepMother.new
- step = Step.new("a given", &lambda {})
- step_mother.store(:given, step)
-
- # when
- found = step_mother.find(:given, "a given")
-
- # then
- found.should == step
- end
-
- it 'should NOT raise an error if a step is missing' do
- # given
- step_mother = StepMother.new
-
- # then
- lambda do
- # when
- step_mother.find(:given, "doesn't exist")
- end.should_not raise_error
- end
-
- it "should create a default step which raises a pending error" do
- # given
- step_mother = StepMother.new
-
- # when
- step = step_mother.find(:given, "doesn't exist")
-
- # then
- step.should be_an_instance_of(Step)
-
- lambda do
- step.perform(Object.new, "doesn't exist")
- end.should raise_error(Spec::Example::ExamplePendingError, /Unimplemented/)
- end
-
- it 'should clear itself' do
- # given
- step_mother = StepMother.new
- step = Step.new("a given") do end
- step_mother.store(:given, step)
-
- # when
- step_mother.clear
-
- # then
- step_mother.should be_empty
- end
-
- it "should use assigned steps" do
- step_mother = StepMother.new
-
- step = Step.new('step') {}
- step_group = StepGroup.new
- step_group.add(:given, step)
-
- step_mother.use(step_group)
-
- step_mother.find(:given, "step").should equal(step)
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe Step, "matching" do
- it "should match a text string" do
- step = Step.new("this text") {}
- step.matches?("this text").should be_true
- end
-
- it "should not match a text string that does not start the same" do
- step = Step.new("this text") {}
- step.matches?("Xthis text").should be_false
- end
-
- it "should not match a text string that does not end the same" do
- step = Step.new("this text") {}
- step.matches?("this textX").should be_false
- end
-
- it "should match a text string with a param" do
- step = Step.new("this $param text") {}
- step.matches?("this anything text").should be_true
- end
-
- it "should not be greedy" do
- step = Step.new("enter $value for $key") {}
- step.parse_args("enter 3 for keys for a piano").should == ['3','keys for a piano']
- end
-
- it "should match a text string with 3 params" do
- step = Step.new("1 $one 2 $two 3 $three 4") {}
- step.matches?("1 a 2 b 3 c 4").should be_true
- end
-
- it "should match a text string with a param at the beginning" do
- step = Step.new("$one 2 3") {}
- step.matches?("a 2 3").should be_true
- end
-
- it "should match a text string with a param at the end" do
- step = Step.new("1 2 $three") {}
- step.matches?("1 2 c").should be_true
- end
-
- it "should not match a different string" do
- step = Step.new("this text") {}
- step.matches?("other text").should be_false
- end
-
- it "should match a regexp" do
- step = Step.new(/this text/) {}
- step.matches?("this text").should be_true
- end
-
- it "should match a regexp with a match group" do
- step = Step.new(/this (.*) text/) {}
- step.matches?("this anything text").should be_true
- end
-
- it "should not match a non matching regexp" do
- step = Step.new(/this (.*) text/) {}
- step.matches?("other anything text").should be_false
- end
-
- it "should not get bogged down by parens in strings" do
- step = Step.new("before () after") {}
- step.matches?("before () after").should be_true
- end
-
- it "should match any option of an alteration" do
- step = Step.new(/(he|she) is cool/) {}
- step.matches?("he is cool").should be_true
- step.matches?("she is cool").should be_true
- end
-
- it "should match alteration as well as a variable" do
- step = Step.new(/(he|she) is (.*)/) {}
- step.matches?("he is cool").should be_true
- step.parse_args("he is cool").should == ['he', 'cool']
- end
-
- end
-
- describe Step do
- it "should make complain with no block" do
- lambda {
- step = Step.new("foo")
- }.should raise_error
- end
-
- it "should perform itself on an object" do
- # given
- $instance = nil
- step = Step.new 'step' do
- $instance = self
- end
- instance = Object.new
-
- # when
- step.perform(instance, "step")
-
- # then
- $instance.should == instance
- end
-
- it "should perform itself with one parameter with match expression" do
- # given
- $result = nil
- step = Step.new 'an account with $count dollars' do |count|
- $result = count
- end
- instance = Object.new
-
- # when
- args = step.parse_args("an account with 3 dollars")
- step.perform(instance, *args)
-
- # then
- $result.should == "3"
- end
-
- it "should perform itself with one parameter without a match expression" do
- # given
- $result = nil
- step = Step.new 'an account with a balance of' do |amount|
- $result = amount
- end
- instance = Object.new
-
- # when
- step.perform(instance, 20)
-
- # then
- $result.should == 20
- end
-
- it "should perform itself with 2 parameters" do
- # given
- $account_type = nil
- $amount = nil
- step = Step.new 'a $account_type account with $amount dollars' do |account_type, amount|
- $account_type = account_type
- $amount = amount
- end
- instance = Object.new
-
- # when
- args = step.parse_args("a savings account with 3 dollars")
- step.perform(instance, *args)
-
- # then
- $account_type.should == "savings"
- $amount.should == "3"
- end
-
- it "should perform itself when defined with a regexp with 2 parameters" do
- # given
- $pronoun = nil
- $adjective = nil
- step = Step.new /(he|she) is (.*)/ do |pronoun, adjective|
- $pronoun = pronoun
- $adjective = adjective
- end
- instance = Object.new
-
- # when
- args = step.parse_args("he is cool")
- step.perform(instance, *args)
-
- # then
- $pronoun.should == "he"
- $adjective.should == "cool"
- end
-
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/builders'
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
- module Story
- describe Story do
- it 'should run itself in a given object' do
- # given
- $instance = nil
- story = Story.new 'title', 'narrative' do
- $instance = self
- end
- object = Object.new
-
- # when
- story.run_in(object)
-
- # then
- $instance.should be(object)
- end
-
- it 'should not raise an error if no block is supplied' do
- # when
- error = exception_from do
- Story.new 'title', 'narrative'
- end
-
- # then
- error.should be_nil
- end
-
- it "should raise when error raised running in another object" do
- #given
- story = Story.new 'title', 'narrative' do
- raise "this is raised in the story"
- end
- object = Object.new
-
- # when/then
- lambda do
- story.run_in(object)
- end.should raise_error
- end
-
- it "should use the steps it is told to using a StepGroup" do
- story = Story.new("title", "narrative", :steps => steps = StepGroup.new) do end
- assignee = mock("assignee")
- assignee.should_receive(:use).with(steps)
- story.assign_steps_to(assignee)
- end
-
- it "should use the steps it is told to using a key" do
- begin
- orig_rspec_story_steps = $rspec_story_steps
- $rspec_story_steps = StepGroupHash.new
- $rspec_story_steps[:foo] = steps = Object.new
-
- story = Story.new("title", "narrative", :steps_for => :foo) do end
- assignee = mock("assignee")
-
- assignee.should_receive(:use).with(steps)
- story.assign_steps_to(assignee)
- ensure
- $rspec_story_steps = orig_rspec_story_steps
- end
- end
-
- it "should use the steps it is told to using multiple keys" do
- begin
- orig_rspec_story_steps = $rspec_story_steps
- $rspec_story_steps = StepGroupHash.new
- $rspec_story_steps[:foo] = foo_steps = Object.new
- $rspec_story_steps[:bar] = bar_steps = Object.new
-
- story = Story.new("title", "narrative", :steps_for => [:foo, :bar]) do end
- assignee = mock("assignee")
-
- assignee.should_receive(:use).with(foo_steps)
- assignee.should_receive(:use).with(bar_steps)
- story.assign_steps_to(assignee)
- ensure
- $rspec_story_steps = orig_rspec_story_steps
- end
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/story_helper'
-
-require 'spec/story'
-
-module Spec
- module Story
- describe World do
- before :each do
- World.listeners.clear
- end
-
- after :each do
- World.listeners.clear
- World.step_mother.clear
- end
-
- it 'should create an object that mixes in a World' do
- # when
- obj = World::create
-
- # then
- obj.should be_kind_of(World)
- end
-
- it 'should create a World from any object type' do
- # when
- obj = World::create String
-
- # then
- obj.should be_kind_of(String)
- obj.should be_kind_of(World)
- end
-
- it 'should pass arguments to #new when creating an object of a specified type that mixes in a world' do
- # given
- Thing = Struct.new(:name, :age)
-
- # when
- obj = World::create Thing, "David", "I'm not telling"
-
- # then
- obj.should be_an_instance_of(Thing)
- obj.name.should == "David"
- obj.age.should == "I'm not telling"
- obj.should be_kind_of(World)
- end
-
- def ensure_world_executes_step(&block)
- # given
- obj = World::create
- $step_ran = false
-
- # when
- obj.instance_eval(&block)
-
- # then
- $step_ran.should be_true
- end
-
- it 'should execute a Given, When or Then step' do
- ensure_world_executes_step do
- Given 'a given' do
- $step_ran = true
- end
- end
-
- ensure_world_executes_step do
- When 'an event' do
- $step_ran = true
- end
- end
-
- ensure_world_executes_step do
- Then 'an outcome' do
- $step_ran = true
- end
- end
- end
-
- it 'should interpret Given... And... as multiple givens' do
- # given
- world = World.create
- $steps = []
-
- # when
- world.instance_eval do
- Given 'step 1' do
- $steps << 1
- end
- And 'step 2' do
- $steps << 2
- end
- end
-
- # then
- $steps.should == [1,2]
- World.step_mother.find(:given, 'step 1').should_not be_nil
- World.step_mother.find(:given, 'step 2').should_not be_nil
- end
-
- it 'should interpret When... And... as multiple events' do
- # given
- world = World.create
- $steps = []
-
- # when
- world.instance_eval do
- When 'step 1' do
- $steps << 1
- end
- And 'step 2' do
- $steps << 2
- end
- end
-
- # then
- $steps.should == [1,2]
- World.step_mother.find(:when, 'step 1').should_not be_nil
- World.step_mother.find(:when, 'step 2').should_not be_nil
- end
-
- it 'should interpret Then... And... as multiple outcomes' do
- # given
- world = World.create
- $steps = []
-
- # when
- world.instance_eval do
- Then 'step 1' do
- $steps << 1
- end
- And 'step 2' do
- $steps << 2
- end
- end
-
- # then
- $steps.should == [1,2]
- World.step_mother.find(:then, 'step 1').should_not be_nil
- World.step_mother.find(:then, 'step 2').should_not be_nil
- end
-
- it 'should reuse a given across scenarios' do
- # given
- $num_invoked = 0
- a_world = World::create
- a_world.instance_eval do
- Given 'a given' do
- $num_invoked += 1
- end
- end
- another_world = World::create
-
- # when
- another_world.instance_eval do
- Given 'a given' # without a body
- end
-
- # then
- $num_invoked.should == 2
- end
-
- it 'should reuse an event across scenarios' do
- # given
- $num_invoked = 0
- a_world = World::create
- a_world.instance_eval do
- When 'an event' do
- $num_invoked += 1
- end
- end
-
- another_world = World::create
-
- # when
- another_world.instance_eval do
- When 'an event' # without a body
- end
-
- # then
- $num_invoked.should == 2
- end
-
- it 'should reuse an outcome across scenarios' do
- # given
- $num_invoked = 0
- a_world = World::create
- a_world.instance_eval do
- Then 'an outcome' do
- $num_invoked += 1
- end
- end
-
- another_world = World::create
-
- # when
- another_world.instance_eval do
- Then 'an outcome' # without a body
- end
-
- # then
- $num_invoked.should == 2
- end
-
- it 'should preserve instance variables between steps within a scenario' do
- # given
- world = World::create
- $first = nil
- $second = nil
-
- # when
- world.instance_eval do
- Given 'given' do
- @first = 'first'
- end
- When 'event' do
- @second = @first # from given
- end
- Then 'outcome' do
- $first = @first # from given
- $second = @second # from event
- end
- end
-
- # then
- $first.should == 'first'
- $second.should == 'first'
- end
-
- it 'should invoke a reused step in the new object instance' do
- # given
- $instances = []
- $debug = true
- world1 = World.create
- world1.instance_eval do
- Given 'a given' do
- $instances << self.__id__
- end
- end
- world2 = World.create
-
- # when
- world2.instance_eval do
- Given 'a given' # reused
- Then 'an outcome' do
- $instances << __id__
- end
- end
- $debug = false
- # then
- $instances.should == [ world1.__id__, world2.__id__, world2.__id__ ]
- end
-
- def ensure_world_collects_error(expected_error, &block)
- # given
- world = World.create
- # $error = nil
-
- # when
- world.start_collecting_errors
- world.instance_eval(&block)
-
- # then
- world.should have(1).errors
- world.errors[0].should be_kind_of(expected_error)
- end
-
- it 'should collect a failure from a Given step' do
- ensure_world_collects_error RuntimeError do
- Given 'a given' do
- raise RuntimeError, "oops"
- end
- end
- end
-
- it 'should collect a failure from a When step' do
- ensure_world_collects_error RuntimeError do
- When 'an event' do
- raise RuntimeError, "oops"
- end
- end
- end
-
- it 'should collect a failure from a Then step' do
- ensure_world_collects_error RuntimeError do
- Then 'an outcome' do
- raise RuntimeError, "oops"
- end
- end
- end
-
- it 'should inform listeners when it runs a Given, When or Then step' do
- # given
- world = World.create
- mock_listener1 = mock('listener1')
- mock_listener2 = mock('listener2')
- World.add_listener(mock_listener1)
- World.add_listener(mock_listener2)
-
- # expect
- mock_listener1.should_receive(:step_succeeded).with(:given, 'a context')
- mock_listener1.should_receive(:step_succeeded).with(:when, 'an event')
- mock_listener1.should_receive(:step_succeeded).with(:then, 'an outcome')
-
- mock_listener2.should_receive(:step_succeeded).with(:given, 'a context')
- mock_listener2.should_receive(:step_succeeded).with(:when, 'an event')
- mock_listener2.should_receive(:step_succeeded).with(:then, 'an outcome')
-
- # when
- world.instance_eval do
- Given 'a context' do end
- When 'an event' do end
- Then 'an outcome' do end
- end
-
- # then
- end
-
- it 'should tell listeners but not execute the step in dry-run mode' do
- # given
- Runner.stub!(:dry_run).and_return(true)
- mock_listener = mock('listener')
- World.add_listener(mock_listener)
- $step_invoked = false
- world = World.create
-
- # expect
- mock_listener.should_receive(:step_succeeded).with(:given, 'a context')
-
- # when
- world.instance_eval do
- Given 'a context' do
- $step_invoked = true
- end
- end
-
- # then
- $step_invoked.should be(false)
- end
-
- it 'should suppress listeners while it runs a GivenScenario' do
- # given
- $scenario_ran = false
-
- scenario = ScenarioBuilder.new.name('a scenario').to_scenario do
- $scenario_ran = true
- Given 'given' do end
- When 'event' do end
- Then 'outcome' do end
- end
-
- given_scenario = GivenScenario.new('a scenario')
- Runner::StoryRunner.should_receive(:scenario_from_current_story).
- with('a scenario').and_return(scenario)
-
- world = World.create
- listener = mock('listener')
- World.add_listener(listener)
-
- # expect
- listener.should_receive(:found_scenario).with(:'given scenario', 'a scenario')
- listener.should_receive(:step_succeeded).never.with(:given, 'given')
- listener.should_receive(:step_succeeded).never.with(:when, 'event')
- listener.should_receive(:step_succeeded).never.with(:then, 'outcome')
-
- # when
- world.GivenScenario 'a scenario'
-
- # then
- $scenario_ran.should be_true
- end
-
- it 'should interpret GivenScenario... And... as multiple givens' do
- # given
- world = World.create
- $steps = []
-
- scenario = ScenarioBuilder.new.name('a scenario').to_scenario do
- $steps << 1
- end
- Runner::StoryRunner.should_receive(:scenario_from_current_story).
- with('a scenario').and_return(scenario)
-
- # when
- world.instance_eval do
- GivenScenario 'a scenario'
- And 'step 2' do
- $steps << 2
- end
- end
-
- # then
- $steps.should == [1,2]
- World.step_mother.find(:given, 'step 2').should_not be_nil
- end
-
- it 'should provide rspec matchers' do
- # given
- world = World.create
-
- # then
- world.instance_eval do
- 'hello'.should match(/^hello$/)
- end
- end
-
- it "should use assigned matchers" do
- world = World.create
-
- World.should_receive(:use).with(steps = Object.new)
-
- World.use(steps)
- end
- end
- end
-end
+++ /dev/null
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-require 'spec/translator'
-
-describe "Translator" do
- before do
- @t = Spec::Translator.new
- end
-
- it "should translate files" do
- from = File.dirname(__FILE__) + '/..'
- to = "#{Dir.tmpdir}/translated_specs"
- @t.translate_dir(from, to)
- end
-
- it "should translate context_setup do" do
- @t.translate_line(
- "context_setup do\n"
- ).should eql(
- "before(:all) do\n"
- )
- end
-
- it "should translate context_setup {foo}" do
- @t.translate_line(
- "context_setup {foo}\n"
- ).should eql(
- "before(:all) {foo}\n"
- )
- end
-
- it "should translate context ' to describe '" do
- @t.translate_line(
- "context 'Translator' do\n"
- ).should eql(
- "describe 'Translator' do\n"
- )
- end
-
- it 'should translate context " to describe "' do
- @t.translate_line(
- 'context "Translator"'
- ).should eql(
- 'describe "Translator"'
- )
- end
-
- it 'should translate spaces then context " to describe "' do
- @t.translate_line(
- ' context "Translator"'
- ).should eql(
- ' describe "Translator"'
- )
- end
-
- it "should not translate context=foo" do
- @t.translate_line(' context=foo').should eql(' context=foo')
- end
-
- it "should not translate context = foo" do
- @t.translate_line(' context = foo').should eql(' context = foo')
- end
-
- it "should not translate context = foo" do
- @t.translate_line(' context = foo').should eql(' context = foo')
- end
-
- it "should translate should_be_close" do
- @t.translate_line('5.0.should_be_close(5.0, 0.5)').should eql('5.0.should be_close(5.0, 0.5)')
- end
-
- it "should translate should_not_raise" do
- @t.translate_line('lambda { self.call }.should_not_raise').should eql('lambda { self.call }.should_not raise_error')
- end
-
- it "should translate should_throw" do
- @t.translate_line('lambda { self.call }.should_throw').should eql('lambda { self.call }.should throw_symbol')
- end
-
- it "should not translate 0.9 should_not" do
- @t.translate_line('@target.should_not @matcher').should eql('@target.should_not @matcher')
- end
-
- it "should leave should_not_receive" do
- @t.translate_line('@mock.should_not_receive(:not_expected).with("unexpected text")').should eql('@mock.should_not_receive(:not_expected).with("unexpected text")')
- end
-
- it "should leave should_receive" do
- @t.translate_line('@mock.should_receive(:not_expected).with("unexpected text")').should eql('@mock.should_receive(:not_expected).with("unexpected text")')
- end
-
- it "should translate multi word predicates" do
- @t.translate_line('foo.should_multi_word_predicate').should eql('foo.should be_multi_word_predicate')
- end
-
- it "should translate multi word predicates prefixed with be" do
- @t.translate_line('foo.should_be_multi_word_predicate').should eql('foo.should be_multi_word_predicate')
- end
-
- it "should translate be(expected) to equal(expected)" do
- @t.translate_line('foo.should_be :cool').should eql('foo.should equal :cool')
- end
-
- it "should translate instance_of" do
- @t.translate_line('5.should_be_an_instance_of(Integer)').should eql('5.should be_an_instance_of(Integer)')
- end
-
- it "should translate should_be <" do
- @t.translate_line('3.should_be < 4').should eql('3.should be < 4')
- end
-
- it "should translate should_be <=" do
- @t.translate_line('3.should_be <= 4').should eql('3.should be <= 4')
- end
-
- it "should translate should_be >=" do
- @t.translate_line('4.should_be >= 3').should eql('4.should be >= 3')
- end
-
- it "should translate should_be >" do
- @t.translate_line('4.should_be > 3').should eql('4.should be > 3')
- end
-
- it "should translate should_be_happy" do
- @t.translate_line("4.should_be_happy").should eql("4.should be_happy")
- end
-
- it "should translate custom method taking regexp with parenthesis" do
- @t.translate_line("@browser.should_contain_text(/Sn.rrunger og annet rusk/)").should eql("@browser.should be_contain_text(/Sn.rrunger og annet rusk/)")
- end
-
- it "should translate custom method taking regexp without parenthesis" do
- @t.translate_line("@browser.should_contain_text /Sn.rrunger og annet rusk/\n").should eql("@browser.should be_contain_text(/Sn.rrunger og annet rusk/)\n")
- end
-
- it "should translate should_not_be_nil" do
- @t.translate_line("foo.should_not_be_nil\n").should eql("foo.should_not be_nil\n")
- end
-
- it "should translate kind of" do
- @t.translate_line('@object.should_be_kind_of(MessageExpectation)').should(
- eql('@object.should be_kind_of(MessageExpectation)'))
- end
-
- it "should translate should_be_true" do
- @t.translate_line("foo.should_be_true\n").should eql("foo.should be_true\n")
- end
-
- # [#9674] spec_translate incorrectly handling shoud_match, when regexp in a var, in a block
- # http://rubyforge.org/tracker/?func=detail&atid=3149&aid=9674&group_id=797
- it "should translate should_match on a regexp, in a var, in a block" do
- @t.translate_line("collection.each { |c| c.should_match a_regexp_in_a_var }\n").should eql("collection.each { |c| c.should match(a_regexp_in_a_var) }\n")
- @t.translate_line("collection.each{|c| c.should_match a_regexp_in_a_var}\n").should eql("collection.each{|c| c.should match(a_regexp_in_a_var) }\n")
- end
-
- # From Rubinius specs
- it "should translate close_to without parens" do
- @t.translate_line("end.should_be_close 3.14159_26535_89793_23846, TOLERANCE\n").should eql("end.should be_close(3.14159_26535_89793_23846, TOLERANCE)\n")
- end
-
- # [#9882] 0.9 Beta 1 - translator bugs
- # http://rubyforge.org/tracker/index.php?func=detail&aid=9882&group_id=797&atid=3149
- it "should support symbol arguments" do
- @t.translate_line(
- "lambda { sequence.parse('bar') }.should_throw :ZeroWidthParseSuccess\n"
- ).should eql(
- "lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)\n"
- )
- end
-
- # [#9882] 0.9 Beta 1 - translator bugs
- # http://rubyforge.org/tracker/index.php?func=detail&aid=9882&group_id=797&atid=3149
- it "should support instance var arguments" do
- @t.translate_line(
- "a.should_eql @local"
- ).should eql(
- "a.should eql(@local)"
- )
- end
-
- # [#9882] 0.9 Beta 1 - translator bugs
- # http://rubyforge.org/tracker/index.php?func=detail&aid=9882&group_id=797&atid=3149
- it "should support lambdas as expecteds" do
- @t.translate_line(
- "@parslet.should_not_eql lambda { nil }.to_parseable"
- ).should eql(
- "@parslet.should_not eql(lambda { nil }.to_parseable)"
- )
- end
-
- # [#9882] 0.9 Beta 1 - translator bugs
- # http://rubyforge.org/tracker/index.php?func=detail&aid=9882&group_id=797&atid=3149
- it "should support fully qualified names" do
- @t.translate_line(
- "results.should_be_kind_of SimpleASTLanguage::Identifier"
- ).should eql(
- "results.should be_kind_of(SimpleASTLanguage::Identifier)"
- )
- end
-
- # [#9882] 0.9 Beta 1 - translator bugs
- # http://rubyforge.org/tracker/index.php?func=detail&aid=9882&group_id=797&atid=3149
- # it "should leave whitespace between expression and comments" do
- # @t.translate_line(
- # "lambda { @instance.foo = foo }.should_raise NoMethodError # no writer defined"
- # ).should eql(
- # "lambda { @instance.foo = foo }.should raise_error(NoMethodError) # no writer defined"
- # )
- # end
-
- it "should translate redirects" do
- @t.translate_line(
- "controller.should_redirect_to 'http://not_existing_domain_for_novalis.test.host/404.html'"
- ).should eql(
- "controller.should redirect_to('http://not_existing_domain_for_novalis.test.host/404.html')"
- )
- end
-
- it "should translate :any_args" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:any_args)"
- ).should eql(
- "mock.should_receive(:foo).with(any_args)"
- )
- end
-
- it "should translate :anything" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:anything)"
- ).should eql(
- "mock.should_receive(:foo).with(anything)"
- )
- end
-
- it "should translate :boolean" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:boolean)"
- ).should eql(
- "mock.should_receive(:foo).with(boolean)"
- )
- end
-
- it "should translate :no_args" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:no_args)"
- ).should eql(
- "mock.should_receive(:foo).with(no_args)"
- )
- end
-
- it "should translate :numeric" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:numeric)"
- ).should eql(
- "mock.should_receive(:foo).with(an_instance_of(Numeric))"
- )
- end
-
- it "should translate :string" do
- @t.translate_line(
- "mock.should_receive(:foo).with(:string)"
- ).should eql(
- "mock.should_receive(:foo).with(an_instance_of(String))"
- )
- end
-end
+++ /dev/null
-require 'stringio'
-
-dir = File.dirname(__FILE__)
-lib_path = File.expand_path("#{dir}/../lib")
-$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
-$_spec_spec = true # Prevents Kernel.exit in various places
-
-require 'spec'
-require 'spec/mocks'
-require 'spec/story'
-spec_classes_path = File.expand_path("#{dir}/../spec/spec/spec_classes")
-require spec_classes_path unless $LOAD_PATH.include?(spec_classes_path)
-require File.dirname(__FILE__) + '/../lib/spec/expectations/differs/default'
-
-module Spec
- module Matchers
- def fail
- raise_error(Spec::Expectations::ExpectationNotMetError)
- end
-
- def fail_with(message)
- raise_error(Spec::Expectations::ExpectationNotMetError, message)
- end
-
- class Pass
- def matches?(proc, &block)
- begin
- proc.call
- true
- rescue Exception => @error
- false
- end
- end
-
- def failure_message
- @error.message + "\n" + @error.backtrace.join("\n")
- end
- end
-
- def pass
- Pass.new
- end
-
- class CorrectlyOrderedMockExpectation
- def initialize(&event)
- @event = event
- end
-
- def expect(&expectations)
- expectations.call
- @event.call
- end
- end
-
- def during(&block)
- CorrectlyOrderedMockExpectation.new(&block)
- end
- end
-end
-
-class NonStandardError < Exception; end
-
-module Custom
- class ExampleGroupRunner
- attr_reader :options, :arg
- def initialize(options, arg)
- @options, @arg = options, arg
- end
-
- def load_files(files)
- end
-
- def run
- end
- end
-end
-
-def exception_from(&block)
- exception = nil
- begin
- yield
- rescue StandardError => e
- exception = e
- end
- exception
-end
-
-describe "sandboxed rspec_options", :shared => true do
- attr_reader :options
-
- before(:all) do
- @original_rspec_options = $rspec_options
- end
-
- before(:each) do
- @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
- $rspec_options = options
- end
-
- after do
- $rspec_options = @original_rspec_options
- end
-end
\ No newline at end of file
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[helper])
-
-["example_groups","interop"].each do |dir|
- require File.join(File.dirname(__FILE__), "#{dir}/stories")
-end
+++ /dev/null
-Story: autogenerated docstrings
-
- As an RSpec user
- I want examples to generate their own names
- So that I can reduce duplication between example names and example code
-
- Scenario: run passing examples with ruby
- Given the file ../../examples/pure/autogenerated_docstrings_example.rb
-
- When I run it with the ruby interpreter -fs
-
- Then the stdout should match /should equal 5/
- And the stdout should match /should be < 5/
- And the stdout should match /should include "a"/
- And the stdout should match /should respond to #size/
-
- Scenario: run failing examples with ruby
- Given the file ../../failing_examples/failing_autogenerated_docstrings_example.rb
-
- When I run it with the ruby interpreter -fs
-
- Then the stdout should match /should equal 2/
- And the stdout should match /should be > 5/
- And the stdout should match /should include "b"/
- And the stdout should match /should not respond to #size/
-
- Scenario: run passing examples with spec
- Given the file ../../examples/pure/autogenerated_docstrings_example.rb
-
- When I run it with the spec script -fs
-
- Then the stdout should match /should equal 5/
- And the stdout should match /should be < 5/
- And the stdout should match /should include "a"/
- And the stdout should match /should respond to #size/
-
- Scenario: run failing examples with spec
- Given the file ../../failing_examples/failing_autogenerated_docstrings_example.rb
-
- When I run it with the spec script -fs
-
- Then the stdout should match /should equal 2/
- And the stdout should match /should be > 5/
- And the stdout should match /should include "b"/
- And the stdout should match /should not respond to #size/
+++ /dev/null
-Story: Spec::ExampleGroup with should methods
-
- As an RSpec adopter accustomed to classes and methods
- I want to use should_* methods in an ExampleGroup
- So that I use RSpec with classes and methods that look more like RSpec examples
-
- Scenario: Run with ruby
- Given the file spec/example_group_with_should_methods.rb
- When I run it with the ruby interpreter
- Then the exit code should be 256
- And the stdout should match "2 examples, 1 failure"
-
- Scenario: Run with spec
- Given the file spec/example_group_with_should_methods.rb
- When I run it with the spec script
- Then the exit code should be 256
- And the stdout should match "2 examples, 1 failure"
+++ /dev/null
-Story: Nested example groups
-
- As an RSpec user
- I want to nest examples groups
- So that I can better organize my examples
-
- Scenario: Run with ruby
- Given the file ../../examples/pure/stack_spec_with_nested_example_groups.rb
- When I run it with the ruby interpreter -fs
- Then the stdout should match /Stack \(empty\)/
- And the stdout should match /Stack \(full\)/
-
- Scenario: Run with ruby
- Given the file ../../examples/pure/stack_spec_with_nested_example_groups.rb
- When I run it with the spec script -fs
- Then the stdout should match /Stack \(empty\)/
- And the stdout should match /Stack \(full\)/
+++ /dev/null
-Story: Getting correct output
-
- As an RSpec user
- I want to see output only once
- So that I don't get confused
-
- Scenario: Run with ruby
- Given the file spec/simple_spec.rb
- When I run it with the ruby interpreter
- Then the exit code should be 0
- And the stdout should not match /\d+ tests, \d+ assertions, \d+ failures, \d+ errors/m
- And the stdout should match "1 example, 0 failures"
-
- Scenario: Run with CommandLine object
- Given the file spec/simple_spec.rb
- When I run it with the CommandLine object
- Then the exit code should be 0
- And the stdout should not match "Loaded suite"
- And the stdout should not match /\d+ tests, \d+ assertions, \d+ failures, \d+ errors/m
- And the stdout should match "1 example, 0 failures"
-
- Scenario: Tweak backtrace
- Given the file stories/failing_story.rb
- When I run it with the ruby interpreter
- Then the stdout should not match /\/lib\/spec\//
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[.. helper])
-
-with_steps_for :running_rspec do
- Dir["#{File.dirname(__FILE__)}/*"].each do |file|
- run file if File.file?(file) && !(file =~ /\.rb$/)
- end
-end
\ No newline at end of file
+++ /dev/null
-$LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../lib")
-require 'spec'
-require 'tempfile'
-require File.join(File.dirname(__FILE__), *%w[resources matchers smart_match])
-require File.join(File.dirname(__FILE__), *%w[resources helpers story_helper])
-require File.join(File.dirname(__FILE__), *%w[resources steps running_rspec])
+++ /dev/null
-Story: Spec and test together
-
- As an RSpec adopter with existing Test::Unit tests
- I want to run a few specs alongside my existing Test::Unit tests
- So that I can experience a smooth, gradual migration path
-
- Scenario: Run with ruby
- Given the file test/spec_and_test_together.rb
-
- When I run it with the ruby interpreter -fs
-
- Then the exit code should be 256
- And the stdout should match "ATest"
- And the stdout should match "Test::Unit::AssertionFailedError in 'An Example should fail with assert'"
- And the stdout should match "'An Example should fail with should' FAILED"
- And the stdout should match "10 examples, 6 failures"
- And the stdout should match /expected: 40,\s*got: 4/m
- And the stdout should match /expected: 50,\s*got: 5/m
- Scenario: Run with spec
- Given the file test/spec_and_test_together.rb
-
- When I run it with the spec script -fs
-
- Then the exit code should be 256
- Ands the stdout should match "ATest"
- And the stdout should match "Test::Unit::AssertionFailedError in 'An Example should fail with assert'"
- And the stdout should match "'An Example should fail with should' FAILED"
- And the stdout should match "10 examples, 6 failures"
- And the stdout should match /expected: 40,\s*got: 4/m
- And the stdout should match /expected: 50,\s*got: 5/m
+++ /dev/null
-require File.join(File.dirname(__FILE__), *%w[.. helper])
-
-with_steps_for :running_rspec do
- Dir["#{File.dirname(__FILE__)}/*"].each do |file|
- run file if File.file?(file) && !(file =~ /\.rb$/)
- end
-end
\ No newline at end of file
+++ /dev/null
-Story: Test::Unit::TestCase extended by rspec with should methods
-
- As an RSpec adopter with existing Test::Unit tests
- I want to use should_* methods in a Test::Unit::TestCase
- So that I use RSpec with classes and methods that look more like RSpec examples
-
- Scenario: Run with ruby
- Given the file test/test_case_with_should_methods.rb
- When I run it with the ruby interpreter
- Then PENDING the exit code should be 256
- And the stdout should match "5 examples, 3 failures"
-
- Scenario: Run with spec
- Given the file test/test_case_with_should_methods.rb
- When I run it with the spec script
- Then the exit code should be 256
- And the stdout should match "5 examples, 3 failures"
+++ /dev/null
-This directory contains stories that are currently not passing
-because they are new or they represent regressions.
-
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-require 'spec'
-
-# Uncommenting next line will break the output story (no output!!)
-# rspec_options
-options = Spec::Runner::OptionParser.parse(
- ARGV, $stderr, $stdout
-)
-Spec::Runner::CommandLine.run(options)
+++ /dev/null
-require 'spec/story'
-require File.dirname(__FILE__) + '/../../../spec/ruby_forker'
-
-module StoryHelper
- include RubyForker
-
- def spec(args, stderr)
- ruby("#{File.dirname(__FILE__) + '/../../../bin/spec'} #{args}", stderr)
- end
-
- def cmdline(args, stderr)
- ruby("#{File.dirname(__FILE__) + '/../../resources/helpers/cmdline.rb'} #{args}", stderr)
- end
-
- Spec::Story::World.send :include, self
-end
+++ /dev/null
-module Spec
- module Matchers
- class SmartMatch
- def initialize(expected)
- @expected = expected
- end
-
- def matches?(actual)
- @actual = actual
- # Satisfy expectation here. Return false or raise an error if it's not met.
-
- if @expected =~ /^\/.*\/?$/ || @expected =~ /^".*"$/
- regex_or_string = eval(@expected)
- if Regexp === regex_or_string
- (@actual =~ regex_or_string) ? true : false
- else
- @actual.index(regex_or_string) != nil
- end
- else
- false
- end
- end
-
- def failure_message
- "expected #{@actual.inspect} to smart_match #{@expected.inspect}, but it didn't"
- end
-
- def negative_failure_message
- "expected #{@actual.inspect} not to smart_match #{@expected.inspect}, but it did"
- end
- end
-
- def smart_match(expected)
- SmartMatch.new(expected)
- end
- end
-end
\ No newline at end of file
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-require 'spec'
-
-class MySpec < Spec::ExampleGroup
- def should_pass_with_should
- 1.should == 1
- end
-
- def should_fail_with_should
- 1.should == 2
- end
-end
\ No newline at end of file
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-require 'spec'
-
-describe "Running an Example" do
- it "should not output twice" do
- true.should be_true
- end
-end
\ No newline at end of file
+++ /dev/null
-steps_for :running_rspec do
-
- Given("the file $relative_path") do |relative_path|
- @path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "resources", relative_path))
- unless File.exist?(@path)
- raise "could not find file at #{@path}"
- end
- end
-
- When("I run it with the $interpreter") do |interpreter|
- stderr_file = Tempfile.new('rspec')
- stderr_file.close
- @stdout = case(interpreter)
- when /^ruby interpreter/
- args = interpreter.gsub('ruby interpreter','')
- ruby("#{@path}#{args}", stderr_file.path)
- when /^spec script/
- args = interpreter.gsub('spec script','')
- spec("#{@path}#{args}", stderr_file.path)
- when 'CommandLine object' then cmdline(@path, stderr_file.path)
- else raise "Unknown interpreter: #{interpreter}"
- end
- @stderr = IO.read(stderr_file.path)
- @exit_code = $?.to_i
- end
-
- Then("the exit code should be $exit_code") do |exit_code|
- if @exit_code != exit_code.to_i
- raise "Did not exit with #{exit_code}, but with #{@exit_code}. Standard error:\n#{@stderr}"
- end
- end
-
- Then("the $stream should match $regex") do |stream, string_or_regex|
- written = case(stream)
- when 'stdout' then @stdout
- when 'stderr' then @stderr
- else raise "Unknown stream: #{stream}"
- end
- written.should smart_match(string_or_regex)
- end
-
- Then("the $stream should not match $regex") do |stream, string_or_regex|
- written = case(stream)
- when 'stdout' then @stdout
- when 'stderr' then @stderr
- else raise "Unknown stream: #{stream}"
- end
- written.should_not smart_match(string_or_regex)
- end
-end
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-
-require 'spec/story'
-
-Story "Failing story",
-%(As an RSpec user
- I want a failing test
- So that I can observe the output) do
-
- Scenario "Failing scenario" do
- Then "true should be false" do
- true.should == false
- end
- end
-end
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-require 'spec'
-# TODO - this should not be necessary, ay?
-require 'spec/interop/test'
-
-describe "An Example" do
- it "should pass with assert" do
- assert true
- end
-
- it "should fail with assert" do
- assert false
- end
-
- it "should pass with should" do
- 1.should == 1
- end
-
- it "should fail with should" do
- 1.should == 2
- end
-end
-
-class ATest < Test::Unit::TestCase
- def test_should_pass_with_assert
- assert true
- end
-
- def test_should_fail_with_assert
- assert false
- end
-
- def test_should_pass_with_should
- 1.should == 1
- end
-
- def test_should_fail_with_should
- 1.should == 2
- end
-
- def setup
- @from_setup ||= 3
- @from_setup += 1
- end
-
- def test_should_fail_with_setup_method_variable
- @from_setup.should == 40
- end
-
- before do
- @from_before = @from_setup + 1
- end
-
- def test_should_fail_with_before_block_variable
- @from_before.should == 50
- end
-end
\ No newline at end of file
+++ /dev/null
-$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
-require 'test/unit'
-require 'spec'
-require 'spec/interop/test'
-
-class MySpec < Test::Unit::TestCase
- def should_pass_with_should
- 1.should == 1
- end
-
- def should_fail_with_should
- 1.should == 2
- end
-
- def should_pass_with_assert
- assert true
- end
-
- def should_fail_with_assert
- assert false
- end
-
- def test
- raise "This is not a real test"
- end
-
- def test_ify
- raise "This is a real test"
- end
-end
\ No newline at end of file
projects / rails.git / commitdiff