--- /dev/null
+lib/**/*.rb
+History.rdoc
+License.txt
+README.rdoc
+Upgrade.rdoc
+features/**/*.feature
+
--- /dev/null
+== Contribute
+
+If you're interested in contributing to rspec-rails, please see
+http://wiki.github.com/dchelimsky/rspec-dev for information.
--- /dev/null
+=== Version 1.3.0 / 2010-01-11
+
+* enhancements
+ * use stub() instead of stub!() in generators
+ * generate gem config in test.rb with 'script/generate rspec'
+
+=== Version 1.2.9 / 2009-10-05
+
+* enhancements
+ * added route_to and be_routable matchers (Randy Harmon). Closes #843.
+ * Provide better failure message for render_template when redirected (Josh
+ Nichols). Closes #885.
+ * generated specs require 'spec_helper'
+
+* bug fixes
+ * pass the correct args to super in controller#render depending on the rails
+ version (Lucas Carlson). Closes #865.
+ * use Rack::Utils.parse_query to convert query strings to hashes. Closes #872.
+ * errors correctly bubble up when a controller spec in isolation mode
+ requests a non-existent action/template
+ * no error if either action or template exist
+ * error if neither exist
+ * Closes #888.
+ * mock_model stubs destroyed? to return false
+
+* removals
+ * spec_server has been removed in favor of spork.
+ * You can still use the --drb flag, but you've got to install the spork
+ gem.
+ * Windows users who cannot use the spork gem can install the spec_server
+ from http://github.com/dchelimsky/spec_server
+
+=== Version 1.2.7 / 2009-06-22
+
+* enhancements
+ * alias :stub!, :stub so rspec-rails extensions of rspec stubs can use the
+ same syntax as rspec (core)
+ * integration specs (Ben Mabey and David Chelimsky)
+ * added support for references and belongs_to generated model specs (José
+ Valim). Closes #792.
+ * add discovery for autotest-rails to keep compatible with ZenTest-4.0.0
+ (Ryan Davis). Closes #838.
+ * controller specs in isolation mode don't care whether the file exists
+ anymore!
+
+* bug fixes
+ * allow rspec-rails to work without ActiveRecord. Closes #810.
+ * fix bug with have() matcher failure message (Dave Giunta). Closes #818.
+ * fix bug where render_template('new') would pass if 'newer' was rendered
+ (or anything that started with 'new')
+
+* deprecations
+ * spec_server is now deprecated - use spork instead (gem install spork).
+ Closes #827.
+
+=== Version 1.2.6 / 2009-04-30
+
+* bug fixes
+ * restored rake tasks for rspec[-rails] as plugins
+
+=== Version 1.2.5 / 2009-04-29
+
+* enhancements
+ * support :xml and :strict config options for have_tag matcher (patch from
+ Peer Allan and Max Murphy). Closes #783.
+
+* bug fixes
+ * Fixed a small typo that makes rake stats fail (José Valim). Closes #802.
+ * link_to and friends are available to ViewExampleGroup again
+ (J.B. Rainsberger). Closes #787.
+ * spec_server works correctly with rails 2.3 again (Neil Buckley). Closes
+ #759.
+
+=== Version 1.2.4 / 2009-03-13
+
+No changes in this release, but aligns with the rspec-1.2.4 release. Someday
+soon, this binding of rspec/rspec-rails versions needs to end!
+
+=== Version 1.2.3 / 2009-03-13
+
+No changes in this release, but aligns with the rspec-1.2.3 release.
+
+=== Version 1.2.2 / 2009-03-22
+
+No changes in this release, but aligns with the rspec-1.2.2 release.
+
+=== Version 1.2.1 / 2009-03-22
+
+This is a bug-fix release, recommended for anybody who has already upgraded to
+rspec-rails-1.2.0 or is upgrading to rails-2.3.2
+
+See Upgrade.rdoc for information about upgrading to rspec-rails-1.2.1
+
+* enhancements
+
+ * more cleanup of internals (reducing dependency on rspec-core)
+ * don't require config/environments more than once
+ * autotest includes spec/routing directory (Matt Peterson). Closes #739.
+ * display helpful messages when installing rspec-rails running
+ script/generate rspec
+ * thanks for Dr Nic for the pointers
+ * restored require 'rubygems' where needed
+ * export NO_RUBYGEMS=true if you don't use rubygems
+
+* bug fixes
+
+ * fix scoping issues in rspec-rails' own suite for ruby 1.9.1 (Matthias
+ Hennemeyer). Closes #717.
+ * rake stats no longer hides test directories. Closes #748.
+ * fixed regression that was introduced in 1.2 in which controller_name
+ failed to override the controller class passed to describe() (patches from
+ Aaron Gibralter and Zach Dennis). Closes #732.
+
+=== Version 1.2.0 / 2009-03-15
+
+IMPORTANT: See Upgrade.rdoc for information about upgrading to rspec-rails-1.2.0
+
+IMPORTANT: This release includes the following backwards-compatibility-breaking changes.
+
+* rspec-rails supports rails 2.0.2, 2.1.2, 2.2.2 and 2.3.2
+
+ * We are no longer supporting 1.x versions of rails.
+
+* expect_render and stub_render have been removed.
+
+ * Both of these methods were deprecated in rspec-rails-1.1.5, released in Sept, 2008.
+
+* { route_for(args).should == "/path" } now delegates to assert_generates (in rails)
+
+ * see Upgrade.txt for more information
+
+* deprecations
+
+ * controller.use_rails_error_handling! is deprecated
+ * use rescue_action_in_public! (from rails) instead
+
+* enhancements
+
+ * Adding status codes to redirect_to matcher (Damian Janowski). Closes #570.
+ * Initialize current URL before executing any examples in a ViewExampleGroup (Wilson Bilkovich). Closes #654.
+ * Support query strings in params_from (Wilson Bilkovich). Closes #652.
+ * delegate route_for to assert_recognizes (less brittle)
+ * it { should be_valid } (Kakutani). Closes #665.
+ * controller is implicit subject in controller specs (Joe Ferris). #686.
+ * template is implicit subject in view specs (Joe Ferris). #686.
+ * redirect_to and render_template matchers can accept controller or response (Joe Ferris). Closes #686.
+ * generated specs use declarative docstrings
+ * rspec_scaffold generator generates layout and stylesheet (per Rails-2.3)
+ * add bypass_rescue for controller specs
+ * infer template path from the first arg passed to describe in view specs
+ * separate routing specs (in spec/routing)
+
+* bug fixes
+
+ * you no longer *have* to load ActionMailer to get specs to run. Closes #650.
+ * query_params are now parsed by Rack::Utils.parse_query in redirect_to matcher. Closes #684.
+ * cleaned up spec_server (there was a bunch of pre-rails 2.0 material). Closes #685.
+ * rspec's rake tasks are not loaded when running "rake gems" or any of its subtasks
+ * only warn when rspec is not installed when trying to invoke an rspec rake task
+ * support 2 arg version of ActionController::Base#render (reported by Nathan Wilmes)
+ * rake spec:server:start doesn't choke if there is no tmp directory
+ * force cache_classes = false when running with spec_server. Closes #287.
+ * keep spec_server working against edge rails (Jonathan Tron). Closes #685.
+ * create lib/tasks if not present when running script/generate rspec. Closes #687.
+ * fixed regression (and added spec so it won't regress again) where
+ render => :inline didn't render unless integrate_views was set
+ * fixed nil.with_output_buffer bug in helper specs. Closes #719.
+
+=== Version 1.1.12 / 2009-01-11
+
+* 2 deprecations
+
+ * TestResponse#[] is deprecated if you're using Rails <= 2.2.x and removed if you're using Rails 2.3
+ * add_stubs(model, {:method => value}) is deprecated. Use model.stub!(:method => value) instead.
+
+* 2 major enhancements
+
+ * support controller and action path params in view specs (Mike Vincent).
+ * use ActiveSupport::TestCase when available, else Test::Unit::TestCase - supports Rails 1.2.6 (Brandon Keepers). Closes #620.
+ * support form tag helpers in helpers (Ivo Dancet). Closes #641.
+
+* 3 minor enhancements
+
+ * improve rdoc for render_template (Patch from Andrew Premdas). Fixes #571.
+ * use more liberal globs to allow for specs in symlinked dirs (Martin Luder). Closes #361.
+ * Enable loading fixtures from arbitrary locations (Jacek Becela). Closes #464.
+
+* 7 bug fixes
+
+ * Attempt to load application_controller before falling back to application (Geoff Garside). Closes #626.
+ * Include _id and reduce quoting of default values in view specs (Steen Lehmann). Closes #598.
+ * Record calls to render and check rendered[:template] and rendered[:partial] for edge rails (> v2.2.2). Closes #633.
+ * config.gem 'rspec' can't be unpacked. Closes #629.
+ * spec_server not working with Rails 2.2.2 (Andreas Wolff). Closes #631.
+ * redirect_to doesn't work with http method constrained urls (Maxim Kulkin). Closes #648.
+ * rescue_with declarations are no longer by-passed (Brandon Keepers). #85
+
+=== Version 1.1.11 / 2008-10-24
+
+* No changes to rspec-rails - release to align with bug-fix release in rspec ... again :(
+
+=== Version 1.1.10 / 2008-10-24
+
+* No changes to rspec-rails - release to align with bug-fix release in rspec
+
+=== Version 1.1.9 / 2008-10-20
+
+* 4 bug fixes
+
+ * require 'rubygems' in script/spec
+ * fix failure message for error_on and errors_on (Patch from Mike Vincent). Fixes #566.
+ * fix issues that arise in view spec if passing actual template name to render (Patch from Mike Vincent). Fixes #551.
+ * fixed bug accessing assigns from helper examples
+
+=== Version 1.1.8 / 2008-10-03
+
+* 2 bug fixes
+
+ * correctly handle assigns that are false. Fixes #552.
+ * ensure that NotYetImplemented examples report as pending (fixed in rspec, not rspec-rails). Fixes #553.
+
+=== Version 1.1.7 / 2008-10-02
+
+* 1 bug fix
+
+ * depend on the correct version of rspec
+
+=== Version 1.1.6 / 2008-10-02
+
+* 1 bug fix
+
+ * fixed regression where values assigned to the assigns hash were not accessible from the example (#549)
+
+=== Version 1.1.5 / 2008-09-28
+
+IMPORTANT: use 'script/autospec' (or just 'autospec' if you have the rspec gem
+installed) instead of 'autotest'. We changed the way autotest discovers rspec
+so the autotest executable won't automatically load rspec anymore. This allows
+rspec to live side by side other spec frameworks without always co-opting
+autotest through autotest's discovery mechanism.
+
+ALSO IMPORTANT: Rails v2.1.1 changed assert_select_rjs such that it doesn't
+always fail when it should. Please see
+http://rails.lighthouseapp.com/projects/8994/tickets/982.
+
+* Generated route specs have shorter names, making it less painful to modify their implementation
+* Add conditional so Rails 2.1.0 doesn't warn about cache_template_extensions (patch from James Herdman)
+* Fixed stub_model examples to work with Rails 2.1.0 (the code was fine, just the examples needed patching)
+* use hoe for build/release
+* reworked generated examples for rspec_scaffold - thanks to Mikel Lindsaar and Dan Manges for their feedback
+* bye, bye translator
+* Added proxy to cookies so you can set them in examples the same way you set them in controllers
+* Added script/autospec so you can run autospec without installing the gem
+* Support --skip-fixture in the rspec_model generator (patches from Alex Tomlins and Niels Ganser)
+* Add mock_model#as_new_record (patch from Zach Dennis)
+* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser)
+* Suppress a deprecation notice in Rails 2.1 (James Herdman)
+* quiet deprecation warning on inflector (RSL)
+* rspec-rails gem (Ben Mabey)
+* updated generated code examples
+* Make rspec_model generator honour --skip-fixtures tag (Niels Ganser, Alex Tomlins)
+* Fix to create new models with attributes in command line (Nicolas)
+* fix to_param in mock_model with stubbed id incorrectly returning autogenerated id (Adam Meehan)
+* Call Rail's TestCase setup/teardown callbacks (Jonathan del Strother)
+* Only run TestUnitTesting once (Jonathan del Strother)
+* use require_dependency instead of require (Brandon Keepers)
+* Fixed a problem caused by controller action names getting out of sync between rspec-dev and rspec-rails for speccing (Matt Patterson)
+* don't mutate hash passed to mock_model (Reg Vos)
+
+=== Version 1.1.4
+
+Maintenance release.
+
+* Moved mock_model and stub_model to their own module: Spec::Rails::Mocks
+* Setting mock_model object id with stubs hash - patch from Adam Meehan
+* Added as_new_record to stub_model e.g. stub_model(Foo).as_new_record
+* Improved stub_model such that new_record? does "the right thing"
+* Patch from Pat Maddox to get integrate_views to work in nested example groups.
+* Patch from Pat Maddox to get controller_name to work in nested example groups.
+* Patch from Corey Haines to add include_text matcher
+* Added stub_model method which creates a real model instance with :id stubbed and data access prohibited.
+* Applied patch from Pat Maddox to handle redirect_to w/ SSL. Closes #320.
+* Added #helper and #assigns to helper specs.
+* Applied patch from Bryan Helmkamp to tweak format of generated spec.opts to be more obvious. Closes #162.
+* Tweaked list of exceptions (ignores) for autotest
+* Applied patch from Rick Olson to get rspec_on_rails working with rails edge (>= 8862)
+* Applied patch from Wincent Colaiuta to invert sense of "spec --diff". Closes #281.
+* Allow any type of render in view specs. Closes #57.
+* Applied patch from Ian White to get rspec working with edge rails (8804). Closes #271.
+* Applied patch from Jon Strother to have spec_server reload fixtures. Closes #344.
--- /dev/null
+(The MIT License)
+
+====================================================================
+==== RSpec, RSpec-Rails
+Copyright (c) 2005-2009 The RSpec Development Team
+====================================================================
+==== ARTS
+Copyright (c) 2006 Kevin Clark, Jake Howerton
+====================================================================
+==== ZenTest
+Copyright (c) 2001-2006 Ryan Davis, Eric Hodel, Zen Spider Software
+====================================================================
+==== AssertSelect
+Copyright (c) 2006 Assaf Arkin
+====================================================================
+
+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
+.document
+Contribute.rdoc
+History.rdoc
+License.txt
+Manifest.txt
+README.rdoc
+Rakefile
+TODO.txt
+Upgrade.rdoc
+generators/integration_spec/integration_spec_generator.rb
+generators/integration_spec/templates/integration_spec.rb
+generators/rspec/CHANGES
+generators/rspec/rspec_generator.rb
+generators/rspec/templates/previous_failures.txt
+generators/rspec/templates/rcov.opts
+generators/rspec/templates/rspec.rake
+generators/rspec/templates/script/autospec
+generators/rspec/templates/script/spec
+generators/rspec/templates/spec.opts
+generators/rspec/templates/spec_helper.rb
+generators/rspec_controller/USAGE
+generators/rspec_controller/rspec_controller_generator.rb
+generators/rspec_controller/templates/controller_spec.rb
+generators/rspec_controller/templates/helper_spec.rb
+generators/rspec_controller/templates/view_spec.rb
+generators/rspec_default_values.rb
+generators/rspec_model/USAGE
+generators/rspec_model/rspec_model_generator.rb
+generators/rspec_model/templates/model_spec.rb
+generators/rspec_scaffold/rspec_scaffold_generator.rb
+generators/rspec_scaffold/templates/controller_spec.rb
+generators/rspec_scaffold/templates/edit_erb_spec.rb
+generators/rspec_scaffold/templates/helper_spec.rb
+generators/rspec_scaffold/templates/index_erb_spec.rb
+generators/rspec_scaffold/templates/new_erb_spec.rb
+generators/rspec_scaffold/templates/routing_spec.rb
+generators/rspec_scaffold/templates/show_erb_spec.rb
+init.rb
+lib/autotest/discover.rb
+lib/autotest/rails_rspec.rb
+lib/spec/rails.rb
+lib/spec/rails/example.rb
+lib/spec/rails/example/assigns_hash_proxy.rb
+lib/spec/rails/example/controller_example_group.rb
+lib/spec/rails/example/cookies_proxy.rb
+lib/spec/rails/example/functional_example_group.rb
+lib/spec/rails/example/helper_example_group.rb
+lib/spec/rails/example/integration_example_group.rb
+lib/spec/rails/example/model_example_group.rb
+lib/spec/rails/example/render_observer.rb
+lib/spec/rails/example/routing_example_group.rb
+lib/spec/rails/example/routing_helpers.rb
+lib/spec/rails/example/view_example_group.rb
+lib/spec/rails/extensions.rb
+lib/spec/rails/extensions/action_controller/rescue.rb
+lib/spec/rails/extensions/action_controller/test_case.rb
+lib/spec/rails/extensions/action_controller/test_response.rb
+lib/spec/rails/extensions/action_view/base.rb
+lib/spec/rails/extensions/active_record/base.rb
+lib/spec/rails/extensions/active_support/test_case.rb
+lib/spec/rails/extensions/spec/matchers/have.rb
+lib/spec/rails/extensions/spec/runner/configuration.rb
+lib/spec/rails/interop/testcase.rb
+lib/spec/rails/matchers.rb
+lib/spec/rails/matchers/ar_be_valid.rb
+lib/spec/rails/matchers/assert_select.rb
+lib/spec/rails/matchers/change.rb
+lib/spec/rails/matchers/have_text.rb
+lib/spec/rails/matchers/include_text.rb
+lib/spec/rails/matchers/redirect_to.rb
+lib/spec/rails/matchers/render_template.rb
+lib/spec/rails/matchers/route_to.rb
+lib/spec/rails/mocks.rb
+lib/spec/rails/version.rb
+spec/autotest/mappings_spec.rb
+spec/rails_suite.rb
+spec/resources/controllers/action_view_base_spec_controller.rb
+spec/resources/controllers/application.rb
+spec/resources/controllers/controller_spec_controller.rb
+spec/resources/controllers/example.txt
+spec/resources/controllers/redirect_spec_controller.rb
+spec/resources/controllers/render_spec_controller.rb
+spec/resources/controllers/rjs_spec_controller.rb
+spec/resources/helpers/addition_helper.rb
+spec/resources/helpers/explicit_helper.rb
+spec/resources/helpers/more_explicit_helper.rb
+spec/resources/helpers/plugin_application_helper.rb
+spec/resources/helpers/view_spec_helper.rb
+spec/resources/models/animal.rb
+spec/resources/models/person.rb
+spec/resources/models/thing.rb
+spec/resources/views/controller_spec/_partial.html.erb
+spec/resources/views/controller_spec/action_setting_flash_after_session_reset.html.erb
+spec/resources/views/controller_spec/action_setting_flash_before_session_reset.html.erb
+spec/resources/views/controller_spec/action_setting_the_assigns_hash.html.erb
+spec/resources/views/controller_spec/action_with_errors_in_template.html.erb
+spec/resources/views/controller_spec/action_with_template.html.erb
+spec/resources/views/layouts/application.html.erb
+spec/resources/views/layouts/simple.html.erb
+spec/resources/views/objects/_object.html.erb
+spec/resources/views/render_spec/_a_partial.html.erb
+spec/resources/views/render_spec/action_with_alternate_layout.html.erb
+spec/resources/views/render_spec/some_action.html.erb
+spec/resources/views/render_spec/some_action.js.rjs
+spec/resources/views/rjs_spec/_replacement_partial.html.erb
+spec/resources/views/rjs_spec/hide_div.js.rjs
+spec/resources/views/rjs_spec/hide_page_element.js.rjs
+spec/resources/views/rjs_spec/insert_html.js.rjs
+spec/resources/views/rjs_spec/replace.js.rjs
+spec/resources/views/rjs_spec/replace_html.js.rjs
+spec/resources/views/rjs_spec/replace_html_with_partial.js.rjs
+spec/resources/views/rjs_spec/visual_effect.js.rjs
+spec/resources/views/rjs_spec/visual_toggle_effect.js.rjs
+spec/resources/views/tag_spec/no_tags.html.erb
+spec/resources/views/tag_spec/single_div_with_no_attributes.html.erb
+spec/resources/views/tag_spec/single_div_with_one_attribute.html.erb
+spec/resources/views/view_spec/_partial.html.erb
+spec/resources/views/view_spec/_partial_used_twice.html.erb
+spec/resources/views/view_spec/_partial_with_local_variable.html.erb
+spec/resources/views/view_spec/_partial_with_sub_partial.html.erb
+spec/resources/views/view_spec/_spacer.html.erb
+spec/resources/views/view_spec/accessor.html.erb
+spec/resources/views/view_spec/block_helper.html.erb
+spec/resources/views/view_spec/entry_form.html.erb
+spec/resources/views/view_spec/explicit_helper.html.erb
+spec/resources/views/view_spec/foo/show.html.erb
+spec/resources/views/view_spec/implicit_helper.html.erb
+spec/resources/views/view_spec/multiple_helpers.html.erb
+spec/resources/views/view_spec/path_params.html.erb
+spec/resources/views/view_spec/should_not_receive.html.erb
+spec/resources/views/view_spec/template_with_partial.html.erb
+spec/resources/views/view_spec/template_with_partial_using_collection.html.erb
+spec/resources/views/view_spec/template_with_partial_with_array.html.erb
+spec/resources/views/view_spec/view_helpers.html.erb
+spec/spec/rails/example/assigns_hash_proxy_spec.rb
+spec/spec/rails/example/configuration_spec.rb
+spec/spec/rails/example/controller_example_group_spec.rb
+spec/spec/rails/example/controller_isolation_spec.rb
+spec/spec/rails/example/cookies_proxy_spec.rb
+spec/spec/rails/example/error_handling_spec.rb
+spec/spec/rails/example/example_group_factory_spec.rb
+spec/spec/rails/example/helper_example_group_spec.rb
+spec/spec/rails/example/model_example_group_spec.rb
+spec/spec/rails/example/routing_example_group_spec.rb
+spec/spec/rails/example/shared_routing_example_group_examples.rb
+spec/spec/rails/example/test_unit_assertion_accessibility_spec.rb
+spec/spec/rails/example/view_example_group_spec.rb
+spec/spec/rails/extensions/action_view_base_spec.rb
+spec/spec/rails/extensions/active_record_spec.rb
+spec/spec/rails/interop/testcase_spec.rb
+spec/spec/rails/matchers/ar_be_valid_spec.rb
+spec/spec/rails/matchers/assert_select_spec.rb
+spec/spec/rails/matchers/errors_on_spec.rb
+spec/spec/rails/matchers/have_text_spec.rb
+spec/spec/rails/matchers/include_text_spec.rb
+spec/spec/rails/matchers/redirect_to_spec.rb
+spec/spec/rails/matchers/render_template_spec.rb
+spec/spec/rails/matchers/should_change_spec.rb
+spec/spec/rails/mocks/ar_classes.rb
+spec/spec/rails/mocks/mock_model_spec.rb
+spec/spec/rails/mocks/stub_model_spec.rb
+spec/spec/rails/sample_modified_fixture.rb
+spec/spec/rails/sample_spec.rb
+spec/spec/rails/spec_spec.rb
+spec/spec_helper.rb
--- /dev/null
+= Spec::Rails
+
+* http://rspec.info
+* http://rubyforge.org/projects/rspec
+* http://github.com/dchelimsky/rspec-rails
+* http://wiki.github.com/dchelimsky/rspec/rails
+* mailto:rspec-devel@rubyforge.org
+
+== DESCRIPTION:
+
+Behaviour Driven Development for Ruby on Rails.
+
+rspec-rails is an RSpec extension that allows you to drive the development of
+Ruby on Rails applications with RSpec.
+
+== FEATURES:
+
+* Use RSpec to independently specify Rails Models, Views, Controllers and Helpers
+* Integrated fixture loading
+* Special generators for Resources, Models, Views and Controllers that generate RSpec code examples.
+
+== VISION:
+
+For people for whom TDD is a brand new concept, the testing support built into
+Ruby on Rails is a huge leap forward. The fact that it is built right in is
+fantastic, and Ruby on Rails apps are generally much easier to maintain than
+they might have been without such support.
+
+For those of us coming from a history with TDD, and now BDD, the existing
+support presents some problems related to dependencies across examples. To
+that end, RSpec on Rails supports 4 types of examples. We’ve also built in
+first class mocking and stubbing support in order to break dependencies across
+these different concerns.
+
+== MORE INFORMATION:
+
+See Spec::Rails::Example for information about the different kinds of example
+groups you can use to spec the different Rails components
+
+See Spec::Rails::Matchers for information about Rails-specific
+expectations you can set on responses and models, etc.
+
+== INSTALL
+
+* Visit http://wiki.github.com/dchelimsky/rspec/rails for installation instructions.
--- /dev/null
+# -*- ruby -*-
+gem 'hoe', '>=2.0.0'
+require 'hoe'
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__),"..","rspec","lib")))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__),"lib")))
+
+require 'spec/rails/version'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+Hoe.spec 'rspec-rails' do
+ self.version = Spec::Rails::VERSION::STRING
+ self.summary = Spec::Rails::VERSION::SUMMARY
+ self.description = "Behaviour Driven Development for Ruby on Rails."
+ self.rubyforge_name = 'rspec'
+ self.developer 'RSpec Development Team', 'rspec-devel@rubyforge.org'
+ self.extra_deps = [["rspec",">=1.3.0"],["rack",">=1.0.0"]]
+ self.extra_dev_deps = [["cucumber",">= 0.3.99"]]
+ self.remote_rdoc_dir = "rspec-rails/#{Spec::Rails::VERSION::STRING}"
+ self.history_file = 'History.rdoc'
+ self.readme_file = 'README.rdoc'
+ self.post_install_message = <<-POST_INSTALL_MESSAGE
+#{'*'*50}
+
+ Thank you for installing rspec-rails-#{Spec::Rails::VERSION::STRING}
+
+ If you are upgrading, do this in each of your rails apps
+ that you want to upgrade:
+
+ $ ruby script/generate rspec
+
+ Please be sure to read History.rdoc and Upgrade.rdoc
+ for useful information about this release.
+
+#{'*'*50}
+POST_INSTALL_MESSAGE
+end
+
+['audit','test','test_deps','default','post_blog', 'release'].each do |task|
+ Rake.application.instance_variable_get('@tasks').delete(task)
+end
+
+task :post_blog do
+ # no-op
+end
+
+task :release => [:clean, :package] do |t|
+ version = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+ abort "Versions don't match #{version} vs #{Spec::Rails::VERSION::STRING}" unless version == Spec::Rails::VERSION::STRING
+ pkg = "pkg/rspec-rails-#{version}"
+
+ rubyforge = RubyForge.new.configure
+ puts "Logging in to rubyforge ..."
+ rubyforge.login
+
+ puts "Releasing rspec-rails version #{version} ..."
+ ["#{pkg}.gem", "#{pkg}.tgz"].each do |file|
+ rubyforge.add_file('rspec', 'rspec', Spec::Rails::VERSION::STRING, file)
+ end
+end
+
+Cucumber::Rake::Task.new
+
+task :default => [:features]
+
+namespace :update do
+ desc "update the manifest"
+ task :manifest do
+ system %q[touch Manifest.txt; rake check_manifest | grep -v "(in " | patch]
+ end
+end
--- /dev/null
+* wiki
+ * need a matrix of which rspec-rails versions support which rails versions
+* CI
+ * need a robust CI setup that runs
+ * Multiple rubies
+ * MRI: 1.8.6
+ * MRI: 1.8.7
+ * MRI: 1.9.1
+ * JRuby
+ * IronRuby??? (perhaps using mono)
+ * Multiple rails-es
+ * 2.0.5
+ * 2.1.2
+ * 2.2.2
+ * 2.3.4
+ * 3.0 (once available)
+ * With and without ActiveRecord
--- /dev/null
+= Upgrade to 1.2.8/1.2.9/1.3.0
+
+== What's new
+
+=== route_to and be_routable matchers
+
+Stop using route_for and params_from today! These new matchers from Randy
+Harmon are more expressive and more reliable. Here's how you use them:
+
+ { :put => "/projects/37" }.should route_to(:controller => 'projects', :action => 'update', :id => '37')
+
+ { :get => "/nonexisting_route" }.should_not be_routable
+
+== What's changed
+
+=== spec_server has been removed
+
+spec_server was deprecated in 1.2.7 and has now been removed. Admittedly, this
+was a short deprecation cycle, but spec server never quite worked right in all
+situations and spork is a great solution that you can use today! This is all
+you need to do:
+
+ [sudo] gem install spork
+ cd path/to/project
+ spork --bootsrap
+
+Now open up spec/spec_helper.rb and follow the directions at the top. You'll
+be up and running in no time.
+
+For more info:
+
+* http://github.com/timcharper/spork
+* http://groups.google.com/group/sporkgem
+
+= Upgrade to 1.2.7
+
+== What's changed
+
+=== spec_server is deprecated
+
+spec_server is deprecated in favor of Tim Harper's new spork library
+(http://github.com/timcharper/spork). Get it. Use it. Love it.
+
+ gem install spork
+
+= Upgrade to 1.2.0-1.2.6
+
+== What's changed
+
+=== Supported Rails Versions
+
+This release supports the following versions of rails:
+
+* 2.0.5
+* 2.1.2
+* 2.2.2
+* 2.3.2
+
+=== update generated files
+
+Be sure to run "script/generate rspec" and allow the following files to be overwritten:
+
+* lib/tasks/rspec.rake
+* script/spec
+* script/spec_server
+
+=== controller.use_rails_error_handling! is deprecated
+
+Use <tt>rescue_action_in_public!</tt> instead. It comes directly from rails and does
+exactly the same thing
+
+=== route_for
+
+After a change to edge rails broke our monkey-patched <tt>route_for</tt> method, I
+decided to just delegate to rails' <tt>assert_generates</tt> method. For most cases,
+this will not present a problem, but for some it might. You'll know if you
+upgrade and see any newly failing, route-related examples. Here are the things
+that you might need to change.
+
+==== Make sure IDs are strings
+
+If you had :id => 1 before, you need to change that to :id => "1"
+
+ #old
+ route_for(:controller => 'things', :action => 'show', :id => 1).should == "/things/1"
+
+ #new
+ route_for(:controller => 'things', :action => 'show', :id => "1").should == "/things/1"
+
+==== Convert paths for non-get methods to hashes
+
+If you had an example with a route that requires post, put, or delete, you'll
+need to declare that explicitly.
+
+ #old
+ route_for(:controller => 'things', :action => 'create').should == "/things"
+
+ #new
+ route_for(:controller => 'things', :action => 'create').should == {:path => "/things", :method => :post}
+
+=== Controller/template isolation
+
+Even though controller specs do not render views by default (use
+<tt>integrate_views</tt> to get them to render views), the way this works has
+changed in this version.
+
+It used to be that the view template need not even exist, but due to changes
+in rails it became much more difficult to manage that for all the different
+versions of rails that rspec-rails supports. So now the template must exist,
+but it still won't be rendered unless you declare <tt>integrate_views</tt>.
+
+== What's new
+
+=== render no longer requires a path
+
+The <tt>render()</tt> method in view specs will infer the path from the
+first argument passed to <tt>describe()</tt>.
+
+ describe "players/show" do
+ it "does something" do
+ render
+ response.should have_tag("....")
+ end
+ end
+
+=== routing specs live in spec/routing
+
+<tt>script/generate rspec_scaffold</tt> now generates its routing spec in
+<tt>spec/routing/</tt>.
+
+=== bypass_rescue
+
+Added a new <tt>bypass_rescue()</tt> declaration for controller specs. Use this
+when you want to specify that an error is raised by an action, even if that
+error is later captured by a <tt>rescue_from()</tt> declaration.
+
+ describe AccountController do
+ describe "GET @account" do
+ context "requested by anonymous user" do
+ it "denies access" do
+ bypass_rescue
+ lambda do
+ get :show, :id => "37"
+ end.should raise_error(AccessDenied)
+ end
+ end
+ end
+ end
--- /dev/null
+require File.dirname(__FILE__) + '/../rspec_default_values'
+
+class IntegrationSpecGenerator < ModelGenerator
+ def manifest
+ record do |m|
+ m.class_collisions class_path, class_name
+ m.template 'integration_spec.rb', File.join('spec/integration', class_path, "#{class_name.tableize}_spec.rb")
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe "<%= class_name.pluralize %>" do
+end
--- /dev/null
+Please refer to the CHANGES file for RSpec's core
\ No newline at end of file
--- /dev/null
+require 'rbconfig'
+
+# This generator bootstraps a Rails project for use with RSpec
+class RspecGenerator < Rails::Generator::Base
+ DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+ Config::CONFIG['ruby_install_name'])
+
+ def initialize(runtime_args, runtime_options = {})
+ if test ?f, 'spec/spec_helper.rb'
+
+ puts <<-HELPFUL_INSTRUCTIONS
+
+It looks like you are upgrading rspec-rails in this application. Please let
+this script overwrite everything it wants to with the following exceptions,
+*if* you have customized any of these files:
+
+ * spec/spec.opts
+ * spec/rcov.opts
+ * spec/spec_helper.rb
+
+If you have customized spec/spec_helper.rb, please set aside a copy of that
+file so that it can be updated and you can manually restore your changes.
+
+HELPFUL_INSTRUCTIONS
+ end
+ Dir.mkdir('lib/tasks') unless File.directory?('lib/tasks')
+
+ if Rails::VERSION::STRING >= '2.1'
+ test_env = 'config/environments/test.rb'
+ contents = File.read(test_env)
+ unless contents =~ /config\.gem\s+(\"|\')rspec/m
+ puts "Configuring rspec and rspec-rails gems in #{test_env} ..."
+ puts
+ require File.expand_path('../../../lib/spec/rails/version.rb', __FILE__)
+ rspec_config = <<-EOF
+ config.gem 'rspec', :version => '>= #{Spec::Rails::VERSION::STRING}', :lib => false unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
+ config.gem 'rspec-rails', :version => '>= #{Spec::Rails::VERSION::STRING}', :lib => false unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
+ EOF
+ File.open(test_env, "wb") do |f|
+ f.puts contents
+ f.puts
+ f.puts rspec_config
+ end
+ end
+ end
+
+ super
+ end
+
+ def manifest
+ record do |m|
+ script_options = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+
+ m.directory 'lib/tasks'
+ m.file 'rspec.rake', 'lib/tasks/rspec.rake'
+
+ m.file 'script/autospec', 'script/autospec', script_options
+ m.file 'script/spec', 'script/spec', script_options
+
+ m.directory 'spec'
+ m.file 'rcov.opts', 'spec/rcov.opts'
+ m.file 'spec.opts', 'spec/spec.opts'
+ m.template 'spec_helper.rb', 'spec/spec_helper.rb'
+ end
+ end
+
+protected
+
+ def banner
+ "Usage: #{$0} rspec"
+ end
+
+end
--- /dev/null
+--exclude "spec/*,gems/*"
+--rails
\ No newline at end of file
--- /dev/null
+gem 'test-unit', '1.2.3' if RUBY_VERSION.to_f >= 1.9
+rspec_gem_dir = nil
+Dir["#{RAILS_ROOT}/vendor/gems/*"].each do |subdir|
+ rspec_gem_dir = subdir if subdir.gsub("#{RAILS_ROOT}/vendor/gems/","") =~ /^(\w+-)?rspec-(\d+)/ && File.exist?("#{subdir}/lib/spec/rake/spectask.rb")
+end
+rspec_plugin_dir = File.expand_path(File.dirname(__FILE__) + '/../../vendor/plugins/rspec')
+
+if rspec_gem_dir && (test ?d, rspec_plugin_dir)
+ raise "\n#{'*'*50}\nYou have rspec installed in both vendor/gems and vendor/plugins\nPlease pick one and dispose of the other.\n#{'*'*50}\n\n"
+end
+
+if rspec_gem_dir
+ $LOAD_PATH.unshift("#{rspec_gem_dir}/lib")
+elsif File.exist?(rspec_plugin_dir)
+ $LOAD_PATH.unshift("#{rspec_plugin_dir}/lib")
+end
+
+# Don't load rspec if running "rake gems:*"
+unless ARGV.any? {|a| a =~ /^gems/}
+
+begin
+ require 'spec/rake/spectask'
+rescue MissingSourceFile
+ module Spec
+ module Rake
+ class SpecTask
+ def initialize(name)
+ task name do
+ # if rspec-rails is a configured gem, this will output helpful material and exit ...
+ require File.expand_path(File.join(File.dirname(__FILE__),"..","..","config","environment"))
+
+ # ... otherwise, do this:
+ raise <<-MSG
+
+#{"*" * 80}
+* You are trying to run an rspec rake task defined in
+* #{__FILE__},
+* but rspec can not be found in vendor/gems, vendor/plugins or system gems.
+#{"*" * 80}
+MSG
+ end
+ end
+ end
+ end
+ end
+end
+
+Rake.application.instance_variable_get('@tasks').delete('default')
+
+spec_prereq = File.exist?(File.join(RAILS_ROOT, 'config', 'database.yml')) ? "db:test:prepare" : :noop
+task :noop do
+end
+
+task :default => :spec
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+Spec::Rake::SpecTask.new(:spec => spec_prereq) do |t|
+ t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+ t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+ desc "Run all specs in spec directory with RCov (excluding plugin specs)"
+ Spec::Rake::SpecTask.new(:rcov) do |t|
+ t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+ t.spec_files = FileList['spec/**/*_spec.rb']
+ t.rcov = true
+ t.rcov_opts = lambda do
+ IO.readlines("#{RAILS_ROOT}/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+ end
+ end
+
+ desc "Print Specdoc for all specs (excluding plugin specs)"
+ Spec::Rake::SpecTask.new(:doc) do |t|
+ t.spec_opts = ["--format", "specdoc", "--dry-run"]
+ t.spec_files = FileList['spec/**/*_spec.rb']
+ end
+
+ desc "Print Specdoc for all plugin examples"
+ Spec::Rake::SpecTask.new(:plugin_doc) do |t|
+ t.spec_opts = ["--format", "specdoc", "--dry-run"]
+ t.spec_files = FileList['vendor/plugins/**/spec/**/*_spec.rb'].exclude('vendor/plugins/rspec/*')
+ end
+
+ [:models, :controllers, :views, :helpers, :lib, :integration].each do |sub|
+ desc "Run the code examples in spec/#{sub}"
+ Spec::Rake::SpecTask.new(sub => spec_prereq) do |t|
+ t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+ t.spec_files = FileList["spec/#{sub}/**/*_spec.rb"]
+ end
+ end
+
+ desc "Run the code examples in vendor/plugins (except RSpec's own)"
+ Spec::Rake::SpecTask.new(:plugins => spec_prereq) do |t|
+ t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+ t.spec_files = FileList['vendor/plugins/**/spec/**/*_spec.rb'].exclude('vendor/plugins/rspec/*').exclude("vendor/plugins/rspec-rails/*")
+ end
+
+ namespace :plugins do
+ desc "Runs the examples for rspec_on_rails"
+ Spec::Rake::SpecTask.new(:rspec_on_rails) do |t|
+ t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+ t.spec_files = FileList['vendor/plugins/rspec-rails/spec/**/*_spec.rb']
+ end
+ end
+
+ # Setup specs for stats
+ task :statsetup do
+ require 'code_statistics'
+ ::STATS_DIRECTORIES << %w(Model\ specs spec/models) if File.exist?('spec/models')
+ ::STATS_DIRECTORIES << %w(View\ specs spec/views) if File.exist?('spec/views')
+ ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers) if File.exist?('spec/controllers')
+ ::STATS_DIRECTORIES << %w(Helper\ specs spec/helpers) if File.exist?('spec/helpers')
+ ::STATS_DIRECTORIES << %w(Library\ specs spec/lib) if File.exist?('spec/lib')
+ ::STATS_DIRECTORIES << %w(Routing\ specs spec/routing) if File.exist?('spec/routing')
+ ::STATS_DIRECTORIES << %w(Integration\ specs spec/integration) if File.exist?('spec/integration')
+ ::CodeStatistics::TEST_TYPES << "Model specs" if File.exist?('spec/models')
+ ::CodeStatistics::TEST_TYPES << "View specs" if File.exist?('spec/views')
+ ::CodeStatistics::TEST_TYPES << "Controller specs" if File.exist?('spec/controllers')
+ ::CodeStatistics::TEST_TYPES << "Helper specs" if File.exist?('spec/helpers')
+ ::CodeStatistics::TEST_TYPES << "Library specs" if File.exist?('spec/lib')
+ ::CodeStatistics::TEST_TYPES << "Routing specs" if File.exist?('spec/routing')
+ ::CodeStatistics::TEST_TYPES << "Integration specs" if File.exist?('spec/integration')
+ end
+
+ namespace :db do
+ namespace :fixtures do
+ desc "Load fixtures (from spec/fixtures) into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z."
+ task :load => :environment do
+ ActiveRecord::Base.establish_connection(Rails.env)
+ base_dir = File.join(Rails.root, 'spec', 'fixtures')
+ fixtures_dir = ENV['FIXTURES_DIR'] ? File.join(base_dir, ENV['FIXTURES_DIR']) : base_dir
+
+ require 'active_record/fixtures'
+ (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/).map {|f| File.join(fixtures_dir, f) } : Dir.glob(File.join(fixtures_dir, '*.{yml,csv}'))).each do |fixture_file|
+ Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+ end
+ end
+ end
+ end
+end
+
+end
--- /dev/null
+#!/usr/bin/env ruby
+gem 'test-unit', '1.2.3' if RUBY_VERSION.to_f >= 1.9
+ENV['RSPEC'] = 'true' # allows autotest to discover rspec
+ENV['AUTOTEST'] = 'true' # allows autotest to run w/ color on linux
+system((RUBY_PLATFORM =~ /mswin|mingw/ ? 'autotest.bat' : 'autotest'), *ARGV) ||
+ $stderr.puts("Unable to find autotest. Please install ZenTest or fix your PATH")
--- /dev/null
+#!/usr/bin/env ruby
+if ARGV.any? {|arg| %w[--drb -X --generate-options -G --help -h --version -v].include?(arg)}
+ require 'rubygems' unless ENV['NO_RUBYGEMS']
+else
+ gem 'test-unit', '1.2.3' if RUBY_VERSION.to_f >= 1.9
+ ENV["RAILS_ENV"] ||= 'test'
+ require File.expand_path(File.dirname(__FILE__) + "/../config/environment") unless defined?(RAILS_ROOT)
+end
+require 'spec/autorun'
+exit ::Spec::Runner::CommandLine.run
--- /dev/null
+--colour
+--format progress
+--loadby mtime
+--reverse
--- /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.join(File.dirname(__FILE__),'..','config','environment'))
+require 'spec/autorun'
+require 'spec/rails'
+
+# Uncomment the next line to use webrat's matchers
+#require 'webrat/integrations/rspec-rails'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+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.
+ #
+ # You can also declare which fixtures to use (for example fixtures for test/fixtures):
+ #
+ # config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
+ #
+ # == Mock Framework
+ #
+ # RSpec uses its 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
+ #
+ # == Notes
+ #
+ # For more information take a look at Spec::Runner::Configuration and Spec::Runner
+end
--- /dev/null
+Description:
+ The rspec_controller generator creates stub specs and files for a new
+ controller and its views.
+
+ The generator takes a controller name and a list of views as arguments.
+ The controller name may be given in CamelCase or under_score and should
+ not be suffixed with 'Controller'. To create a controller within a
+ module, specify the controller name as 'module/controller'.
+
+ The generator creates stubs for a controller (and spec), a view (and spec)
+ for each view in the argument list, plus a helper.
+
+Example:
+ ./script/generate rspec_controller dog bark fetch
+ ...
+ create spec/controllers/dog_controller_spec.rb
+ create app/controllers/dog_controller.rb
+ create app/helpers/dog_helper.rb
+ create spec/views/dog/bark_view_spec.rb
+ create app/views/dog/bark.rhtml
+ create spec/views/dog/fetch_view_spec.rb
+ create app/views/dog/fetch.rhtml
+
+Modules Example:
+ ./script/generate rspec_controller 'pets/dog' bark fetch
+ ...
+ create spec/controllers/pets/dog_controller_spec.rb
+ create app/controllers/pets/dog_controller.rb
+ create app/helpers/pets/dog_helper.rb
+ create spec/views/pets/dog/bark_view_spec.rb
+ create app/views/pets/dog/bark.rhtml
+ create spec/views/pets/dog/fetch_view_spec.rb
+ create app/views/pets/dog/fetch.rhtml
--- /dev/null
+require 'rails_generator/generators/components/controller/controller_generator'
+
+class RspecControllerGenerator < ControllerGenerator
+
+ def manifest
+ record do |m|
+ # Check for class naming collisions.
+ m.class_collisions class_path, "#{class_name}Controller", "#{class_name}Helper"
+
+ # Controller, helper, views, and spec directories.
+ m.directory File.join('app/controllers', class_path)
+ m.directory File.join('app/helpers', class_path)
+ m.directory File.join('app/views', class_path, file_name)
+ m.directory File.join('spec/controllers', class_path)
+ m.directory File.join('spec/helpers', class_path)
+ m.directory File.join('spec/views', class_path, file_name)
+
+ @default_file_extension = "html.erb"
+
+ # Controller spec, class, and helper.
+ m.template 'controller_spec.rb',
+ File.join('spec/controllers', class_path, "#{file_name}_controller_spec.rb")
+
+ m.template 'helper_spec.rb',
+ File.join('spec/helpers', class_path, "#{file_name}_helper_spec.rb")
+
+ m.template 'controller:controller.rb',
+ File.join('app/controllers', class_path, "#{file_name}_controller.rb")
+
+ m.template 'controller:helper.rb',
+ File.join('app/helpers', class_path, "#{file_name}_helper.rb")
+
+
+
+ # Spec and view template for each action.
+ actions.each do |action|
+ m.template 'view_spec.rb',
+ File.join('spec/views', class_path, file_name, "#{action}.#{@default_file_extension}_spec.rb"),
+ :assigns => { :action => action, :model => file_name }
+ path = File.join('app/views', class_path, file_name, "#{action}.#{@default_file_extension}")
+ m.template "controller:view.#{@default_file_extension}",
+ path,
+ :assigns => { :action => action, :path => path }
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= class_name %>Controller do
+
+<% if actions.empty? -%>
+ #Delete this example and add some real ones
+<% else -%>
+ #Delete these examples and add some real ones
+<% end -%>
+ it "should use <%= class_name %>Controller" do
+ controller.should be_an_instance_of(<%= class_name %>Controller)
+ end
+
+<% unless actions.empty? -%>
+<% for action in actions -%>
+
+ describe "GET '<%= action %>'" do
+ it "should be successful" do
+ get '<%= action %>'
+ response.should be_success
+ end
+ end
+<% end -%>
+<% end -%>
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= class_name %>Helper do
+
+ #Delete this example and add some real ones or delete this file
+ it "should be included in the object returned by #helper" do
+ included_modules = (class << helper; self; end).send :included_modules
+ included_modules.should include(<%= class_name %>Helper)
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+describe "/<%= class_name.underscore %>/<%= action %>" do
+ before(:each) do
+ render '<%= class_name.underscore %>/<%= action %>'
+ end
+
+ #Delete this example and add some real ones or delete this file
+ it "should tell you where to find the file" do
+ response.should have_tag('p', %r[Find me in app/views/<%= class_name.underscore %>/<%= action %>])
+ end
+end
--- /dev/null
+module Rails
+ module Generator
+ class GeneratedAttribute
+ def default_value
+ @default_value ||= case type
+ when :int, :integer then "1"
+ when :float then "1.5"
+ when :decimal then "9.99"
+ when :datetime, :timestamp, :time then "Time.now"
+ when :date then "Date.today"
+ when :string, :text then "\"value for #{@name}\""
+ when :boolean then "false"
+ when :belongs_to, :references then "1"
+ else
+ ""
+ end
+ end
+
+ def name_or_reference
+ if ::Rails::VERSION::STRING >= '2.2'
+ reference? ? :"#{name}_id" : name
+ else
+ name
+ end
+ end
+ end
+ end
+end
--- /dev/null
+Description:
+ The rspec_model generator creates stubs for a new model.
+
+ The generator takes a model name as its argument. The model name may be
+ given in CamelCase or under_score and should not be suffixed with 'Model'.
+
+ The generator creates a model class in app/models, an RSpec spec in
+ spec/models, database fixtures in spec/fixtures/plural_name.yml, and a migration
+ in db/migrate.
+
+Example:
+ ./script/generate rspec_model Account
+
+ This will create an Account model:
+ Model: app/models/account.rb
+ Spec: spec/models/account_spec.rb
+ Fixtures: spec/fixtures/accounts.yml
+ Migration: db/migrate/XXX_add_accounts.rb
--- /dev/null
+require 'rails_generator/generators/components/model/model_generator'
+require File.dirname(__FILE__) + '/../rspec_default_values'
+
+class RspecModelGenerator < ModelGenerator
+
+ def manifest
+
+ record do |m|
+ # Check for class naming collisions.
+ m.class_collisions class_path, class_name
+
+ # Model, spec, and fixture directories.
+ m.directory File.join('app/models', class_path)
+ m.directory File.join('spec/models', class_path)
+ unless options[:skip_fixture]
+ m.directory File.join('spec/fixtures', class_path)
+ end
+
+ # Model class, spec and fixtures.
+ m.template 'model:model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+ m.template 'model_spec.rb', File.join('spec/models', class_path, "#{file_name}_spec.rb")
+ unless options[:skip_fixture]
+ m.template 'model:fixtures.yml', File.join('spec/fixtures', "#{table_name}.yml")
+ end
+
+ unless options[:skip_migration]
+ m.migration_template 'model:migration.rb', 'db/migrate', :assigns => {
+ :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+ }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+ end
+
+ end
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= class_name %> do
+ before(:each) do
+ @valid_attributes = {
+ <%= attributes.map{|a| ":#{a.name_or_reference} => #{a.default_value}" }.join(",\n ") %>
+ }
+ end
+
+ it "should create a new instance given valid attributes" do
+ <%= class_name %>.create!(@valid_attributes)
+ end
+end
--- /dev/null
+require File.dirname(__FILE__) + '/../rspec_default_values'
+
+class RspecScaffoldGenerator < Rails::Generator::NamedBase
+ default_options :skip_migration => false
+
+ attr_reader :controller_name,
+ :controller_class_path,
+ :controller_file_path,
+ :controller_class_nesting,
+ :controller_class_nesting_depth,
+ :controller_class_name,
+ :controller_singular_name,
+ :controller_plural_name,
+ :resource_edit_path,
+ :default_file_extension
+ alias_method :controller_file_name, :controller_singular_name
+ alias_method :controller_table_name, :controller_plural_name
+
+ def initialize(runtime_args, runtime_options = {})
+ super
+
+ @controller_name = @name.pluralize
+
+ base_name, @controller_class_path, @controller_file_path, @controller_class_nesting, @controller_class_nesting_depth = extract_modules(@controller_name)
+ @controller_class_name_without_nesting, @controller_singular_name, @controller_plural_name = inflect_names(base_name)
+
+ if @controller_class_nesting.empty?
+ @controller_class_name = @controller_class_name_without_nesting
+ else
+ @controller_class_name = "#{@controller_class_nesting}::#{@controller_class_name_without_nesting}"
+ end
+
+ @default_file_extension = "html.erb"
+ end
+
+ def manifest
+ record do |m|
+
+ # Check for class naming collisions.
+ m.class_collisions(controller_class_path, "#{controller_class_name}Controller", "#{controller_class_name}Helper")
+ m.class_collisions(class_path, "#{class_name}")
+
+ # Controller, helper, views, and spec directories.
+ m.directory(File.join('app/models', class_path))
+ m.directory(File.join('app/controllers', controller_class_path))
+ m.directory(File.join('app/helpers', controller_class_path))
+ m.directory(File.join('app/views', controller_class_path, controller_file_name))
+ m.directory(File.join('app/views/layouts', controller_class_path))
+ m.directory(File.join('public/stylesheets', class_path))
+
+ m.directory(File.join('spec/controllers', controller_class_path))
+ m.directory(File.join('spec/routing', controller_class_path))
+ m.directory(File.join('spec/models', class_path))
+ m.directory(File.join('spec/helpers', class_path))
+ m.directory File.join('spec/fixtures', class_path)
+ m.directory File.join('spec/views', controller_class_path, controller_file_name)
+ m.directory File.join('spec/integration', class_path)
+
+ # Layout and stylesheet.
+ m.template("scaffold:layout.html.erb", File.join('app/views/layouts', controller_class_path, "#{controller_file_name}.html.erb"))
+ m.template("scaffold:style.css", 'public/stylesheets/scaffold.css')
+
+ # Controller spec, class, and helper.
+ m.template 'rspec_scaffold:routing_spec.rb',
+ File.join('spec/routing', controller_class_path, "#{controller_file_name}_routing_spec.rb")
+
+ m.template 'rspec_scaffold:controller_spec.rb',
+ File.join('spec/controllers', controller_class_path, "#{controller_file_name}_controller_spec.rb")
+
+ m.template "scaffold:controller.rb",
+ File.join('app/controllers', controller_class_path, "#{controller_file_name}_controller.rb")
+
+ m.template 'rspec_scaffold:helper_spec.rb',
+ File.join('spec/helpers', class_path, "#{controller_file_name}_helper_spec.rb")
+
+ m.template "scaffold:helper.rb",
+ File.join('app/helpers', controller_class_path, "#{controller_file_name}_helper.rb")
+
+ for action in scaffold_views
+ m.template(
+ "scaffold:view_#{action}.#{@default_file_extension}",
+ File.join('app/views', controller_class_path, controller_file_name, "#{action}.#{default_file_extension}")
+ )
+ end
+
+ # Model class, unit test, and fixtures.
+ m.template 'model:model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+ m.template 'model:fixtures.yml', File.join('spec/fixtures', class_path, "#{table_name}.yml")
+ m.template 'rspec_model:model_spec.rb', File.join('spec/models', class_path, "#{file_name}_spec.rb")
+
+ # View specs
+ m.template "rspec_scaffold:edit_erb_spec.rb",
+ File.join('spec/views', controller_class_path, controller_file_name, "edit.#{default_file_extension}_spec.rb")
+ m.template "rspec_scaffold:index_erb_spec.rb",
+ File.join('spec/views', controller_class_path, controller_file_name, "index.#{default_file_extension}_spec.rb")
+ m.template "rspec_scaffold:new_erb_spec.rb",
+ File.join('spec/views', controller_class_path, controller_file_name, "new.#{default_file_extension}_spec.rb")
+ m.template "rspec_scaffold:show_erb_spec.rb",
+ File.join('spec/views', controller_class_path, controller_file_name, "show.#{default_file_extension}_spec.rb")
+
+ # Integration
+ m.template 'integration_spec:integration_spec.rb', File.join('spec/integration', class_path, "#{table_name}_spec.rb")
+
+ unless options[:skip_migration]
+ m.migration_template(
+ 'model:migration.rb', 'db/migrate',
+ :assigns => {
+ :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}",
+ :attributes => attributes
+ },
+ :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+ )
+ end
+
+ m.route_resources controller_file_name
+
+ end
+ end
+
+ protected
+ # Override with your own usage banner.
+ def banner
+ "Usage: #{$0} rspec_scaffold ModelName [field:type field:type]"
+ end
+
+ def add_options!(opt)
+ opt.separator ''
+ opt.separator 'Options:'
+ opt.on("--skip-migration",
+ "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+ end
+
+ def scaffold_views
+ %w[ index show new edit ]
+ end
+
+ def model_name
+ class_name.demodulize
+ end
+end
+
+module Rails
+ module Generator
+ class GeneratedAttribute
+ def input_type
+ @input_type ||= case type
+ when :text then "textarea"
+ else
+ "input"
+ end
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= controller_class_name %>Controller do
+
+ def mock_<%= file_name %>(stubs={})
+ @mock_<%= file_name %> ||= mock_model(<%= class_name %>, stubs)
+ end
+
+ describe "GET index" do
+ it "assigns all <%= table_name.pluralize %> as @<%= table_name.pluralize %>" do
+ <%= class_name %>.stub(:find).with(:all).and_return([mock_<%= file_name %>])
+ get :index
+ assigns[:<%= table_name %>].should == [mock_<%= file_name %>]
+ end
+ end
+
+ describe "GET show" do
+ it "assigns the requested <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:find).with("37").and_return(mock_<%= file_name %>)
+ get :show, :id => "37"
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+ end
+
+ describe "GET new" do
+ it "assigns a new <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:new).and_return(mock_<%= file_name %>)
+ get :new
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+ end
+
+ describe "GET edit" do
+ it "assigns the requested <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:find).with("37").and_return(mock_<%= file_name %>)
+ get :edit, :id => "37"
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+ end
+
+ describe "POST create" do
+
+ describe "with valid params" do
+ it "assigns a newly created <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:new).with({'these' => 'params'}).and_return(mock_<%= file_name %>(:save => true))
+ post :create, :<%= file_name %> => {:these => 'params'}
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+
+ it "redirects to the created <%= file_name %>" do
+ <%= class_name %>.stub(:new).and_return(mock_<%= file_name %>(:save => true))
+ post :create, :<%= file_name %> => {}
+ response.should redirect_to(<%= table_name.singularize %>_url(mock_<%= file_name %>))
+ end
+ end
+
+ describe "with invalid params" do
+ it "assigns a newly created but unsaved <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:new).with({'these' => 'params'}).and_return(mock_<%= file_name %>(:save => false))
+ post :create, :<%= file_name %> => {:these => 'params'}
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+
+ it "re-renders the 'new' template" do
+ <%= class_name %>.stub(:new).and_return(mock_<%= file_name %>(:save => false))
+ post :create, :<%= file_name %> => {}
+ response.should render_template('new')
+ end
+ end
+
+ end
+
+ describe "PUT update" do
+
+ describe "with valid params" do
+ it "updates the requested <%= file_name %>" do
+ <%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
+ mock_<%= file_name %>.should_receive(:update_attributes).with({'these' => 'params'})
+ put :update, :id => "37", :<%= file_name %> => {:these => 'params'}
+ end
+
+ it "assigns the requested <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:find).and_return(mock_<%= file_name %>(:update_attributes => true))
+ put :update, :id => "1"
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+
+ it "redirects to the <%= file_name %>" do
+ <%= class_name %>.stub(:find).and_return(mock_<%= file_name %>(:update_attributes => true))
+ put :update, :id => "1"
+ response.should redirect_to(<%= table_name.singularize %>_url(mock_<%= file_name %>))
+ end
+ end
+
+ describe "with invalid params" do
+ it "updates the requested <%= file_name %>" do
+ <%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
+ mock_<%= file_name %>.should_receive(:update_attributes).with({'these' => 'params'})
+ put :update, :id => "37", :<%= file_name %> => {:these => 'params'}
+ end
+
+ it "assigns the <%= file_name %> as @<%= file_name %>" do
+ <%= class_name %>.stub(:find).and_return(mock_<%= file_name %>(:update_attributes => false))
+ put :update, :id => "1"
+ assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
+ end
+
+ it "re-renders the 'edit' template" do
+ <%= class_name %>.stub(:find).and_return(mock_<%= file_name %>(:update_attributes => false))
+ put :update, :id => "1"
+ response.should render_template('edit')
+ end
+ end
+
+ end
+
+ describe "DELETE destroy" do
+ it "destroys the requested <%= file_name %>" do
+ <%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
+ mock_<%= file_name %>.should_receive(:destroy)
+ delete :destroy, :id => "37"
+ end
+
+ it "redirects to the <%= table_name %> list" do
+ <%= class_name %>.stub(:find).and_return(mock_<%= file_name %>(:destroy => true))
+ delete :destroy, :id => "1"
+ response.should redirect_to(<%= table_name %>_url)
+ end
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+<% output_attributes = attributes.reject{|attribute| [:datetime, :timestamp, :time, :date].index(attribute.type) } -%>
+describe "/<%= table_name %>/edit.<%= default_file_extension %>" do
+ include <%= controller_class_name %>Helper
+
+ before(:each) do
+ assigns[:<%= file_name %>] = @<%= file_name %> = stub_model(<%= class_name %>,
+ :new_record? => false<%= output_attributes.empty? ? '' : ',' %>
+<% output_attributes.each_with_index do |attribute, attribute_index| -%>
+ :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == output_attributes.length - 1 ? '' : ','%>
+<% end -%>
+ )
+ end
+
+ it "renders the edit <%= file_name %> form" do
+ render
+
+ response.should have_tag("form[action=#{<%= file_name %>_path(@<%= file_name %>)}][method=post]") do
+<% for attribute in output_attributes -%>
+ with_tag('<%= attribute.input_type -%>#<%= file_name %>_<%= attribute.name %>[name=?]', "<%= file_name %>[<%= attribute.name %>]")
+<% end -%>
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= controller_class_name %>Helper do
+
+ #Delete this example and add some real ones or delete this file
+ it "is included in the helper object" do
+ included_modules = (class << helper; self; end).send :included_modules
+ included_modules.should include(<%= controller_class_name %>Helper)
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+<% output_attributes = attributes.reject{|attribute| [:datetime, :timestamp, :time, :date].index(attribute.type) } -%>
+describe "/<%= table_name %>/index.<%= default_file_extension %>" do
+ include <%= controller_class_name %>Helper
+
+ before(:each) do
+ assigns[:<%= table_name %>] = [
+<% [1,2].each_with_index do |id, model_index| -%>
+ stub_model(<%= class_name %><%= output_attributes.empty? ? (model_index == 1 ? ')' : '),') : ',' %>
+<% output_attributes.each_with_index do |attribute, attribute_index| -%>
+ :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == output_attributes.length - 1 ? '' : ','%>
+<% end -%>
+<% if !output_attributes.empty? -%>
+ <%= model_index == 1 ? ')' : '),' %>
+<% end -%>
+<% end -%>
+ ]
+ end
+
+ it "renders a list of <%= table_name %>" do
+ render
+<% for attribute in output_attributes -%>
+ response.should have_tag("tr>td", <%= attribute.default_value %>.to_s, 2)
+<% end -%>
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+<% output_attributes = attributes.reject{|attribute| [:datetime, :timestamp, :time, :date].index(attribute.type) } -%>
+describe "/<%= table_name %>/new.<%= default_file_extension %>" do
+ include <%= controller_class_name %>Helper
+
+ before(:each) do
+ assigns[:<%= file_name %>] = stub_model(<%= class_name %>,
+ :new_record? => true<%= output_attributes.empty? ? '' : ',' %>
+<% output_attributes.each_with_index do |attribute, attribute_index| -%>
+ :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == output_attributes.length - 1 ? '' : ','%>
+<% end -%>
+ )
+ end
+
+ it "renders new <%= file_name %> form" do
+ render
+
+ response.should have_tag("form[action=?][method=post]", <%= table_name %>_path) do
+<% for attribute in output_attributes -%>
+ with_tag("<%= attribute.input_type -%>#<%= file_name %>_<%= attribute.name %>[name=?]", "<%= file_name %>[<%= attribute.name %>]")
+<% end -%>
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe <%= controller_class_name %>Controller do
+ describe "routing" do
+ it "recognizes and generates #index" do
+ { :get => "/<%= table_name %>" }.should route_to(:controller => "<%= table_name %>", :action => "index")
+ end
+
+ it "recognizes and generates #new" do
+ { :get => "/<%= table_name %>/new" }.should route_to(:controller => "<%= table_name %>", :action => "new")
+ end
+
+ it "recognizes and generates #show" do
+ { :get => "/<%= table_name %>/1" }.should route_to(:controller => "<%= table_name %>", :action => "show", :id => "1")
+ end
+
+ it "recognizes and generates #edit" do
+ { :get => "/<%= table_name %>/1/edit" }.should route_to(:controller => "<%= table_name %>", :action => "edit", :id => "1")
+ end
+
+ it "recognizes and generates #create" do
+ { :post => "/<%= table_name %>" }.should route_to(:controller => "<%= table_name %>", :action => "create")
+ end
+
+ it "recognizes and generates #update" do
+ { :put => "/<%= table_name %>/1" }.should route_to(:controller => "<%= table_name %>", :action => "update", :id => "1")
+ end
+
+ it "recognizes and generates #destroy" do
+ { :delete => "/<%= table_name %>/1" }.should route_to(:controller => "<%= table_name %>", :action => "destroy", :id => "1")
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+<% output_attributes = attributes.reject{|attribute| [:datetime, :timestamp, :time, :date].index(attribute.type) } -%>
+describe "/<%= table_name %>/show.<%= default_file_extension %>" do
+ include <%= controller_class_name %>Helper
+ before(:each) do
+ assigns[:<%= file_name %>] = @<%= file_name %> = stub_model(<%= class_name %><%= output_attributes.empty? ? ')' : ',' %>
+<% output_attributes.each_with_index do |attribute, attribute_index| -%>
+ :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == output_attributes.length - 1 ? '' : ','%>
+<% end -%>
+<% if !output_attributes.empty? -%>
+ )
+<% end -%>
+ end
+
+ it "renders attributes in <p>" do
+ render
+<% for attribute in output_attributes -%>
+ response.should have_text(/<%= Regexp.escape(attribute.default_value).gsub(/^"|"$/, '')%>/)
+<% end -%>
+ end
+end
--- /dev/null
+# Placeholder to satisfy Rails.
+#
+# Do NOT add any require statements to this file. Doing
+# so will cause Rails to load this plugin all of the time.
+#
+# Running 'ruby script/generate rspec' will
+# generate spec/spec_helper.rb, which includes the necessary
+# require statements and configuration. This file should
+# be required by all of your spec files.
\ No newline at end of file
--- /dev/null
+Autotest.add_discovery do
+ style = []
+ style << "rails" if File.exist? 'config/environment.rb'
+ style
+end
\ No newline at end of file
--- /dev/null
+# (c) Copyright 2006 Nick Sieger <nicksieger@gmail.com>
+#
+# 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.
+
+$:.push(*Dir["vendor/rails/*/lib"])
+
+require 'active_support'
+require 'autotest/rspec'
+
+Autotest.add_hook :initialize do |at|
+ %w{config/ coverage/ db/ doc/ log/ public/ script/ tmp/ vendor/rails vendor/plugins previous_failures.txt}.each do |exception|
+ at.add_exception(exception)
+ end
+
+ at.clear_mappings
+
+ at.add_mapping(%r%^(test|spec)/fixtures/(.*).yml$%) { |_, m|
+ ["spec/models/#{m[2].singularize}_spec.rb"] + at.files_matching(%r%^spec\/views\/#{m[2]}/.*_spec\.rb$%)
+ }
+ at.add_mapping(%r%^spec/(models|controllers|routing|views|helpers|lib)/.*rb$%) { |filename, _|
+ filename
+ }
+ at.add_mapping(%r%^app/models/(.*)\.rb$%) { |_, m|
+ ["spec/models/#{m[1]}_spec.rb"]
+ }
+ at.add_mapping(%r%^app/views/(.*)$%) { |_, m|
+ at.files_matching %r%^spec/views/#{m[1]}_spec.rb$%
+ }
+ at.add_mapping(%r%^app/controllers/(.*)\.rb$%) { |_, m|
+ if m[1] == "application"
+ at.files_matching %r%^spec/controllers/.*_spec\.rb$%
+ else
+ ["spec/controllers/#{m[1]}_spec.rb"]
+ end
+ }
+ at.add_mapping(%r%^app/helpers/(.*)_helper\.rb$%) { |_, m|
+ if m[1] == "application" then
+ at.files_matching(%r%^spec/(views|helpers)/.*_spec\.rb$%)
+ else
+ ["spec/helpers/#{m[1]}_helper_spec.rb"] + at.files_matching(%r%^spec\/views\/#{m[1]}/.*_spec\.rb$%)
+ end
+ }
+ at.add_mapping(%r%^config/routes\.rb$%) {
+ at.files_matching %r%^spec/(controllers|routing|views|helpers)/.*_spec\.rb$%
+ }
+ at.add_mapping(%r%^config/database\.yml$%) { |_, m|
+ at.files_matching %r%^spec/models/.*_spec\.rb$%
+ }
+ at.add_mapping(%r%^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$%) {
+ at.files_matching %r%^spec/(models|controllers|routing|views|helpers)/.*_spec\.rb$%
+ }
+ at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+ ["spec/lib/#{m[1]}_spec.rb"]
+ }
+end
+
+class Autotest::RailsRspec < Autotest::Rspec
+end
--- /dev/null
+begin
+ require_dependency 'application_controller'
+rescue MissingSourceFile
+ require_dependency 'application'
+end
+require 'rack/utils'
+
+require 'action_controller/test_process'
+require 'action_controller/integration'
+require 'active_support/test_case'
+require 'active_record/fixtures' if defined?(ActiveRecord::Base)
+
+require 'spec/test/unit'
+
+require 'spec/rails/matchers'
+require 'spec/rails/mocks'
+require 'spec/rails/example'
+require 'spec/rails/extensions'
+require 'spec/rails/interop/testcase'
+
+Spec::Example::ExampleGroupFactory.default(ActiveSupport::TestCase)
+
+if ActionView::Base.respond_to?(:cache_template_extensions)
+ ActionView::Base.cache_template_extensions = false
+end
+
--- /dev/null
+dir = File.dirname(__FILE__)
+
+require 'spec/rails/example/routing_helpers'
+require 'spec/rails/example/assigns_hash_proxy'
+require "spec/rails/example/render_observer"
+require "spec/rails/example/model_example_group"
+require "spec/rails/example/functional_example_group"
+require "spec/rails/example/controller_example_group"
+require "spec/rails/example/helper_example_group"
+require "spec/rails/example/view_example_group"
+require "spec/rails/example/routing_example_group"
+require "spec/rails/example/integration_example_group"
+require "spec/rails/example/cookies_proxy"
+
+module Spec
+ module Rails
+ # Spec::Rails::Example extends Spec::Example (RSpec's core Example module) to provide
+ # Rails-specific contexts for describing Rails Models, Views, Controllers and Helpers.
+ #
+ # == Model Examples
+ #
+ # These are the equivalent of unit tests in Rails' built in testing. Ironically (for the traditional TDD'er) these are the only specs that we feel should actually interact with the database.
+ #
+ # See Spec::Rails::Example::ModelExampleGroup
+ #
+ # == Controller Examples
+ #
+ # These align somewhat with functional tests in rails, except that they do not actually render views (though you can force rendering of views if you prefer). Instead of setting expectations about what goes on a page, you set expectations about what templates get rendered.
+ #
+ # See Spec::Rails::Example::ControllerExampleGroup
+ #
+ # == View Examples
+ #
+ # This is the other half of Rails functional testing. View specs allow you to set up assigns and render
+ # a template. By assigning mock model data, you can specify view behaviour with no dependency on a database
+ # or your real models.
+ #
+ # See Spec::Rails::Example::ViewExampleGroup
+ #
+ # == Helper Examples
+ #
+ # These let you specify directly methods that live in your helpers.
+ #
+ # See Spec::Rails::Example::HelperExampleGroup
+ module Example
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+ class AssignsHashProxy #:nodoc:
+ def initialize(example_group, &block)
+ @target = block.call
+ @example_group = example_group
+ end
+
+ def [](key)
+ return false if false == assigns[key] || false == assigns[key.to_s]
+ assigns[key] || assigns[key.to_s] || @target.instance_variable_get("@#{key}")
+ end
+
+ def []=(key, val)
+ @target.instance_variable_set("@#{key}", val)
+ end
+
+ def delete(key)
+ assigns.delete(key.to_s)
+ @target.instance_variable_set("@#{key}", nil)
+ end
+
+ def each(&block)
+ assigns.each &block
+ end
+
+ def has_key?(key)
+ assigns.key?(key.to_s)
+ end
+
+ protected
+ def assigns
+ @example_group.orig_assigns
+ end
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+ # Controller Examples live in $RAILS_ROOT/spec/controllers/.
+ #
+ # Controller Examples use Spec::Rails::Example::ControllerExampleGroup,
+ # which supports running specs for Controllers in two modes, which
+ # represent the tension between the more granular testing common in TDD
+ # and the more high level testing built into rails. BDD sits somewhere
+ # in between: we want to a balance between specs that are close enough
+ # to the code to enable quick fault isolation and far enough away from
+ # the code to enable refactoring with minimal changes to the existing
+ # specs.
+ #
+ # == Isolation mode (default)
+ #
+ # No dependencies on views because none are ever rendered. The benefit
+ # of this mode is that can spec the controller completely independent of
+ # the view, allowing that responsibility to be handled later, or by
+ # somebody else. Combined w/ separate view specs, this also provides
+ # better fault isolation.
+ #
+ # == Integration mode
+ #
+ # To run in this mode, include the +integrate_views+ declaration
+ # in your controller context:
+ #
+ # describe ThingController do
+ # integrate_views
+ # ...
+ #
+ # In this mode, controller specs are run in the same way that rails
+ # functional tests run - one set of tests for both the controllers and
+ # the views. The benefit of this approach is that you get wider coverage
+ # from each spec. Experienced rails developers may find this an easier
+ # approach to begin with, however we encourage you to explore using the
+ # isolation mode and revel in its benefits.
+ #
+ # == Expecting Errors
+ #
+ # Rspec on Rails will raise errors that occur in controller actions and
+ # are not rescued or handeled with rescue_from.
+ #
+ class ControllerExampleGroup < FunctionalExampleGroup
+ class << self
+
+ # Use integrate_views to instruct RSpec to render views in
+ # your controller examples in Integration mode.
+ #
+ # describe ThingController do
+ # integrate_views
+ # ...
+ #
+ # See Spec::Rails::Example::ControllerExampleGroup for more
+ # information about Integration and Isolation modes.
+ def integrate_views(integrate_views = true)
+ @integrate_views = integrate_views
+ end
+
+ def integrate_views? # :nodoc:
+ @integrate_views
+ end
+
+ def inherited(klass) # :nodoc:
+ klass.integrate_views(integrate_views?)
+ klass.subject { controller }
+ super
+ end
+
+ def set_description(*args) # :nodoc:
+ super
+ if described_class && described_class.ancestors.include?(ActionController::Base)
+ controller_klass = if superclass.controller_class.ancestors.include?(ActionController::Base)
+ superclass.controller_class
+ else
+ described_class
+ end
+ tests controller_klass
+ end
+ end
+
+ # When you don't pass a controller to describe, like this:
+ #
+ # describe ThingsController do
+ #
+ # ... then you must provide a controller_name within the context of
+ # your controller specs:
+ #
+ # describe "ThingController" do
+ # controller_name :thing
+ # ...
+ def controller_name(name)
+ tests "#{name}_controller".camelize.constantize
+ end
+ end
+
+ before(:each) do
+ # Some Rails apps explicitly disable ActionMailer in environment.rb
+ if defined?(ActionMailer)
+ @deliveries = []
+ ActionMailer::Base.deliveries = @deliveries
+ end
+
+ unless @controller.class.ancestors.include?(ActionController::Base)
+ Spec::Expectations.fail_with <<-MESSAGE
+Controller specs need to know what controller is being specified. You can
+indicate this by passing the controller to describe():
+
+ describe MyController do
+
+or by declaring the controller's name
+
+ describe "a MyController" do
+ controller_name :my #invokes the MyController
+end
+MESSAGE
+ end
+ @controller.extend ControllerInstanceMethods
+ @controller.integrate_views! if integrate_views?
+ @controller.session = session
+ end
+
+ attr_reader :response, :request, :controller
+
+ def integrate_views?
+ @integrate_views || self.class.integrate_views?
+ end
+
+ # Bypasses any error rescues defined with rescue_from. Useful
+ # in cases in which you want to specify errors coming out of
+ # actions that might be caught by a rescue_from clause that is
+ # specified separately.
+ #
+ # Note that this will override the effect of rescue_action_in_public
+ def bypass_rescue
+ if ::Rails::VERSION::STRING >= '2.2'
+ def controller.rescue_action(exception)
+ raise exception
+ end
+ else
+ def controller.rescue_action_with_handler(exception)
+ raise exception
+ end
+ end
+ end
+
+ protected
+
+ def _assigns_hash_proxy
+ @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {@response.template}
+ end
+
+ private
+
+ module TemplateIsolationExtensions
+ def file_exists?(ignore); true; end
+
+ def render_file(*args)
+ @first_render ||= args[0] unless args[0] =~ /^layouts/
+ end
+
+ # Rails 2.2
+ def _pick_template(*args)
+ @_first_render ||= args[0] unless args[0] =~ /^layouts/
+ PickedTemplate.new
+ end
+
+ def __action_exists?(params)
+ controller.respond_to? params[:action]
+ end
+
+ def __template_exists?(args)
+ self.view_paths.respond_to?(:find_template) ?
+ self.view_paths.find_template(args[0][:file], template_format) :
+ false
+ end
+
+ def render(*args)
+ if ::Rails::VERSION::STRING >= "2.1"
+ return super unless __action_exists?(params) || __template_exists?(args)
+ end
+ if file = args.last[:file].instance_eval{@template_path}
+ record_render :file => file
+ elsif args.last[:inline]
+ super
+ elsif @_rendered
+ record_render(args[0])
+ else
+ super
+ end
+ end
+
+ private
+
+ def record_render(opts)
+ return unless @_rendered
+ @_rendered[:template] ||= opts[:file] if opts[:file]
+ @_rendered[:partials][opts[:partial]] += 1 if opts[:partial]
+ end
+
+ # Returned by _pick_template when running controller examples in isolation mode.
+ class PickedTemplate
+ # Do nothing when running controller examples in isolation mode.
+ def render_template(*ignore_args); end
+ # Do nothing when running controller examples in isolation mode.
+ def render_partial(*ignore_args); end
+ end
+ end
+
+ module ControllerInstanceMethods # :nodoc:
+ include Spec::Rails::Example::RenderObserver
+
+ # === render(options = nil, extra_options={}, &block)
+ #
+ # This gets added to the controller's singleton meta class,
+ # allowing Controller Examples to run in two modes, freely switching
+ # from example group to example group.
+ def render(options=nil, extra_options={}, &block)
+ unless block_given?
+ unless integrate_views?
+ @template.extend TemplateIsolationExtensions
+ end
+ end
+
+ if matching_message_expectation_exists(options)
+ render_proxy.render(options, &block)
+ @performed_render = true
+ else
+ if matching_stub_exists(options)
+ @performed_render = true
+ else
+ if ::Rails::VERSION::STRING > '2.1'
+ super(options, extra_options, &block)
+ else
+ super(options, &block)
+ end
+ end
+ end
+ end
+
+ # Rails 2.3
+ def default_template(action_name = self.action_name)
+ if integrate_views?
+ super
+ else
+ begin
+ super
+ rescue ActionView::MissingTemplate
+ "#{self.class.name.sub(/Controller$/,'').underscore}/#{action_name}"
+ end
+ end
+ end
+
+ def response(&block)
+ # NOTE - we're setting @update for the assert_select_spec - kinda weird, huh?
+ @update = block
+ super
+ end
+
+ def integrate_views!
+ @integrate_views = true
+ end
+
+ private
+
+ def integrate_views?
+ @integrate_views
+ end
+
+ def matching_message_expectation_exists(options)
+ render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options)
+ end
+
+ def matching_stub_exists(options)
+ render_proxy.__send__(:__mock_proxy).__send__(:find_matching_method_stub, :render, options)
+ end
+
+ end
+
+ Spec::Example::ExampleGroupFactory.register(:controller, self)
+
+ end
+ end
+ end
+end
--- /dev/null
+require 'action_controller/cookies'
+
+module Spec
+ module Rails
+ module Example
+ class CookiesProxy
+ def initialize(example)
+ @example = example
+ end
+
+ def[]=(name, value)
+ if ::Rails::VERSION::STRING >= '2.3'
+ @example.request.cookies[name.to_s] = value
+ else
+ @example.request.cookies[name.to_s] = CGI::Cookie.new(name.to_s, value)
+ end
+ end
+
+ def [](name)
+ @example.response.cookies[name.to_s]
+ end
+
+ def delete(name)
+ @example.response.cookies.delete(name.to_s)
+ end
+ end
+ end
+ end
+end
--- /dev/null
+require 'action_controller/test_case'
+
+module Spec
+ module Rails
+ module Example
+ class FunctionalExampleGroup < ActionController::TestCase
+ def setup
+ # no-op to override AC::TC's setup w/ conflicts with the before(:each) below
+ end
+
+ attr_reader :request, :response
+
+ # The params hash accessed within a view or helper. Use this before
+ # rendering a view or calling a helper to provide data used by the
+ # view or helper.
+ #
+ # == Examples
+ # # in a view spec
+ # params[:name] = "David"
+ # render
+ # response.should have_tag("div.name","David")
+ #
+ # # in a helper spec
+ # params[:first_name] = "David"
+ # params[:last_name] = "Chelimsky"
+ # helper.full_name.should == "David Chelimsky"
+ def params
+ request.parameters
+ end
+
+ # Provides access to the flash hash. Use this after rendering a
+ # view, calling a helper or calling a controller action.
+ #
+ # == Examples
+ # post :create
+ # flash[:notice].should == "Success!"
+ def flash
+ @controller.__send__ :flash
+ end
+
+ # Provides access to the session hash. Use this before or after
+ # rendering a view, calling a helper or calling a controller action.
+ def session
+ request.session
+ end
+
+ # Overrides the <tt>cookies()</tt> method in
+ # ActionController::TestResponseBehaviour, returning a proxy that
+ # accesses the requests cookies when setting a cookie and the
+ # responses cookies when reading one. This allows you to set and read
+ # cookies in examples using the same API with which you set and read
+ # them in controllers.
+ #
+ # == Examples (Rails 2.0 > 2.2)
+ #
+ # cookies[:user_id] = {:value => '1234', :expires => 1.minute.ago}
+ # get :index
+ # response.should be_redirect
+ #
+ # == Examples (Rails 2.3)
+ #
+ # Rails 2.3 changes the way cookies are made available to functional
+ # tests (and therefore rspec controller specs), only making single
+ # values available with no access to other aspects of the cookie. This
+ # is backwards-incompatible, so you have to change your examples to
+ # look like this:
+ #
+ # cookies[:foo] = 'bar'
+ # get :index
+ # cookies[:foo].should == 'bar'
+ def cookies
+ @cookies ||= Spec::Rails::Example::CookiesProxy.new(self)
+ end
+
+ alias_method :orig_assigns, :assigns
+
+ # :call-seq:
+ # assigns()
+ #
+ # Hash of instance variables to values that are made available to
+ # views. == Examples
+ #
+ # #in thing_controller.rb
+ # def new
+ # @thing = Thing.new
+ # end
+ #
+ # #in thing_controller_spec
+ # get 'new'
+ # assigns[:registration].should == Thing.new
+ #--
+ # NOTE - Even though docs only use assigns[:key] format, this supports
+ # assigns(:key) for backwards compatibility.
+ #++
+ def assigns(key = nil)
+ if key.nil?
+ _assigns_hash_proxy
+ else
+ _assigns_hash_proxy[key]
+ end
+ end
+
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+ class HelperExampleGroupController < ApplicationController #:nodoc:
+ attr_accessor :request, :url
+ end
+
+ # Helper Specs live in $RAILS_ROOT/spec/helpers/.
+ #
+ # Helper Specs use Spec::Rails::Example::HelperExampleGroup, which allows you to
+ # include your Helper directly in the context and write specs directly
+ # against its methods.
+ #
+ # HelperExampleGroup also includes the standard lot of ActionView::Helpers in case your
+ # helpers rely on any of those.
+ #
+ # == Example
+ #
+ # module ThingHelper
+ # def number_of_things
+ # Thing.count
+ # end
+ # end
+ #
+ # describe "ThingHelper example_group" do
+ # include ThingHelper
+ # it "should tell you the number of things" do
+ # Thing.should_receive(:count).and_return(37)
+ # number_of_things.should == 37
+ # end
+ # end
+ class HelperExampleGroup < FunctionalExampleGroup
+ tests HelperExampleGroupController
+ attr_accessor :output_buffer
+
+ class HelperObject < ActionView::Base
+ def initialize(*args)
+ @template = self
+ super
+ end
+ def protect_against_forgery?
+ false
+ end
+
+ attr_writer :session, :request, :flash, :params, :controller
+
+ private
+ attr_reader :session, :request, :flash, :params, :controller
+ end
+
+ class << self
+ # The helper name....
+ def helper_name(name=nil)
+ @helper_being_described = "#{name}_helper".camelize.constantize
+ send :include, @helper_being_described
+ end
+
+ def helper
+ @helper_object ||= returning HelperObject.new do |helper_object|
+ if @helper_being_described.nil?
+ if described_type.class == Module
+ helper_object.extend described_type
+ end
+ else
+ helper_object.extend @helper_being_described
+ end
+ end
+ end
+ end
+
+ # Returns an instance of ActionView::Base with the helper being spec'd
+ # included.
+ #
+ # == Example
+ #
+ # describe PersonHelper do
+ # it "should write a link to person with the name" do
+ # assigns[:person] = mock_model(Person, :full_name => "Full Name", :id => 37, :new_record? => false)
+ # helper.link_to_person.should == %{<a href="/people/37">Full Name</a>}
+ # end
+ # end
+ #
+ # module PersonHelper
+ # def link_to_person
+ # link_to person.full_name, url_for(person)
+ # end
+ # end
+ #
+ def helper
+ self.class.helper
+ end
+
+ def orig_assigns
+ helper.assigns
+ end
+
+ # Reverse the load order so that custom helpers which are defined last
+ # are also loaded last.
+ ActionView::Base.included_modules.reverse.each do |mod|
+ include mod if mod.parents.include?(ActionView::Helpers)
+ end
+
+ before(:each) do
+ @controller.request = @request
+ @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
+
+ @flash = ActionController::Flash::FlashHash.new
+ session['flash'] = @flash
+
+ @output_buffer = ""
+ @template = helper
+ ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+
+ helper.session = session
+ helper.request = @request
+ helper.flash = flash
+ helper.params = params
+ helper.controller = @controller
+ end
+
+ def flash
+ @flash
+ end
+
+ def eval_erb(text)
+ erb_args = [text]
+ if helper.respond_to?(:output_buffer)
+ erb_args += [nil, nil, '@output_buffer']
+ end
+
+ helper.instance_eval do
+ ERB.new(*erb_args).result(binding)
+ end
+ end
+
+ # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
+ # When that is done, remove this method
+ def protect_against_forgery?
+ false
+ end
+
+ Spec::Example::ExampleGroupFactory.register(:helper, self)
+
+ protected
+
+ def _assigns_hash_proxy
+ @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {helper}
+ end
+
+ end
+ end
+ end
+end
--- /dev/null
+class ActionController::IntegrationTest
+ alias_method :orig_initialize, :initialize
+ def initialize(*args)
+ super
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ class IntegrationExampleGroup < ActionController::IntegrationTest
+ Spec::Example::ExampleGroupFactory.register(:integration, self)
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+ # Model examples live in $RAILS_ROOT/spec/models/.
+ #
+ # Model examples use Spec::Rails::Example::ModelExampleGroup, which
+ # provides support for fixtures and some custom expectations via extensions
+ # to ActiveRecord::Base.
+ base = defined?(ActiveRecord::TestCase) ? ActiveRecord::TestCase : ActiveSupport::TestCase
+ class ModelExampleGroup < base
+ Spec::Example::ExampleGroupFactory.register(:model, self)
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec/mocks/framework'
+
+module Spec
+ module Rails
+ module Example
+ # Extends the #should_receive, #should_not_receive and #stub! methods in rspec's
+ # mocking framework to handle #render calls to controller in controller examples
+ # and template and view examples
+ module RenderObserver
+
+ def verify_rendered # :nodoc:
+ render_proxy.rspec_verify
+ end
+
+ def unregister_verify_after_each #:nodoc:
+ proc = verify_rendered_proc
+ Spec::Example::ExampleGroup.remove_after(:each, &proc)
+ end
+
+ def should_receive(*args)
+ if args[0] == :render
+ register_verify_after_each
+ render_proxy.should_receive(:render, :expected_from => caller(1)[0])
+ else
+ super
+ end
+ end
+
+ def should_not_receive(*args)
+ if args[0] == :render
+ register_verify_after_each
+ render_proxy.should_not_receive(:render)
+ else
+ super
+ end
+ end
+
+ def stub(*args)
+ if args[0] == :render
+ register_verify_after_each
+ render_proxy.stub(args.first, :expected_from => caller(1)[0])
+ else
+ super
+ end
+ end
+
+ # FIXME - for some reason, neither alias nor alias_method are working
+ # as expected in the else branch, so this is a duplicate of stub()
+ # above. Could delegate, but then we'd run into craziness handling
+ # :expected_from. This will have to do for the moment.
+ def stub!(*args)
+ if args[0] == :render
+ register_verify_after_each
+ render_proxy.stub!(args.first, :expected_from => caller(1)[0])
+ else
+ super
+ end
+ end
+
+ def verify_rendered_proc #:nodoc:
+ template = self
+ @verify_rendered_proc ||= Proc.new do
+ template.verify_rendered
+ template.unregister_verify_after_each
+ end
+ end
+
+ def register_verify_after_each #:nodoc:
+ proc = verify_rendered_proc
+ Spec::Example::ExampleGroup.after(:each, &proc)
+ end
+
+ def render_proxy #:nodoc:
+ @render_proxy ||= Spec::Mocks::Mock.new("render_proxy")
+ end
+
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+
+ class RoutingExampleGroup < ActionController::TestCase
+ tests Class.new(ActionController::Base)
+
+ Spec::Example::ExampleGroupFactory.register(:routing, self)
+ end
+
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'rack/utils'
+
+module Spec
+ module Rails
+ module Example
+ module RoutingHelpers
+
+ class RouteFor
+ def initialize(example, options)
+ @example, @options = example, options
+ end
+
+ def ==(expected)
+ if Hash === expected
+ path, querystring = expected[:path].split('?')
+ path_string = path
+ path = expected.merge(:path => path)
+ else
+ path, querystring = expected.split('?')
+ path_string = path
+ path = { :path => path, :method => :get }
+ end
+ params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+ begin
+ @example.assert_routing(path, @options, {}, params)
+ true
+ rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError => e
+ raise e.class, "#{e}\nIf you're expecting this failure, we suggest {:#{path[:method]}=>\"#{path[:path]}\"}.should_not be_routable"
+ end
+ end
+ end
+ # Uses ActionController::Routing::Routes to generate
+ # the correct route for a given set of options.
+ # == Examples
+ # route_for(:controller => 'registrations', :action => 'edit', :id => '1')
+ # => '/registrations/1/edit'
+ # route_for(:controller => 'registrations', :action => 'create')
+ # => {:path => "/registrations", :method => :post}
+ def route_for(options)
+ RouteFor.new(self, options)
+ end
+
+ # Uses ActionController::Routing::Routes to parse
+ # an incoming path so the parameters it generates can be checked
+ #
+ # Note that this method is obsoleted by the route_to matcher.
+ # == Example
+ # params_from(:get, '/registrations/1/edit')
+ # => :controller => 'registrations', :action => 'edit', :id => '1'
+ def params_from(method, path)
+ ensure_that_routes_are_loaded
+ path, querystring = path.split('?')
+ params = ActionController::Routing::Routes.recognize_path(path, :method => method)
+ querystring.blank? ? params : params.merge(Rack::Utils.parse_query(querystring).symbolize_keys!)
+ end
+
+ private
+
+ def ensure_that_routes_are_loaded
+ ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+ end
+
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Example
+ class ViewExampleGroupController < ApplicationController #:nodoc:
+ include Spec::Rails::Example::RenderObserver
+ attr_reader :template
+
+ def add_helper_for(template_path)
+ add_helper(template_path.split('/')[0])
+ end
+
+ def add_helper(name)
+ begin
+ helper_module = "#{name}_helper".camelize.constantize
+ rescue
+ return
+ end
+ (class << template; self; end).class_eval do
+ include helper_module
+ end
+ end
+
+ def forget_variables_added_to_assigns
+ end
+ end
+
+ # View Examples live in $RAILS_ROOT/spec/views/.
+ #
+ # View Specs use Spec::Rails::Example::ViewExampleGroup,
+ # which provides access to views without invoking any of your controllers.
+ # See Spec::Rails::Expectations::Matchers for information about specific
+ # expectations that you can set on views.
+ #
+ # == Example
+ #
+ # describe "login/login" do
+ # before do
+ # render 'login/login'
+ # end
+ #
+ # it "should display login form" do
+ # response.should have_tag("form[action=/login]") do
+ # with_tag("input[type=text][name=email]")
+ # with_tag("input[type=password][name=password]")
+ # with_tag("input[type=submit][value=Login]")
+ # end
+ # end
+ # end
+ class ViewExampleGroup < FunctionalExampleGroup
+ if ActionView::Base.respond_to?(:load_helpers) # Rails 2.0.x
+ ActionView::Helpers.constants.each do |name|
+ const = ActionView::Helpers.const_get(name)
+ include const if name.include?("Helper") && Module === const
+ end
+ elsif ActionView::Base.respond_to?(:helper_modules) # Rails 2.1.x
+ ActionView::Base.helper_modules.each do |helper_module|
+ include helper_module
+ end
+ else # Rails 2.2.x
+ include ActionView::Helpers
+ end
+
+ tests ViewExampleGroupController
+ class << self
+ def inherited(klass) # :nodoc:
+ klass.subject { template }
+ super
+ end
+ end
+
+ before {ensure_that_flash_and_session_work_properly}
+ after {ensure_that_base_view_path_is_not_set_across_example_groups}
+
+ def ensure_that_flash_and_session_work_properly #:nodoc:
+ @controller.class.__send__ :public, :flash
+ @controller.__send__ :initialize_template_class, @response
+ @controller.__send__ :assign_shortcuts, @request, @response
+ @controller.__send__ :initialize_current_url
+ @session = @controller.session
+ end
+
+ def ensure_that_base_view_path_is_not_set_across_example_groups #:nodoc:
+ ActionView::Base.base_view_path = nil
+ end
+
+ def set_base_view_path(options) #:nodoc:
+ ActionView::Base.base_view_path = base_view_path(options)
+ end
+
+ def base_view_path(options) #:nodoc:
+ "/#{derived_controller_name(options)}/"
+ end
+
+ def derived_controller_name(options) #:nodoc:
+ parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+ "#{parts[0..-2].join('/')}"
+ end
+
+ def derived_action_name(options) #:nodoc:
+ parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+ "#{parts.last}".split('.').first
+ end
+
+ def subject_of_render(options) #:nodoc:
+ [:template, :partial, :file].each do |render_type|
+ if options.has_key?(render_type)
+ return options[render_type]
+ end
+ end
+ return ""
+ end
+
+ def add_helpers(options) #:nodoc:
+ @controller.add_helper("application")
+ @controller.add_helper(derived_controller_name(options))
+ @controller.add_helper(options[:helper]) if options[:helper]
+ options[:helpers].each { |helper| @controller.add_helper(helper) } if options[:helpers]
+ end
+
+ # Renders a template for a View Spec, which then provides access to the result
+ # through the +response+. Also supports render with :inline, which you can
+ # use to spec custom form builders, helpers, etc, in the context of a view.
+ #
+ # == Examples
+ #
+ # render('/people/list')
+ # render('/people/list', :helper => MyHelper)
+ # render('/people/list', :helpers => [MyHelper, MyOtherHelper])
+ # render(:partial => '/people/_address')
+ # render(:inline => "<% custom_helper 'argument', 'another argument' %>")
+ #
+ # See Spec::Rails::Example::ViewExampleGroup for more information.
+ def render(*args)
+ options = Hash === args.last ? args.pop : {}
+
+ if args.empty?
+ unless [:partial, :inline, :file, :template, :xml, :json, :update].any? {|k| options.has_key? k}
+ args << self.class.description_parts.first
+ end
+ end
+
+ options[:template] = args.first.to_s.sub(/^\//,'') unless args.empty?
+
+ set_base_view_path(options)
+ add_helpers(options)
+
+ assigns[:action_name] = @action_name
+
+ @request.path_parameters = @request.path_parameters.merge(
+ :controller => derived_controller_name(options),
+ :action => derived_action_name(options)
+ ).merge(options[:path_parameters] || {})
+
+ defaults = { :layout => false }
+ options = defaults.merge options
+
+ @controller.__send__(:params).reverse_merge! @request.parameters
+
+ @controller.class.instance_eval %{
+ def controller_path
+ "#{derived_controller_name(options)}"
+ end
+
+ def controller_name
+ "#{derived_controller_name(options).split('/').last}"
+ end
+ }
+
+ @controller.__send__ :forget_variables_added_to_assigns
+ @controller.__send__ :render, options
+ @controller.__send__ :process_cleanup
+ end
+
+ # This provides the template. Use this to set mock
+ # expectations for dealing with partials
+ #
+ # == Example
+ #
+ # describe "/person/new" do
+ # it "should use the form partial" do
+ # template.should_receive(:render).with(:partial => 'form')
+ # render "/person/new"
+ # end
+ # end
+ def template
+ @controller.template
+ end
+
+ Spec::Example::ExampleGroupFactory.register(:view, self)
+
+ protected
+ def _assigns_hash_proxy
+ @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {@response.template}
+ end
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'spec'
+
+require 'spec/rails/extensions/spec/runner/configuration'
+require 'spec/rails/extensions/spec/matchers/have'
+
+require 'spec/rails/extensions/active_support/test_case'
+require 'spec/rails/extensions/active_record/base'
+require 'spec/rails/extensions/action_controller/rescue'
+require 'spec/rails/extensions/action_controller/test_case'
+require 'spec/rails/extensions/action_controller/test_response'
+require 'spec/rails/extensions/action_view/base'
--- /dev/null
+module ActionController
+ module Rescue
+ def use_rails_error_handling!
+ Kernel.warn <<-WARNING
+DEPRECATION NOTICE: controller.use_rails_error_handling! is
+deprecated and will be removed from a future version of
+rspec-rails.
+
+Use rescue_action_in_public!, which is defined directly in
+rails' testing framework, instead.
+WARNING
+ if ::Rails::VERSION::STRING =~ /^2\.0/
+ @use_rails_error_handling = true
+ else
+ # anything but 0.0.0.0 - borrowed from rails own rescue_action_in_public!
+ request.remote_addr = '208.77.188.166'
+ end
+ end
+
+ def use_rails_error_handling?
+ @use_rails_error_handling ||= false
+ end
+
+ protected
+
+ if ::Rails::VERSION::STRING =~ /^2\.0/
+ def rescue_action_in_public?
+ request.respond_to?(:rescue_action_in_public?) and request.rescue_action_in_public?
+ end
+
+ def rescue_action_with_handler_with_fast_errors(exception)
+ if (use_rails_error_handling? || rescue_action_in_public?) & !handler_for_rescue(exception)
+ rescue_action_in_public(exception)
+ else
+ rescue_action_with_handler_without_fast_errors(exception)
+ end
+ end
+ alias_method_chain :rescue_action_with_handler, :fast_errors
+ end
+
+ end
+end
--- /dev/null
+module ActionController
+ class TestCase
+ include ::Spec::Rails::Example::RoutingHelpers
+
+ if ::Rails::VERSION::STRING =~ /2\.0/
+ # Introduced in Rails 2.1, but we need it for 2.0
+ def rescue_action_in_public!
+ # See rescue.rb in this same directory
+ def request.rescue_action_in_public?
+ true
+ end
+ end
+
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+module ActionController #:nodoc:
+ class TestResponse #:nodoc:
+ attr_writer :controller_path
+
+ def capture(name)
+ template.instance_variable_get "@content_for_#{name.to_s}"
+ end
+
+ if ::Rails::VERSION::STRING < "2.3"
+ def [](name)
+ Kernel.warn <<-WARNING
+DEPRECATION NOTICE: [](name) as an alias for capture(name) (TestResponse
+extension in rspec-rails) is deprecated and will not be defined by rspec-rails
+when working with rails >= 2.3.0. It will also be removed entirely from
+a future version of rspec-rails.
+WARNING
+ capture(name)
+ end
+ end
+ end
+end
--- /dev/null
+module ActionView #:nodoc:
+ class Base #:nodoc:
+ include Spec::Rails::Example::RenderObserver
+ cattr_accessor :base_view_path
+
+ def render_partial_with_base_view_path_handling(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+ if partial_path.is_a?(String)
+ unless partial_path.include?("/")
+ unless self.class.base_view_path.nil?
+ partial_path = "#{self.class.base_view_path}/#{partial_path}"
+ end
+ end
+ end
+ begin
+ render_partial_without_base_view_path_handling(partial_path, local_assigns, deprecated_local_assigns)
+ rescue ArgumentError # edge rails > 2.1 changed render_partial to accept only one arg
+ render_partial_without_base_view_path_handling(partial_path)
+ end
+ end
+ alias_method_chain :render_partial, :base_view_path_handling
+
+ def render_with_mock_proxy(options = {}, old_local_assigns = {}, &block)
+ if render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options)
+ render_proxy.render(options)
+ else
+ unless render_proxy.__send__(:__mock_proxy).__send__(:find_matching_method_stub, :render, options)
+ render_without_mock_proxy(options, old_local_assigns, &block)
+ end
+ end
+ end
+ alias_method_chain :render, :mock_proxy
+ end
+end
--- /dev/null
+if defined?(ActiveRecord::Base)
+ module Spec
+ module Rails
+ module Extensions
+ module ActiveRecord
+ module ClassMethods
+ # :call-seq:
+ # ModelClass.should have(:no).records
+ # ModelClass.should have(1).record
+ # ModelClass.should have(n).records
+ #
+ # Extension to enhance <tt>should have</tt> on AR Model classes
+ def records
+ find(:all)
+ end
+ alias :record :records
+ end
+
+ module InstanceMethods
+ # :call-seq:
+ # model.should have(:no).errors_on(:attribute)
+ # model.should have(1).error_on(:attribute)
+ # model.should have(n).errors_on(:attribute)
+ #
+ # Extension to enhance <tt>should have</tt> on AR Model instances.
+ # Calls model.valid? in order to prepare the object's errors
+ # object.
+ def errors_on(attribute)
+ self.valid?
+ [self.errors.on(attribute)].flatten.compact
+ end
+ alias :error_on :errors_on
+ end
+ end
+ end
+ end
+ end
+
+ module ActiveRecord #:nodoc:
+ class Base
+ extend Spec::Rails::Extensions::ActiveRecord::ClassMethods
+ include Spec::Rails::Extensions::ActiveRecord::InstanceMethods
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+module ActiveSupport
+ class TestCase
+ include ::Spec::Rails::Matchers
+ include ::Spec::Rails::Mocks
+ end
+end
+
--- /dev/null
+require 'spec/matchers/have'
+
+module Spec #:nodoc:
+ module Matchers #:nodoc:
+ class Have #:nodoc:
+
+ def failure_message_for_should_with_errors_on_extensions
+ return "expected #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}, got #{@actual}" if @collection_name == :errors_on
+ return "expected #{relativities[@relativity]}#{@expected} error on :#{@args[0]}, got #{@actual}" if @collection_name == :error_on
+ return failure_message_for_should_without_errors_on_extensions
+ end
+ alias_method_chain :failure_message_for_should, :errors_on_extensions
+
+ def description_with_errors_on_extensions
+ return "have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+ return "have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}" if @collection_name == :error_on
+ return description_without_errors_on_extensions
+ end
+ alias_method_chain :description, :errors_on_extensions
+
+ end
+ end
+end
--- /dev/null
+require 'spec/runner/configuration'
+require 'test_help'
+
+if defined?(ActiveRecord::Base)
+ module Spec
+ module Runner
+ class Configuration
+
+ def initialize
+ super
+ self.fixture_path = RAILS_ROOT + '/spec/fixtures'
+ end
+
+ def use_transactional_fixtures
+ ActiveSupport::TestCase.use_transactional_fixtures
+ end
+ def use_transactional_fixtures=(value)
+ ActiveSupport::TestCase.use_transactional_fixtures = value
+ end
+
+ def use_instantiated_fixtures
+ ActiveSupport::TestCase.use_instantiated_fixtures
+ end
+ def use_instantiated_fixtures=(value)
+ ActiveSupport::TestCase.use_instantiated_fixtures = value
+ end
+
+ def fixture_path
+ ActiveSupport::TestCase.fixture_path
+ end
+ def fixture_path=(path)
+ ActiveSupport::TestCase.fixture_path = path
+ end
+
+ def global_fixtures
+ ActiveSupport::TestCase.fixture_table_names
+ end
+ def global_fixtures=(fixtures)
+ ActiveSupport::TestCase.fixtures(*fixtures)
+ end
+ end
+ end
+ end
+end
--- /dev/null
+module Test
+ module Unit
+ class TestCase
+ # Edge rails (r8664) introduces class-wide setup & teardown callbacks for Test::Unit::TestCase.
+ # Make sure these still get run when running TestCases under rspec:
+ prepend_before(:each) do
+ run_callbacks :setup if respond_to?(:run_callbacks)
+ end
+ append_after(:each) do
+ run_callbacks :teardown if respond_to?(:run_callbacks)
+ end
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+dir = File.dirname(__FILE__)
+require 'spec/rails/matchers/ar_be_valid'
+require 'spec/rails/matchers/assert_select'
+require 'spec/rails/matchers/change'
+require 'spec/rails/matchers/have_text'
+require 'spec/rails/matchers/include_text'
+require 'spec/rails/matchers/redirect_to'
+require 'spec/rails/matchers/route_to'
+require 'spec/rails/matchers/render_template'
+
+module Spec
+ module Rails
+ # Spec::Rails::Expectations::Matchers provides several expectation matchers
+ # intended to work with Rails components like models and responses. For example:
+ #
+ # response.should redirect_to("some/url") #redirect_to(url) is the matcher.
+ #
+ # In addition to those you see below, the arbitrary predicate feature of RSpec
+ # makes the following available as well:
+ #
+ # response.should be_success #passes if response.success?
+ # response.should be_redirect #passes if response.redirect?
+ #
+ # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
+ # the documentation comes straight from that with some slight modifications.
+ # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
+ # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
+ #
+ # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
+ module Matchers
+ end
+ end
+end
--- /dev/null
+if defined?(ActiveRecord::Base)
+ module Spec::Rails::Matchers
+ # :call-seq:
+ # response.should be_valid
+ # response.should_not be_valid
+ def be_valid
+ ::Spec::Matchers::Matcher.new :be_valid do
+ match do |actual|
+ actual.valid?
+ end
+
+ failure_message_for_should do |actual|
+ if actual.respond_to?(:errors) && ActiveRecord::Errors === actual.errors
+ "Expected #{actual.inspect} to be valid, but it was not\nErrors: " + actual.errors.full_messages.join(", ")
+ else
+ "Expected #{actual.inspect} to be valid"
+ end
+ end
+ end
+ end
+
+ end
+end
--- /dev/null
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+ module Rails
+ module Matchers
+
+ class AssertSelect #:nodoc:
+ attr_reader :options
+
+ def initialize(selector_assertion, spec_scope, *args, &block)
+ @args, @options = args_and_options(args)
+ @spec_scope = spec_scope
+ @selector_assertion = selector_assertion
+ @block = block
+ end
+
+ def matches?(response_or_text, &block)
+ @block = block if block
+
+ if doc = doc_from(response_or_text)
+ @args.unshift(doc)
+ end
+
+ begin
+ @spec_scope.__send__(@selector_assertion, *@args, &@block)
+ true
+ rescue ::Test::Unit::AssertionFailedError => @error
+ false
+ end
+ end
+
+ def failure_message_for_should; @error.message; end
+ def failure_message_for_should_not; "should not #{description}, but did"; end
+
+ def description
+ {
+ :assert_select => "have tag#{format_args(*@args)}",
+ :assert_select_email => "send email#{format_args(*@args)}",
+ }[@selector_assertion]
+ end
+
+ private
+
+ module TestResponseOrString
+ def test_response?
+ ActionController::TestResponse === self and
+ !self.headers['Content-Type'].blank? and
+ self.headers['Content-Type'].to_sym == :xml
+ end
+
+ def string?
+ String === self
+ end
+ end
+
+ def doc_from(response_or_text)
+ response_or_text.extend TestResponseOrString
+ if response_or_text.test_response?
+ HTML::Document.new(response_or_text.body, @options[:strict], @options[:xml]).root
+ elsif response_or_text.string?
+ HTML::Document.new(response_or_text, @options[:strict], @options[:xml]).root
+ end
+ end
+
+ def format_args(*args)
+ args.empty? ? "" : "(#{arg_list(*args)})"
+ end
+
+ def arg_list(*args)
+ args.map do |arg|
+ arg.respond_to?(:description) ? arg.description : arg.inspect
+ end.join(", ")
+ end
+
+ def args_and_options(args)
+ opts = {:xml => false, :strict => false}
+ if args.last.is_a?(::Hash)
+ opts[:strict] = args.last.delete(:strict) unless args.last[:strict].nil?
+ opts[:xml] = args.last.delete(:xml) unless args.last[:xml].nil?
+ args.pop if args.last.empty?
+ end
+ return [args, opts]
+ end
+
+ end
+
+ # :call-seq:
+ # response.should have_tag(*args, &block)
+ # string.should have_tag(*args, &block)
+ #
+ # wrapper for assert_select with additional support for using
+ # css selectors to set expectation on Strings. Use this in
+ # helper specs, for example, to set expectations on the results
+ # of helper methods. Also allow specification of how the
+ # response is parsed using the options :xml and :strict options.
+ # By default, these options are set to false.
+ #
+ # == Examples
+ #
+ # # in a controller spec
+ # response.should have_tag("div", "some text")
+ #
+ # # to force xml and/or strict parsing of the response
+ # response.should have_tag("div", "some text", :xml => true)
+ # response.should have_tag("div", "some text", :strict => true)
+ # response.should have_tag("div", "some text", :xml => true, :strict => false)
+ #
+ # # in a helper spec (person_address_tag is a method in the helper)
+ # person_address_tag.should have_tag("input#person_address")
+ #
+ # see documentation for assert_select at http://api.rubyonrails.org/
+ def have_tag(*args, &block)
+ @__current_scope_for_assert_select = AssertSelect.new(:assert_select, self, *args, &block)
+ end
+
+ # wrapper for a nested assert_select
+ #
+ # response.should have_tag("div#form") do
+ # with_tag("input#person_name[name=?]", "person[name]")
+ # end
+ #
+ # see documentation for assert_select at http://api.rubyonrails.org/
+ def with_tag(*args, &block)
+ args = prepare_args(args, @__current_scope_for_assert_select)
+ @__current_scope_for_assert_select.should have_tag(*args, &block)
+ end
+
+ # wrapper for a nested assert_select with false
+ #
+ # response.should have_tag("div#1") do
+ # without_tag("span", "some text that shouldn't be there")
+ # end
+ #
+ # see documentation for assert_select at http://api.rubyonrails.org/
+ def without_tag(*args, &block)
+ args = prepare_args(args, @__current_scope_for_assert_select)
+ @__current_scope_for_assert_select.should_not have_tag(*args, &block)
+ end
+
+ # :call-seq:
+ # response.should have_rjs(*args, &block)
+ #
+ # wrapper for assert_select_rjs
+ #
+ # see documentation for assert_select_rjs at http://api.rubyonrails.org/
+ def have_rjs(*args, &block)
+ AssertSelect.new(:assert_select_rjs, self, *args, &block)
+ end
+
+ # :call-seq:
+ # response.should send_email(*args, &block)
+ #
+ # wrapper for assert_select_email
+ #
+ # see documentation for assert_select_email at http://api.rubyonrails.org/
+ def send_email(*args, &block)
+ AssertSelect.new(:assert_select_email, self, *args, &block)
+ end
+
+ # wrapper for assert_select_encoded
+ #
+ # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+ def with_encoded(*args, &block)
+ should AssertSelect.new(:assert_select_encoded, self, *args, &block)
+ end
+
+ private
+
+ def prepare_args(args, current_scope = nil)
+ return args if current_scope.nil?
+ defaults = current_scope.options || {:strict => false, :xml => false}
+ args << {} unless args.last.is_a?(::Hash)
+ args.last[:strict] = defaults[:strict] if args.last[:strict].nil?
+ args.last[:xml] = defaults[:xml] if args.last[:xml].nil?
+ args
+ end
+
+ end
+ end
+end
--- /dev/null
+if defined?(ActiveRecord::Base)
+ module Spec
+ module Matchers
+ class Change
+ def evaluate_value_proc_with_ensured_evaluation_of_proxy
+ value = evaluate_value_proc_without_ensured_evaluation_of_proxy
+ ActiveRecord::Associations::AssociationProxy === value ? value.dup : value
+ end
+ alias_method_chain :evaluate_value_proc, :ensured_evaluation_of_proxy
+ end
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Matchers
+
+ class HaveText #:nodoc:
+
+ def initialize(expected)
+ @expected = expected
+ end
+
+ def matches?(response_or_text)
+ @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+ return actual =~ expected if Regexp === expected
+ return actual == expected unless Regexp === expected
+ end
+
+ def failure_message_for_should
+ "expected #{expected.inspect}, got #{actual.inspect}"
+ end
+
+ def failure_message_for_should_not
+ "expected not to have text #{expected.inspect}"
+ end
+
+ def description
+ "have text #{expected.inspect}"
+ end
+
+ private
+ attr_reader :expected
+ attr_reader :actual
+
+ end
+
+ # :call-seq:
+ # response.should have_text(expected)
+ # response.should_not have_text(expected)
+ #
+ # Accepts a String or a Regexp, matching a String using ==
+ # and a Regexp using =~.
+ #
+ # If response_or_text has a #body, then that is used as to match against
+ # else it uses response_or_text
+ #
+ # Use this instead of <tt>response.should have_tag()</tt>
+ # when you want to match the whole string or whole body
+ #
+ # == Examples
+ #
+ # response.should have_text("This is the expected text")
+ def have_text(text)
+ HaveText.new(text)
+ end
+
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Matchers
+
+ class IncludeText #:nodoc:
+
+ def initialize(expected)
+ @expected = expected
+ end
+
+ def matches?(response_or_text)
+ @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+ return actual.include?(expected)
+ end
+
+ def failure_message_for_should
+ "expected to find #{expected.inspect} in #{actual.inspect}"
+ end
+
+ def failure_message_for_should_not
+ "expected not to include text #{expected.inspect}"
+ end
+
+ def description
+ "include text #{expected.inspect}"
+ end
+
+ private
+ attr_reader :expected
+ attr_reader :actual
+
+ end
+
+
+ # :call-seq:
+ # response.should include_text(expected)
+ # response.should_not include_text(expected)
+ #
+ # Accepts a String, matching using include?
+ #
+ # Use this instead of <tt>response.should have_text()</tt>
+ # when you either don't know or don't care where on the page
+ # this text appears.
+ #
+ # == Examples
+ #
+ # response.should include_text("This text will be in the actual string")
+ def include_text(text)
+ IncludeText.new(text)
+ end
+
+ end
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Matchers
+
+ class RedirectTo #:nodoc:
+
+ include ActionController::StatusCodes
+
+ def initialize(request, expected)
+ @expected = expected
+ @request = request
+ end
+
+ def matches?(response_or_controller)
+ response = response_or_controller.respond_to?(:response) ?
+ response_or_controller.response :
+ response_or_controller
+
+ @redirected = response.redirect?
+ @actual = response.redirect_url
+ return false unless @redirected
+
+ if @expected_status
+ @actual_status = interpret_status(response.code.to_i)
+ @status_matched = @expected_status == @actual_status
+ else
+ @status_matched = true
+ end
+
+ if @expected.instance_of? Hash
+ return false unless @actual =~ %r{^\w+://#{@request.host}}
+ return false unless actual_redirect_to_valid_route
+ return actual_hash == expected_hash && @status_matched
+ else
+ return @actual == expected_url && @status_matched
+ end
+ end
+
+ def actual_hash
+ hash_from_url @actual
+ end
+
+ def expected_hash
+ hash_from_url expected_url
+ end
+
+ def actual_redirect_to_valid_route
+ actual_hash
+ end
+
+ def hash_from_url(url)
+ query_hash(url).merge(path_hash(url)).with_indifferent_access
+ end
+
+ def path_hash(url)
+ path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+ ActionController::Routing::Routes.recognize_path path, { :method => :get }
+ end
+
+ def query_hash(url)
+ query = url.split("?", 2)[1] || ""
+ Rack::Utils.parse_query(query)
+ end
+
+ def with(options)
+ @expected_status = interpret_status(options[:status])
+ self
+ end
+
+ def expected_url
+ case @expected
+ when Hash
+ return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+ when :back
+ return @request.env['HTTP_REFERER']
+ when %r{^\w+://.*}
+ return @expected
+ else
+ return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+ end
+ end
+
+ def failure_message_for_should
+ if @redirected
+ if @status_matched
+ return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+ else
+ return %Q{expected redirect to #{@expected.inspect} with status #{@expected_status}, got #{@actual_status}}
+ end
+ else
+ return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+ end
+ end
+
+ def failure_message_for_should_not
+ return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+ end
+
+ def description
+ "redirect to #{@expected.inspect}"
+ end
+ end
+
+ # :call-seq:
+ # response.should redirect_to(url)
+ # response.should redirect_to(:action => action_name)
+ # response.should redirect_to(:controller => controller_name, :action => action_name)
+ # response.should_not redirect_to(url)
+ # response.should_not redirect_to(:action => action_name)
+ # response.should_not redirect_to(:controller => controller_name, :action => action_name)
+ #
+ # Passes if the response is a redirect to the url, action or controller/action.
+ # Useful in controller specs (integration or isolation mode).
+ #
+ # == Examples
+ #
+ # response.should redirect_to("path/to/action")
+ # response.should redirect_to("http://test.host/path/to/action")
+ # response.should redirect_to(:action => 'list')
+ def redirect_to(opts)
+ RedirectTo.new(request, opts)
+ end
+ end
+
+ end
+end
--- /dev/null
+module Spec
+ module Rails
+ module Matchers
+
+ class RenderTemplate #:nodoc:
+
+ def initialize(expected, controller)
+ @controller = controller
+ @expected = expected
+ end
+
+ def matches?(response_or_controller)
+ response = response_or_controller.respond_to?(:response) ?
+ response_or_controller.response :
+ response_or_controller
+
+ if response.respond_to?(:redirect?) && response.redirect?
+ @redirect_url = response.redirect_url
+ elsif response.respond_to?(:rendered_file)
+ @actual = response.rendered_file
+ elsif response.respond_to?(:rendered)
+ case template = response.rendered[:template]
+ when nil
+ unless response.rendered[:partials].empty?
+ @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
+ end
+ when ActionView::Template
+ @actual = template.path
+ when String
+ @actual = template
+ end
+ else
+ @actual = response.rendered_template.to_s
+ end
+ return false if @actual.blank?
+ given_controller_path, given_file = path_and_file(@actual)
+ expected_controller_path, expected_file = path_and_file(@expected)
+ given_controller_path == expected_controller_path && match_files(given_file, expected_file)
+ end
+
+ def match_files(actual, expected)
+ actual_parts = actual.split('.')
+ expected_parts = expected.split('.')
+ expected_parts.each_with_index do |expected_part, index|
+ return false unless expected_part == actual_parts[index]
+ end
+ true
+ end
+
+ def failure_message_for_should
+ if @redirect_url
+ "expected #{@expected.inspect}, got redirected to #{@redirect_url.inspect}"
+ else
+ "expected #{@expected.inspect}, got #{@actual.inspect}"
+ end
+ end
+
+ def failure_message_for_should_not
+ "expected not to render #{@expected.inspect}, but did"
+ end
+
+ def description
+ "render template #{@expected.inspect}"
+ end
+
+ private
+ def path_and_file(path)
+ parts = path.split('/')
+ file = parts.pop
+ controller = parts.empty? ? current_controller_path : parts.join('/')
+ return controller, file
+ end
+
+ def controller_path_from(path)
+ parts = path.split('/')
+ parts.pop
+ parts.join('/')
+ end
+
+ def current_controller_path
+ @controller.class.to_s.underscore.gsub(/_controller$/,'')
+ end
+
+ end
+
+ # :call-seq:
+ # response.should render_template(template)
+ # response.should_not render_template(template)
+ #
+ # For use in controller code examples (integration or isolation mode).
+ #
+ # Passes if the specified template (view file) is rendered by the
+ # response. This file can be any view file, including a partial. However
+ # if it is a partial it must be rendered directly i.e. you can't detect
+ # that a partial has been rendered as part of a view using
+ # render_template. For that you should use a message expectation
+ # (mock) instead:
+ #
+ # controller.should_receive(:render).with(:partial => 'path/to/partial')
+ #
+ # <code>template</code> can include the controller path. It can also
+ # include an optional extension, which you only need to use when there
+ # is ambiguity.
+ #
+ # Note that partials must be spelled with the preceding underscore.
+ #
+ # == Examples
+ #
+ # response.should render_template('list')
+ # response.should render_template('same_controller/list')
+ # response.should render_template('other_controller/list')
+ #
+ # # with extensions
+ # response.should render_template('list.rjs')
+ # response.should render_template('list.haml')
+ # response.should render_template('same_controller/list.rjs')
+ # response.should render_template('other_controller/list.rjs')
+ #
+ # # partials
+ # response.should render_template('_a_partial')
+ # response.should render_template('same_controller/_a_partial')
+ # response.should render_template('other_controller/_a_partial')
+ def render_template(path)
+ RenderTemplate.new(path.to_s, @controller)
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'rack/utils'
+
+module Spec
+ module Rails
+ module Matchers
+ USAGE = ArgumentError.new( 'usage: { :method => "path" }.should route_to( :controller => "controller", :action => "action", [ args ] )' )
+
+ class PathDecomposer
+ def self.decompose_path(path)
+ method, path = if Hash === path
+ raise USAGE if path.keys.size > 1
+ path.entries.first
+ else
+ [:get, path]
+ end
+ path, querystring = path.split('?')
+ return method, path, querystring
+ end
+ end
+
+ class RouteTo #:nodoc:
+ def initialize(expected, example)
+ @route, @example = expected,example
+ end
+
+ def matches?(path)
+ begin
+ @actual = path
+ method, path, querystring = PathDecomposer.decompose_path(path)
+ params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+ @example.assert_routing({ :method => method, :path => path }, @route, {}, params)
+ true
+ rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError, ActionController::MethodNotAllowed => e
+ raise e.class, "#{e}\nIf you're expecting this failure, we suggest { :#{method} => \"#{path}\" }.should_not be_routable"
+ rescue Exception => e
+ raise e.class, "#{e}\n#{e.backtrace.join( "\n" )}"
+ end
+ end
+
+ def does_not_match(path)
+ raise ArgumentError, "Don't test a negative route like this."
+ end
+
+ def failure_message_for_should
+ "Expected #{@expected.inspect} to route to #{@actual.inspect}, but it didn't.\n"+
+ "In this case, we expected you to get an exception. So this message probably means something weird happened."
+ end
+
+ def failure_message_for_should_not
+ "Expected a routing error, but the route passed instead. \nNote, when expecting routes to fail, you should use 'should_not be_routable' instead."
+ end
+
+ def description
+ "route to #{@expected.inspect}"
+ end
+
+ private
+ attr_reader :expected
+ attr_reader :actual
+
+ end
+
+ # :call-seq:
+ # "path".should route_to(expected) # assumes GET
+ # { :get => "path" }.should route_to(expected)
+ # { :put => "path" }.should route_to(expected)
+ #
+ # Uses ActionController::Routing::Routes to verify that
+ # the path-and-method routes to a given set of options.
+ # Also verifies route-generation, so that the expected options
+ # do generate a pathname consisten with the indicated path/method.
+ #
+ # For negative tests, only the route recognition failure can be
+ # tested; since route generation via path_to() will always generate
+ # a path as requested. Use .should_not be_routable() in this case.
+ #
+ # == Examples
+ # { :get => '/registrations/1/edit' }.
+ # should route_to(:controller => 'registrations', :action => 'edit', :id => '1')
+ # { :put => "/registrations/1" }.should
+ # route_to(:controller => 'registrations', :action => 'update', :id => 1)
+ # { :post => "/registrations/" }.should
+ # route_to(:controller => 'registrations', :action => 'create')
+
+ def route_to(expected)
+ RouteTo.new(expected, self)
+ end
+
+ class BeRoutable
+ def initialize(example)
+ @example = example
+ end
+
+ def matches?(path)
+ begin
+ @actual = path
+ method, path = PathDecomposer.decompose_path(path)
+ @example.assert_recognizes({}, { :method => method, :path => path }, {} )
+ true
+ rescue ActionController::RoutingError, ActionController::MethodNotAllowed
+ false
+ rescue ::Test::Unit::AssertionFailedError => e
+ # the second thingy will always be "<{}>" becaues of the way we called assert_recognizes({}...) above.
+ e.to_s =~ /<(.*)> did not match <\{\}>/ and @actual_place = $1 or raise
+ true
+ end
+ end
+ def failure_message_for_should
+ "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to be routable, but it wasn't.\n"+
+ "To really test routability, we recommend #{@actual.inspect}.\n"+
+ " should route_to( :action => 'action', :controller => 'controller' )\n\n"+
+
+ "That way, you'll verify where your route goes to. Plus, we'll verify\n"+
+ "the generation of the expected path from the action/controller, as in\n"+
+ "the url_for() helper."
+ end
+
+ def failure_message_for_should_not
+ "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to fail, but it routed to #{@actual_place} instead"
+ end
+
+ end
+ # :call-seq:
+ # { "path" }.should_not be_routable # assumes GET
+ # { :get => "path" }.should_not be_routable
+ # { :put => "path" }.should_not be_routable
+ #
+ # Uses ActionController::Routing::Routes to verify that
+ # the path-and-method cannot be routed to a controller.
+ # Since url_for() will always generate a path, even if that
+ # path is not routable, the negative test only needs to be
+ # performed on the route recognition.
+ #
+ # Don't use this matcher for testing expected routability -
+ # use .should route_to( :controller => "controller", :action => "action" ) instead
+ #
+ # == Examples
+ # { :get => '/registrations/1/attendees/3/edit' }.should_not be_routable
+ # { :get => '/attendees/3/edit' }.should route_to( ...<controller/action>... )
+
+ def be_routable
+ BeRoutable.new(self)
+ end
+
+ alias_method :be_routeable, :be_routable
+ end
+ end
+end
+
--- /dev/null
+module Spec
+ module Rails
+
+ class IllegalDataAccessException < StandardError; end
+
+ module Mocks
+
+ # Creates a mock object instance for a +model_class+ with common
+ # methods stubbed out. Additional methods may be easily stubbed (via
+ # add_stubs) if +stubs+ is passed.
+ def mock_model(model_class, options_and_stubs = {})
+ id = options_and_stubs[:id] || next_id
+ options_and_stubs = options_and_stubs.reverse_merge({
+ :id => id,
+ :to_param => id.to_s,
+ :new_record? => false,
+ :destroyed? => false,
+ :errors => stub("errors", :count => 0)
+ })
+ m = mock("#{model_class.name}_#{id}", options_and_stubs)
+ m.__send__(:__mock_proxy).instance_eval <<-CODE
+ def @target.as_new_record
+ self.stub!(:id).and_return nil
+ self.stub!(:to_param).and_return nil
+ self.stub!(:new_record?).and_return true
+ self
+ end
+ def @target.is_a?(other)
+ #{model_class}.ancestors.include?(other)
+ end
+ def @target.kind_of?(other)
+ #{model_class}.ancestors.include?(other)
+ end
+ def @target.instance_of?(other)
+ other == #{model_class}
+ end
+ def @target.class
+ #{model_class}
+ end
+ CODE
+ yield m if block_given?
+ m
+ end
+
+ module ModelStubber
+ def connection
+ raise Spec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+ end
+ def new_record?
+ id.nil?
+ end
+ def as_new_record
+ self.id = nil
+ self
+ end
+ end
+
+ # :call-seq:
+ # stub_model(Model)
+ # stub_model(Model).as_new_record
+ # stub_model(Model, hash_of_stubs)
+ # stub_model(Model, instance_variable_name, hash_of_stubs)
+ #
+ # Creates an instance of +Model+ that is prohibited from accessing the
+ # database*. For each key in +hash_of_stubs+, if the model has a
+ # matching attribute (determined by asking it) are simply assigned the
+ # submitted values. If the model does not have a matching attribute, the
+ # key/value pair is assigned as a stub return value using RSpec's
+ # mocking/stubbing framework.
+ #
+ # <tt>new_record?</tt> is overridden to return the result of id.nil?
+ # This means that by default new_record? will return false. If you want
+ # the object to behave as a new record, sending it +as_new_record+ will
+ # set the id to nil. You can also explicitly set :id => nil, in which
+ # case new_record? will return true, but using +as_new_record+ makes the
+ # example a bit more descriptive.
+ #
+ # While you can use stub_model in any example (model, view, controller,
+ # helper), it is especially useful in view examples, which are
+ # inherently more state-based than interaction-based.
+ #
+ # == Database Independence
+ #
+ # +stub_model+ does not make your examples entirely
+ # database-independent. It does not stop the model class itself from
+ # loading up its columns from the database. It just prevents data access
+ # from the object itself. To completely decouple from the database, take
+ # a look at libraries like unit_record or NullDB.
+ #
+ # == Examples
+ #
+ # stub_model(Person)
+ # stub_model(Person).as_new_record
+ # stub_model(Person, :id => 37)
+ # stub_model(Person) do |person|
+ # person.first_name = "David"
+ # end
+ def stub_model(model_class, stubs={})
+ stubs = {:id => next_id}.merge(stubs)
+ returning model_class.new do |model|
+ model.id = stubs.delete(:id)
+ model.extend ModelStubber
+ stubs.each do |k,v|
+ if model.has_attribute?(k)
+ model[k] = stubs.delete(k)
+ end
+ end
+ model.stub!(stubs)
+ yield model if block_given?
+ end
+ end
+
+ # DEPRECATED - use object.stub!(:method => value, :method2 => value)
+ #
+ # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
+ # with that name will be created). +stubs+ is a Hash of +method=>value+
+ def add_stubs(object, stubs = {}) #:nodoc:
+ Kernel.warn <<-WARNING
+DEPRECATION NOTICE: add_stubs is deprecated and will be removed
+from a future version of rspec-rails. Use this instead:
+
+ object.stub!(:method => value, :method2 => value)
+
+WARNING
+ object.stub!(stubs)
+ end
+
+ private
+ @@model_id = 1000
+ def next_id
+ @@model_id += 1
+ end
+
+ end
+ end
+end
--- /dev/null
+module Spec # :nodoc:
+ module Rails # :nodoc:
+ module VERSION # :nodoc:
+ unless defined? MAJOR
+ MAJOR = 1
+ MINOR = 3
+ TINY = 0
+ PRE = nil
+
+ STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+ SUMMARY = "rspec-rails #{STRING}"
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../lib/autotest/rails_rspec'
+require File.dirname(__FILE__) + '/../../../rspec/spec/autotest/autotest_matchers'
+
+describe Autotest::RailsRspec, "file mapping" do
+ before(:each) do
+ @autotest = Autotest::RailsRspec.new
+ @autotest.hook :initialize
+ end
+
+ it "should map model example to model" do
+ @autotest.should map_specs(['spec/models/thing_spec.rb']).
+ to('app/models/thing.rb')
+ end
+
+ it "should map controller example to controller" do
+ @autotest.should map_specs(['spec/controllers/things_controller_spec.rb']).
+ to('app/controllers/things_controller.rb')
+ end
+
+ it "should map view.rhtml" do
+ @autotest.should map_specs(['spec/views/things/index.rhtml_spec.rb']).
+ to('app/views/things/index.rhtml')
+ end
+
+ it "should map view.rhtml with underscores in example filename" do
+ @autotest.should map_specs(['spec/views/things/index_rhtml_spec.rb']).
+ to('app/views/things/index.rhtml')
+ end
+
+ it "should map view.html.erb" do
+ @autotest.should map_specs(['spec/views/things/index.html.erb_spec.rb']).
+ to('app/views/things/index.html.erb')
+ end
+
+ describe "between routes.rb and things which depend on routes" do
+ it "should map routes.rb to controllers" do
+ @autotest.should map_specs(['spec/controllers/things_controller_spec.rb']).
+ to('config/routes.rb')
+ end
+
+ it "should map routes.rb to views" do
+ @autotest.should map_specs(['spec/views/things/action.html.erb_spec.rb']).
+ to('config/routes.rb')
+ end
+
+ it "should map routes.rb to helpers" do
+ @autotest.should map_specs(['spec/helpers/things_helper_spec.rb']).
+ to('config/routes.rb')
+ end
+
+ it "should map routing example to routes" do
+ @autotest.should map_specs(['spec/routing/thing_spec.rb']).
+ to('config/routes.rb')
+ end
+ end
+
+ describe "between the config and specs" do
+ ['spec/controllers/things_controller_spec.rb',
+ 'spec/views/things/action.html.erb_spec.rb',
+ 'spec/helpers/things_helper_spec.rb',
+ 'spec/routing/thing_spec.rb',
+ 'spec/models/thing_spec.rb'].each do |file_path|
+
+ it "should map environment.rb to #{file_path}" do
+ @autotest.should map_specs([file_path]).
+ to('config/environment.rb')
+ end
+
+ it "should map environments/test.rb to #{file_path}" do
+ @autotest.should map_specs([file_path]).
+ to('config/environments/test.rb')
+ end
+
+ it "should map boot.rb to #{file_path}" do
+ @autotest.should map_specs([file_path]).
+ to('config/boot.rb')
+ end
+
+ it "should map spec_helper.rb to #{file_path}" do
+ @autotest.should map_specs([file_path]).
+ to('spec/spec_helper.rb')
+ end
+ end
+ end
+end
--- /dev/null
+dir = File.dirname(__FILE__)
+Dir["#{dir}/**/*_example.rb"].each do |file|
+ require file
+end
+Dir["#{dir}/**/*_spec.rb"].each do |file|
+ require file
+end
--- /dev/null
+class ActionViewBaseSpecController < ActionController::Base
+end
--- /dev/null
+class ApplicationController < ActionController::Base
+ before_filter :i_should_only_be_run_once,
+ :only => 'action_with_inherited_before_filter'
+
+ def i_should_only_be_run_once
+ true
+ end
+ private :i_should_only_be_run_once
+end
\ No newline at end of file
--- /dev/null
+class ControllerSpecController < ActionController::Base
+ before_filter :raise_error, :only => :action_with_skipped_before_filter
+
+ def raise_error
+ raise "from a before filter"
+ end
+
+ skip_before_filter :raise_error
+
+ prepend_view_path File.join(File.dirname(__FILE__), "..", "views")
+
+ def some_action
+ render :template => "template/that/does/not/actually/exist"
+ end
+
+ def some_action_with_implied_template
+ end
+
+ def action_with_template
+ render :template => "controller_spec/action_with_template"
+ end
+
+ def action_which_sets_flash
+ flash[:flash_key] = "flash value"
+ render :text => ""
+ end
+
+ def action_which_gets_session
+ raise "expected #{params[:session_key].inspect}\ngot #{session[:session_key].inspect}" unless (session[:session_key] == params[:expected])
+ render :text => ""
+ end
+
+ def action_which_sets_session
+ session[:session_key] = "session value"
+ end
+
+ def action_which_gets_cookie
+ raise "expected #{params[:expected].inspect}, got #{cookies[:cookie_key].inspect}" unless (cookies[:cookie_key] == params[:expected])
+ render :text => ""
+ end
+
+ def action_which_sets_cookie
+ cookies['cookie_key'] = params[:value]
+ render :text => ""
+ end
+
+ def action_with_partial
+ render :partial => "controller_spec/partial"
+ end
+
+ def action_with_partial_with_object
+ render :partial => "controller_spec/partial", :object => params[:thing]
+ end
+
+ def action_with_partial_with_locals
+ render :partial => "controller_spec/partial", :locals => {:thing => params[:thing]}
+ end
+
+ def action_with_errors_in_template
+ render :template => "controller_spec/action_with_errors_in_template"
+ end
+
+ def action_setting_the_assigns_hash
+ @indirect_assigns_key = :indirect_assigns_key_value
+ end
+
+ def action_setting_flash_after_session_reset
+ reset_session
+ flash[:after_reset] = "available"
+ end
+
+ def action_setting_flash_before_session_reset
+ flash[:before_reset] = 'available'
+ reset_session
+ end
+
+ def action_with_render_update
+ render :update do |page|
+ page.replace :bottom, 'replace_me',
+ :partial => 'non_existent_partial'
+ end
+ end
+
+ def action_with_skipped_before_filter
+ render :text => ""
+ end
+
+ def action_that_renders_inline
+ render :inline => "<%= 'inline code' %>"
+ end
+
+ def action_that_assigns_false_to_a_variable
+ @a_variable = false
+ render :text => ""
+ end
+
+ def action_with_two_arg_render
+ render :update, :status => 404 do |page|
+ page.visual_effect :highlight, 'user_list'
+ end
+ end
+
+ class RescuedError < Exception; end
+ class UnRescuedError < Exception; end
+
+ rescue_from RescuedError do |e|
+ render :text => 'Rescued!'
+ end
+
+ def rescued_error_action
+ raise ControllerSpecController::RescuedError
+ end
+
+ def un_rescued_error_action
+ raise ControllerSpecController::UnRescuedError
+ end
+
+ def action_that_returns_headers
+ render :text => request.headers[params[:header]]
+ end
+end
+
+class ControllerInheritingFromApplicationControllerController < ApplicationController
+ def action_with_inherited_before_filter
+ render :text => ""
+ end
+end
--- /dev/null
+This is an example file to download.
\ No newline at end of file
--- /dev/null
+class RedirectSpecController < ApplicationController
+
+ def action_with_no_redirect
+ render :text => "this is just here to keep this from causing a MissingTemplate error"
+ end
+
+ def action_with_redirect_to_somewhere
+ redirect_to :action => 'somewhere'
+ end
+
+ def action_with_redirect_to_other_somewhere
+ redirect_to :controller => 'render_spec', :action => 'text_action'
+ end
+
+ def action_with_redirect_to_somewhere_and_return
+ redirect_to :action => 'somewhere' and return
+ render :text => "this is after the return"
+ end
+
+ def somewhere
+ render :text => "this is just here to keep this from causing a MissingTemplate error"
+ end
+
+ def action_with_redirect_to_rspec_site
+ redirect_to "http://rspec.rubyforge.org"
+ end
+
+ def action_with_redirect_back
+ redirect_to :back
+ end
+
+ def action_with_redirect_in_respond_to
+ respond_to do |wants|
+ wants.html { redirect_to :action => 'somewhere' }
+ end
+ end
+
+ def action_with_redirect_which_creates_query_string
+ redirect_to :action => "somewhere", :id => 1111, :param1 => "value1", :param2 => "value2"
+ end
+
+ # note: sometimes this is the URL which rails will generate from the hash in
+ # action_with_redirect_which_creates_query_string
+ def action_with_redirect_with_query_string_order1
+ redirect_to "http://test.host/redirect_spec/somewhere/1111?param1=value1¶m2=value2"
+ end
+
+ # note: sometimes this is the URL which rails will generate from the hash in
+ # action_with_redirect_which_creates_query_string
+ def action_with_redirect_with_query_string_order2
+ redirect_to "http://test.host/redirect_spec/somewhere/1111?param2=value2¶m1=value1"
+ end
+
+ def action_with_redirect_to_unroutable_url_inside_app
+ redirect_to :controller => "nonexistant", :action => "none"
+ end
+
+ def action_with_method_restriction
+ render :text => ''
+ end
+
+ def action_to_redirect_to_action_with_method_restriction
+ redirect_to :action => 'action_with_method_restriction'
+ end
+
+ def action_with_redirect_to_somewhere_with_status
+ redirect_to :action => 'somewhere', :status => 301
+ end
+end
+
--- /dev/null
+class RenderSpecController < ApplicationController
+ prepend_view_path File.join(File.dirname(__FILE__), "..", "views")
+
+ def some_action
+ respond_to do |format|
+ format.html
+ format.js
+ end
+ end
+
+ def action_which_renders_template_from_other_controller
+ render :template => 'controller_spec/action_with_template'
+ end
+
+ def text_action
+ render :text => "this is the text for this action"
+ end
+
+ def action_with_redirect
+ redirect_to :action => :some_action
+ end
+
+ def action_with_partial
+ render :partial => "a_partial"
+ end
+
+ def action_that_renders_nothing
+ render :nothing => true
+ end
+
+ def action_with_alternate_layout
+ render :layout => 'simple'
+ end
+end
--- /dev/null
+class RjsSpecController < ApplicationController
+ prepend_view_path File.join(File.dirname(__FILE__), "..", "views")
+
+ def replace_html
+ end
+
+ def insert_html
+ end
+
+ def replace
+ end
+
+ def hide_div
+ end
+
+ def hide_page_element
+ end
+
+ def replace_html_with_partial
+ end
+
+ def render_replace_html
+ render :update do |page|
+ page.replace_html 'mydiv', 'replacement text'
+ page.replace_html 'myotherdiv', 'other replacement text'
+ end
+ end
+
+ def render_replace_html_with_partial
+ render :update do |page|
+ page.replace_html 'mydiv', :partial => 'rjs_spec/replacement_partial'
+ end
+ end
+
+ def render_insert_html
+ render :update do |page|
+ page.insert_html 'mydiv', 'replacement text'
+ end
+ end
+
+ def render_replace
+ render :update do |page|
+ page.replace 'mydiv', 'replacement text'
+ end
+ end
+
+ def render_hide_div
+ render :update do |page|
+ page.hide 'mydiv'
+ end
+ end
+
+ def render_hide_page_element
+ render :update do |page|
+ page['mydiv'].hide
+ end
+ end
+end
--- /dev/null
+module AdditionHelper
+ def plus(addend)
+ @addend + addend
+ end
+end
--- /dev/null
+module ExplicitHelper
+ def method_in_explicit_helper
+ "<div>This is text from a method in the ExplicitHelper</div>"
+ end
+
+ # this is an example of a method spec'able with eval_erb in helper specs
+ def prepend(arg, &block)
+ begin # rails edge after 2.1.0 eliminated need for block.binding
+ concat(arg) + block.call
+ rescue
+ concat(arg, block.binding) + block.call
+ end
+ end
+
+ def named_url
+ rspec_on_rails_specs_url
+ end
+
+ def named_path
+ rspec_on_rails_specs_path
+ end
+
+ def params_foo
+ params[:foo]
+ end
+
+ def session_foo
+ session[:foo]
+ end
+
+ def request_thing
+ request.thing
+ end
+
+ def flash_thing
+ flash[:thing]
+ end
+
+ def method_using_output_buffer
+ concat("the_text_from_concat")
+ end
+
+ def method_using_template
+ update_page { |p| p["#some_id"].replace_html "" }
+ end
+end
--- /dev/null
+module MoreExplicitHelper
+ def method_in_more_explicit_helper
+ "<div>This is text from a method in the MoreExplicitHelper</div>"
+ end
+end
--- /dev/null
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+ def method_in_plugin_application_helper
+ "<div>This is text from a method in the ApplicationHelper</div>"
+ end
+end
--- /dev/null
+module ViewSpecHelper
+ def method_in_helper
+ "<div>This is text from a method in the ViewSpecHelper</div>"
+ end
+
+ def method_in_template_with_partial
+ "<div>method_in_template_with_partial in ViewSpecHelper</div>"
+ end
+
+ def method_in_partial
+ "<div>method_in_partial in ViewSpecHelper</div>"
+ end
+end
--- /dev/null
+class Animal < ActiveRecord::Base
+ belongs_to :person
+ validates_uniqueness_of :name
+end
--- /dev/null
+class Person < ActiveRecord::Base
+ has_many :animals do
+ def pups
+ find(:all, :conditions => 'age < 1')
+ end
+ def adults
+ find(:all, :conditions => 'age >= 1')
+ end
+ end
+ validates_presence_of :name
+
+ def add_animal animal
+ animal.person = self
+ animals << animal
+ animal.save
+ end
+
+end
--- /dev/null
+class Thing < ActiveRecord::Base
+ validates_presence_of :name
+end
--- /dev/null
+<% raise %>
\ No newline at end of file
--- /dev/null
+<div>This is action_with_template.rhtml</div>
--- /dev/null
+<%- raise "THIS TEMPLATE SHOULD NOT BE RENDERED" -%>
\ No newline at end of file
--- /dev/null
+<%= object.name %>
\ No newline at end of file
--- /dev/null
+# This is used for rails > 1.2.3
\ No newline at end of file
--- /dev/null
+This is the text in the replacement partial.
\ No newline at end of file
--- /dev/null
+page.hide 'mydiv'
--- /dev/null
+page['mydiv'].hide
--- /dev/null
+page.insert_html 'mydiv', 'replacement text'
--- /dev/null
+page.replace 'mydiv', 'replacement text'
--- /dev/null
+page.replace_html 'mydiv', 'replacement text'
\ No newline at end of file
--- /dev/null
+page.replace_html 'mydiv', :partial => 'rjs_spec/replacement_partial'
\ No newline at end of file
--- /dev/null
+page.visual_effect :fade, 'mydiv'
--- /dev/null
+page.visual_effect :toggle_blind, 'mydiv'
--- /dev/null
+<!-THIS FILE HAS NO TAGS->
\ No newline at end of file
--- /dev/null
+<div></div>
\ No newline at end of file
--- /dev/null
+<div key="value"></div>
\ No newline at end of file
--- /dev/null
+<%= method_in_plugin_application_helper %>
+<%= method_in_partial %>
\ No newline at end of file
--- /dev/null
+<div><%= x %></div>
\ No newline at end of file
--- /dev/null
+<%= render :partial => 'partial', :object => partial %>
\ No newline at end of file
--- /dev/null
+<hr id="spacer" />
--- /dev/null
+<div id="session"><%= session[:key] %></div>
+<div id="params"><%= params[:key] %></div>
+<div id="flash"><%= flash[:key] %></div>
+<div id="flash_now"><%= flash[:now_key] %></div>
+<div id="controller"><%= params[:controller] %></div>
+<div id="action"><%= params[:action] %></div>
--- /dev/null
+<% if_allowed do %>
+ <div>block helper was rendered</div>
+<% end %>
\ No newline at end of file
--- /dev/null
+<% form_tag do %>
+<% end %>
\ No newline at end of file
--- /dev/null
+<%= method_in_plugin_application_helper %>
+<%= method_in_explicit_helper %>
--- /dev/null
+<%= method_in_plugin_application_helper %>
--- /dev/null
+<%= method_in_plugin_application_helper %>
+<%= method_in_helper %>
--- /dev/null
+<%= method_in_plugin_application_helper %>
+<%= method_in_explicit_helper %>
+<%= method_in_more_explicit_helper %>
\ No newline at end of file
--- /dev/null
+<%= params[:controller] %>
\ No newline at end of file
--- /dev/null
+<% if @obj.render_partial? %>
+ <%= render :partial => 'some_partial' %>
+<% end %>
--- /dev/null
+<%= method_in_template_with_partial %>
+<%= render :partial => 'partial' %>
+
+<%= render :partial => 'partial_used_twice' %>
+<%= render :partial => 'partial_used_twice' %>
--- /dev/null
+<%= render :partial => 'partial',
+ :collection => ['Alice', 'Bob'],
+ :spacer_template => 'spacer' %>
--- /dev/null
+<%= render :partial => @array %>
--- /dev/null
+<span><%= link_to "edit", "this_is_the_link" %></span>
--- /dev/null
+require 'spec_helper'
+
+describe "AssignsHashProxy" do
+ def orig_assigns
+ @object.assigns
+ end
+
+ class Foo
+ def initialize(bar)
+ @bar = bar
+ end
+ attr_reader :bar
+
+ def ==(other)
+ self.bar == other.bar
+ end
+ end
+
+ before(:each) do
+ @object = Class.new do
+ def assigns; @assigns ||= Hash.new; end
+ end.new
+ @proxy = Spec::Rails::Example::AssignsHashProxy.new(self) {@object}
+ end
+
+ it "doesn't wig out on objects that define their own == method" do
+ @object.assigns['foo'] = Foo.new(1)
+ @proxy['foo'].should == Foo.new(1)
+ end
+
+ it "should set ivars on object using string" do
+ @proxy['foo'] = 'bar'
+ @object.instance_eval{@foo}.should == 'bar'
+ end
+
+ it "should set ivars on object using symbol" do
+ @proxy[:foo] = 'bar'
+ @object.instance_eval{@foo}.should == 'bar'
+ end
+
+ it "should access object's assigns with a string" do
+ @object.assigns['foo'] = 'bar'
+ @proxy['foo'].should == 'bar'
+ end
+
+ it "should access object's assigns with a symbol" do
+ @object.assigns['foo'] = 'bar'
+ @proxy[:foo].should == 'bar'
+ end
+
+ it "should access object's ivars with a string" do
+ @object.instance_variable_set('@foo', 'bar')
+ @proxy['foo'].should == 'bar'
+ end
+
+ it "should access object's ivars with a symbol" do
+ @object.instance_variable_set('@foo', 'bar')
+ @proxy[:foo].should == 'bar'
+ end
+
+ it "should iterate through each element like a Hash" do
+ values = {
+ 'foo' => 1,
+ 'bar' => 2,
+ 'baz' => 3
+ }
+ @proxy['foo'] = values['foo']
+ @proxy['bar'] = values['bar']
+ @proxy['baz'] = values['baz']
+
+ @proxy.each do |key, value|
+ key.should == key
+ value.should == values[key]
+ end
+ end
+
+ it "should delete the ivar of passed in key" do
+ @object.instance_variable_set('@foo', 'bar')
+ @proxy.delete('foo')
+ @proxy['foo'].should be_nil
+ end
+
+ it "should delete the assigned element of passed in key" do
+ @object.assigns['foo'] = 'bar'
+ @proxy.delete('foo')
+ @proxy['foo'].should be_nil
+ end
+
+ it "should detect the presence of a key in assigns" do
+ @object.assigns['foo'] = 'bar'
+ @proxy.has_key?('foo').should == true
+ @proxy.has_key?('bar').should == false
+ end
+
+ it "should expose values set in example back to the example" do
+ @proxy[:foo] = 'bar'
+ @proxy[:foo].should == 'bar'
+ end
+
+ it "should allow assignment of false via proxy" do
+ @proxy['foo'] = false
+ @proxy['foo'].should be_false
+ end
+
+ it "should allow assignment of false" do
+ @object.instance_variable_set('@foo',false)
+ @proxy['foo'].should be_false
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+module Spec
+ module Runner
+ describe Configuration do
+
+ def config
+ @config ||= Configuration.new
+ end
+
+ describe "#use_transactional_fixtures" do
+ it "should return ActiveSupport::TestCase.use_transactional_fixtures" do
+ config.use_transactional_fixtures.should == ActiveSupport::TestCase.use_transactional_fixtures
+ end
+
+ it "should set ActiveSupport::TestCase.use_transactional_fixtures to false" do
+ ActiveSupport::TestCase.should_receive(:use_transactional_fixtures=).with(false)
+ config.use_transactional_fixtures = false
+ end
+
+ it "should set ActiveSupport::TestCase.use_transactional_fixtures to true" do
+ ActiveSupport::TestCase.should_receive(:use_transactional_fixtures=).with(true)
+ config.use_transactional_fixtures = true
+ end
+ end
+
+ describe "#use_instantiated_fixtures" do
+ it "should return ActiveSupport::TestCase.use_transactional_fixtures" do
+ config.use_instantiated_fixtures.should == ActiveSupport::TestCase.use_instantiated_fixtures
+ end
+
+ it "should set ActiveSupport::TestCase.use_instantiated_fixtures to false" do
+ ActiveSupport::TestCase.should_receive(:use_instantiated_fixtures=).with(false)
+ config.use_instantiated_fixtures = false
+ end
+
+ it "should set ActiveSupport::TestCase.use_instantiated_fixtures to true" do
+ ActiveSupport::TestCase.should_receive(:use_instantiated_fixtures=).with(true)
+ config.use_instantiated_fixtures = true
+ end
+ end
+
+ describe "#fixture_path" do
+ it "should default to RAILS_ROOT + '/spec/fixtures'" do
+ config.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
+ ActiveSupport::TestCase.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
+ end
+
+ it "should set fixture_path" do
+ config.fixture_path = "/new/path"
+ config.fixture_path.should == "/new/path"
+ ActiveSupport::TestCase.fixture_path.should == "/new/path"
+ end
+ end
+
+ describe "#global_fixtures" do
+ it "should set fixtures on TestCase" do
+ ActiveSupport::TestCase.should_receive(:fixtures).with(:blah)
+ config.global_fixtures = [:blah]
+ end
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+require 'controller_spec_controller'
+require File.join(File.dirname(__FILE__), "/shared_routing_example_group_examples.rb")
+
+['integration', 'isolation'].each do |mode|
+ describe "A controller example running in #{mode} mode", :type => :controller do
+ controller_name :controller_spec
+ integrate_views if mode == 'integration'
+
+ accesses_configured_helper_methods
+ include RoutingExampleGroupSpec
+
+ describe "with an implicit subject" do
+ it "uses the controller" do
+ subject.should == controller
+ end
+ end
+
+ describe "with a specified subject" do
+ subject { 'specified' }
+
+ it "uses the specified subject" do
+ subject.should == 'specified'
+ end
+ end
+
+ it "should provide controller.session as session" do
+ get 'action_with_template'
+ session.should equal(controller.session)
+ end
+
+ it "should provide the same session object before and after the action" do
+ session_before = session
+ get 'action_with_template'
+ session.should equal(session_before)
+ end
+
+ it "should keep the same data in the session before and after the action" do
+ session[:foo] = :bar
+ get 'action_with_template'
+ session[:foo].should == :bar
+ end
+
+ it "should ensure controller.session is NOT nil before the action" do
+ controller.session.should_not be_nil
+ get 'action_with_template'
+ end
+
+ it "should ensure controller.session is NOT nil after the action" do
+ get 'action_with_template'
+ controller.session.should_not be_nil
+ end
+
+ it "should allow specifying a partial with partial name only" do
+ get 'action_with_partial'
+ response.should render_template("_partial")
+ end
+
+ it "should allow specifying a partial with should_receive(:render)" do
+ controller.should_receive(:render).with(:partial => "controller_spec/partial")
+ get 'action_with_partial'
+ end
+
+ it "should allow specifying a partial with should_receive(:render) with object" do
+ controller.should_receive(:render).with(:partial => "controller_spec/partial", :object => "something")
+ get 'action_with_partial_with_object', :thing => "something"
+ end
+
+ it "should allow specifying a partial with should_receive(:render) with locals" do
+ controller.should_receive(:render).with(:partial => "controller_spec/partial", :locals => {:thing => "something"})
+ get 'action_with_partial_with_locals', :thing => "something"
+ end
+
+ it "should yield to render :update" do
+ template = stub("template")
+ controller.should_receive(:render).with(:update).and_yield(template)
+ template.should_receive(:replace).with(:bottom, "replace_me", :partial => "non_existent_partial")
+ get 'action_with_render_update'
+ end
+
+ it "should allow a path relative to RAILS_ROOT/app/views/ when specifying a partial" do
+ get 'action_with_partial'
+ response.should render_template("controller_spec/_partial")
+ end
+
+ it "should provide access to flash" do
+ get 'action_which_sets_flash'
+ flash[:flash_key].should == "flash value"
+ end
+
+ it "should provide access to flash values set after a session reset" do
+ get 'action_setting_flash_after_session_reset'
+ flash[:after_reset].should == "available"
+ end
+
+ it "should not provide access to flash values set before a session reset" do
+ get 'action_setting_flash_before_session_reset'
+ flash[:before_reset].should_not == "available"
+ end
+
+ it "should provide access to session" do
+ session[:session_key] = "session value"
+ lambda do
+ get 'action_which_gets_session', :expected => "session value"
+ end.should_not raise_error
+ end
+
+ it "allows inline rendering" do
+ get 'action_that_renders_inline'
+ response.body.should == "inline code"
+ end
+
+ describe "handling should_receive(:render)" do
+ it "should warn" do
+ controller.should_receive(:render).with(:template => "controller_spec/action_with_template")
+ get :action_with_template
+ end
+ end
+
+ describe "handling should_not_receive(:render)" do
+ it "should warn" do
+ controller.should_not_receive(:render).with(:template => "the/wrong/template")
+ get :action_with_template
+ end
+ end
+
+ describe "setting cookies in the request" do
+
+ it "should support a String key" do
+ cookies['cookie_key'] = 'cookie value'
+ get 'action_which_gets_cookie', :expected => "cookie value"
+ end
+
+ it "should support a Symbol key" do
+ cookies[:cookie_key] = 'cookie value'
+ get 'action_which_gets_cookie', :expected => "cookie value"
+ end
+
+ it "should support a Hash value" do
+ cookies[:cookie_key] = {'value' => 'cookie value', 'path' => '/not/default'}
+ get 'action_which_gets_cookie', :expected => {'value' => 'cookie value', 'path' => '/not/default'}
+ end
+
+ end
+
+ describe "reading cookies from the response" do
+
+ it "should support a Symbol key" do
+ get 'action_which_sets_cookie', :value => "cookie value"
+ if ::Rails::VERSION::STRING >= "2.3"
+ cookies[:cookie_key].should match("cookie[\+ ]value")
+ else
+ cookies[:cookie_key].should == ["cookie value"]
+ end
+ end
+
+ it "should support a String key" do
+ get 'action_which_sets_cookie', :value => "cookie value"
+ if ::Rails::VERSION::STRING >= "2.3"
+ cookies['cookie_key'].should match("cookie[\+ ]value")
+ else
+ cookies['cookie_key'].should == ["cookie value"]
+ end
+ end
+
+ end
+
+ it "should expose instance vars through the assigns hash" do
+ get 'action_setting_the_assigns_hash'
+ assigns[:indirect_assigns_key].should == :indirect_assigns_key_value
+ end
+
+ it "should expose instance vars through the assigns hash that are set to false" do
+ get 'action_that_assigns_false_to_a_variable'
+ assigns[:a_variable].should be_false
+ end
+
+ it "should NOT complain when calling should_receive with arguments other than :render" do
+ controller.should_receive(:anything_besides_render)
+ lambda {
+ controller.rspec_verify
+ }.should raise_error(Exception, /expected :anything_besides_render/)
+ end
+
+ it "should not run a skipped before_filter" do
+ lambda {
+ get 'action_with_skipped_before_filter'
+ }.should_not raise_error
+ end
+
+ if ::Rails::VERSION::STRING > '2.1'
+ describe "extending #render on a controller" do
+ it "supports two arguments (as with rails 2.1)" do
+ get 'action_with_two_arg_render'
+ response.body.should =~ /new Effect\.Highlight/
+ end
+ end
+ end
+
+ it "should access headers" do
+ request.env['ACCEPT'] = "application/json"
+ get 'action_that_returns_headers', :header => 'ACCEPT'
+ response.body.should == "application/json"
+ end
+ end
+
+ describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :type => :controller do
+ controller_name :redirect_spec
+ integrate_views if mode == 'integration'
+
+ it "a redirect should ignore the absence of a template" do
+ get 'action_with_redirect_to_somewhere'
+ response.should be_redirect
+ response.redirect_url.should == "http://test.host/redirect_spec/somewhere"
+ response.should redirect_to("http://test.host/redirect_spec/somewhere")
+ end
+
+ it "a call to response.should redirect_to should fail if no redirect" do
+ get 'action_with_no_redirect'
+ lambda {
+ response.redirect?.should be_true
+ }.should fail
+ lambda {
+ response.should redirect_to("http://test.host/redirect_spec/somewhere")
+ }.should fail_with("expected redirect to \"http://test.host/redirect_spec/somewhere\", got no redirect")
+ end
+ end
+
+ describe "Given a controller spec running in #{mode} mode" do
+ example_group = describe "A controller spec"
+ # , :type => :controller do
+ # integrate_views if mode == 'integration'
+ it "a spec in a context without controller_name set should fail with a useful warning" do
+ pending("need a new way to deal with examples that should_raise")
+ # ,
+ # :should_raise => [
+ # Spec::Expectations::ExpectationNotMetError,
+ # /You have to declare the controller name in controller specs/
+ # ] do
+ end
+ end
+
+end
+
+['integration', 'isolation'].each do |mode|
+ describe "A controller example running in #{mode} mode", :type => :controller do
+ controller_name :controller_inheriting_from_application_controller
+ integrate_views if mode == 'integration'
+
+ it "should only have a before filter inherited from ApplicationController run once..." do
+ controller.should_receive(:i_should_only_be_run_once).once
+ get :action_with_inherited_before_filter
+ end
+ end
+end
+
+describe ControllerSpecController, :type => :controller do
+ it "should use the controller passed to #describe" do
+ end
+end
+
+describe "A controller spec with controller_name set", :type => :controller do
+ controller_name :controller_spec
+
+ describe "nested" do
+ it "should inherit the controller name" do
+ get 'action_with_template'
+ response.should be_success
+ end
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ describe ApplicationController, :type => :controller do
+ describe "controller_name" do
+ controller_name :controller_spec
+ it "overrides the controller class submitted to the outermost group" do
+ subject.should be_an_instance_of(ControllerSpecController)
+ end
+ describe "in a nested group" do
+ it "overrides the controller class submitted to the outermost group" do
+ subject.should be_an_instance_of(ControllerSpecController)
+ end
+ describe "(doubly nested)" do
+ it "overrides the controller class submitted to the outermost group" do
+ subject.should be_an_instance_of(ControllerSpecController)
+ end
+ end
+ end
+ end
+ end
+
+ describe ControllerExampleGroup do
+ it "should clear its name from the description" do
+ group = describe("foo", :type => :controller) do
+ $nested_group = describe("bar") do
+ end
+ end
+ group.description.to_s.should == "foo"
+ $nested_group.description.to_s.should == "foo bar"
+ end
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+require 'controller_spec_controller'
+
+describe "a controller spec running in isolation mode", :type => :controller do
+ controller_name :controller_spec
+
+ it "does not care if the specified template doesn't exist" do
+ get 'some_action'
+ response.should be_success
+ response.should render_template("template/that/does/not/actually/exist")
+ end
+
+ it "does not care if the implied template doesn't exist" do
+ get 'some_action_with_implied_template'
+ response.should be_success
+ response.should render_template("some_action_with_implied_template")
+ end
+
+ it "does not care if the template has errors" do
+ get 'action_with_errors_in_template'
+ response.should be_success
+ response.should render_template("action_with_errors_in_template")
+ end
+
+ it "does not care if the template exists but the action doesn't" do
+ get 'non_existent_action_with_existent_template'
+ response.should be_success
+ end
+
+ it "fails if the neither the action nor the template exist" do
+ expect {get 'non_existent_action'}.to raise_error(ActionController::UnknownAction)
+ end
+end
+
+describe "a controller spec running in integration mode", :type => :controller do
+ controller_name :controller_spec
+ integrate_views
+
+ it "renders a template" do
+ get 'action_with_template'
+ response.should be_success
+ response.should have_tag('div', 'This is action_with_template.rhtml')
+ end
+
+ it "fails if the template doesn't exist" do
+ error = defined?(ActionController::MissingTemplate) ? ActionController::MissingTemplate : ActionView::MissingTemplate
+ lambda { get 'some_action' }.should raise_error(error)
+ end
+
+ it "fails if the template has errors" do
+ lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
+ end
+
+ it "fails if the action doesn't exist" do
+ expect {get 'non_existent_action'}.to raise_error(ActionController::UnknownAction)
+ end
+
+ describe "nested" do
+ it "should render a template" do
+ get 'action_with_template'
+ response.should be_success
+ response.should have_tag('div', 'This is action_with_template.rhtml')
+ end
+
+ describe "with integrate_views turned off" do
+ integrate_views false
+
+ it "should not care if the template doesn't exist" do
+ get 'some_action'
+ response.should be_success
+ response.should render_template("template/that/does/not/actually/exist")
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+class CookiesProxyExamplesController < ActionController::Base
+ def index
+ cookies[:key] = cookies[:key]
+ render :text => ""
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ describe CookiesProxy, :type => :controller do
+ controller_name :cookies_proxy_examples
+
+ describe "with a String key" do
+
+ it "should accept a String value" do
+ proxy = CookiesProxy.new(self)
+ proxy['key'] = 'value'
+ get :index
+ if ::Rails::VERSION::STRING >= "2.3"
+ proxy['key'].should == 'value'
+ else
+ proxy['key'].should == ['value']
+ end
+ end
+
+ it "should accept a Hash value" do
+ proxy = CookiesProxy.new(self)
+ proxy['key'] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+ get :index
+ if ::Rails::VERSION::STRING >= "2.3"
+ proxy['key'].should == 'value'
+ else
+ proxy['key'].should == ['value']
+ proxy['key'].value.should == ['value']
+ proxy['key'].expires.should == expiration
+ proxy['key'].path.should == path
+ end
+ end
+
+ end
+
+ describe "with a Symbol key" do
+
+ it "should accept a String value" do
+ proxy = CookiesProxy.new(self)
+ proxy[:key] = 'value'
+ get :index
+ if ::Rails::VERSION::STRING >= "2.3"
+ proxy[:key].should == 'value'
+ else
+ proxy[:key].should == ['value']
+ end
+ end
+
+ it "should accept a Hash value" do
+ proxy = CookiesProxy.new(self)
+ proxy[:key] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+ get :index
+ if ::Rails::VERSION::STRING >= "2.3"
+ proxy[:key].should == 'value'
+ else
+ proxy[:key].should == ['value']
+ proxy[:key].value.should == ['value']
+ proxy[:key].expires.should == expiration
+ proxy[:key].path.should == path
+ end
+ end
+
+ end
+
+ describe "#delete" do
+ it "should delete from the response cookies" do
+ proxy = CookiesProxy.new(self)
+ response_cookies = mock('cookies')
+ response.should_receive(:cookies).and_return(response_cookies)
+ response_cookies.should_receive(:delete).with('key')
+ proxy.delete :key
+ end
+ end
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+require 'controller_spec_controller'
+
+['integration', 'isolation'].each do |mode|
+ describe "A controller example running in #{mode} mode", :type => :controller do
+ controller_name :controller_spec
+ integrate_views if mode == 'integration'
+
+ describe "without use_rails_error_handling!" do
+ describe "with an error that is *not* rescued" do
+ it "raises the error" do
+ lambda do
+ get 'un_rescued_error_action'
+ end.should raise_error(ControllerSpecController::UnRescuedError)
+ end
+ end
+ describe "with an error that *is* rescued" do
+ it "returns a 200" do
+ get 'rescued_error_action'
+ response.response_code.should == 200
+ end
+ end
+ end
+
+ describe "with deprecated use_rails_error_handling!" do
+ before(:each) do
+ Kernel.stub!(:warn)
+ end
+
+ it "warns of deprecation" do
+ Kernel.should_receive(:warn).with(/DEPRECATION NOTICE/)
+ controller.use_rails_error_handling!
+ end
+
+ describe "with an error that is *not* rescued" do
+ it "returns the error code" do
+ controller.use_rails_error_handling!
+ get 'un_rescued_error_action'
+ response.response_code.should == 500
+ end
+ end
+
+ describe "with an error that *is* rescued" do
+ it "returns a 200" do
+ controller.use_rails_error_handling!
+ get 'rescued_error_action'
+ response.response_code.should == 200
+ end
+ end
+ end
+
+ describe "with rescue_action_in_public!" do
+ describe "with an error that is *not* rescued" do
+ it "returns the error code" do
+ rescue_action_in_public!
+ get 'un_rescued_error_action'
+ response.response_code.should == 500
+ end
+ end
+
+ describe "with an error that *is* rescued" do
+ it "returns a 200" do
+ rescue_action_in_public!
+ get 'rescued_error_action'
+ response.response_code.should == 200
+ end
+ end
+ end
+
+ describe "with bypass_rescue" do
+ describe "with an error that is *not* rescued" do
+ it "raises the error" do
+ bypass_rescue
+ lambda do
+ get 'un_rescued_error_action'
+ end.should raise_error(ControllerSpecController::UnRescuedError)
+ end
+ end
+
+ describe "with an error that *is* rescued" do
+ it "raises the error" do
+ bypass_rescue
+ lambda do
+ get 'rescued_error_action'
+ end.should raise_error(ControllerSpecController::RescuedError)
+ end
+ end
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+
+module Spec
+ module Example
+ describe ExampleGroupFactory do
+ it "should return a ModelExampleGroup when given :type => :model" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :type => :model
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
+ end
+
+ it "should return a ModelExampleGroup when given :location => '/blah/spec/models/'" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/models/blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
+ end
+
+ it "should return a ModelExampleGroup when given :location => '\\blah\\spec\\models\\' (windows format)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '\\blah\\spec\\models\\blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
+ end
+
+ it "should return an ActiveSupport::TestCase when given :location => '/blah/spec/foo/' (anything other than controllers, views and helpers)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/foo/blah.rb'
+ ) {}
+ example_group.superclass.should == ActiveSupport::TestCase
+ end
+
+ it "should return an ActiveSupport::TestCase when given :location => '\\blah\\spec\\foo\\' (windows format) (anything other than controllers, views and helpers)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '\\blah\\spec\\foo\\blah.rb'
+ ) {}
+ example_group.superclass.should == ActiveSupport::TestCase
+ end
+
+ it "should return a ViewExampleGroup when given :type => :view" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :type => :view
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
+ end
+
+ it "should return a ViewExampleGroup when given :location => '/blah/spec/views/'" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/views/blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
+ end
+
+ it "should return a ModelExampleGroup when given :location => '\\blah\\spec\\views\\' (windows format)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '\\blah\\spec\\views\\blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
+ end
+
+ it "should return a HelperExampleGroup when given :type => :helper" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :type => :helper
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
+ end
+
+ it "should return a HelperExampleGroup when given :location => '/blah/spec/helpers/'" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/helpers/blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
+ end
+
+ it "should return a ModelExampleGroup when given :location => '\\blah\\spec\\helpers\\' (windows format)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '\\blah\\spec\\helpers\\blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
+ end
+
+ it "should return a ControllerExampleGroup when given :type => :controller" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :type => :controller
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
+ end
+
+ it "should return a ControllerExampleGroup when given :location => '/blah/spec/controllers/'" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/controllers/blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
+ end
+
+ it "should return a ModelExampleGroup when given :location => '\\blah\\spec\\controllers\\' (windows format)" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '\\blah\\spec\\controllers\\blah.rb'
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
+ end
+
+ it "should favor the :type over the :location" do
+ example_group = Spec::Example::ExampleGroupFactory.create_example_group(
+ "name", :location => '/blah/spec/models/blah.rb', :type => :controller
+ ) {}
+ example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+Spec::Runner.configuration.global_fixtures = :people
+
+describe ExplicitHelper, :type => :helper do
+ include ExplicitHelper
+
+ it "should not require naming the helper if describe is passed a type" do
+ method_in_explicit_helper.should match(/text from a method/)
+ helper.method_in_explicit_helper.should match(/text from a method/)
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ describe HelperExampleGroup, :type => :helper do
+ helper_name :explicit
+
+ accesses_configured_helper_methods
+
+ it "DEPRECATED should have direct access to methods defined in helpers" do
+ method_in_explicit_helper.should =~ /text from a method/
+ end
+
+ it "should expose the helper with the #helper method" do
+ helper.method_in_explicit_helper.should =~ /text from a method/
+ end
+
+ it "should have access to named routes" do
+ rspec_on_rails_specs_url.should == "http://test.host/rspec_on_rails_specs"
+ rspec_on_rails_specs_path.should == "/rspec_on_rails_specs"
+
+ helper.named_url.should == "http://test.host/rspec_on_rails_specs"
+ helper.named_path.should == "/rspec_on_rails_specs"
+ end
+
+ it "should fail if the helper method deson't exist" do
+ lambda { non_existent_helper_method }.should raise_error(NameError)
+ lambda { helper.non_existent_helper_method }.should raise_error(NameError)
+ end
+
+ it "should have access to session" do
+ session[:foo] = 'bar'
+ session_foo.should == 'bar'
+ helper.session_foo.should == 'bar'
+ end
+
+ it "should have access to params" do
+ params[:foo] = 'bar'
+ params_foo.should == 'bar'
+ helper.params_foo.should == 'bar'
+ end
+
+ it "should have access to request" do
+ request.stub!(:thing).and_return('bar')
+ request_thing.should == 'bar'
+ helper.request_thing.should == 'bar'
+ end
+
+ it "should have access to flash" do
+ flash[:thing] = 'camera'
+ flash_thing.should == 'camera'
+ helper.flash_thing.should == 'camera'
+ end
+ end
+
+ describe HelperExampleGroup, "#eval_erb", :type => :helper do
+ helper_name :explicit
+
+ it "should support methods that accept blocks" do
+ eval_erb("<% prepend 'foo' do %>bar<% end %>").should == "foobar"
+ end
+ end
+
+ describe HelperExampleGroup, ".fixtures", :type => :helper do
+ helper_name :explicit
+ fixtures :animals
+
+ it "should load fixtures" do
+ pig = animals(:pig)
+ pig.class.should == Animal
+ end
+
+ it "should load global fixtures" do
+ lachie = people(:lachie)
+ lachie.class.should == Person
+ end
+ end
+
+ describe "methods from standard helpers", :type => :helper do
+ helper_name :explicit
+ it "should be exposed to the helper" do
+ helper.link_to("Foo","http://bar").should have_tag("a")
+ end
+ end
+
+ describe HelperExampleGroup, "included modules", :type => :helper do
+ helpers = [
+ ActionView::Helpers::ActiveRecordHelper,
+ ActionView::Helpers::AssetTagHelper,
+ ActionView::Helpers::BenchmarkHelper,
+ ActionView::Helpers::CacheHelper,
+ ActionView::Helpers::CaptureHelper,
+ ActionView::Helpers::DateHelper,
+ ActionView::Helpers::DebugHelper,
+ ActionView::Helpers::FormHelper,
+ ActionView::Helpers::FormOptionsHelper,
+ ActionView::Helpers::FormTagHelper,
+ ActionView::Helpers::JavaScriptHelper,
+ ActionView::Helpers::NumberHelper,
+ ActionView::Helpers::PrototypeHelper,
+ ActionView::Helpers::ScriptaculousHelper,
+ ActionView::Helpers::TagHelper,
+ ActionView::Helpers::TextHelper,
+ ActionView::Helpers::UrlHelper
+ ]
+ helpers.each do |helper_module|
+ it "should include #{helper_module}" do
+ self.class.ancestors.should include(helper_module)
+ helper.class.ancestors.should include(helper_module)
+ end
+ end
+ end
+
+ # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
+ # When that is done, remove this method
+ describe HelperExampleGroup, "#protect_against_forgery?", :type => :helper do
+ it "should return false" do
+ protect_against_forgery?.should be_false
+ helper.protect_against_forgery?.should be_false
+ end
+ end
+
+ describe HelperExampleGroup, "#assigns", :type => :helper do
+ helper_name :addition
+ it "should expose variables to helper" do
+ assigns[:addend] = 3
+ helper.plus(4).should == 7
+ end
+
+ it "should make helper ivars available in example" do
+ assigns[:addend] = 3
+ assigns[:addend].should == 3
+ end
+ end
+
+ describe HelperExampleGroup, "using a helper that uses output_buffer inside helper", :type => :helper do
+ helper_name :explicit
+
+ before(:each) do
+ if ::Rails::VERSION::STRING < "2.2"
+ pending("need to get this new feature working against pre 2.2 versions of rails")
+ end
+ end
+
+ it "should not raise an error" do
+ lambda { method_using_output_buffer }.should_not raise_error
+ end
+
+ it "should put the output in the output_buffer" do
+ method_using_output_buffer
+ output_buffer.should == "the_text_from_concat"
+ end
+ end
+
+ describe HelperExampleGroup, "using a helper that tries to access @template", :type => :helper do
+ helper_name :explicit
+
+ it "should not raise an error" do
+ lambda { method_using_template }.should_not raise_error
+ end
+
+ it "should have the correct output" do
+ method_using_template.should have_text(/#some_id/)
+ end
+ end
+
+ end
+ end
+end
+
+module Bug11223
+ # see http://rubyforge.org/tracker/index.php?func=detail&aid=11223&group_id=797&atid=3149
+ describe 'Accessing flash from helper spec', :type => :helper do
+ it 'should not raise an error' do
+ lambda { flash['test'] }.should_not raise_error
+ end
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ describe HelperExampleGroup do
+ it "should clear its name from the description" do
+ group = describe("foo", :type => :helper) do
+ $nested_group = describe("bar") do
+ end
+ end
+ group.description.to_s.should == "foo"
+ $nested_group.description.to_s.should == "foo bar"
+ end
+ end
+ end
+ end
+end
+
+module Bug719
+ # see http://rspec.lighthouseapp.com/projects/5645/tickets/719
+ # FIXME - helper and example provided in ticket. The example did
+ # fail initially, so running it now shows that the bug is fixed,
+ # but this doesn't serve as a good internal example.
+ module ImagesHelper
+ def hide_images_button
+ content_tag :div, :class => :hide_images_button do
+ button_to_function "Hide Images", :id => :hide_images_button do |page|
+ page[:more_images_button].toggle
+ page[:image_browser].toggle
+ end
+ end
+ end
+ end
+
+ describe ImagesHelper, :type => :helper do
+ it "should render a hide_images_button" do
+ helper.hide_images_button.should have_tag('div[class=?]','hide_images_button') do
+ with_tag('input[id=?][type=?][value=?][onclick^=?]',
+ 'hide_images_button', 'button', 'Hide Images',
+ "$("more_images_button").toggle();\n$("image_browser").toggle();;")
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+module Spec
+ module Rails
+ module Example
+ describe ModelExampleGroup do
+ accesses_configured_helper_methods
+
+ if defined?(ActiveRecord::TestCase)
+ it "derives from ActiveRecord::TestCase" do
+ group = describe("foo", :type => :model) do; end
+ group.ancestors.should include(ActiveRecord::TestCase)
+ end
+ else
+ it "derives from ActiveSupport::TestCase" do
+ group = describe("foo", :type => :model) do; end
+ group.ancestors.should include(ActiveSupport::TestCase)
+ end
+ end
+
+ it "clears its name from the description" do
+ group = describe("foo", :type => :model) do
+ $nested_group = describe("bar") do
+ end
+ end
+ group.description.to_s.should == "foo"
+ $nested_group.description.to_s.should == "foo bar"
+ end
+ end
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+require 'controller_spec_controller'
+require File.join(File.dirname(__FILE__), "/shared_routing_example_group_examples.rb")
+
+describe "Routing Examples", :type => :routing do
+
+ include RoutingExampleGroupSpec
+ include RouteToExampleGroupSpec
+ include BeRoutableExampleGroupSpec
+end
--- /dev/null
+class CustomRouteSpecController < ActionController::Base; end
+class RspecOnRailsSpecsController < ActionController::Base; end
+
+share_as :RoutingExampleGroupSpec do
+ describe "using backward compatible route_for()" do
+ it "translates GET-only paths to be explicit" do
+ self.should_receive(:assert_routing).with(hash_including(:method => :get), anything, {}, anything)
+ route_for(:controller => "controller_spec", :action => "some_action").
+ should == "/controller_spec/some_action"
+ end
+
+ it "uses assert_routing to specify that the :controller and :action are involved" do
+ @route = { :controller => "controller_spec", :action => "some_action" }
+ self.should_receive(:assert_routing).with(anything, @route, {}, anything)
+ route_for(@route).
+ should == "/controller_spec/some_action"
+ end
+
+ it "passes extra args through to assert_routing" do
+ @route = { :controller => "controller_spec", :action => "some_action" }
+ self.should_receive(:assert_routing).with(anything, anything, {}, { :a => "1", :b => "2" } )
+ route_for(@route).
+ should == "/controller_spec/some_action?a=1&b=2"
+ end
+
+ it "passes with an existing route" do
+ route_for(:controller => "controller_spec", :action => "some_action").
+ should == "/controller_spec/some_action"
+ end
+
+ it "passes with an existing route with additional parameters" do
+ route_for(:controller => "controller_spec", :action => "some_action", :param => '1').
+ should == "/controller_spec/some_action?param=1"
+ end
+
+ it "recognizes routes with methods besides :get" do
+ should_receive(:assert_routing).with(hash_including(:method => :put), anything, {}, anything)
+
+ route_for(:controller => "rspec_on_rails_specs", :action => "update", :id => "37").
+ should == {:path => "/rspec_on_rails_specs/37", :method => :put}
+ end
+
+ describe "failing due to bad path:" do
+ it "raises routing error and suggests should_not be_routeable()" do
+ lambda {
+ route_for(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37") ==
+ {:path => "/rspec_on_rails_specs/bad_route/37", :method => :put}
+ }.should raise_error( ActionController::RoutingError, /suggest.*should_not be_routable/ )
+ end
+ end
+
+ describe "failing due to params mismatch:" do
+ it "re-raises assertion and suggests should_not be_routeable()" do
+ lambda {
+ route_for(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37") ==
+ {:path => "/rspec_on_rails_specs/37", :method => :put}
+ }.should raise_error( ::Test::Unit::AssertionFailedError, /suggest.*should_not be_routable/ )
+ end
+ end
+
+ describe "failing due to wrong HTTP method" do
+ it "raises method error and suggest should_not be_routable()" do
+ lambda {
+ route_for(:controller => "rspec_on_rails_specs", :action => "update", :id => "37").
+ should == {:path => "/rspec_on_rails_specs/37", :method => :post}
+ }.should raise_error(ActionController::MethodNotAllowed) { |error| error.should_not =~ /should_not be_routable/ }
+ end
+ end
+
+ it "generates params for custom routes" do
+ # redundant, deprecated
+ params_from(:get, '/custom_route').
+ should == {:controller => "custom_route_spec", :action => "custom_route"}
+ end
+
+ it "generates params for existing routes" do
+ # redundant, deprecated
+ params_from(:get, '/controller_spec/some_action').
+ should == {:controller => "controller_spec", :action => "some_action"}
+ end
+
+ it "generates params for existing routes with a query parameters" do
+ # redundant, deprecated
+ params_from(:get, '/controller_spec/some_action?param=1').
+ should == {:controller => "controller_spec", :action => "some_action", :param => '1'}
+ end
+
+ it "generates params for existing routes with multiple query parameters" do
+ # redundant, deprecated
+ params_from(:get, '/controller_spec/some_action?param1=1¶m2=2').
+ should == {:controller => "controller_spec", :action => "some_action", :param1 => '1', :param2 => '2' }
+ end
+ end
+end
+
+share_as :BeRoutableExampleGroupSpec do
+ describe "using should_not be_routable()" do
+ it "passes for a bad route" do
+ { :put => "/rspec_on_rails_specs/bad_route/37" }.
+ should_not be_routable
+ end
+ it "passes for a bad route having an arg" do
+ { :put => "/rspec_on_rails_specs/bad_route/37?some_arg=1" }.
+ should_not be_routable
+ end
+ describe "when assert_recognizes throws exceptions:" do
+ [ ActionController::RoutingError, ActionController::MethodNotAllowed ].each do |e|
+ it "passes on #{e}" do
+ self.stub!( :assert_recognizes ).and_return { raise e, "stubbed exception" }
+ { :get => "/rspec_on_rails_spec/bad_route/37" }.should_not be_routable
+ end
+ it "should be_routable on usual Test::Unit::AssertionFailedError" do
+ # <{}> is predictable because of the way we call assert_recognizes during be_routable().
+ self.stub!( :assert_recognizes ).and_return { raise ::Test::Unit::AssertionFailedError, "<{a}> did not match <{}>" }
+ { :get => "/rspec_on_rails_spec/arguably_bad_route" }.should be_routable
+ end
+ it "should re-raise on unusual Test::Unit::AssertionFailedError" do
+ self.stub!( :assert_recognizes ).and_return { raise ::Test::Unit::AssertionFailedError, "some other message" }
+ expect { { :get => "/rspec_on_rails_spec/weird_case_route/" }.should be_routable }.
+ to raise_error
+ end
+ end
+ end
+ it "test should be_routable" do
+ { :get => "/custom_route" }.
+ should be_routable
+ end
+
+ it "recommends route_to() on failure with should()" do
+ lambda {
+ { :get => "/nonexisting_route" }.
+ should be_routable
+ }.should raise_error( /route_to\(/)
+ end
+
+ it "shows actual route that was generated on failure with should_not()" do
+ begin
+ { :get => "/custom_route" }.should_not be_routable
+ rescue Exception => e
+ ensure
+ # Different versions of ruby order these differently
+ e.message.should =~ /"action"=>"custom_route"/
+ e.message.should =~ /"controller"=>"custom_route_spec"/
+ end
+ end
+
+ it "works with routeable (alternate spelling)" do
+ { :put => "/nonexisting_route" }.
+ should_not be_routeable
+ end
+ end
+end
+
+share_as :RouteToExampleGroupSpec do
+ describe "using should[_not] route_to()" do
+ it "supports existing routes" do
+ { :get => "/controller_spec/some_action" }.
+ should route_to( :controller => "controller_spec", :action => "some_action" )
+ end
+
+ it "translates GET-only paths to be explicit, when matching against a string (for parity with route_for().should == '/path')" do
+ self.should_receive(:assert_routing).with(hash_including(:method => :get), anything, {}, anything)
+ "/controller_spec/some_action".
+ should route_to({})
+ end
+
+ it "asserts, using assert_routing, that the :controller and :action are involved" do
+ @route = { :controller => "controller_spec", :action => "some_action" }
+ self.should_receive(:assert_routing).with(anything, @route, {}, anything)
+ "/controller_spec/some_action".
+ should route_to(@route)
+ end
+
+ it "sends extra args through" do
+ @route = { :controller => "controller_spec", :action => "some_action" }
+ self.should_receive(:assert_routing).with(anything, anything, {}, { :a => "1", :b => "2" } )
+ "/controller_spec/some_action?a=1&b=2".
+ should route_to( @route )
+ end
+
+ it "supports routes with additional parameters" do
+ { :get => "/controller_spec/some_action?param=1" }.
+ should route_to( :controller => "controller_spec", :action => "some_action", :param => '1' )
+ end
+
+ it "recognizes routes with methods besides :get" do
+ self.should_receive(:assert_routing).with(hash_including(:method => :put), anything, {}, anything)
+ { :put => "/rspec_on_rails_specs/37" }.
+ should route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37")
+ end
+
+ it "allows only one key/value in the path - :method => path" do
+ lambda {
+ { :a => "b" ,:c => "d" }.
+ should route_to("anything")
+ }.should raise_error( ArgumentError, /usage/ )
+ end
+
+ describe "failing due to bad path" do
+ it "raises routing error, and suggests should_not be_routeable()" do
+ lambda {
+ { :put => "/rspec_on_rails_specs/nonexistent/37" }.
+ should route_to(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37")
+ }.should raise_error( ActionController::RoutingError, /suggest.*nonexistent.*should_not be_routable/ )
+ end
+ end
+
+ describe "failing due to params mismatch" do
+ it "raises assertion, and suggests should_not be_routeable()" do
+ lambda {
+ { :put => "/rspec_on_rails_specs/37" }.
+ should route_to(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37")
+ }.should raise_error( ::Test::Unit::AssertionFailedError, /suggest.*rspec_on_rails_specs\/37.*should_not be_routable/ )
+ end
+ end
+
+ describe "passing when expected failure" do
+ it "suggests should_not be_routable()" do
+ self.stub!(:assert_routing).and_return true
+ lambda {
+ { :put => "/rspec_on_rails_specs/37" }.
+ should_not route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37")
+ }.should raise_error( /expected a routing error.*be_routable/im )
+ end
+ end
+
+ describe "failing due to wrong HTTP method" do
+ it "raises method error and suggests should_not be_routable()" do
+ self.stub!(:assert_routing) { raise ActionController::MethodNotAllowed }
+ lambda {
+ { :post => "/rspec_on_rails_specs/37" }.
+ should route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37" )
+ }.should raise_error(ActionController::MethodNotAllowed, /rspec_on_rails_specs\/37.*should_not be_routable/ )
+ end
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe "assert_equal", :shared => true do
+ it "like assert_equal" do
+ assert_equal 1, 1
+ lambda {
+ assert_equal 1, 2
+ }.should raise_error(::Test::Unit::AssertionFailedError)
+ end
+end
+
+describe "A model spec should be able to access 'test/unit' assertions", :type => :model do
+ it_should_behave_like "assert_equal"
+end
+
+describe "A view spec should be able to access 'test/unit' assertions", :type => :view do
+ it_should_behave_like "assert_equal"
+end
+
+describe "A helper spec should be able to access 'test/unit' assertions", :type => :helper do
+ it_should_behave_like "assert_equal"
+end
+
+describe "A controller spec with integrated views should be able to access 'test/unit' assertions", :type => :controller do
+ controller_name :controller_spec
+ integrate_views
+ it_should_behave_like "assert_equal"
+end
+
+describe "A controller spec should be able to access 'test/unit' assertions", :type => :controller do
+ controller_name :controller_spec
+ it_should_behave_like "assert_equal"
+end
--- /dev/null
+require 'spec_helper'
+
+describe "A template with an implicit helper", :type => :view do
+ before(:each) do
+ render "view_spec/implicit_helper"
+ end
+
+ accesses_configured_helper_methods
+
+ it "should include the helper" do
+ response.should have_tag('div', :content => "This is text from a method in the ViewSpecHelper")
+ end
+
+ it "should include the application helper" do
+ response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
+ end
+
+ it "should have access to named routes" do
+ rspec_on_rails_specs_url.should == "http://test.host/rspec_on_rails_specs"
+ rspec_on_rails_specs_path.should == "/rspec_on_rails_specs"
+ end
+end
+
+describe "A template requiring an explicit helper", :type => :view do
+ before(:each) do
+ render "view_spec/explicit_helper", :helper => 'explicit'
+ end
+
+ it "should include the helper if specified" do
+ response.should have_tag('div', :content => "This is text from a method in the ExplicitHelper")
+ end
+
+ it "should include the application helper" do
+ response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
+ end
+end
+
+describe "A template requiring multiple explicit helpers", :type => :view do
+ before(:each) do
+ render "view_spec/multiple_helpers", :helpers => ['explicit', 'more_explicit']
+ end
+
+ it "should include all specified helpers" do
+ response.should have_tag('div', :content => "This is text from a method in the ExplicitHelper")
+ response.should have_tag('div', :content => "This is text from a method in the MoreExplicitHelper")
+ end
+
+ it "should include the application helper" do
+ response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
+ end
+end
+
+describe "Message Expectations on helper methods", :type => :view do
+ it "should work" do
+ template.should_receive(:method_in_plugin_application_helper).and_return('alternate message 1')
+ render "view_spec/implicit_helper"
+ response.body.should =~ /alternate message 1/
+ end
+
+ it "should work twice" do
+ template.should_receive(:method_in_plugin_application_helper).and_return('alternate message 2')
+ render "view_spec/implicit_helper"
+ response.body.should =~ /alternate message 2/
+ end
+end
+
+describe "A template that includes a partial", :type => :view do
+ def render!
+ render "view_spec/template_with_partial"
+ end
+
+ it "should render the enclosing template" do
+ render!
+ response.should have_tag('div', "method_in_partial in ViewSpecHelper")
+ end
+
+ it "should render the partial" do
+ render!
+ response.should have_tag('div', "method_in_template_with_partial in ViewSpecHelper")
+ end
+
+ it "should include the application helper" do
+ render!
+ response.should have_tag('div', "This is text from a method in the ApplicationHelper")
+ end
+
+ it "should pass should_receive(:render) with the right partial" do
+ template.should_receive(:render).with(:partial => 'partial')
+ render!
+ template.verify_rendered
+ end
+
+ it "should fail should_receive(:render) with the wrong partial" do
+ template.should_receive(:render).with(:partial => 'non_existent')
+ render!
+ begin
+ template.verify_rendered
+ rescue Spec::Mocks::MockExpectationError => e
+ ensure
+ e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
+ end
+ end
+
+ it "should pass should_receive(:render) when a partial is expected twice and happens twice" do
+ template.should_receive(:render).with(:partial => 'partial_used_twice').twice
+ render!
+ template.verify_rendered
+ end
+
+ it "should pass should_receive(:render) when a partial is expected once and happens twice" do
+ template.should_receive(:render).with(:partial => 'partial_used_twice')
+ render!
+ begin
+ template.verify_rendered
+ rescue Spec::Mocks::MockExpectationError => e
+ ensure
+ e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
+ end
+ end
+
+ it "should fail should_receive(:render) with the right partial but wrong options" do
+ template.should_receive(:render).with(:partial => 'partial', :locals => {:thing => Object.new})
+ render!
+ lambda {template.verify_rendered}.should raise_error(Spec::Mocks::MockExpectationError)
+ end
+end
+
+describe "A partial that includes a partial", :type => :view do
+ it "should support should_receive(:render) with nested partial" do
+ obj = Object.new
+ template.should_receive(:render).with(:partial => 'partial', :object => obj)
+ render :partial => "view_spec/partial_with_sub_partial", :locals => { :partial => obj }
+ end
+end
+
+describe "A view that includes a partial using :collection and :spacer_template", :type => :view do
+ it "should render the partial w/ spacer_tamplate" do
+ render "view_spec/template_with_partial_using_collection"
+ response.should have_tag('div',/method_in_partial/)
+ response.should have_tag('div',/ApplicationHelper/)
+ response.should have_tag('div',/ViewSpecHelper/)
+ response.should have_tag('hr#spacer')
+ end
+
+ it "should render the partial" do
+ template.should_receive(:render).with(:partial => 'partial',
+ :collection => ['Alice', 'Bob'],
+ :spacer_template => 'spacer')
+ render "view_spec/template_with_partial_using_collection"
+ end
+
+end
+
+describe "A view that includes a partial using an array as partial_path", :type => :view do
+ before(:each) do
+ renderable_object = Object.new
+ renderable_object.stub!(:name).and_return("Renderable Object")
+ assigns[:array] = [renderable_object]
+ end
+
+ it "should render the array passed through to render_partial without modification" do
+ render "view_spec/template_with_partial_with_array"
+ response.body.should match(/^Renderable Object$/)
+ end
+end
+
+describe "Different types of renders (not :template)", :type => :view do
+ it "should render partial with local" do
+ render :partial => "view_spec/partial_with_local_variable", :locals => {:x => "Ender"}
+ response.should have_tag('div', :content => "Ender")
+ end
+end
+
+describe "A view", :type => :view do
+ before(:each) do
+ session[:key] = "session"
+ params[:key] = "params"
+ flash[:key] = "flash"
+ flash.now[:now_key] = "flash.now"
+ render "view_spec/accessor"
+ end
+
+ it "uses the template as the implicit subject" do
+ subject.should == template
+ end
+
+ it "has access to session data" do
+ response.should have_tag("div#session", "session")
+ end
+
+ it "has access to params data" do
+ response.should have_tag("div#params", "params")
+ end
+
+ it "has access to flash" do
+ response.should have_tag("div#flash", "flash")
+ end
+
+ it "has access to flash.now" do
+ response.should have_tag("div#flash_now", "flash.now")
+ end
+
+ it "has a controller param" do
+ response.should have_tag("div#controller", "view_spec")
+ end
+
+ it "has an action param" do
+ response.should have_tag("div#action", "accessor")
+ end
+end
+
+describe "A view with a form_tag", :type => :view do
+ it "should render the right action" do
+ render "view_spec/entry_form"
+ response.should have_tag("form[action=?]","/view_spec/entry_form")
+ end
+end
+
+describe "An instantiated ViewExampleGroupController", :type => :view do
+ before do
+ render "view_spec/foo/show"
+ end
+
+ it "should return the name of the real controller that it replaces" do
+ @controller.controller_name.should == 'foo'
+ end
+
+ it "should return the path of the real controller that it replaces" do
+ @controller.controller_path.should == 'view_spec/foo'
+ end
+end
+
+describe "a block helper", :type => :view do
+ it "should not yield when not told to in the example" do
+ template.should_receive(:if_allowed)
+ render "view_spec/block_helper"
+ response.should_not have_tag("div","block helper was rendered")
+ end
+
+ it "should yield when told to in the example" do
+ template.should_receive(:if_allowed).and_yield
+ render "view_spec/block_helper"
+ response.should have_tag("div","block helper was rendered")
+ end
+end
+
+describe "render :inline => ...", :type => :view do
+ it "should render ERB right in the spec" do
+ render :inline => %|<%= text_field_tag('field_name', 'Value') %>|
+ response.should have_tag("input[type=?][name=?][value=?]","text","field_name","Value")
+ end
+end
+
+describe "render 'view_spec/foo/show'", :type => :view do
+ it "should derive action name using the first part of the template name" do
+ render 'view_spec/foo/show'
+ request.path_parameters[:action].should == 'show'
+ end
+end
+
+describe "view_spec/foo/show", :type => :view do
+ context "rendered with no args" do
+ it "renders just fine" do
+ render
+ request.path_parameters[:action].should == 'show'
+ end
+ end
+end
+
+describe "setting path parameters", :type => :view do
+ describe "(controller)" do
+ it "should supercede the default path parameters" do
+ render "view_spec/entry_form", :path_parameters => {:controller => 'foo'}
+ request.path_parameters[:controller].should == 'foo'
+ end
+ end
+ describe "(action)" do
+ it "should supercede the default path parameters" do
+ render "view_spec/entry_form", :path_parameters => {:action => 'foo'}
+ request.path_parameters[:action].should == 'foo'
+ end
+ end
+ describe "(something arbitrary)" do
+ it "should supercede the default path parameters" do
+ render "view_spec/entry_form", :path_parameters => {:foo => 'bar'}
+ request.path_parameters[:foo].should == 'bar'
+ end
+ end
+end
+
+describe "route helpers", :type => :view do
+ it "should be available before render is called" do
+ custom_route_path.should == '/custom_route'
+ end
+end
+
+module Spec
+ module Rails
+ module Example
+ describe ViewExampleGroup do
+ it "should clear its name from the description" do
+ group = describe("foo", :type => :view) do
+ $nested_group = describe("bar") do
+ end
+ end
+ group.description.to_s.should == "foo"
+ $nested_group.description.to_s.should == "foo bar"
+ end
+
+ it "should clear ActionView::Base.base_view_path on teardown" do
+ group = describe("base_view_path_cleared flag", :type => :view) {}
+ example = group.new(Spec::Example::ExampleProxy.new) {}
+
+ ActionView::Base.should_receive(:base_view_path=).with(nil)
+ example.run_after_each
+ end
+ end
+ end
+ end
+end
+
+describe "bug http://rspec.lighthouseapp.com/projects/5645/tickets/510", :type => :view do
+ describe "a view example with should_not_receive" do
+ it "should render the view" do
+ obj = mock('model')
+ obj.should_receive(:render_partial?).and_return false
+ assigns[:obj] = obj
+ template.should_not_receive(:render).with(:partial => 'some_partial')
+ render "view_spec/should_not_receive"
+ end
+ end
+end
+
+describe "bug https://rspec.lighthouseapp.com/projects/5645/tickets/787", :type => :view do
+ describe "a view example checking a link" do
+ it "should have access to link_to" do
+ render "view_spec/view_helpers"
+ response.body.should include(link_to("edit", "this_is_the_link"))
+ end
+
+ it "should use link_to within have_tag" do
+ render "view_spec/view_helpers"
+ response.body.should have_tag("span", :html => link_to("edit", "this_is_the_link"))
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+require 'spec/mocks/errors'
+
+describe ActionView::Base, "with RSpec extensions:", :type => :view do
+
+ describe "should_receive(:render)" do
+ it "should not raise when render has been received" do
+ template.should_receive(:render).with(:partial => "name")
+ template.render :partial => "name"
+ end
+
+ it "should raise when render has NOT been received" do
+ template.should_receive(:render).with(:partial => "name")
+ lambda {
+ template.verify_rendered
+ }.should raise_error
+ end
+
+ it "should return something (like a normal mock)" do
+ template.should_receive(:render).with(:partial => "name").and_return("Little Johnny")
+ result = template.render :partial => "name"
+ result.should == "Little Johnny"
+ end
+ end
+
+ [:stub!, :stub].each do |method|
+ describe "#{method}(:render)" do
+ it "should not raise when stubbing and render has been received" do
+ template.send(method, :render).with(:partial => "name")
+ template.render :partial => "name"
+ end
+
+ it "should not raise when stubbing and render has NOT been received" do
+ template.send(method, :render).with(:partial => "name")
+ end
+
+ it "should not raise when stubbing and render has been received with different options" do
+ template.send(method, :render).with(:partial => "name")
+ template.render :partial => "view_spec/spacer"
+ end
+
+ it "should not raise when stubbing and expecting and render has been received" do
+ template.send(method, :render).with(:partial => "name")
+ template.should_receive(:render).with(:partial => "name")
+ template.render(:partial => "name")
+ end
+ end
+
+ describe "#{method}(:helper_method)" do
+ it "should not raise when stubbing and helper_method has been received" do
+ template.send(method, :helper_method).with(:arg => "value")
+ template.helper_method :arg => "value"
+ end
+
+ it "should not raise when stubbing and helper_method has NOT been received" do
+ template.send(method, :helper_method).with(:arg => "value")
+ end
+
+ it "SHOULD raise when stubbing and helper_method has been received with different options" do
+ template.send(method, :helper_method).with(:arg => "value")
+ expect { template.helper_method :arg => "other_value" }.
+ to raise_error(/undefined .* `helper_method'/)
+ end
+
+ it "should not raise when stubbing and expecting and helper_method has been received" do
+ template.send(method, :helper_method).with(:arg => "value")
+ template.should_receive(:helper_method).with(:arg => "value")
+ template.helper_method(:arg => "value")
+ end
+ end
+
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+describe "A model" do
+ fixtures :things
+ it "should tell you its required fields" do
+ Thing.new.should have(1).error_on(:name)
+ end
+
+ it "should tell you how many records it has" do
+ Thing.should have(:no).records
+ Thing.create(:name => "THE THING")
+ Thing.should have(1).record
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+
+if ActiveSupport.const_defined?(:Callbacks) && Test::Unit::TestCase.include?(ActiveSupport::Callbacks)
+
+ class TestUnitTesting < Test::Unit::TestCase
+ @@setup_callback_count = 0
+ @@setup_method_count = 0
+ @@teardown_callback_count = 0
+ @@teardown_method_count = 0
+ cattr_accessor :setup_callback_count, :setup_method_count, :teardown_callback_count, :teardown_method_count
+
+ setup :do_some_setup
+ teardown :do_some_teardown
+
+ @@has_been_run = false
+ def self.run?
+ @@has_been_run
+ end
+
+ def self.run(options=Spec::Runner.options)
+ super options
+ end
+
+ def do_some_setup
+ @@setup_callback_count += 1
+ end
+
+ def setup
+ @@setup_method_count += 1
+ end
+
+ def test_something
+ assert_equal true, true
+ @@has_been_run = true
+ end
+
+ def teardown
+ @@teardown_method_count += 1
+ end
+
+ def do_some_teardown
+ @@teardown_callback_count += 1
+ end
+ end
+
+ module Test
+ module Unit
+ describe "Running TestCase tests" do
+ before(:all) do
+ TestUnitTesting.run unless TestUnitTesting.run?
+ end
+
+ it "should call the setup callbacks" do
+ TestUnitTesting.setup_callback_count.should == 1
+ end
+ it "should still only call the normal setup method once" do
+ TestUnitTesting.setup_method_count.should == 1
+ end
+ it "should call the teardown callbacks" do
+ TestUnitTesting.teardown_callback_count.should == 1
+ end
+ it "should still only call the normal teardown method once" do
+ TestUnitTesting.teardown_method_count.should == 1
+ end
+ end
+ end
+ end
+
+end
--- /dev/null
+require 'spec_helper'
+
+describe "be_valid" do
+ context "with valid attributes" do
+ it "returns true" do
+ be_valid.matches?(Thing.new(:name => 'thing')).should == true
+ end
+ end
+
+ context "with invalid attributes" do
+ it "returns false" do
+ be_valid.matches?(Thing.new).should == false
+ end
+
+ it "adds errors to the errors " do
+ expect { Thing.new.should be_valid }.to raise_error(/can't be blank/)
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+# assert_select plugins for Rails
+#
+# Copyright (c) 2006 Assaf Arkin, under Creative Commons Attribution and/or MIT License
+# Developed for http://co.mments.com
+# Code and documention: http://labnotes.org
+
+class AssertSelectController < ActionController::Base
+
+ def response=(content)
+ @content = content
+ end
+
+ def html()
+ render :text=>@content, :layout=>false, :content_type=>Mime::HTML
+ @content = nil
+ end
+
+ def rjs()
+ update = @update
+ render :update do |page|
+ update.call page
+ end
+ @update = nil
+ end
+
+ def xml()
+ render :text=>@content, :layout=>false, :content_type=>Mime::XML
+ @content = nil
+ end
+
+end
+
+class AssertSelectMailer < ActionMailer::Base
+
+ def test(html)
+ recipients "test <test@test.host>"
+ from "test@test.host"
+ subject "Test e-mail"
+ part :content_type=>"text/html", :body=>html
+ end
+
+end
+
+module AssertSelectSpecHelpers
+ def render_html(html)
+ @controller.response = html
+ get :html
+ end
+
+ def render_rjs(&block)
+ clear_response
+ @controller.response &block
+ get :rjs
+ end
+
+ def render_xml(xml)
+ @controller.response = xml
+ get :xml
+ end
+
+ def first_non_rspec_line_in_backtrace_of(error)
+ rlocation = File.join('rspec', 'lib', 'spec')
+ error.backtrace.reject { |line|
+ line =~ /#{rlocation}/
+ }.first
+ end
+
+ private
+ # necessary for 1.2.1
+ def clear_response
+ render_html("")
+ end
+end
+
+unless defined?(SpecFailed)
+ SpecFailed = Spec::Expectations::ExpectationNotMetError
+end
+
+describe "should have_tag", :type => :controller do
+ include AssertSelectSpecHelpers
+ controller_name :assert_select
+ integrate_views
+
+ it "should not care about the XML setting on HTML with unclosed singletons when using a response" do
+ render_html %Q{<table id="1"><tr><td><img src="image.png" alt="image">Hello</td></tr><tr><td></td></tr><tr><td>World</td></tr></table>}
+ response.should have_tag("tr", 3)
+ response.should have_tag("tr", 3, :xml => true)
+ end
+
+ it "should find specific numbers of elements" do
+ render_html %Q{<div id="1"></div><div id="2"></div>}
+ response.should have_tag( "div" )
+ response.should have_tag("div", 2)
+ lambda { response.should_not have_tag("div") }.should raise_error(SpecFailed, "should not have tag(\"div\"), but did")
+
+ lambda { response.should have_tag("div", 3) }.should raise_error(SpecFailed)
+ lambda { response.should have_tag("p") }.should raise_error(SpecFailed)
+ end
+
+ it "should expect to find elements when using true" do
+ render_html %Q{<div id="1"></div><div id="2"></div>}
+ response.should have_tag( "div", true )
+ lambda { response.should have_tag( "p", true )}.should raise_error(SpecFailed)
+ end
+
+ it "should expect to not find elements when using false" do
+ render_html %Q{<div id="1"></div><div id="2"></div>}
+ response.should have_tag( "p", false )
+ lambda { response.should have_tag( "div", false )}.should raise_error(SpecFailed)
+ end
+
+
+ it "should match submitted text using text or regexp" do
+ render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+ response.should have_tag("div", "foo")
+ response.should have_tag("div", /(foo|bar)/)
+ response.should have_tag("div", :text=>"foo")
+ response.should have_tag("div", :text=>/(foo|bar)/)
+
+ lambda { response.should have_tag("div", "bar") }.should raise_error(SpecFailed)
+ lambda { response.should have_tag("div", :text=>"bar") }.should raise_error(SpecFailed)
+ lambda { response.should have_tag("p", :text=>"foo") }.should raise_error(SpecFailed)
+
+ lambda { response.should have_tag("div", /foobar/) }.should raise_error(SpecFailed)
+ lambda { response.should have_tag("div", :text=>/foobar/) }.should raise_error(SpecFailed)
+ lambda { response.should have_tag("p", :text=>/foo/) }.should raise_error(SpecFailed)
+ end
+
+ it "should use submitted message" do
+ render_html %Q{nothing here}
+ lambda {
+ response.should have_tag("div", {}, "custom message")
+ }.should raise_error(SpecFailed, /custom message/)
+ end
+
+ it "should match submitted html" do
+ render_html %Q{<p>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</p>}
+ text = "\"This is not a big problem,\" he said."
+ html = "<em>\"This is <strong>not</strong> a big problem,\"</em> he said."
+ response.should have_tag("p", text)
+ lambda { response.should have_tag("p", html) }.should raise_error(SpecFailed)
+ response.should have_tag("p", :html=>html)
+ lambda { response.should have_tag("p", :html=>text) }.should raise_error(SpecFailed)
+
+ # # No stripping for pre.
+ render_html %Q{<pre>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</pre>}
+ text = "\n\"This is not a big problem,\" he said.\n"
+ html = "\n<em>\"This is <strong>not</strong> a big problem,\"</em> he said.\n"
+ response.should have_tag("pre", text)
+ lambda { response.should have_tag("pre", html) }.should raise_error(SpecFailed)
+ response.should have_tag("pre", :html=>html)
+ lambda { response.should have_tag("pre", :html=>text) }.should raise_error(SpecFailed)
+ end
+
+ it "should match number of instances" do
+ render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+ response.should have_tag("div", 2)
+ lambda { response.should have_tag("div", 3) }.should raise_error(SpecFailed)
+ response.should have_tag("div", 1..2)
+ lambda { response.should have_tag("div", 3..4) }.should raise_error(SpecFailed)
+ response.should have_tag("div", :count=>2)
+ lambda { response.should have_tag("div", :count=>3) }.should raise_error(SpecFailed)
+ response.should have_tag("div", :minimum=>1)
+ response.should have_tag("div", :minimum=>2)
+ lambda { response.should have_tag("div", :minimum=>3) }.should raise_error(SpecFailed)
+ response.should have_tag("div", :maximum=>2)
+ response.should have_tag("div", :maximum=>3)
+ lambda { response.should have_tag("div", :maximum=>1) }.should raise_error(SpecFailed)
+ response.should have_tag("div", :minimum=>1, :maximum=>2)
+ lambda { response.should have_tag("div", :minimum=>3, :maximum=>4) }.should raise_error(SpecFailed)
+ end
+
+ it "substitution values" do
+ render_html %Q{<div id="1">foo</div><div id="2">foo</div><span id="3"></span>}
+ response.should have_tag("div#?", /\d+/) do |elements| #using do/end
+ elements.size.should == 2
+ end
+ response.should have_tag("div#?", /\d+/) { |elements| #using {}
+ elements.size.should == 2
+ }
+ lambda {
+ response.should have_tag("div#?", /\d+/) do |elements|
+ elements.size.should == 3
+ end
+ }.should raise_error(SpecFailed, "expected: 3,\n got: 2 (using ==)")
+
+ lambda {
+ response.should have_tag("div#?", /\d+/) { |elements|
+ elements.size.should == 3
+ }
+ }.should raise_error(SpecFailed, "expected: 3,\n got: 2 (using ==)")
+
+ response.should have_tag("div#?", /\d+/) do |elements|
+ elements.size.should == 2
+ with_tag("#1")
+ with_tag("#2")
+ without_tag("#3")
+ end
+ end
+
+ #added for RSpec
+ it "nested tags in form" do
+ render_html %Q{
+ <form action="test">
+ <input type="text" name="email">
+ </form>
+ <form action="other">
+ <input type="text" name="other_input">
+ </form>
+ }
+ response.should have_tag("form[action=test]") { |form|
+ with_tag("input[type=text][name=email]")
+ }
+ response.should have_tag("form[action=other]") { |form|
+ with_tag("input[type=text][name=other_input]")
+ }
+
+ lambda {
+ response.should have_tag("form[action=test]") { |form|
+ with_tag("input[type=text][name=other_input]")
+ }
+ }.should raise_error(SpecFailed)
+
+ lambda {
+ response.should have_tag("form[action=test]") {
+ with_tag("input[type=text][name=other_input]")
+ }
+ }.should raise_error(SpecFailed)
+ end
+
+ it "should report the correct line number for a nested failed expectation" do
+ render_html %Q{
+ <form action="test">
+ <input type="text" name="email">
+ </form>
+ }
+ begin
+ response.should have_tag("form[action=test]") {
+ @expected_error_line = __LINE__; should have_tag("input[type=text][name=other_input]")
+ }
+ rescue => e
+ first_non_rspec_line_in_backtrace_of(e).should =~
+ /#{File.basename(__FILE__)}:#{@expected_error_line}/
+ else
+ fail
+ end
+ end
+
+ it "should report the correct line number for a nested raised exception" do
+ render_html %Q{
+ <form action="test">
+ <input type="text" name="email">
+ </form>
+ }
+ begin
+ response.should have_tag("form[action=test]") {
+ @expected_error_line = __LINE__; raise "Failed!"
+ }
+ rescue => e
+ first_non_rspec_line_in_backtrace_of(e).should =~
+ /#{File.basename(__FILE__)}:#{@expected_error_line}/
+ else
+ fail
+ end
+ end
+
+ it "should report the correct line number for a nested failed test/unit assertion" do
+ pending "Doesn't work at the moment. Do we want to support this?" do
+ render_html %Q{
+ <form action="test">
+ <input type="text" name="email">
+ </form>
+ }
+ begin
+ response.should have_tag("form[action=test]") {
+ @expected_error_line = __LINE__; assert false
+ }
+ rescue => e
+ first_non_rspec_line_in_backtrace_of(e).should =~
+ /#{File.basename(__FILE__)}:#{@expected_error_line}/
+ else
+ fail
+ end
+ end
+ end
+
+
+ it "beatles" do
+ unless defined?(BEATLES)
+ BEATLES = [
+ ["John", "Guitar"],
+ ["George", "Guitar"],
+ ["Paul", "Bass"],
+ ["Ringo", "Drums"]
+ ]
+ end
+
+ render_html %Q{
+ <div id="beatles">
+ <div class="beatle">
+ <h2>John</h2><p>Guitar</p>
+ </div>
+ <div class="beatle">
+ <h2>George</h2><p>Guitar</p>
+ </div>
+ <div class="beatle">
+ <h2>Paul</h2><p>Bass</p>
+ </div>
+ <div class="beatle">
+ <h2>Ringo</h2><p>Drums</p>
+ </div>
+ </div>
+ }
+ response.should have_tag("div#beatles>div[class=\"beatle\"]", 4)
+
+ response.should have_tag("div#beatles>div.beatle") {
+ BEATLES.each { |name, instrument|
+ with_tag("div.beatle>h2", name)
+ with_tag("div.beatle>p", instrument)
+ without_tag("div.beatle>span")
+ }
+ }
+ end
+
+ it "assert_select_text_match" do
+ render_html %Q{<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>}
+ response.should have_tag("div") do |divs|
+ with_tag("div", "foo")
+ with_tag("div", "bar")
+ with_tag("div", /\w*/)
+ with_tag("div", /\w*/, :count=>2)
+ without_tag("div", :text=>"foo", :count=>2)
+ with_tag("div", :html=>"<span>bar</span>")
+ with_tag("div", :html=>"<span>bar</span>")
+ with_tag("div", :html=>/\w*/)
+ with_tag("div", :html=>/\w*/, :count=>2)
+ without_tag("div", :html=>"<span>foo</span>", :count=>2)
+ end
+ end
+
+
+ it "assert_select_from_rjs with one item" do
+ render_rjs do |page|
+ page.replace_html "test", "<div id=\"1\">foo</div>\n<div id=\"2\">foo</div>"
+ end
+ response.should have_tag("div") { |elements|
+ elements.size.should == 2
+ with_tag("#1")
+ with_tag("#2")
+ }
+
+ lambda {
+ response.should have_tag("div") { |elements|
+ elements.size.should == 2
+ with_tag("#1")
+ with_tag("#3")
+ }
+ }.should raise_error(SpecFailed)
+
+ lambda {
+ response.should have_tag("div") { |elements|
+ elements.size.should == 2
+ with_tag("#1")
+ without_tag("#2")
+ }
+ }.should raise_error(SpecFailed, "should not have tag(\"#2\"), but did")
+
+ lambda {
+ response.should have_tag("div") { |elements|
+ elements.size.should == 3
+ with_tag("#1")
+ with_tag("#2")
+ }
+ }.should raise_error(SpecFailed)
+
+
+ response.should have_tag("div#?", /\d+/) { |elements|
+ with_tag("#1")
+ with_tag("#2")
+ }
+ end
+
+ it "assert_select_from_rjs with multiple items" do
+ render_rjs do |page|
+ page.replace_html "test", "<div id=\"1\">foo</div>"
+ page.replace_html "test2", "<div id=\"2\">foo</div>"
+ end
+ response.should have_tag("div")
+ response.should have_tag("div") { |elements|
+ elements.size.should == 2
+ with_tag("#1")
+ with_tag("#2")
+ }
+
+ lambda {
+ response.should have_tag("div") { |elements|
+ with_tag("#3")
+ }
+ }.should raise_error(SpecFailed)
+ end
+end
+
+describe "css_select", :type => :controller do
+ include AssertSelectSpecHelpers
+ controller_name :assert_select
+ integrate_views
+
+ it "can select tags from html" do
+ render_html %Q{<div id="1"></div><div id="2"></div>}
+ css_select("div").size.should == 2
+ css_select("p").size.should == 0
+ end
+
+
+ it "can select nested tags from html" do
+ render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+ response.should have_tag("div#?", /\d+/) { |elements|
+ css_select(elements[0], "div").should have(1).element
+ css_select(elements[1], "div").should have(1).element
+ }
+ response.should have_tag("div") {
+ css_select("div").should have(2).elements
+ css_select("div").each { |element|
+ # Testing as a group is one thing
+ css_select("#1,#2").should have(2).elements
+ # Testing individually is another
+ css_select("#1").should have(1).element
+ css_select("#2").should have(1).element
+ }
+ }
+ end
+
+ it "can select nested tags from rjs (one result)" do
+ render_rjs do |page|
+ page.replace_html "test", "<div id=\"1\">foo</div>\n<div id=\"2\">foo</div>"
+ end
+ css_select("div").should have(2).elements
+ css_select("#1").should have(1).element
+ css_select("#2").should have(1).element
+ end
+
+ it "can select nested tags from rjs (two results)" do
+ render_rjs do |page|
+ page.replace_html "test", "<div id=\"1\">foo</div>"
+ page.replace_html "test2", "<div id=\"2\">foo</div>"
+ end
+ css_select("div").should have(2).elements
+ css_select("#1").should have(1).element
+ css_select("#2").should have(1).element
+ end
+
+end
+
+describe "have_rjs behaviour_type", :type => :controller do
+ include AssertSelectSpecHelpers
+ controller_name :assert_select
+ integrate_views
+
+ before(:each) do
+ render_rjs do |page|
+ page.replace "test1", "<div id=\"1\">foo</div>"
+ page.replace_html "test2", "<div id=\"2\">bar</div><div id=\"3\">none</div>"
+ page.insert_html :top, "test3", "<div id=\"4\">loopy</div>"
+ page.hide "test4"
+ page["test5"].hide
+ end
+ end
+
+ it "should pass if any rjs exists" do
+ response.should have_rjs
+ end
+
+ it "should fail if no rjs exists" do
+ render_rjs do |page|
+ end
+ lambda do
+ response.should have_rjs
+ end.should raise_error(SpecFailed)
+ end
+
+ it "should find all rjs from multiple statements" do
+ response.should have_rjs do
+ with_tag("#1")
+ with_tag("#2")
+ with_tag("#3")
+ with_tag("#4")
+ end
+ end
+
+ it "should find by id" do
+ response.should have_rjs("test1") { |rjs|
+ rjs.size.should == 1
+ with_tag("div", 1)
+ with_tag("div#1", "foo")
+ }
+
+ lambda do
+ response.should have_rjs("test1") { |rjs|
+ rjs.size.should == 1
+ without_tag("div#1", "foo")
+ }
+ end.should raise_error(SpecFailed, "should not have tag(\"div#1\", \"foo\"), but did")
+
+ response.should have_rjs("test2") { |rjs|
+ rjs.size.should == 2
+ with_tag("div", 2)
+ with_tag("div#2", "bar")
+ with_tag("div#3", "none")
+ }
+ # response.should have_rjs("test4")
+ # response.should have_rjs("test5")
+ end
+
+ # specify "should find rjs using :hide" do
+ # response.should have_rjs(:hide)
+ # response.should have_rjs(:hide, "test4")
+ # response.should have_rjs(:hide, "test5")
+ # lambda do
+ # response.should have_rjs(:hide, "test3")
+ # end.should raise_error(SpecFailed)
+ # end
+
+ it "should find rjs using :replace" do
+ response.should have_rjs(:replace) { |rjs|
+ with_tag("div", 1)
+ with_tag("div#1", "foo")
+ }
+ response.should have_rjs(:replace, "test1") { |rjs|
+ with_tag("div", 1)
+ with_tag("div#1", "foo")
+ }
+ lambda {
+ response.should have_rjs(:replace, "test2")
+ }.should raise_error(SpecFailed)
+
+ lambda {
+ response.should have_rjs(:replace, "test3")
+ }.should raise_error(SpecFailed)
+ end
+
+ it "should find rjs using :replace_html" do
+ response.should have_rjs(:replace_html) { |rjs|
+ with_tag("div", 2)
+ with_tag("div#2", "bar")
+ with_tag("div#3", "none")
+ }
+
+ response.should have_rjs(:replace_html, "test2") { |rjs|
+ with_tag("div", 2)
+ with_tag("div#2", "bar")
+ with_tag("div#3", "none")
+ }
+
+ lambda {
+ response.should have_rjs(:replace_html, "test1")
+ }.should raise_error(SpecFailed)
+
+ lambda {
+ response.should have_rjs(:replace_html, "test3")
+ }.should raise_error(SpecFailed)
+ end
+
+ it "should find rjs using :insert_html (non-positioned)" do
+ response.should have_rjs(:insert_html) { |rjs|
+ with_tag("div", 1)
+ with_tag("div#4", "loopy")
+ }
+
+ response.should have_rjs(:insert_html, "test3") { |rjs|
+ with_tag("div", 1)
+ with_tag("div#4", "loopy")
+ }
+
+ lambda {
+ response.should have_rjs(:insert_html, "test1")
+ }.should raise_error(SpecFailed)
+
+ lambda {
+ response.should have_rjs(:insert_html, "test2")
+ }.should raise_error(SpecFailed)
+ end
+
+ it "should find rjs using :insert (positioned)" do
+ render_rjs do |page|
+ page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
+ page.insert_html :bottom, "test2", "<div id=\"2\">bar</div>"
+ page.insert_html :before, "test3", "<div id=\"3\">none</div>"
+ page.insert_html :after, "test4", "<div id=\"4\">loopy</div>"
+ end
+ response.should have_rjs(:insert, :top) do
+ with_tag("div", 1)
+ with_tag("#1")
+ end
+ response.should have_rjs(:insert, :top, "test1") do
+ with_tag("div", 1)
+ with_tag("#1")
+ end
+ response.should have_rjs(:insert, :bottom) {|rjs|
+ with_tag("div", 1)
+ with_tag("#2")
+ }
+ response.should have_rjs(:insert, :bottom, "test2") {|rjs|
+ with_tag("div", 1)
+ with_tag("#2")
+ }
+ response.should have_rjs(:insert, :before) {|rjs|
+ with_tag("div", 1)
+ with_tag("#3")
+ }
+ response.should have_rjs(:insert, :before, "test3") {|rjs|
+ with_tag("div", 1)
+ with_tag("#3")
+ }
+ response.should have_rjs(:insert, :after) {|rjs|
+ with_tag("div", 1)
+ with_tag("#4")
+ }
+ response.should have_rjs(:insert, :after, "test4") {|rjs|
+ with_tag("div", 1)
+ with_tag("#4")
+ }
+ end
+
+ it "should find rjs using :insert (positioned)" do
+ pending("await fix for http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/982")
+ render_rjs do |page|
+ page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
+ page.insert_html :bottom, "test2", "<div id=\"2\">bar</div>"
+ end
+ lambda {
+ response.should have_rjs(:insert, :top, "test2")
+ }.should raise_error(SpecFailed)
+ end
+end
+
+describe "send_email behaviour_type", :type => :controller do
+ include AssertSelectSpecHelpers
+ controller_name :assert_select
+ integrate_views
+
+ before(:each) do
+ ActionMailer::Base.delivery_method = :test
+ ActionMailer::Base.perform_deliveries = true
+ ActionMailer::Base.deliveries = []
+ end
+
+ after(:each) do
+ ActionMailer::Base.deliveries.clear
+ end
+
+ it "should fail with nothing sent" do
+ response.should_not send_email
+ lambda {
+ response.should send_email{}
+ }.should raise_error(SpecFailed, /No e-mail in delivery list./)
+ end
+
+ it "should pass otherwise" do
+ AssertSelectMailer.deliver_test "<div><p>foo</p><p>bar</p></div>"
+ response.should send_email
+ lambda {
+ response.should_not send_email
+ }.should raise_error(SpecFailed)
+ response.should send_email{}
+ response.should send_email {
+ with_tag("div:root") {
+ with_tag("p:first-child", "foo")
+ with_tag("p:last-child", "bar")
+ }
+ }
+
+ lambda {
+ response.should_not send_email
+ }.should raise_error(SpecFailed, "should not send email, but did")
+ end
+
+end
+
+describe "string.should have_tag", :type => :helper do
+ include AssertSelectSpecHelpers
+
+ it "should find root element" do
+ "<p>a paragraph</p>".should have_tag("p", "a paragraph")
+ end
+
+ it "should not find non-existent element" do
+ lambda do
+ "<p>a paragraph</p>".should have_tag("p", "wrong text")
+ end.should raise_error(SpecFailed)
+ end
+
+ it "should find child element" do
+ "<div><p>a paragraph</p></div>".should have_tag("p", "a paragraph")
+ end
+
+ it "should find nested element in one line" do
+ "<div><p>a paragraph</p></div>".should have_tag("div p","a paragraph")
+ end
+
+ it "should find nested element" do
+ "<div><p>a paragraph</p></div>".should have_tag("div") do
+ with_tag("p", "a paragraph")
+ end
+ end
+
+ it "should not find wrong nested element" do
+ lambda do
+ "<div><p>a paragraph</p></div>".should have_tag("div") do
+ with_tag("p", "wrong text")
+ end
+ end.should raise_error(SpecFailed)
+ end
+
+ it "should raise when using an HTML string with unclosed singleton tags when using the XML parsing setting" do
+ lambda do
+ %Q{<table id="1"><tr><td><img src="image.png" alt="image">Hello</td></tr><tr><td></td></tr><tr><td>World</td></tr></table>}.
+ should have_tag("tr", 3, :xml => true)
+ end.should raise_error
+ end
+
+ it "should find the specific number of elements regardless of unclosed singletons in a HTML string" do
+ %Q{<table id="1"><tr><td><img src="image.png" alt="image">Hello</td></tr><tr><td></td></tr><tr><td>World</td></tr></table>}.
+ should have_tag("tr", 3)
+ end
+
+ it "should find nested tags in an HTML string regardless unclosed singletons" do
+ %Q{<table id="1"><tr><td><img src="image.png" alt="image">Hello</td></tr><tr><td></td></tr><tr><td>World</td></tr></table>}.
+ should have_tag("table") do
+ with_tag('tr',3)
+ end
+ end
+
+end
+
+describe "have_tag", :type => :controller do
+ include AssertSelectSpecHelpers
+ controller_name :assert_select
+ integrate_views
+
+ it "should work exactly the same as assert_select" do
+ render_html %Q{
+ <div id="wrapper">foo
+ <div class="piece">
+ <h3>Text</h3>
+ </div>
+ <div class="piece">
+ <h3>Another</h3>
+ </div>
+ </div>
+ }
+
+ assert_select "#wrapper .piece h3", :text => "Text"
+ assert_select "#wrapper .piece h3", :text => "Another"
+
+ response.should have_tag("#wrapper .piece h3", :text => "Text")
+ response.should have_tag("#wrapper .piece h3", :text => "Another")
+ end
+end
+
+describe 'selecting in HTML that contains a mock with null_object' do
+ include ActionController::Assertions::SelectorAssertions
+ module HTML
+ class Document
+ def initialize_with_strict_error_checking(text, strict=false, xml=false)
+ initialize_without_strict_error_checking(text, true, xml)
+ end
+ alias_method :initialize_without_strict_error_checking, :initialize
+ alias_method :initialize, :initialize_with_strict_error_checking
+ end
+ end
+
+ describe 'modified HTML::Document' do
+ it 'should raise error on valid HTML even though false is specified' do
+ lambda {HTML::Document.new("<b>#<Spec::Mocks::Mock:0x267b4f0></b>", false, false)}.should raise_error
+ end
+ end
+
+ it 'should not print errors from assert_select' do
+ mock = mock("Dog", :null_object => true)
+ html = "<b>#{mock.colour}</b>"
+ lambda {html.should have_tag('b')}.should_not raise_error
+ end
+end
+
+# describe "An rjs call to :visual_effect, a 'should have_rjs' spec with",
+# :type => :view do
+#
+# before do
+# render 'rjs_spec/visual_effect'
+# end
+#
+# it "should pass with the correct element name" do
+# response.should have_rjs(:effect, :fade, 'mydiv')
+# end
+#
+# it "should fail the wrong element name" do
+# lambda {
+# response.should have_rjs(:effect, :fade, 'wrongname')
+# }.should raise_error(SpecFailed)
+# end
+#
+# it "should fail with the correct element but the wrong command" do
+# lambda {
+# response.should have_rjs(:effect, :puff, 'mydiv')
+# }.should raise_error(SpecFailed)
+# end
+#
+# end
+#
+# describe "An rjs call to :visual_effect for a toggle, a 'should have_rjs' spec with",
+# :type => :view do
+#
+# before do
+# render 'rjs_spec/visual_toggle_effect'
+# end
+#
+# it "should pass with the correct element name" do
+# response.should have_rjs(:effect, :toggle_blind, 'mydiv')
+# end
+#
+# it "should fail with the wrong element name" do
+# lambda {
+# response.should have_rjs(:effect, :toggle_blind, 'wrongname')
+# }.should raise_error(SpecFailed)
+# end
+#
+# it "should fail the correct element but the wrong command" do
+# lambda {
+# response.should have_rjs(:effect, :puff, 'mydiv')
+# }.should raise_error(SpecFailed)
+# end
+#
+# end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+
+describe "error_on" do
+ it "should provide a description including the name of what the error is on" do
+ have(1).error_on(:whatever).description.should == "have 1 error on :whatever"
+ end
+
+ it "should provide a failure message including the number actually given" do
+ lambda {
+ [].should have(1).error_on(:whatever)
+ }.should fail_with("expected 1 error on :whatever, got 0")
+ end
+end
+
+describe "errors_on" do
+ it "should provide a description including the name of what the error is on" do
+ have(2).errors_on(:whatever).description.should == "have 2 errors on :whatever"
+ end
+
+ it "should provide a failure message including the number actually given" do
+ lambda {
+ [1].should have(3).errors_on(:whatever)
+ }.should fail_with("expected 3 errors on :whatever, got 1")
+ end
+end
+
+describe "have something other than error_on or errors_on" do
+ it "has a standard rspec failure message" do
+ lambda {
+ [1,2,3].should have(2).elements
+ }.should fail_with("expected 2 elements, got 3")
+ end
+
+ it "has a standard rspec description" do
+ have(2).elements.description.should == "have 2 elements"
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+
+describe "have_text" do
+
+ it "should have a helpful description" do
+ matcher = have_text("foo bar")
+ matcher.description.should == 'have text "foo bar"'
+ end
+
+ describe "where target is a Regexp" do
+ it 'should should match submitted text using a regexp' do
+ matcher = have_text(/fo*/)
+ matcher.matches?('foo').should be_true
+ matcher.matches?('bar').should be_nil
+ end
+ end
+
+ describe "where target is a String" do
+ it 'should match submitted text using a string' do
+ matcher = have_text('foo')
+ matcher.matches?('foo').should be_true
+ matcher.matches?('foo bar').should be_false
+ end
+ end
+
+end
+
+describe "have_text",
+ :type => :controller do
+ ['isolation','integration'].each do |mode|
+ if mode == 'integration'
+ integrate_views
+ end
+
+ describe "where target is a response (in #{mode} mode)" do
+ controller_name :render_spec
+
+ it "should pass with exactly matching text" do
+ post 'text_action'
+ response.should have_text("this is the text for this action")
+ end
+
+ it "should pass with matching text (using Regexp)" do
+ post 'text_action'
+ response.should have_text(/is the text/)
+ end
+
+ it "should fail with matching text" do
+ post 'text_action'
+ lambda {
+ response.should have_text("this is NOT the text for this action")
+ }.should fail_with("expected \"this is NOT the text for this action\", got \"this is the text for this action\"")
+ end
+
+ it "should fail when a template is rendered" do
+ post 'some_action'
+ lambda {
+ response.should have_text("this is the text for this action")
+ }.should fail_with(/expected \"this is the text for this action\", got .*/)
+ end
+
+ it "should pass using should_not with incorrect text" do
+ post 'text_action'
+ response.should_not have_text("the accordian guy")
+ end
+ end
+ end
+end
+
--- /dev/null
+require 'spec_helper'
+
+describe "include_text" do
+
+ it "should have a helpful description" do
+ matcher = include_text("foo bar")
+ matcher.description.should == 'include text "foo bar"'
+ end
+
+ it 'should match if the text is contained' do
+ matcher = include_text('big piece')
+ matcher.matches?('I am a big piece of text').should be_true
+ end
+
+ it 'should not match if text is not contained' do
+ matcher = include_text('foo bar')
+ matcher.matches?('hello world').should be_false
+ end
+
+end
+
+describe "include_text", :type => :controller do
+ ['isolation','integration'].each do |mode|
+ if mode == 'integration'
+ integrate_views
+ end
+
+ describe "where target is a response (in #{mode} mode)" do
+ controller_name :render_spec
+
+ it "should pass with exactly matching text" do
+ post 'text_action'
+ response.should include_text("this is the text for this action")
+ end
+
+ it 'should pass with substring matching text' do
+ post 'text_action'
+ response.should include_text('text for this')
+ end
+
+ it "should fail with incorrect text" do
+ post 'text_action'
+ lambda {
+ response.should include_text("the accordian guy")
+ }.should fail_with("expected to find \"the accordian guy\" in \"this is the text for this action\"")
+ end
+
+ it "should pass using should_not with incorrect text" do
+ post 'text_action'
+ response.should_not include_text("the accordian guy")
+ end
+
+ it "should fail when a template is rendered" do
+ get 'some_action'
+ lambda {
+ response.should include_text("this is the text for this action")
+ }.should fail_with(/expected to find \"this is the text for this action\"/)
+ end
+ end
+ end
+end
+
--- /dev/null
+require 'spec_helper'
+
+[:response, :controller].each do |subject_method|
+ ['isolation','integration'].each do |mode|
+ describe "redirect_to behaviour", :type => :controller do
+ if mode == 'integration'
+ integrate_views
+ end
+ controller_name :redirect_spec
+
+ subject { send(subject_method) }
+
+ it "redirected to another action" do
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to(:action => 'somewhere')
+ end
+
+ it "redirected to another controller and action" do
+ get 'action_with_redirect_to_other_somewhere'
+ should redirect_to(:controller => 'render_spec', :action => 'text_action')
+ end
+
+ it "redirected to another action (with 'and return')" do
+ get 'action_with_redirect_to_somewhere_and_return'
+ should redirect_to(:action => 'somewhere')
+ end
+
+ it "redirected from an SSL action to a non-SSL action" do
+ request.stub!(:ssl?).and_return true
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to(:action => 'somewhere')
+ end
+
+ it "redirected to correct path with leading /" do
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to('/redirect_spec/somewhere')
+ end
+
+ it "redirected to correct path without leading /" do
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to('redirect_spec/somewhere')
+ end
+
+ it "redirected to correct internal URL" do
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to("http://test.host/redirect_spec/somewhere")
+ end
+
+ it "redirected to correct external URL" do
+ get 'action_with_redirect_to_rspec_site'
+ should redirect_to("http://rspec.rubyforge.org")
+ end
+
+ it "redirected :back" do
+ request.env['HTTP_REFERER'] = "http://test.host/previous/page"
+ get 'action_with_redirect_back'
+ should redirect_to(:back)
+ end
+
+ it "redirected :back and should redirect_to URL matches" do
+ request.env['HTTP_REFERER'] = "http://test.host/previous/page"
+ get 'action_with_redirect_back'
+ should redirect_to("http://test.host/previous/page")
+ end
+
+ it "redirected from within a respond_to block" do
+ get 'action_with_redirect_in_respond_to'
+ should redirect_to('redirect_spec/somewhere')
+ end
+
+ params_as_hash = {:action => "somewhere", :id => 1111, :param1 => "value1", :param2 => "value2"}
+
+ it "redirected to an internal URL containing a query string" do
+ get "action_with_redirect_which_creates_query_string"
+ should redirect_to(params_as_hash)
+ end
+
+ it "redirected to an internal URL containing a query string, one way it might be generated" do
+ get "action_with_redirect_with_query_string_order1"
+ should redirect_to(params_as_hash)
+ end
+
+ it "redirected to an internal URL containing a query string, another way it might be generated" do
+ get "action_with_redirect_with_query_string_order2"
+ should redirect_to(params_as_hash)
+ end
+
+ it "redirected to an internal URL which is unroutable but matched via a string" do
+ get "action_with_redirect_to_unroutable_url_inside_app"
+ should redirect_to("http://test.host/nonexistant/none")
+ end
+
+ it "redirected to a URL with a specific status code" do
+ get "action_with_redirect_to_somewhere_with_status"
+ should redirect_to(:action => 'somewhere').with(:status => 301)
+ end
+
+ it "redirected to a URL with a specific status code (using names)" do
+ get "action_with_redirect_to_somewhere_with_status"
+ should redirect_to(:action => 'somewhere').with(:status => :moved_permanently)
+ end
+
+ end
+
+
+ describe "redirect_to with a controller spec in #{mode} mode and a custom request.host", :type => :controller do
+ if mode == 'integration'
+ integrate_views
+ end
+ controller_name :redirect_spec
+
+ subject { send(subject_method) }
+
+ before do
+ request.host = "some.custom.host"
+ end
+
+ it "should pass when redirected to another action" do
+ get 'action_with_redirect_to_somewhere'
+ should redirect_to(:action => 'somewhere')
+ end
+ end
+
+ describe "Given a controller spec in #{mode} mode", :type => :controller do
+ if mode == 'integration'
+ integrate_views
+ end
+ controller_name :redirect_spec
+
+ subject { send(subject_method) }
+
+ it "an action that redirects should not result in an error if no should redirect_to expectation is called" do
+ get 'action_with_redirect_to_somewhere'
+ end
+
+ it "an action that redirects should not result in an error if should_not redirect_to expectation was called, but not to that action" do
+ get 'action_with_redirect_to_somewhere'
+ should_not redirect_to(:action => 'another_destination')
+ end
+
+ it "an action that redirects should result in an error if should_not redirect_to expectation was called to that action" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should_not redirect_to(:action => 'somewhere')
+ }.should fail_with("expected not to be redirected to {:action=>\"somewhere\"}, but was")
+ end
+
+ it "an action that does not redirects should not result in an error if should_not redirect_to expectation was called" do
+ get 'action_with_no_redirect'
+ should_not redirect_to(:action => 'any_destination')
+ end
+
+
+ end
+
+ describe "Given a controller spec in #{mode} mode, should redirect_to should fail when", :type => :controller do
+ if mode == 'integration'
+ integrate_views
+ end
+ controller_name :redirect_spec
+
+ subject { send(subject_method) }
+
+ it "redirected to wrong action" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should redirect_to(:action => 'somewhere_else')
+ }.should fail_with("expected redirect to {:action=>\"somewhere_else\"}, got redirect to \"http://test.host/redirect_spec/somewhere\"")
+ end
+
+ it "redirected with wrong status code" do
+ get 'action_with_redirect_to_somewhere_with_status'
+ lambda {
+ should redirect_to(:action => 'somewhere').with(:status => 302)
+ }.should fail_with("expected redirect to {:action=>\"somewhere\"} with status 302 Found, got 301 Moved Permanently")
+ end
+
+ it "redirected with wrong status code (using names)" do
+ get 'action_with_redirect_to_somewhere_with_status'
+ lambda {
+ should redirect_to(:action => 'somewhere').with(:status => :found)
+ }.should fail_with("expected redirect to {:action=>\"somewhere\"} with status 302 Found, got 301 Moved Permanently")
+ end
+
+ it "redirected to incorrect path with leading /" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should redirect_to('/redirect_spec/somewhere_else')
+ }.should fail_with('expected redirect to "/redirect_spec/somewhere_else", got redirect to "http://test.host/redirect_spec/somewhere"')
+ end
+
+ it "redirected to incorrect path without leading /" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should redirect_to('redirect_spec/somewhere_else')
+ }.should fail_with('expected redirect to "redirect_spec/somewhere_else", got redirect to "http://test.host/redirect_spec/somewhere"')
+ end
+
+ it "redirected to incorrect internal URL (based on the action)" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should redirect_to("http://test.host/redirect_spec/somewhere_else")
+ }.should fail_with('expected redirect to "http://test.host/redirect_spec/somewhere_else", got redirect to "http://test.host/redirect_spec/somewhere"')
+ end
+
+ it "redirected to wrong external URL" do
+ get 'action_with_redirect_to_rspec_site'
+ lambda {
+ should redirect_to("http://test.unit.rubyforge.org")
+ }.should fail_with('expected redirect to "http://test.unit.rubyforge.org", got redirect to "http://rspec.rubyforge.org"')
+ end
+
+ it "redirected to incorrect internal URL (based on the directory path)" do
+ get 'action_with_redirect_to_somewhere'
+ lambda {
+ should redirect_to("http://test.host/non_existent_controller/somewhere")
+ }.should fail_with('expected redirect to "http://test.host/non_existent_controller/somewhere", got redirect to "http://test.host/redirect_spec/somewhere"')
+ end
+
+ it "expected redirect :back, but redirected to a new URL" do
+ get 'action_with_no_redirect'
+ lambda {
+ should redirect_to(:back)
+ }.should fail_with('expected redirect to :back, got no redirect')
+ end
+
+ it "no redirect at all" do
+ get 'action_with_no_redirect'
+ lambda {
+ should redirect_to(:action => 'nowhere')
+ }.should fail_with("expected redirect to {:action=>\"nowhere\"}, got no redirect")
+ end
+
+ it "redirected to an internal URL which is unroutable and matched via a hash" do
+ get "action_with_redirect_to_unroutable_url_inside_app"
+ route = {:controller => "nonexistant", :action => "none"}
+ lambda {
+ should redirect_to(route)
+ }.should raise_error(ActionController::RoutingError, /(no route found to match|No route matches) \"\/nonexistant\/none\" with \{.*\}/)
+ end
+
+ it "provides a description" do
+ redirect_to("foo/bar").description.should == %q|redirect to "foo/bar"|
+ end
+
+ it "redirects to action with http method restriction" do
+ post 'action_to_redirect_to_action_with_method_restriction'
+ should redirect_to(:action => 'action_with_method_restriction')
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+[:response, :controller].each do |subject_method|
+ ['isolation','integration'].each do |mode|
+ describe "#{subject_method}.should render_template (in #{mode} mode)",
+ :type => :controller do
+ controller_name :render_spec
+ if mode == 'integration'
+ integrate_views
+ end
+
+ subject { send(subject_method) }
+
+ it "matches an action (using a string)" do
+ post 'some_action'
+ should render_template('some_action')
+ end
+
+ it "does not match an action that is a truncated version of the actual action" do
+ post 'some_action'
+ should_not render_template('some_actio')
+ end
+
+ if ::Rails::VERSION::STRING >= '2.3'
+ it "matches an action with specified extenstions (implicit format)" do
+ post 'some_action'
+ should render_template('some_action.html.erb')
+ end
+
+ it "matches an action with specified extenstions (explicit format)" do
+ post 'some_action', :format => 'js'
+ should render_template('some_action.js.rjs')
+ end
+ end
+
+ it "matches an action (using a symbol)" do
+ post 'some_action'
+ should render_template(:some_action)
+ end
+
+ it "matches an action on a specific controller" do
+ post 'some_action'
+ should render_template('render_spec/some_action')
+ end
+
+ it "matches an action on a non-default specific controller" do
+ post 'action_which_renders_template_from_other_controller'
+ should render_template('controller_spec/action_with_template')
+ end
+
+ it "matches an rjs template" do
+ xhr :post, 'some_action'
+ should render_template('render_spec/some_action')
+ end
+
+ it "matches a partial template (simple path)" do
+ get 'action_with_partial'
+ should render_template("_a_partial")
+ end
+
+ it "matches a partial template (complex path)" do
+ get 'action_with_partial'
+ should render_template("render_spec/_a_partial")
+ end
+
+ it "fails when the wrong template is rendered" do
+ post 'some_action'
+ lambda do
+ should render_template('non_existent_template')
+ end.should fail_with(/expected \"non_existent_template\", got \"render_spec\/some_action(\.html\.erb)?\"/)
+ end
+
+ it "fails when redirected" do
+ post :action_with_redirect
+ lambda do
+ should render_template(:some_action)
+ end.should fail_with(/expected \"some_action\", got redirected to \"http:\/\/test.host\/render_spec\/some_action\"/)
+ end
+
+ it "fails when template is associated with a different controller but controller is not specified" do
+ post 'action_which_renders_template_from_other_controller'
+ lambda do
+ should render_template('action_with_template')
+ end.should fail_with(/expected \"action_with_template\", got \"controller_spec\/action_with_template(\.html\.erb)?\"/)
+ end
+
+ it "fails with incorrect full path when template is associated with a different controller" do
+ post 'action_which_renders_template_from_other_controller'
+ lambda do
+ should render_template('render_spec/action_with_template')
+ end.should fail_with(/expected \"render_spec\/action_with_template\", got \"controller_spec\/action_with_template(\.html\.erb)?\"/)
+ end
+
+ it "fails on the wrong extension" do
+ get 'some_action'
+ lambda {
+ should render_template('render_spec/some_action.js.rjs')
+ }.should fail_with(/expected \"render_spec\/some_action\.js\.rjs\", got \"render_spec\/some_action(\.html\.erb)?\"/)
+ end
+
+ it "faild when TEXT is rendered" do
+ post 'text_action'
+ lambda do
+ should render_template('some_action')
+ end.should fail_with(/expected \"some_action\", got (nil|\"\")/)
+ end
+
+ describe "with an alternate layout" do
+ it "says it rendered the action's layout" do
+ pending("record rendering of layouts") do
+ get 'action_with_alternate_layout'
+ should render_template('layouts/simple')
+ end
+ end
+ end
+
+ it "provides a description" do
+ render_template("foo/bar").description.should == %q|render template "foo/bar"|
+ end
+ end
+
+ describe "#{subject_method}.should_not render_template (in #{mode} mode)",
+ :type => :controller do
+ controller_name :render_spec
+ if mode == 'integration'
+ integrate_views
+ end
+
+ subject { send(subject_method) }
+
+ it "passes when the action renders nothing" do
+ post 'action_that_renders_nothing'
+ should_not render_template('action_that_renders_nothing')
+ end
+
+ it "passes when the action renders nothing (symbol)" do
+ post 'action_that_renders_nothing'
+ should_not render_template(:action_that_renders_nothing)
+ end
+
+ it "passes when the action does not render the template" do
+ post 'some_action'
+ should_not render_template('some_other_template')
+ end
+
+ it "passes when the action does not render the template (symbol)" do
+ post 'some_action'
+ should_not render_template(:some_other_template)
+ end
+
+ it "passes when the action does not render the template (named with controller)" do
+ post 'some_action'
+ should_not render_template('render_spec/some_other_template')
+ end
+
+ it "passes when the action renders the template with a different controller" do
+ post 'action_which_renders_template_from_other_controller'
+ should_not render_template('action_with_template')
+ end
+
+ it "passes when the action renders the template (named with controller) with a different controller" do
+ post 'action_which_renders_template_from_other_controller'
+ should_not render_template('render_spec/action_with_template')
+ end
+
+ it "passes when TEXT is rendered" do
+ post 'text_action'
+ should_not render_template('some_action')
+ end
+
+ it "fails when the action renders the template" do
+ post 'some_action'
+ lambda do
+ should_not render_template('some_action')
+ end.should fail_with("expected not to render \"some_action\", but did")
+ end
+
+ it "fails when the action renders the template (symbol)" do
+ post 'some_action'
+ lambda do
+ should_not render_template(:some_action)
+ end.should fail_with("expected not to render \"some_action\", but did")
+ end
+
+ it "fails when the action renders the template (named with controller)" do
+ post 'some_action'
+ lambda do
+ should_not render_template('render_spec/some_action')
+ end.should fail_with("expected not to render \"render_spec/some_action\", but did")
+ end
+
+ it "fails when the action renders the partial" do
+ post 'action_with_partial'
+ lambda do
+ should_not render_template('_a_partial')
+ end.should fail_with("expected not to render \"_a_partial\", but did")
+ end
+
+ it "fails when the action renders the partial (named with controller)" do
+ post 'action_with_partial'
+ lambda do
+ should_not render_template('render_spec/_a_partial')
+ end.should fail_with("expected not to render \"render_spec/_a_partial\", but did")
+ end
+
+ end
+ end
+end
--- /dev/null
+require 'spec_helper'
+
+describe "should change" do
+ describe "handling association proxies" do
+ it "should match expected collection with proxied collection" do
+ person = Person.create!(:name => 'David')
+ koala = person.animals.create!(:name => 'Koala')
+ zebra = person.animals.create!(:name => 'Zebra')
+
+ lambda {
+ person.animals.delete(koala)
+ }.should change{person.animals}.to([zebra])
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+class MockableModel < ActiveRecord::Base
+ has_one :associated_model
+end
+
+class SubMockableModel < MockableModel
+end
+
+class AssociatedModel < ActiveRecord::Base
+ belongs_to :mockable_model
+end
--- /dev/null
+require 'spec_helper'
+require File.dirname(__FILE__) + '/ar_classes'
+
+describe "mock_model" do
+ describe "responding to interrogation" do
+ before(:each) do
+ @model = mock_model(SubMockableModel)
+ end
+ it "should say it is_a? if it is" do
+ @model.is_a?(SubMockableModel).should be(true)
+ end
+ it "should say it is_a? if it's ancestor is" do
+ @model.is_a?(MockableModel).should be(true)
+ end
+ it "should say it is kind_of? if it is" do
+ @model.kind_of?(SubMockableModel).should be(true)
+ end
+ it "should say it is kind_of? if it's ancestor is" do
+ @model.kind_of?(MockableModel).should be(true)
+ end
+ it "should say it is instance_of? if it is" do
+ @model.instance_of?(SubMockableModel).should be(true)
+ end
+ it "should not say it instance_of? if it isn't, even if it's ancestor is" do
+ @model.instance_of?(MockableModel).should be(false)
+ end
+ it "should say it is not destroyed" do
+ @model.destroyed?(SubMockableModel).should be(false)
+ end
+ end
+
+ describe "with params" do
+ it "should not mutate its parameters" do
+ params = {:a => 'b'}
+ model = mock_model(MockableModel, params)
+ params.should == {:a => 'b'}
+ end
+ end
+
+ describe "with #id stubbed", :type => :view do
+ before(:each) do
+ @model = mock_model(MockableModel, :id => 1)
+ end
+ it "should be named using the stubbed id value" do
+ @model.instance_variable_get(:@name).should == "MockableModel_1"
+ end
+ it "should return string of id value for to_param" do
+ @model.to_param.should == "1"
+ end
+ end
+
+ describe "as association", :type => :view do
+ before(:each) do
+ @real = AssociatedModel.create!
+ @mock_model = mock_model(MockableModel)
+ @real.mockable_model = @mock_model
+ end
+
+ it "should pass associated_model == mock" do
+ @mock_model.should == @real.mockable_model
+ end
+
+ it "should pass mock == associated_model" do
+ @real.mockable_model.should == @mock_model
+ end
+ end
+
+ describe "with :null_object => true", :type => :view do
+ before(:each) do
+ @model = mock_model(MockableModel, :null_object => true, :mocked_method => "mocked")
+ end
+
+ it "should be able to mock methods" do
+ @model.mocked_method.should == "mocked"
+ end
+ it "should return itself to unmocked methods" do
+ @model.unmocked_method.should equal(@model)
+ end
+ end
+
+ describe "#as_null_object", :type => :view do
+ before(:each) do
+ @model = mock_model(MockableModel, :mocked_method => "mocked").as_null_object
+ end
+
+ it "should be able to mock methods" do
+ @model.mocked_method.should == "mocked"
+ end
+ it "should return itself to unmocked methods" do
+ @model.unmocked_method.should equal(@model)
+ end
+ end
+
+ describe "#as_new_record" do
+ it "should say it is a new record" do
+ mock_model(MockableModel).as_new_record.should be_new_record
+ end
+
+ it "should have a nil id" do
+ mock_model(MockableModel).as_new_record.id.should be(nil)
+ end
+
+ it "should return nil for #to_param" do
+ mock_model(MockableModel).as_new_record.to_param.should be(nil)
+ end
+ end
+end
+
+
--- /dev/null
+require 'spec_helper'
+require File.dirname(__FILE__) + '/ar_classes'
+
+describe "stub_model" do
+ describe "defaults" do
+ it "should have an id" do
+ stub_model(MockableModel).id.should be > 0
+ end
+
+ it "should say it is not a new record" do
+ stub_model(MockableModel).should_not be_new_record
+ end
+ end
+
+ it "should accept a stub id" do
+ stub_model(MockableModel, :id => 37).id.should == 37
+ end
+
+ it "should say it is a new record when id is set to nil" do
+ stub_model(MockableModel, :id => nil).should be_new_record
+ end
+
+ it "should accept any arbitrary stub" do
+ stub_model(MockableModel, :foo => "bar").foo.should == "bar"
+ end
+
+ it "should accept a stub for save" do
+ stub_model(MockableModel, :save => false).save.should be(false)
+ end
+
+ describe "#as_new_record" do
+ it "should say it is a new record" do
+ stub_model(MockableModel).as_new_record.should be_new_record
+ end
+
+ it "should have a nil id" do
+ stub_model(MockableModel).as_new_record.id.should be(nil)
+ end
+ end
+
+ it "should raise when hitting the db" do
+ lambda do
+ model = stub_model(MockableModel, :changed => true, :attributes_with_quotes => {'this' => 'that'})
+ model.save
+ end.should raise_error(Spec::Rails::IllegalDataAccessException, /stubbed models are not allowed to access the database/)
+ end
+
+ it "should increment the id" do
+ first = stub_model(MockableModel)
+ second = stub_model(MockableModel)
+ second.id.should == (first.id + 1)
+ end
+
+ describe "as association" do
+ before(:each) do
+ @real = AssociatedModel.create!
+ @stub_model = stub_model(MockableModel)
+ @real.mockable_model = @stub_model
+ end
+
+ it "should pass associated_model == mock" do
+ @stub_model.should == @real.mockable_model
+ end
+
+ it "should pass mock == associated_model" do
+ @real.mockable_model.should == @stub_model
+ end
+ end
+
+ describe "with a block" do
+ it "should yield the model" do
+ model = stub_model(MockableModel) do |block_arg|
+ @block_arg = block_arg
+ end
+ model.should be(@block_arg)
+ end
+ end
+end
+
+
--- /dev/null
+require 'spec_helper'
+
+describe "A sample spec", :type => :model do
+ fixtures :animals
+ it "should pass" do
+ animals(:pig).name.should == "Piggy"
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+
+describe "A sample spec", :type => :model do
+ fixtures :animals
+ it "should pass" do
+ animals(:pig).name.should == "Pig"
+ end
+end
\ No newline at end of file
--- /dev/null
+require 'spec_helper'
+
+describe "script/spec file" do
+ it "should run a spec" do
+ dir = File.dirname(__FILE__)
+ output = `#{RAILS_ROOT}/script/spec #{dir}/sample_spec.rb`
+ unless $?.exitstatus == 0
+ flunk "command 'script/spec spec/sample_spec' failed\n#{output}"
+ end
+ end
+end
\ No newline at end of file
--- /dev/null
+$LOAD_PATH.unshift '../rspec/lib'
+$LOAD_PATH.unshift '../../../'
+$LOAD_PATH.unshift 'spec/resources/controllers'
+$LOAD_PATH.unshift 'spec/resources/helpers'
+
+require '../../../spec/spec_helper'
+
+require 'spec/resources/controllers/application'
+require 'spec/resources/controllers/render_spec_controller'
+require 'spec/resources/controllers/controller_spec_controller'
+require 'spec/resources/controllers/rjs_spec_controller'
+require 'spec/resources/controllers/redirect_spec_controller'
+require 'spec/resources/controllers/action_view_base_spec_controller'
+require 'spec/resources/helpers/addition_helper'
+require 'spec/resources/helpers/explicit_helper'
+require 'spec/resources/helpers/more_explicit_helper'
+require 'spec/resources/helpers/view_spec_helper'
+require 'spec/resources/helpers/plugin_application_helper'
+require 'spec/resources/models/animal'
+require 'spec/resources/models/person'
+require 'spec/resources/models/thing'
+
+unless ActionController::Routing.controller_paths.include?('spec/resources/controllers')
+ ActionController::Routing.instance_eval {@possible_controllers = nil}
+ ActionController::Routing.controller_paths << 'spec/resources/controllers'
+end
+
+module Spec
+ module Rails
+ module Example
+ class ViewExampleGroupController
+ prepend_view_path 'spec/resources/views'
+ end
+ end
+ end
+end
+
+def fail()
+ raise_error(Spec::Expectations::ExpectationNotMetError)
+end
+
+def fail_with(message)
+ raise_error(Spec::Expectations::ExpectationNotMetError,message)
+end
+
+class Proc
+ def should_pass
+ lambda { self.call }.should_not raise_error
+ end
+end
+
+ActionController::Routing::Routes.draw do |map|
+ map.connect 'action_with_method_restriction', :controller => 'redirect_spec', :action => 'action_with_method_restriction', :conditions => { :method => :get }
+ map.connect 'action_to_redirect_to_action_with_method_restriction', :controller => 'redirect_spec', :action => 'action_to_redirect_to_action_with_method_restriction'
+
+ map.resources :rspec_on_rails_specs
+ map.custom_route 'custom_route', :controller => 'custom_route_spec', :action => 'custom_route'
+ map.connect ':controller/:action/:id'
+end
+
+module HelperMethods
+ def method_in_module_included_in_configuration
+ end
+end
+
+module HelperMacros
+ def accesses_configured_helper_methods
+ it "has access to methods in modules included in configuration" do
+ method_in_module_included_in_configuration
+ end
+ end
+end
+
+Spec::Runner.configure do |config|
+ config.include HelperMethods
+ config.extend HelperMacros
+end
+
OSDN Git Service
