lib/tasks/rspec.rake script/autospec vendor/plugins/rspec-rails/.gitignore vendor/plugins/rspec-rails/History.txt vendor/plugins/rspec-rails/License.txt vendor/plugins/rspec-rails/Manifest.txt vendor/plugins/rspec-rails/README.txt vendor/plugins/rspec-rails/Rakefile vendor/plugins/rspec-rails/generators/rspec/CHANGES vendor/plugins/rspec-rails/generators/rspec/rspec_generator.rb vendor/plugins/rspec-rails/generators/rspec/templates/all_stories.rb vendor/plugins/rspec-rails/generators/rspec/templates/previous_failures.txt vendor/plugins/rspec-rails/generators/rspec/templates/rcov.opts vendor/plugins/rspec-rails/generators/rspec/templates/rspec.rake vendor/plugins/rspec-rails/generators/rspec/templates/script/autospec vendor/plugins/rspec-rails/generators/rspec/templates/script/spec vendor/plugins/rspec-rails/generators/rspec/templates/script/spec_server vendor/plugins/rspec-rails/generators/rspec/templates/spec.opts vendor/plugins/rspec-rails/generators/rspec/templates/spec_helper.rb vendor/plugins/rspec-rails/generators/rspec/templates/stories_helper.rb vendor/plugins/rspec-rails/generators/rspec_controller/USAGE vendor/plugins/rspec-rails/generators/rspec_controller/rspec_controller_generator.rb vendor/plugins/rspec-rails/generators/rspec_controller/templates/controller_spec.rb vendor/plugins/rspec-rails/generators/rspec_controller/templates/helper_spec.rb vendor/plugins/rspec-rails/generators/rspec_controller/templates/view_spec.rb vendor/plugins/rspec-rails/generators/rspec_default_values.rb vendor/plugins/rspec-rails/generators/rspec_model/USAGE vendor/plugins/rspec-rails/generators/rspec_model/rspec_model_generator.rb vendor/plugins/rspec-rails/generators/rspec_model/templates/model_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/rspec_scaffold_generator.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/controller_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/edit_erb_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/helper_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/index_erb_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/new_erb_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/routing_spec.rb vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/show_erb_spec.rb vendor/plugins/rspec-rails/init.rb vendor/plugins/rspec-rails/lib/autotest/discover.rb vendor/plugins/rspec-rails/lib/autotest/rails_rspec.rb vendor/plugins/rspec-rails/lib/spec/rails.rb vendor/plugins/rspec-rails/lib/spec/rails/example.rb vendor/plugins/rspec-rails/lib/spec/rails/example/assigns_hash_proxy.rb vendor/plugins/rspec-rails/lib/spec/rails/example/controller_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/example/cookies_proxy.rb vendor/plugins/rspec-rails/lib/spec/rails/example/functional_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/example/helper_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/example/model_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/example/rails_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/example/render_observer.rb vendor/plugins/rspec-rails/lib/spec/rails/example/view_example_group.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/action_controller/base.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/action_controller/rescue.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/action_controller/test_response.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/action_view/base.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/active_record/base.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/object.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/spec/example/configuration.rb vendor/plugins/rspec-rails/lib/spec/rails/extensions/spec/matchers/have.rb vendor/plugins/rspec-rails/lib/spec/rails/interop/testcase.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/assert_select.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/change.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/have_text.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/include_text.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/redirect_to.rb vendor/plugins/rspec-rails/lib/spec/rails/matchers/render_template.rb vendor/plugins/rspec-rails/lib/spec/rails/mocks.rb vendor/plugins/rspec-rails/lib/spec/rails/story_adapter.rb vendor/plugins/rspec-rails/lib/spec/rails/version.rb vendor/plugins/rspec-rails/rspec-rails.gemspec vendor/plugins/rspec-rails/spec/rails/autotest/mappings_spec.rb vendor/plugins/rspec-rails/spec/rails/example/assigns_hash_proxy_spec.rb vendor/plugins/rspec-rails/spec/rails/example/configuration_spec.rb vendor/plugins/rspec-rails/spec/rails/example/controller_isolation_spec.rb vendor/plugins/rspec-rails/spec/rails/example/controller_spec_spec.rb vendor/plugins/rspec-rails/spec/rails/example/cookies_proxy_spec.rb vendor/plugins/rspec-rails/spec/rails/example/example_group_factory_spec.rb vendor/plugins/rspec-rails/spec/rails/example/helper_spec_spec.rb vendor/plugins/rspec-rails/spec/rails/example/model_spec_spec.rb vendor/plugins/rspec-rails/spec/rails/example/shared_behaviour_spec.rb vendor/plugins/rspec-rails/spec/rails/example/test_unit_assertion_accessibility_spec.rb vendor/plugins/rspec-rails/spec/rails/example/view_spec_spec.rb vendor/plugins/rspec-rails/spec/rails/extensions/action_controller_rescue_action_spec.rb vendor/plugins/rspec-rails/spec/rails/extensions/action_view_base_spec.rb vendor/plugins/rspec-rails/spec/rails/extensions/active_record_spec.rb vendor/plugins/rspec-rails/spec/rails/interop/testcase_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/assert_select_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/description_generation_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/errors_on_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/have_text_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/include_text_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/redirect_to_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/render_template_spec.rb vendor/plugins/rspec-rails/spec/rails/matchers/should_change_spec.rb vendor/plugins/rspec-rails/spec/rails/mocks/ar_classes.rb vendor/plugins/rspec-rails/spec/rails/mocks/mock_model_spec.rb vendor/plugins/rspec-rails/spec/rails/mocks/stub_model_spec.rb vendor/plugins/rspec-rails/spec/rails/sample_modified_fixture.rb vendor/plugins/rspec-rails/spec/rails/sample_spec.rb vendor/plugins/rspec-rails/spec/rails/spec_server_spec.rb vendor/plugins/rspec-rails/spec/rails/spec_spec.rb vendor/plugins/rspec-rails/spec/rails_suite.rb vendor/plugins/rspec-rails/spec/resources/controllers/action_view_base_spec_controller.rb vendor/plugins/rspec-rails/spec/resources/controllers/controller_spec_controller.rb vendor/plugins/rspec-rails/spec/resources/controllers/redirect_spec_controller.rb vendor/plugins/rspec-rails/spec/resources/controllers/render_spec_controller.rb vendor/plugins/rspec-rails/spec/resources/controllers/rjs_spec_controller.rb vendor/plugins/rspec-rails/spec/resources/helpers/addition_helper.rb vendor/plugins/rspec-rails/spec/resources/helpers/explicit_helper.rb vendor/plugins/rspec-rails/spec/resources/helpers/more_explicit_helper.rb vendor/plugins/rspec-rails/spec/resources/helpers/plugin_application_helper.rb vendor/plugins/rspec-rails/spec/resources/helpers/view_spec_helper.rb vendor/plugins/rspec-rails/spec/resources/views/controller_spec/_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/controller_spec/action_setting_flash_after_session_reset.rhtml vendor/plugins/rspec-rails/spec/resources/views/controller_spec/action_setting_flash_before_session_reset.rhtml vendor/plugins/rspec-rails/spec/resources/views/controller_spec/action_setting_the_assigns_hash.rhtml vendor/plugins/rspec-rails/spec/resources/views/controller_spec/action_with_errors_in_template.rhtml vendor/plugins/rspec-rails/spec/resources/views/controller_spec/action_with_template.rhtml vendor/plugins/rspec-rails/spec/resources/views/layouts/application.rhtml vendor/plugins/rspec-rails/spec/resources/views/layouts/simple.rhtml vendor/plugins/rspec-rails/spec/resources/views/objects/_object.html.erb vendor/plugins/rspec-rails/spec/resources/views/render_spec/_a_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/render_spec/action_with_alternate_layout.rhtml vendor/plugins/rspec-rails/spec/resources/views/render_spec/some_action.js.rjs vendor/plugins/rspec-rails/spec/resources/views/render_spec/some_action.rhtml vendor/plugins/rspec-rails/spec/resources/views/render_spec/some_action.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/_replacement_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/hide_div.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/hide_page_element.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/insert_html.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/replace.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/replace_html.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/replace_html_with_partial.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/visual_effect.rjs vendor/plugins/rspec-rails/spec/resources/views/rjs_spec/visual_toggle_effect.rjs vendor/plugins/rspec-rails/spec/resources/views/tag_spec/no_tags.rhtml vendor/plugins/rspec-rails/spec/resources/views/tag_spec/single_div_with_no_attributes.rhtml vendor/plugins/rspec-rails/spec/resources/views/tag_spec/single_div_with_one_attribute.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/_partial_used_twice.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/_partial_with_local_variable.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/_partial_with_sub_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/_spacer.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/accessor.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/block_helper.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/entry_form.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/explicit_helper.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/foo/show.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/implicit_helper.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/multiple_helpers.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/path_params.html.erb vendor/plugins/rspec-rails/spec/resources/views/view_spec/should_not_receive.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/template_with_partial.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/template_with_partial_using_collection.rhtml vendor/plugins/rspec-rails/spec/resources/views/view_spec/template_with_partial_with_array.rhtml vendor/plugins/rspec-rails/spec/spec_helper.rb vendor/plugins/rspec-rails/stories/all.rb vendor/plugins/rspec-rails/stories/configuration/stories.rb vendor/plugins/rspec-rails/stories/helper.rb vendor/plugins/rspec-rails/stories/steps/people.rb vendor/plugins/rspec-rails/stories/transactions_should_rollback vendor/plugins/rspec-rails/stories/transactions_should_rollback.rb vendor/plugins/rspec/.autotest vendor/plugins/rspec/.gitignore vendor/plugins/rspec/History.txt vendor/plugins/rspec/License.txt vendor/plugins/rspec/Manifest.txt vendor/plugins/rspec/README.txt vendor/plugins/rspec/TODO.txt vendor/plugins/rspec/bin/autospec vendor/plugins/rspec/examples/failing/README.txt vendor/plugins/rspec/examples/failing/diffing_spec.rb vendor/plugins/rspec/examples/failing/failing_autogenerated_docstrings_example.rb vendor/plugins/rspec/examples/failing/failure_in_setup.rb vendor/plugins/rspec/examples/failing/failure_in_teardown.rb vendor/plugins/rspec/examples/failing/mocking_example.rb vendor/plugins/rspec/examples/failing/mocking_with_flexmock.rb vendor/plugins/rspec/examples/failing/mocking_with_mocha.rb vendor/plugins/rspec/examples/failing/mocking_with_rr.rb vendor/plugins/rspec/examples/failing/partial_mock_example.rb vendor/plugins/rspec/examples/failing/predicate_example.rb vendor/plugins/rspec/examples/failing/raising_example.rb vendor/plugins/rspec/examples/failing/spec_helper.rb vendor/plugins/rspec/examples/failing/syntax_error_example.rb vendor/plugins/rspec/examples/failing/team_spec.rb vendor/plugins/rspec/examples/failing/timeout_behaviour.rb vendor/plugins/rspec/examples/passing/autogenerated_docstrings_example.rb vendor/plugins/rspec/examples/passing/before_and_after_example.rb vendor/plugins/rspec/examples/passing/behave_as_example.rb vendor/plugins/rspec/examples/passing/custom_expectation_matchers.rb vendor/plugins/rspec/examples/passing/custom_formatter.rb vendor/plugins/rspec/examples/passing/dynamic_spec.rb vendor/plugins/rspec/examples/passing/file_accessor.rb vendor/plugins/rspec/examples/passing/file_accessor_spec.rb vendor/plugins/rspec/examples/passing/greeter_spec.rb vendor/plugins/rspec/examples/passing/helper_method_example.rb vendor/plugins/rspec/examples/passing/io_processor.rb vendor/plugins/rspec/examples/passing/io_processor_spec.rb vendor/plugins/rspec/examples/passing/legacy_spec.rb vendor/plugins/rspec/examples/passing/mocking_example.rb vendor/plugins/rspec/examples/passing/multi_threaded_behaviour_runner.rb vendor/plugins/rspec/examples/passing/nested_classes_example.rb vendor/plugins/rspec/examples/passing/partial_mock_example.rb vendor/plugins/rspec/examples/passing/pending_example.rb vendor/plugins/rspec/examples/passing/predicate_example.rb vendor/plugins/rspec/examples/passing/priority.txt vendor/plugins/rspec/examples/passing/shared_example_group_example.rb vendor/plugins/rspec/examples/passing/shared_stack_examples.rb vendor/plugins/rspec/examples/passing/simple_matcher_example.rb vendor/plugins/rspec/examples/passing/spec_helper.rb vendor/plugins/rspec/examples/passing/stack.rb vendor/plugins/rspec/examples/passing/stack_spec.rb vendor/plugins/rspec/examples/passing/stack_spec_with_nested_example_groups.rb vendor/plugins/rspec/examples/passing/stubbing_example.rb vendor/plugins/rspec/examples/passing/yielding_example.rb vendor/plugins/rspec/lib/spec/adapters.rb vendor/plugins/rspec/lib/spec/adapters/ruby_engine.rb vendor/plugins/rspec/lib/spec/adapters/ruby_engine/mri.rb vendor/plugins/rspec/lib/spec/adapters/ruby_engine/rubinius.rb vendor/plugins/rspec/lib/spec/dsl.rb vendor/plugins/rspec/lib/spec/dsl/main.rb vendor/plugins/rspec/lib/spec/example/before_and_after_hooks.rb vendor/plugins/rspec/lib/spec/expectations/wrap_expectation.rb vendor/plugins/rspec/lib/spec/interop/test.rb vendor/plugins/rspec/lib/spec/interop/test/unit/autorunner.rb vendor/plugins/rspec/lib/spec/interop/test/unit/testcase.rb vendor/plugins/rspec/lib/spec/interop/test/unit/testresult.rb vendor/plugins/rspec/lib/spec/interop/test/unit/testsuite_adapter.rb vendor/plugins/rspec/lib/spec/interop/test/unit/ui/console/testrunner.rb vendor/plugins/rspec/lib/spec/matchers/errors.rb vendor/plugins/rspec/lib/spec/matchers/exist.rb vendor/plugins/rspec/lib/spec/matchers/generated_descriptions.rb vendor/plugins/rspec/lib/spec/matchers/match_array.rb vendor/plugins/rspec/lib/spec/matchers/method_missing.rb vendor/plugins/rspec/lib/spec/mocks/argument_constraints.rb vendor/plugins/rspec/lib/spec/mocks/extensions.rb vendor/plugins/rspec/lib/spec/mocks/framework.rb vendor/plugins/rspec/lib/spec/runner/formatter/failing_example_groups_formatter.rb vendor/plugins/rspec/lib/spec/runner/formatter/nested_text_formatter.rb vendor/plugins/rspec/lib/spec/runner/formatter/story/progress_bar_formatter.rb vendor/plugins/rspec/lib/spec/story/extensions/regexp.rb vendor/plugins/rspec/lib/spec/story/extensions/string.rb vendor/plugins/rspec/rspec.gemspec vendor/plugins/rspec/spec/autotest/autotest_helper.rb vendor/plugins/rspec/spec/autotest/autotest_matchers.rb vendor/plugins/rspec/spec/autotest/failed_results_re_spec.rb vendor/plugins/rspec/spec/ruby_forker.rb vendor/plugins/rspec/spec/spec.opts vendor/plugins/rspec/spec/spec/adapters/ruby_engine_spec.rb vendor/plugins/rspec/spec/spec/dsl/main_spec.rb vendor/plugins/rspec/spec/spec/example/example_group_methods_spec.rb vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb vendor/plugins/rspec/spec/spec/example/subclassing_example_group_spec.rb vendor/plugins/rspec/spec/spec/expectations/wrap_expectation_spec.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_that_fails.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_that_passes.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_errors.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_that_fails.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_that_passes.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_with_errors.rb vendor/plugins/rspec/spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb vendor/plugins/rspec/spec/spec/interop/test/unit/spec_spec.rb vendor/plugins/rspec/spec/spec/interop/test/unit/test_unit_spec_helper.rb vendor/plugins/rspec/spec/spec/interop/test/unit/testcase_spec.rb vendor/plugins/rspec/spec/spec/interop/test/unit/testsuite_adapter_spec.rb vendor/plugins/rspec/spec/spec/matchers/match_array_spec.rb vendor/plugins/rspec/spec/spec/mocks/bug_report_10263_spec.rb vendor/plugins/rspec/spec/spec/mocks/bug_report_496.rb vendor/plugins/rspec/spec/spec/mocks/bug_report_600_spec.rb vendor/plugins/rspec/spec/spec/mocks/hash_including_matcher_spec.rb vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb vendor/plugins/rspec/spec/spec/runner/formatter/base_formatter_spec.rb vendor/plugins/rspec/spec/spec/runner/formatter/base_text_formatter_spec.rb vendor/plugins/rspec/spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html vendor/plugins/rspec/spec/spec/runner/formatter/nested_text_formatter_spec.rb vendor/plugins/rspec/spec/spec/runner/formatter/story/progress_bar_formatter_spec.rb vendor/plugins/rspec/spec/spec/runner/resources/a_bar.rb vendor/plugins/rspec/spec/spec/runner/resources/a_foo.rb vendor/plugins/rspec/spec/spec/runner/resources/a_spec.rb vendor/plugins/rspec/spec/spec/runner/spec_drb.opts vendor/plugins/rspec/spec/spec/runner/spec_parser/spec_parser_fixture.rb vendor/plugins/rspec/spec/spec/spec_spec.rb vendor/plugins/rspec/stories/configuration/before_blocks.story vendor/plugins/rspec/stories/configuration/stories.rb vendor/plugins/rspec/stories/example_groups/autogenerated_docstrings vendor/plugins/rspec/stories/example_groups/example_group_with_should_methods vendor/plugins/rspec/stories/example_groups/nested_groups vendor/plugins/rspec/stories/example_groups/output vendor/plugins/rspec/stories/example_groups/stories.rb vendor/plugins/rspec/stories/helper.rb vendor/plugins/rspec/stories/interop/examples_and_tests_together vendor/plugins/rspec/stories/interop/stories.rb vendor/plugins/rspec/stories/interop/test_but_not_test_unit vendor/plugins/rspec/stories/interop/test_case_with_should_methods vendor/plugins/rspec/stories/mock_framework_integration/stories.rb vendor/plugins/rspec/stories/mock_framework_integration/use_flexmock.story vendor/plugins/rspec/stories/pending_stories/README vendor/plugins/rspec/stories/resources/helpers/cmdline.rb vendor/plugins/rspec/stories/resources/helpers/story_helper.rb vendor/plugins/rspec/stories/resources/matchers/smart_match.rb vendor/plugins/rspec/stories/resources/spec/before_blocks_example.rb vendor/plugins/rspec/stories/resources/spec/example_group_with_should_methods.rb vendor/plugins/rspec/stories/resources/spec/simple_spec.rb vendor/plugins/rspec/stories/resources/spec/spec_with_flexmock.rb vendor/plugins/rspec/stories/resources/steps/running_rspec.rb vendor/plugins/rspec/stories/resources/stories/failing_story.rb vendor/plugins/rspec/stories/resources/test/spec_and_test_together.rb vendor/plugins/rspec/stories/resources/test/spec_including_test_but_not_unit.rb vendor/plugins/rspec/stories/resources/test/test_case_with_should_methods.rb vendor/plugins/rspec/stories/stories/multiline_steps.story vendor/plugins/rspec/stories/stories/steps/multiline_steps.rb vendor/plugins/rspec/stories/stories/stories.rb vendor/plugins/rspec/story_server/prototype/javascripts/rspec.js vendor/plugins/rspec/story_server/prototype/stylesheets/rspec.css @@ -1,4 +1,5 @@ #!/usr/bin/env ruby $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/rspec/lib")) +require 'rubygems' require 'spec' exit ::Spec::Runner::CommandLine.run(::Spec::Runner::OptionParser.parse(ARGV, STDERR, STDOUT)) script/spec @@ -1,5 +1,4 @@ #!/usr/bin/env ruby -$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../rspec/lib' # For svn $LOAD_PATH.unshift File.dirname(__FILE__) + '/../vendor/plugins/rspec/lib' # For rspec installed as plugin require 'rubygems' require 'drb/drb' @@ -23,17 +22,29 @@ module Spec active_connections.delete(name) end end - end + end - if ::Dispatcher.respond_to?(:cleanup_application) - ::Dispatcher.cleanup_application + if ActionController.const_defined?(:Dispatcher) + dispatcher = ::ActionController::Dispatcher.new($stdout) + dispatcher.cleanup_application elsif ::Dispatcher.respond_to?(:reset_application!) ::Dispatcher.reset_application! + else + raise "Application reloading failed" + end + if Object.const_defined?(:Fixtures) && Fixtures.respond_to?(:reset_cache) + Fixtures.reset_cache end + ::Dependencies.mechanism = :load require_dependency('application.rb') unless Object.const_defined?(:ApplicationController) load File.dirname(__FILE__) + '/../spec/spec_helper.rb' + if in_memory_database? + load "#{RAILS_ROOT}/db/schema.rb" # use db agnostic schema by default + ActiveRecord::Migrator.up('db/migrate') # use migrations + end + ::Spec::Runner::CommandLine.run( ::Spec::Runner::OptionParser.parse( argv, @@ -42,6 +53,12 @@ module Spec ) ) end + + def in_memory_database? + ENV["RAILS_ENV"] == "test" and + ::ActiveRecord::Base.connection.class.to_s == "ActiveRecord::ConnectionAdapters::SQLite3Adapter" and + ::Rails::Configuration.new.database_configuration['test']['database'] == ':memory:' + end end end end @@ -88,7 +105,7 @@ opts.parse!(ARGV) puts "Ready" exec_server = lambda { trap("USR2") { restart_test_server } if Signal.list.has_key?("USR2") - DRb.start_service("druby://localhost:8989", Spec::Runner::RailsSpecServer.new) + DRb.start_service("druby://127.0.0.1:8989", Spec::Runner::RailsSpecServer.new) DRb.thread.join } script/spec_server @@ -1,7 +1,4 @@ --colour ---format -progress ---loadby -mtime +--format progress +--loadby mtime --reverse ---backtrace \ No newline at end of file spec/spec.opts @@ -1,108 +1,60 @@ -$:.unshift('lib') +# -*- ruby -*- + +$:.unshift(File.join(File.dirname(__FILE__), 'lib')) require 'rubygems' -require 'rake/gempackagetask' -require 'rake/contrib/rubyforgepublisher' -require 'rake/clean' -require 'rake/rdoctask' -require 'rake/testtask' +require 'hoe' require 'spec/version' -dir = File.dirname(__FILE__) -$LOAD_PATH.unshift(File.expand_path("#{dir}/../pre_commit/lib")) -require "pre_commit" +require 'spec/rake/spectask' -# Some of the tasks are in separate files since they are also part of the website documentation +class Hoe + def extra_deps + @extra_deps.reject! { |x| Array(x).first == 'hoe' } + @extra_deps + end +end + +Hoe.new('rspec', Spec::VERSION::STRING) do |p| + p.summary = Spec::VERSION::SUMMARY + p.url = 'http://rspec.info/' + p.description = "Behaviour Driven Development for Ruby." + p.rubyforge_name = 'rspec' + p.developer('RSpec Development Team', 'rspec-devel@rubyforge.org') + p.remote_rdoc_dir = "rspec/#{Spec::VERSION::STRING}" +end + +['audit','test','test_deps','default','post_blog'].each do |task| + Rake.application.instance_variable_get('@tasks').delete(task) +end + +task :verify_rcov => [:spec, :stories] +task :default => :verify_rcov + +# # Some of the tasks are in separate files since they are also part of the website documentation load File.dirname(__FILE__) + '/rake_tasks/examples.rake' load File.dirname(__FILE__) + '/rake_tasks/examples_with_rcov.rake' load File.dirname(__FILE__) + '/rake_tasks/failing_examples_with_html.rake' load File.dirname(__FILE__) + '/rake_tasks/verify_rcov.rake' -PKG_NAME = "rspec" -PKG_VERSION = Spec::VERSION::STRING -PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}" -PKG_FILES = FileList[ - '[A-Z]*', - 'lib/**/*.rb', - 'spec/**/*.rb', - 'examples/**/*', - 'plugins/**/*', - 'stories/**/*' -] - -task :default => [:verify_rcov] -task :verify_rcov => [:spec, :stories] - desc "Run all specs" Spec::Rake::SpecTask.new do |t| t.spec_files = FileList['spec/**/*_spec.rb'] - t.spec_opts = ['--options', 'spec.opts'] - t.rcov = true - t.rcov_dir = '../doc/output/coverage' - t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec,examples,\/var\/lib\/gems,\/Library\/Ruby,\.autotest'] + t.spec_opts = ['--options', 'spec/spec.opts'] + unless ENV['NO_RCOV'] + t.rcov = true + t.rcov_dir = 'coverage' + t.rcov_opts = ['--text-report', '--exclude', "lib/spec.rb,lib/spec/runner.rb,spec\/spec,bin\/spec,examples,\/var\/lib\/gems,\/Library\/Ruby,\.autotest,#{ENV['GEM_HOME']}"] + end end desc "Run all stories" task :stories do - html = 'story_server/prototype/rspec_stories.html' - ruby "stories/all.rb --colour --format plain --format html:#{html}" - unless IO.read(html) =~ /<span class="param">/m - raise 'highlighted parameters are broken in story HTML' - end -end - -desc "Run all specs and store html output in doc/output/report.html" -Spec::Rake::SpecTask.new('spec_html') do |t| - t.spec_files = FileList['spec/**/*_spec.rb', '../../RSpec.tmbundle/Support/spec/*_spec.rb'] - t.spec_opts = ['--format html:../doc/output/report.html','--backtrace'] + ruby "stories/all.rb --colour --format plain" end -desc "Run all failing examples" +desc "Run failing examples (see failure output)" Spec::Rake::SpecTask.new('failing_examples') do |t| t.spec_files = FileList['failing_examples/**/*_spec.rb'] -end - -desc 'Generate HTML documentation for website' -task :webgen do - core.webgen -end - -desc 'Generate RDoc' -rd = Rake::RDocTask.new do |rdoc| - rdoc.rdoc_dir = '../doc/output/rdoc' - rdoc.options << '--title' << 'RSpec' << '--line-numbers' << '--inline-source' << '--main' << 'README' - rdoc.rdoc_files.include('README', 'CHANGES', 'MIT-LICENSE', 'UPGRADE', 'lib/**/*.rb') -end - -spec = Gem::Specification.new do |s| - s.name = PKG_NAME - s.version = PKG_VERSION - s.summary = Spec::VERSION::DESCRIPTION - s.description = <<-EOF - RSpec is a behaviour driven development (BDD) framework for Ruby. RSpec was - created in response to Dave Astels' article _A New Look at Test Driven Development_ - which can be read at: http://daveastels.com/index.php?p=5 RSpec is intended to - provide the features discussed in Dave's article. - EOF - - s.files = PKG_FILES.to_a - s.require_path = 'lib' - - s.has_rdoc = true - s.rdoc_options = rd.options - s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$|^EXAMPLES.rd$/ }.to_a - - s.autorequire = 'spec' - s.bindir = 'bin' - s.executables = ['spec', 'spec_translator'] - s.default_executable = 'spec' - s.author = "RSpec Development Team" - s.email = "rspec-devel@rubyforge.org" - s.homepage = "http://rspec.rubyforge.org" - s.rubyforge_project = "rspec" -end - -Rake::GemPackageTask.new(spec) do |pkg| - pkg.need_zip = true - pkg.need_tar = true + t.spec_opts = ['--options', 'spec/spec.opts'] end def egrep(pattern) @@ -124,158 +76,14 @@ task :todo do egrep /(FIXME|TODO|TBD)/ end -task :clobber do - core.clobber -end - -task :release => [:clobber, :verify_committed, :verify_user, :spec, :publish_packages, :tag, :publish_website, :publish_news] +desc "verify_committed, verify_rcov, post_news, release" +task :complete_release => [:verify_committed, :verify_rcov, :post_news, :release] desc "Verifies that there is no uncommitted code" task :verify_committed do - IO.popen('svn stat') do |io| + IO.popen('git status') do |io| io.each_line do |line| - raise "\n!!! Do a svn commit first !!!\n\n" if line =~ /^\s*M\s*/ - end - end -end - -desc "Creates a tag in svn" -task :tag do - from = `svn info #{File.dirname(__FILE__)}`.match(/URL: (.*)\/rspec/n)[1] - to = from.gsub(/trunk/, "tags/#{Spec::VERSION::TAG}") - current = from.gsub(/trunk/, "tags/CURRENT") - - puts "Creating tag in SVN" - tag_cmd = "svn cp #{from} #{to} -m \"Tag release #{Spec::VERSION::FULL_VERSION}\"" - `#{tag_cmd}` ; raise "ERROR: #{tag_cmd}" unless $? == 0 - - puts "Removing CURRENT" - remove_current_cmd = "svn rm #{current} -m \"Remove tags/CURRENT\"" - `#{remove_current_cmd}` ; raise "ERROR: #{remove_current_cmd}" unless $? == 0 - - puts "Re-Creating CURRENT" - create_current_cmd = "svn cp #{to} #{current} -m \"Copy #{Spec::VERSION::TAG} to tags/CURRENT\"" - `#{create_current_cmd}` ; "ERROR: #{create_current_cmd}" unless $? == 0 -end - -desc "Run this task before you commit. You should see 'OK TO COMMIT'" -task(:pre_commit) {core.pre_commit} - -desc "Build the website, but do not publish it" -task(:website) {core.website} - -task(:rdoc_rails) {core.rdoc_rails} - -task :verify_user do - raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER'] -end - -desc "Upload Website to RubyForge" -task :publish_website => [:verify_user, :website] do - unless Spec::VERSION::RELEASE_CANDIDATE - publisher = Rake::SshDirPublisher.new( - "rspec-website@rubyforge.org", - "/var/www/gforge-projects/#{PKG_NAME}", - "../doc/output" - ) - publisher.upload - else - puts "** Not publishing packages to RubyForge - this is a prerelease" - end -end - -desc "Upload Website archive to RubyForge" -task :archive_website => [:verify_user, :website] do - publisher = Rake::SshDirPublisher.new( - "rspec-website@rubyforge.org", - "/var/www/gforge-projects/#{PKG_NAME}/#{Spec::VERSION::TAG}", - "../doc/output" - ) - publisher.upload -end - -desc "Package the Rails plugin" -task :package_rspec_on_rails do - mkdir 'pkg' rescue nil - rm_rf 'pkg/rspec_on_rails' rescue nil - `svn export ../rspec_on_rails pkg/rspec_on_rails-#{PKG_VERSION}` - Dir.chdir 'pkg' do - `tar cvzf rspec_on_rails-#{PKG_VERSION}.tgz rspec_on_rails-#{PKG_VERSION}` - end -end -task :pkg => :package_rspec_on_rails - -desc "Package the RSpec.tmbundle" -task :package_tmbundle do - mkdir 'pkg' rescue nil - rm_rf 'pkg/RSpec.tmbundle' rescue nil - `svn export ../RSpec.tmbundle pkg/RSpec.tmbundle` - Dir.chdir 'pkg' do - `tar cvzf RSpec-#{PKG_VERSION}.tmbundle.tgz RSpec.tmbundle` - end -end -task :pkg => :package_tmbundle - -desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file" -task :publish_packages => [:verify_user, :package] do - require File.dirname(__FILE__) + '/../spec_ui/lib/spec/ui/version' - release_files = FileList[ - "pkg/#{PKG_FILE_NAME}.gem", - "pkg/#{PKG_FILE_NAME}.tgz", - "pkg/rspec_on_rails-#{PKG_VERSION}.tgz", - "pkg/#{PKG_FILE_NAME}.zip", - "pkg/RSpec-#{PKG_VERSION}.tmbundle.tgz", - "../spec_ui/pkg/spec_ui-#{Spec::Ui::VERSION::STRING}.gem" - ] - unless Spec::VERSION::RELEASE_CANDIDATE - require 'meta_project' - require 'rake/contrib/xforge' - - Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf| - # Never hardcode user name and password in the Rakefile! - xf.user_name = ENV['RUBYFORGE_USER'] - xf.files = release_files.to_a - xf.release_name = "RSpec #{PKG_VERSION}" - end - else - puts "SINCE THIS IS A PRERELEASE, FILES ARE UPLOADED WITH SSH, NOT TO THE RUBYFORGE FILE SECTION" - puts "YOU MUST TYPE THE PASSWORD #{release_files.length} TIMES..." - - host = "rspec-website@rubyforge.org" - remote_dir = "/var/www/gforge-projects/#{PKG_NAME}" - - publisher = Rake::SshFilePublisher.new( - host, - remote_dir, - File.dirname(__FILE__), - *release_files - ) - publisher.upload - - puts "UPLADED THE FOLLOWING FILES:" - release_files.each do |file| - name = file.match(/pkg\/(.*)/)[1] - puts "* http://rspec.rubyforge.org/#{name}" + raise "\n!!! Do a git commit first !!!\n\n" if line =~ /^#\s*modified:/ end - - puts "They are not linked to anywhere, so don't forget to tell people!" - end -end - -desc "Publish news on RubyForge" -task :publish_news => [:verify_user] do - unless Spec::VERSION::RELEASE_CANDIDATE - require 'meta_project' - require 'rake/contrib/xforge' - Rake::XForge::NewsPublisher.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |news| - # Never hardcode user name and password in the Rakefile! - news.user_name = ENV['RUBYFORGE_USER'] - end - else - puts "** Not publishing news to RubyForge - this is a prerelease" end -end - -def core - PreCommit::Core.new(self) -end +end \ No newline at end of file vendor/plugins/rspec/Rakefile @@ -1,3 +1,4 @@ +#!/usr/bin/env ruby $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib")) require 'spec' -exit ::Spec::Runner::CommandLine.run(rspec_options) +exit ::Spec::Runner::CommandLine.run vendor/plugins/rspec/bin/spec @@ -1,3 +1,3 @@ Autotest.add_discovery do - "rspec" if File.exist?('spec') + "rspec" if File.directory?('spec') && ENV['RSPEC'] end vendor/plugins/rspec/lib/autotest/discover.rb @@ -1,94 +1,47 @@ require 'autotest' +Autotest.add_hook :initialize do |at| + at.clear_mappings + # watch out: Ruby bug (1.8.6): + # %r(/) != /\// + at.add_mapping(%r%^spec/.*_spec.rb$%) { |filename, _| + filename + } + at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| + ["spec/#{m[1]}_spec.rb"] + } + at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) { + at.files_matching %r%^spec/.*_spec\.rb$% + } +end + class RspecCommandError < StandardError; end class Autotest::Rspec < Autotest - - def initialize(kernel=Kernel, separator=File::SEPARATOR, alt_separator=File::ALT_SEPARATOR) # :nodoc: - super() - @kernel, @separator, @alt_separator = kernel, separator, alt_separator - @spec_command = spec_command - # watch out: Ruby bug (1.8.6): - # %r(/) != /\// - # since Ruby compares the REGEXP source, not the resulting pattern - @test_mappings = { - %r%^spec/.*\.rb$% => kernel.proc { |filename, _| - filename - }, - %r%^lib/(.*)\.rb$% => kernel.proc { |_, m| - ["spec/#{m[1]}_spec.rb"] - }, - %r%^spec/(spec_helper|shared/.*)\.rb$% => kernel.proc { - files_matching %r%^spec/.*_spec\.rb$% - } - } - end - - def tests_for_file(filename) - super.select { |f| @files.has_key? f } + def initialize + super + self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m + self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m end - alias :specs_for_file :tests_for_file - - def failed_results(results) - results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m) - end - - def handle_results(results) - @files_to_test = consolidate_failures failed_results(results) - unless @files_to_test.empty? then - hook :red - else - hook :green - end unless $TESTING - @tainted = true unless @files_to_test.empty? - end - def consolidate_failures(failed) - filters = Hash.new { |h,k| h[k] = [] } - failed.each do |spec, failed_trace| - @files.keys.select{|f| f =~ /spec\//}.each do |f| - if failed_trace =~ Regexp.new(f) - filters[f] << spec - break - end + filters = new_hash_of_arrays + failed.each do |spec, trace| + if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:/ + filters[$2] << spec end end return filters end def make_test_cmd(files_to_test) - return "#{ruby} -S #{@spec_command} #{add_options_if_present} #{files_to_test.keys.flatten.join(' ')}" + return '' if files_to_test.empty? + spec_program = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')) + return "#{ruby} #{spec_program} #{files_to_test.keys.flatten.join(' ')} #{add_options_if_present}" end - def add_options_if_present + def add_options_if_present # :nodoc: File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : "" end - - # Finds the proper spec command to use. Precendence - # is set in the lazily-evaluated method spec_commands. Alias + Override - # that in ~/.autotest to provide a different spec command - # then the default paths provided. - def spec_command - spec_commands.each do |command| - if File.exists?(command) - return @alt_separator ? (command.gsub @separator, @alt_separator) : command - end - end - raise RspecCommandError, "No spec command could be found!" - end - - # Autotest will look for spec commands in the following - # locations, in this order: - # - # * bin/spec - # * default spec bin/loader installed in Rubygems - def spec_commands - [ - File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')), - File.join(Config::CONFIG['bindir'], 'spec') - ] - end - end vendor/plugins/rspec/lib/autotest/rspec.rb @@ -1,38 +1,34 @@ -require 'spec/version' require 'spec/matchers' require 'spec/expectations' -require 'spec/translator' require 'spec/example' -require 'spec/extensions' require 'spec/runner' -require 'spec/story' +require 'spec/adapters' +require 'spec/version' +require 'spec/dsl' -if Object.const_defined?(:Test); \ - require 'spec/extensions/test'; \ -end module Spec - class << self - def run? - @run || rspec_options.examples_run? - end + def self.test_unit_defined? + Object.const_defined?(:Test) && Test.const_defined?(:Unit) && Test::Unit.respond_to?(:run?) + end - def run; \ - return true if run?; \ - result = rspec_options.run_examples; \ - @run = true; \ - result; \ - end - attr_writer :run + def self.run? + Runner.options.examples_run? + end - def exit?; \ - !Object.const_defined?(:Test) || Test::Unit.run?; \ - end + def self.run + return true if run? + Runner.options.run_examples + end + + def self.exit? + !test_unit_defined? || Test::Unit.run? + end + + def self.spec_command? + $0.split('/').last == 'spec' end end -at_exit do \ - unless $! || Spec.run?; \ - success = Spec.run; \ - exit success if Spec.exit?; \ - end \ -end \ No newline at end of file +if Spec::test_unit_defined? + require 'spec/interop/test' +end vendor/plugins/rspec/lib/spec.rb @@ -1,16 +1,38 @@ +module Spec + module Example + def self.args_and_options(*args) + with_options_from(args) do |options| + return args, options + end + end + + def self.scope_from(*args) + args[0] || :each + end + + def self.scope_and_options(*args) + args, options = args_and_options(*args) + return scope_from(*args), options + end + + private + + def self.with_options_from(args) + yield Hash === args.last ? args.pop : {} if block_given? + end + end +end + require 'timeout' -require 'forwardable' +require 'spec/example/before_and_after_hooks' require 'spec/example/pending' require 'spec/example/module_reopening_fix' require 'spec/example/example_group_methods' require 'spec/example/example_methods' require 'spec/example/example_group' -require 'spec/example/example_group_description' require 'spec/example/shared_example_group' require 'spec/example/example_group_factory' require 'spec/example/errors' require 'spec/example/configuration' -require 'spec/example/example_suite' -require 'spec/example/example' -require 'spec/example/example_runner' require 'spec/example/example_matcher' + vendor/plugins/rspec/lib/spec/example.rb @@ -7,14 +7,20 @@ module Spec # config.mock_with :rspec, :mocha, :flexmock, or :rr # end # - # To use any other mock framework, you'll have to provide - # your own adapter. This is simply a module that responds to - # setup_mocks_for_rspec, verify_mocks_for_rspec and teardown_mocks_for_rspec. + # To use any other mock framework, you'll have to provide your own + # adapter. This is simply a module that responds to the following + # methods: + # + # setup_mocks_for_rspec + # verify_mocks_for_rspec + # teardown_mocks_for_rspec. + # # These are your hooks into the lifecycle of a given example. RSpec will - # call setup_mocks_for_rspec before running anything else in each Example. - # After executing the #after methods, RSpec will then call verify_mocks_for_rspec - # and teardown_mocks_for_rspec (this is guaranteed to run even if there are - # failures in verify_mocks_for_rspec). + # call setup_mocks_for_rspec before running anything else in each + # Example. After executing the #after methods, RSpec will then call + # verify_mocks_for_rspec and teardown_mocks_for_rspec (this is + # guaranteed to run even if there are failures in + # verify_mocks_for_rspec). # # Once you've defined this module, you can pass that to mock_with: # @@ -35,93 +41,122 @@ module Spec @mock_framework ||= mock_framework_path("rspec") end - # Declares modules to be included in all behaviours (<tt>describe</tt> blocks). + # :call-seq: + # include(Some::Helpers) + # include(Some::Helpers, More::Helpers) + # include(My::Helpers, :type => :key) + # + # Declares modules to be included in multiple example groups + # (<tt>describe</tt> blocks). With no <tt>:type</tt>, the modules listed + # will be included in all example groups. # - # config.include(My::Bottle, My::Cup) + # Use <tt>:type</tt> to restrict + # the inclusion to a subset of example groups. The value assigned to + # <tt>:type</tt> should be a key that maps to a class that is either a + # subclass of Spec::Example::ExampleGroup or extends + # Spec::Example::ExampleGroupMethods and includes + # Spec::Example::ExampleMethods. # - # If you want to restrict the inclusion to a subset of all the behaviours then - # specify this in a Hash as the last argument: + # For example, the rspec-rails gem/plugin extends Test::Unit::TestCase + # with Spec::Example::ExampleGroupMethods and includes + # Spec::Example::ExampleMethods in it. So if you have a module of helper + # methods for controller examples, you could do this: # - # config.include(My::Pony, My::Horse, :behaviour_type => :farm) + # config.include(ControllerExampleHelpers, :type => :controller) # - # Only behaviours that have that type will get the modules included: + # Only example groups that have that type will get the modules included: # - # describe "Downtown", :behaviour_type => :city do - # # Will *not* get My::Pony and My::Horse included + # describe Account, :type => :model do + # # Will *not* include ControllerExampleHelpers # end # - # describe "Old Mac Donald", :behaviour_type => :farm do - # # *Will* get My::Pony and My::Horse included + # describe AccountsController, :type => :controller do + # # *Will* include ControllerExampleHelpers # end # def include(*args) - args << {} unless Hash === args.last - modules, options = args_and_options(*args) - required_behaviour_type = options[:behaviour_type] - required_behaviour_type = required_behaviour_type.to_sym if required_behaviour_type - modules.each do |mod| - ExampleGroupFactory.get!(required_behaviour_type).send(:include, mod) - end + include_or_extend(:include, *args) end - + + # :call-seq: + # extend(Some::Helpers) + # extend(Some::Helpers, More::Helpers) + # extend(My::Helpers, :type => :key) + # + # Works just like #include, but extends the example groups + # with the modules rather than including them. + def extend(*args) + include_or_extend(:extend, *args) + end + # Defines global predicate matchers. Example: # # config.predicate_matchers[:swim] = :can_swim? # # This makes it possible to say: # - # person.should swim # passes if person.should_swim? returns true + # person.should swim # passes if person.can_swim? returns true # def predicate_matchers @predicate_matchers ||= {} end - # Prepends a global <tt>before</tt> block to all behaviours. + # Prepends a global <tt>before</tt> block to all example groups. # See #append_before for filtering semantics. def prepend_before(*args, &proc) - scope, options = scope_and_options(*args) - behaviour_type = ExampleGroupFactory.get!(options[:behaviour_type]) - behaviour_type.prepend_before(scope, &proc) + add_callback(:prepend_before, *args, &proc) end - # Appends a global <tt>before</tt> block to all behaviours. + + # Appends a global <tt>before</tt> block to all example groups. # - # If you want to restrict the block to a subset of all the behaviours then - # specify this in a Hash as the last argument: + # If you want to restrict the block to a subset of all the example + # groups then specify this in a Hash as the last argument: # - # config.prepend_before(:all, :behaviour_type => :farm) + # config.prepend_before(:all, :type => :farm) # # or # - # config.prepend_before(:behaviour_type => :farm) + # config.prepend_before(:type => :farm) # def append_before(*args, &proc) - scope, options = scope_and_options(*args) - behaviour_type = ExampleGroupFactory.get!(options[:behaviour_type]) - behaviour_type.append_before(scope, &proc) + add_callback(:append_before, *args, &proc) end alias_method :before, :append_before - # Prepends a global <tt>after</tt> block to all behaviours. + # Prepends a global <tt>after</tt> block to all example groups. # See #append_before for filtering semantics. def prepend_after(*args, &proc) - scope, options = scope_and_options(*args) - behaviour_type = ExampleGroupFactory.get!(options[:behaviour_type]) - behaviour_type.prepend_after(scope, &proc) + add_callback(:prepend_after, *args, &proc) end alias_method :after, :prepend_after - # Appends a global <tt>after</tt> block to all behaviours. + + # Appends a global <tt>after</tt> block to all example groups. # See #append_before for filtering semantics. def append_after(*args, &proc) - scope, options = scope_and_options(*args) - behaviour_type = ExampleGroupFactory.get!(options[:behaviour_type]) - behaviour_type.append_after(scope, &proc) + add_callback(:append_after, *args, &proc) end private + + def include_or_extend(*args) + action = args.shift + args << {} unless Hash === args.last + modules, options = Spec::Example.args_and_options(*args) + required_example_group = get_type_from_options(options) + required_example_group = required_example_group.to_sym if required_example_group + modules.each do |mod| + ExampleGroupFactory.get(required_example_group).__send__(action, mod) + end + end + + def add_callback(sym, *args, &proc) + scope, options = Spec::Example.scope_and_options(*args) + example_group = ExampleGroupFactory.get(get_type_from_options(options)) + example_group.__send__(sym, scope, &proc) + end - def scope_and_options(*args) - args, options = args_and_options(*args) - scope = (args[0] || :each), options + def get_type_from_options(options) + options[:type] || options[:behaviour_type] end def mock_framework_path(framework_name) vendor/plugins/rspec/lib/spec/example/configuration.rb @@ -1,9 +1,30 @@ module Spec module Example class ExamplePendingError < StandardError - end + attr_reader :pending_caller - class PendingExampleFixedError < StandardError + def initialize(message=nil) + super + @pending_caller = caller[2] + end + end + + class NotYetImplementedError < ExamplePendingError + MESSAGE = "Not Yet Implemented" + RSPEC_ROOT_LIB = File.expand_path(File.dirname(__FILE__) + "/../..") + + def initialize(backtrace) + super(MESSAGE) + @pending_caller = pending_caller_from(backtrace) + end + + private + + def pending_caller_from(backtrace) + backtrace.detect {|line| !line.include?(RSPEC_ROOT_LIB) } + end end + + class PendingExampleFixedError < StandardError; end end end vendor/plugins/rspec/lib/spec/example/errors.rb @@ -1,13 +1,23 @@ module Spec module Example - # The superclass for all regular RSpec examples. - # See also Test::Unit::TestCase::ExampleGroup + # Base class for customized example groups. Use this if you + # want to make a custom example group. class ExampleGroup extend Spec::Example::ExampleGroupMethods include Spec::Example::ExampleMethods - def initialize(example) #:nodoc: - @_example = example + def initialize(defined_description, options={}, &implementation) + @_options = options + @_defined_description = defined_description + @_implementation = implementation || pending_implementation + @_backtrace = caller + end + + private + + def pending_implementation + error = NotYetImplementedError.new(caller) + lambda { raise(error) } end end end vendor/plugins/rspec/lib/spec/example/example_group.rb @@ -1,103 +1,82 @@ module Spec module Example class ExampleGroupFactory - class << self + module ClassMethods def reset - @example_group_types = { - :default => Spec::Example::ExampleGroup, - :shared => Spec::Example::SharedExampleGroup - } + @example_group_types = nil + default(ExampleGroup) end - # Registers an example group class +klass+ with the symbol - # +type+. For example: + def registered_or_ancestor_of_registered?(example_group_classes) # :nodoc: + example_group_classes.each do |example_group_class| + return false unless registered_types.any? do |registered_type| + registered_type.ancestors.include? example_group_class + end + end + return true + end + + # Registers an example group class +klass+ with the symbol +type+. For + # example: # - # Spec::Example::ExampleGroupFactory.register(:farm, Spec::Farm::Example::FarmExampleGroup) + # Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup) # - # This will cause Main#describe from a file living in - # <tt>spec/farm</tt> to create example group instances of type - # Spec::Farm::Example::FarmExampleGroup. - def register(id, behaviour) - @example_group_types[id] = behaviour + # With that you can append a hash with :type => :farm to the describe + # method and it will load an instance of FarmExampleGroup. + # + # describe Pig, :type => :farm do + # ... + # + # If you don't use the hash explicitly, <tt>describe</tt> will + # implicitly use an instance of FarmExampleGroup for any file loaded + # from the <tt>./spec/farm</tt> directory. + def register(key, example_group_class) + @example_group_types[key] = example_group_class + end + + # Sets the default ExampleGroup class + def default(example_group_class) + old = @example_group_types + @example_group_types = Hash.new(example_group_class) + @example_group_types.merge!(old) if old end - def get(id=:default) - id ||= :default - if @example_group_types.values.include?(id) - return id + def get(key=nil) + if @example_group_types.values.include?(key) + key else - return @example_group_types[id] + @example_group_types[key] end end - def get!(id=:default) - example_group_class = get(id) - unless example_group_class - raise "ExampleGroup #{id.inspect} is not registered. Use ::Spec::Example::ExampleGroupFactory.register" - end - return example_group_class - end - - # Dynamically creates a class def create_example_group(*args, &block) - opts = Hash === args.last ? args.last : {} - if opts[:shared] - return create_shared_example_group(*args, &block) - else - superclass = determine_superclass(opts) - create_example_group_class(superclass, *args, &block) - end + raise ArgumentError if args.empty? + raise ArgumentError unless block + args << {} unless Hash === args.last + args.last[:spec_path] ||= File.expand_path(caller(0)[2]) + superclass = determine_superclass(args.last) + superclass.describe(*args, &block) end - - protected + + protected def determine_superclass(opts) - # new: replaces behaviour_type - if opts[:type] - id = opts[:type] - - #backwards compatibility - elsif opts[:behaviour_type] - id = opts[:behaviour_type] - + key = if opts[:type] + opts[:type] elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.join('|')})/ - id = $2.to_sym - else - id = :default - end - get(id) - end - - def create_example_group_class(superclass, *args, &block) - create_uniquely_named_class(superclass) do - describe(*args) - register - module_eval(&block) + $2 == '' ? nil : $2.to_sym end + get(key) end - def create_uniquely_named_class(superclass, &block) - example_group_class = Class.new(superclass) - class_name = "Subclass_#{class_count}" - superclass.instance_eval do - const_set(class_name, example_group_class) - end - example_group_class.instance_eval(&block) - example_group_class - end + private - def create_shared_example_group(*args, &block) - shared_example_group = @example_group_types[:shared].new(*args, &block) - shared_example_group.register - shared_example_group + def registered_types + @example_group_types.values end - def class_count - @class_count ||= 0 - @class_count += 1 - @class_count - end end + extend ClassMethods self.reset end end vendor/plugins/rspec/lib/spec/example/example_group_factory.rb @@ -1,18 +1,51 @@ module Spec module Example - # See http://rspec.rubyforge.org/documentation/before_and_after.html module ExampleGroupMethods - attr_accessor :description + include Spec::Example::BeforeAndAfterHooks + + def self.matcher_class + @matcher_class + end + + def self.matcher_class=(matcher_class) + @matcher_class = matcher_class + end - def inherited(klass) - super - unless klass.name.to_s == "" - klass.describe(klass.name) - klass.register + def self.description_text(*args) + args.inject("") do |description, arg| + description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/) + description << arg.to_s end end + attr_reader :description_options, :spec_path + alias :options :description_options + + # Provides the backtrace up to where this example_group was declared. + def backtrace + @backtrace + end + + # Deprecated - use +backtrace()+ + def example_group_backtrace + Kernel.warn <<-WARNING +ExampleGroupMethods#example_group_backtrace is deprecated and will be removed +from a future version. Please use ExampleGroupMethods#backtrace instead. +WARNING + backtrace + end + + def description_args + @description_args ||= [] + end + + def inherited(klass) + super + klass.register + Spec::Runner.register_at_exit_hook + end + # Makes the describe/it syntax available from a class. For example: # # class StackSpec < Spec::ExampleGroup @@ -28,34 +61,57 @@ module Spec # end # def describe(*args, &example_group_block) + args << {} unless Hash === args.last if example_group_block - Class.new(self) do - describe(*args) - register - module_eval(&example_group_block) + options = args.last + # Ruby 1.9 - the next line uses example_group_block.binding instead of example_group_block + options[:spec_path] = eval("caller(0)[1]", example_group_block.binding) unless options[:spec_path] + if options[:shared] + create_shared_example_group(*args, &example_group_block) + else + create_subclass(*args, &example_group_block) end else set_description(*args) - before_eval - self end end - - # Use this to pull in examples from shared behaviours. - # See Spec::Runner for information about shared behaviours. - def it_should_behave_like(shared_example_group) - case shared_example_group - when SharedExampleGroup - include shared_example_group - else - example_group = SharedExampleGroup.find_shared_example_group(shared_example_group) - unless example_group - raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found") - end - include(example_group) + alias :context :describe + + def create_shared_example_group(*args, &example_group_block) # :nodoc: + SharedExampleGroup.register(*args, &example_group_block) + end + + def create_subclass(*args, &example_group_block) # :nodoc: + subclass("Subclass") do + set_description(*args) + module_eval(&example_group_block) end end - + + # Creates a new subclass of self, with a name "under" our own name. + # Example: + # + # x = Foo::Bar.subclass('Zap'){} + # x.name # => Foo::Bar::Zap_1 + # x.superclass.name # => Foo::Bar + def subclass(base_name, &body) # :nodoc: + @class_count ||= 0 + @class_count += 1 + klass = Class.new(self) + class_name = "#{base_name}_#{@class_count}" + const_set(class_name, klass) + klass.instance_eval(&body) + klass + end + + # Use this to pull in examples from shared example groups. + # See Spec::Runner for information about shared example groups. + def it_should_behave_like(*shared_example_groups) + shared_example_groups.each do |group| + include_shared_example_group(group) + end + end + # :call-seq: # predicate_matchers[matcher_name] = method_on_object # predicate_matchers[matcher_name] = [method1_on_object, method2_on_object] @@ -85,113 +141,97 @@ module Spec # end # end def predicate_matchers - @predicate_matchers ||= {:exist => :exist?, :an_instance_of => :is_a?} - end - - # Creates an instance of Spec::Example::Example and adds - # it to a collection of examples of the current behaviour. - def it(description=:__generate_docstring, &block) - example = create_example(description, &block) - example_objects << example - example - end - - alias_method :specify, :it - - # Use this to temporarily disable an example. - def xit(description=:__generate_docstring, opts={}, &block) - Kernel.warn("Example disabled: #{description}") + @predicate_matchers ||= {:an_instance_of => :is_a?} end - def add_example(example) - example_objects << example + # Creates an instance of the current example group class and adds it to + # a collection of examples of the current example group. + def example(description=nil, options={}, &implementation) + e = new(description, options, &implementation) + example_objects << e + e end - def described_type #:nodoc: - description.described_type - end + alias_method :it, :example + alias_method :specify, :example - def examples #:nodoc: - examples = example_objects.dup - instance_methods.sort.each do |method_name| - if (is_test?(method_name) || is_spec?(method_name)) && ( - instance_method(method_name).arity == 0 || - instance_method(method_name).arity == -1 - ) - examples << create_example(method_name) do - __send__(method_name) - end - end - end - rspec_options.reverse ? examples.reverse : examples + # Use this to temporarily disable an example. + def xexample(description=nil, opts={}, &block) + Kernel.warn("Example disabled: #{description}") end - def number_of_examples #:nodoc: - examples.length - end + alias_method :xit, :xexample + alias_method :xspecify, :xexample - # Registers a block to be executed before each example. - # This method prepends +block+ to existing before blocks. - def prepend_before(*args, &block) - scope, options = scope_and_options(*args) - parts = before_parts_from_scope(scope) - parts.unshift(block) - end + def run + examples = examples_to_run + reporter.add_example_group(self) unless examples_to_run.empty? + return true if examples.empty? + return dry_run(examples) if dry_run? - # Registers a block to be executed before each example. - # This method appends +block+ to existing before blocks. - def append_before(*args, &block) - scope, options = scope_and_options(*args) - parts = before_parts_from_scope(scope) - parts << block - end - alias_method :before, :append_before + plugin_mock_framework + define_methods_from_predicate_matchers - # Registers a block to be executed after each example. - # This method prepends +block+ to existing after blocks. - def prepend_after(*args, &block) - scope, options = scope_and_options(*args) - parts = after_parts_from_scope(scope) - parts.unshift(block) + success, before_all_instance_variables = run_before_all + success, after_all_instance_variables = execute_examples(success, before_all_instance_variables, examples) + success = run_after_all(success, after_all_instance_variables) end - alias_method :after, :prepend_after - # Registers a block to be executed after each example. - # This method appends +block+ to existing after blocks. - def append_after(*args, &block) - scope, options = scope_and_options(*args) - parts = after_parts_from_scope(scope) - parts << block + def description + result = ExampleGroupMethods.description_text(*description_parts) + (result.nil? || result == "") ? to_s : result end - - def remove_after(scope, &block) - after_each_parts.delete(block) + + def described_type + description_parts.reverse.find {|part| part.is_a?(Module)} end - - # Deprecated. Use before(:each) - def setup(&block) - before(:each, &block) + + # Defines an explicit subject for an example group which can then be the + # implicit receiver (through delegation) of calls to +should+. + # + # == Examples + # + # describe CheckingAccount, "with $50" do + # subject { CheckingAccount.new(:amount => 50, :currency => :USD) } + # it { should have_a_balance_of(50, :USD)} + # it { should_not be_overdrawn} + # end + # + # See +ExampleMethods#should+ for more information about this approach. + def subject(&block) + @_subject_block = block end - - # Deprecated. Use after(:each) - def teardown(&block) - after(:each, &block) + + def subject_block + @_subject_block || lambda {nil} end - - def before_all_parts # :nodoc: - @before_all_parts ||= [] + + def description_parts #:nodoc: + parts = [] + each_ancestor_example_group_class do |example_group_class| + parts << example_group_class.description_args + end + parts.flatten.compact end - def after_all_parts # :nodoc: - @after_all_parts ||= [] + def set_description(*args) + args, options = Spec::Example.args_and_options(*args) + @description_args = args + @description_options = options + @description_text = ExampleGroupMethods.description_text(*args) + @backtrace = caller(1) + @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path] + self end - - def before_each_parts # :nodoc: - @before_each_parts ||= [] + + def examples #:nodoc: + examples = example_objects.dup + add_method_examples(examples) + Spec::Runner.options.reverse ? examples.reverse : examples end - def after_each_parts # :nodoc: - @after_each_parts ||= [] + def number_of_examples #:nodoc: + examples.length end # Only used from RSpec's own examples @@ -201,92 +241,117 @@ module Spec @before_each_parts = nil @after_each_parts = nil end - - def suite - description = description ? description.description : "RSpec Description Suite" - customize_example - suite = ExampleSuite.new(description, self) - add_examples(suite) - suite - end - + def register - rspec_options.add_example_group self + Spec::Runner.options.add_example_group self end - def unregister - rspec_options.remove_example_group self + def unregister #:nodoc: + Spec::Runner.options.remove_example_group self end def run_before_each(example) - execute_in_class_hierarchy(false) do |behaviour| - example.eval_each_fail_fast(behaviour.before_each_parts) + each_ancestor_example_group_class do |example_group_class| + example.eval_each_fail_fast(example_group_class.before_each_parts) end end - - def run_before_all(example) - execute_in_class_hierarchy(false) do |behaviour| - example.eval_each_fail_fast(behaviour.before_all_parts) + + def run_after_each(example) + each_ancestor_example_group_class(:superclass_first) do |example_group_class| + example.eval_each_fail_slow(example_group_class.after_each_parts) + end + end + + private + def dry_run(examples) + examples.each do |example| + Spec::Runner.options.reporter.example_started(example) + Spec::Runner.options.reporter.example_finished(example) end + return true end - def run_after_all(example) - execute_in_class_hierarchy(true) do |behaviour| - example.eval_each_fail_slow(behaviour.after_all_parts) + def run_before_all + before_all = new("before(:all)") + begin + each_ancestor_example_group_class do |example_group_class| + before_all.eval_each_fail_fast(example_group_class.before_all_parts) + end + return [true, before_all.instance_variable_hash] + rescue Exception => e + reporter.failure(before_all, e) + return [false, before_all.instance_variable_hash] end end - - def run_after_each(example) - execute_in_class_hierarchy(true) do |behaviour| - example.eval_each_fail_slow(behaviour.after_each_parts) + + def execute_examples(success, instance_variables, examples) + return [success, instance_variables] unless success + + after_all_instance_variables = instance_variables + examples.each do |example_group_instance| + success &= example_group_instance.execute(Spec::Runner.options, instance_variables) + after_all_instance_variables = example_group_instance.instance_variable_hash end + return [success, after_all_instance_variables] end - private - def create_example(description, &implementation) #:nodoc: - Example.new(description, &implementation) + def run_after_all(success, instance_variables) + after_all = new("after(:all)") + after_all.set_instance_variables_from_hash(instance_variables) + each_ancestor_example_group_class(:superclass_first) do |example_group_class| + after_all.eval_each_fail_slow(example_group_class.after_all_parts) + end + return success + rescue Exception => e + reporter.failure(after_all, e) + return false + end + + def examples_to_run + all_examples = examples + return all_examples unless specified_examples? + all_examples.reject do |example| + matcher = ExampleGroupMethods.matcher_class. + new(description.to_s, example.description) + !matcher.matches?(specified_examples) + end end - - def example_objects - @example_objects ||= [] + + def specified_examples? + specified_examples && !specified_examples.empty? end - def customize_example - plugin_mock_framework - define_predicate_matchers predicate_matchers - define_predicate_matchers(Spec::Runner.configuration.predicate_matchers) + def specified_examples + Spec::Runner.options.examples end - def execute_in_class_hierarchy(superclass_first) + def reporter + Spec::Runner.options.reporter + end + + def dry_run? + Spec::Runner.options.dry_run + end + + def example_objects + @example_objects ||= [] + end + + def each_ancestor_example_group_class(superclass_last=false) classes = [] current_class = self - while is_example_group?(current_class) - superclass_first ? classes << current_class : classes.unshift(current_class) + while is_example_group_class?(current_class) + superclass_last ? classes << current_class : classes.unshift(current_class) current_class = current_class.superclass end - superclass_first ? classes << ExampleMethods : classes.unshift(ExampleMethods) - - classes.each do |behaviour| - yield behaviour - end - end - - def is_example_group?(klass) - klass.kind_of?(ExampleGroupMethods) - end - - def add_examples(suite) - examples.each do |example| - suite << new(example) + + classes.each do |example_group| + yield example_group end end - def is_test?(method_name) - method_name =~ /^test_./ - end - - def is_spec?(method_name) - !(method_name =~ /^should(_not)?$/) && method_name =~ /^should/ + def is_example_group_class?(klass) + klass.kind_of?(ExampleGroupMethods) && klass.included_modules.include?(ExampleMethods) end def plugin_mock_framework @@ -299,48 +364,52 @@ module Spec end end - def define_predicate_matchers(definitions) # :nodoc: - definitions.each_pair do |matcher_method, method_on_object| + def define_methods_from_predicate_matchers # :nodoc: + all_predicate_matchers = predicate_matchers.merge( + Spec::Runner.configuration.predicate_matchers + ) + all_predicate_matchers.each_pair do |matcher_method, method_on_object| define_method matcher_method do |*args| eval("be_#{method_on_object.to_s.gsub('?','')}(*args)") end end end - def scope_and_options(*args) - args, options = args_and_options(*args) - scope = (args[0] || :each), options - end - - def before_parts_from_scope(scope) - case scope - when :each; before_each_parts - when :all; before_all_parts + def add_method_examples(examples) + instance_methods.sort.each do |method_name| + if example_method?(method_name) + examples << new(method_name) do + __send__(method_name) + end + end end end - def after_parts_from_scope(scope) - case scope - when :each; after_each_parts - when :all; after_all_parts - end + def example_method?(method_name) + should_method?(method_name) end - def before_eval + def should_method?(method_name) + !(method_name =~ /^should(_not)?$/) && + method_name =~ /^should/ && ( + [-1,0].include?(instance_method(method_name).arity) + ) end - def set_description(*args) - unless self.class == ExampleGroup - args << {} unless Hash === args.last - args.last[:example_group] = self - end - self.description = ExampleGroupDescription.new(*args) - if described_type.class == Module - include described_type + def include_shared_example_group(shared_example_group) + case shared_example_group + when SharedExampleGroup + include shared_example_group + else + example_group = SharedExampleGroup.find(shared_example_group) + unless example_group + raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found") + end + include(example_group) end - self.description end + end - + end -end \ No newline at end of file +end vendor/plugins/rspec/lib/spec/example/example_group_methods.rb @@ -1,8 +1,8 @@ module Spec module Example class ExampleMatcher - def initialize(example_group_name, example_name) - @example_group_name = example_group_name + def initialize(example_group_description, example_name) + @example_group_description = example_group_description @example_name = example_name end @@ -15,28 +15,30 @@ module Spec protected def matches_literal_example?(specified_example) - specified_example =~ /(^#{behaviour_regexp} #{example_regexp}$|^#{behaviour_regexp}$|^#{behaviour_with_before_all_regexp}$|^#{example_regexp}$)/ + specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/ end def matches_example_not_considering_modules?(specified_example) - specified_example =~ /(^#{behaviour_regexp_not_considering_modules} #{example_regexp}$|^#{behaviour_regexp_not_considering_modules}$|^#{example_regexp}$)/ + specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/ end - def behaviour_regexp - Regexp.escape(@example_group_name) + def example_group_regex + Regexp.escape(@example_group_description) end - def behaviour_with_before_all_regexp - Regexp.escape("#{@example_group_name} before(:all)") + def example_group_with_before_all_regexp + Regexp.escape("#{@example_group_description} before(:all)") end - def behaviour_regexp_not_considering_modules - Regexp.escape(@example_group_name.split('::').last) + def example_group_regex_not_considering_modules + Regexp.escape(@example_group_description.split('::').last) end def example_regexp Regexp.escape(@example_name) end end + + ExampleGroupMethods.matcher_class = ExampleMatcher end end vendor/plugins/rspec/lib/spec/example/example_matcher.rb @@ -1,65 +1,87 @@ module Spec module Example module ExampleMethods - extend ExampleGroupMethods - extend ModuleReopeningFix - - include ::Spec::Matchers - include ::Spec::Example::Pending - attr_reader :_example + extend ModuleReopeningFix - def violated(message="") - raise Spec::Expectations::ExpectationNotMetError.new(message) + def subject # :nodoc: this is somewhat experimental + @subject ||= ( instance_variable_get(subject_variable_name) || + instance_eval(&self.class.subject_block) || + (described_class ? described_class.new : nil) ) end - - def run - _example.run_in(self) + + # When +should+ is called with no explicit receiver, the call is + # delegated to the *subject* of the example group. This could be either + # an explicit subject generated by calling the block passed to + # +ExampleGroupMethods#subject+, or, if the group is describing a class, + # an implicitly generated instance of that class. + def should(matcher=nil) + if matcher + subject.should(matcher) + else + subject.should + end end - - def description - _example.description + + # Just like +should+, +should_not+ delegates to the subject (implicit or + # explicit) of the example group. + def should_not(matcher) + subject.should_not(matcher) end - def description=(description) - _example.description=(description) - end - - def use_generated_description? - _example.description == :__generate_docstring + def violated(message="") + raise Spec::Expectations::ExpectationNotMetError.new(message) end - def copy_instance_variables_from(obj) - super(obj, [:@_example, :@_result]) + def description + @_defined_description || ::Spec::Matchers.generated_description || "NO NAME" end - - def run_before_all - self.class.run_before_all(self) + + def options + @_options end - def run_before_each - self.class.run_before_each(self) - end + def execute(options, instance_variables) + options.reporter.example_started(self) + set_instance_variables_from_hash(instance_variables) + + execution_error = nil + Timeout.timeout(options.timeout) do + begin + before_each_example + eval_block + rescue Exception => e + execution_error ||= e + end + begin + after_each_example + rescue Exception => e + execution_error ||= e + end + end - def run_after_each - self.class.run_after_each(self) + options.reporter.example_finished(self, execution_error) + success = execution_error.nil? || ExamplePendingError === execution_error end - def run_after_all - self.class.run_after_all(self) + def instance_variable_hash # :nodoc: + instance_variables.inject({}) do |variable_hash, variable_name| + variable_hash[variable_name] = instance_variable_get(variable_name) + variable_hash + end end - def eval_each_fail_fast(procs) #:nodoc: - procs.each do |proc| - instance_eval(&proc) + def eval_each_fail_fast(examples) # :nodoc: + examples.each do |example| + instance_eval(&example) end end - def eval_each_fail_slow(procs) #:nodoc: + def eval_each_fail_slow(examples) # :nodoc: first_exception = nil - procs.each do |proc| + examples.each do |example| begin - instance_eval(&proc) + instance_eval(&example) rescue Exception => e first_exception ||= e end @@ -67,6 +89,80 @@ module Spec raise first_exception if first_exception end + # Concats the class description with the example description. + # + # describe Account do + # it "should start with a balance of 0" do + # ... + # + # full_description + # => "Account should start with a balance of 0" + def full_description + "#{self.class.description} #{self.description}" + end + + def set_instance_variables_from_hash(ivars) # :nodoc: + ivars.each do |variable_name, value| + # Ruby 1.9 requires variable.to_s on the next line + unless ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].include?(variable_name.to_s) + instance_variable_set variable_name, value + end + end + end + + def eval_block # :nodoc: + instance_eval(&@_implementation) + end + + # Provides the backtrace up to where this example was declared. + def backtrace + @_backtrace + end + + # Deprecated - use +backtrace()+ + def implementation_backtrace + Kernel.warn <<-WARNING +ExampleMethods#implementation_backtrace is deprecated and will be removed +from a future version. Please use ExampleMethods#backtrace instead. +WARNING + backtrace + end + + private + include Matchers + include Pending + + def before_each_example + setup_mocks_for_rspec + self.class.run_before_each(self) + end + + def after_each_example + self.class.run_after_each(self) + verify_mocks_for_rspec + ensure + teardown_mocks_for_rspec + end + + def subject_variable_name + '@' << (described_class ? underscore(described_class.name) : '__this_does_not_exist') + end + + def described_class + Class === described_type ? described_type : nil + end + + def described_type + self.class.described_type + end + + def underscore(camel_cased_word) + camel_cased_word.to_s.gsub(/::/, '_'). + gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). + gsub(/([a-z\d])([A-Z])/,'\1_\2'). + tr("-", "_"). + downcase + end end end -end \ No newline at end of file +end vendor/plugins/rspec/lib/spec/example/example_methods.rb @@ -1,5 +1,6 @@ module Spec module Example + # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak) module ModuleReopeningFix def child_modules @child_modules ||= [] vendor/plugins/rspec/lib/spec/example/module_reopening_fix.rb @@ -1,58 +1,62 @@ module Spec module Example class SharedExampleGroup < Module - class << self - def add_shared_example_group(new_example_group) - guard_against_redefining_existing_example_group(new_example_group) - shared_example_groups << new_example_group + module ClassMethods + def register(*args, &block) + new_example_group = new(*args, &block) + shared_example_groups << new_example_group unless already_registered?(new_example_group) + new_example_group + end + + def find(example_group_description) + shared_example_groups.find {|b| b.description == example_group_description} end - def find_shared_example_group(example_group_description) - shared_example_groups.find do |b| - b.description == example_group_description - end + def clear + shared_example_groups.clear + end + + def include?(group) + shared_example_groups.include?(group) + end + + def count + shared_example_groups.length end + private + def shared_example_groups - # TODO - this needs to be global, or at least accessible from - # from subclasses of Example in a centralized place. I'm not loving - # this as a solution, but it works for now. - $shared_example_groups ||= [] + @shared_example_groups ||= [] end - - private - def guard_against_redefining_existing_example_group(new_example_group) - existing_example_group = find_shared_example_group(new_example_group.description) - return unless existing_example_group - return if new_example_group.equal?(existing_example_group) - return if spec_path(new_example_group) == spec_path(existing_example_group) + + def already_registered?(new_example_group) + existing_example_group = find(new_example_group.description) + return false unless existing_example_group + return true if new_example_group.equal?(existing_example_group) + return true if spec_path(new_example_group) == spec_path(existing_example_group) raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists") end def spec_path(example_group) - File.expand_path(example_group.description[:spec_path]) + File.expand_path(example_group.spec_path) end end + + extend ClassMethods include ExampleGroupMethods - public :include def initialize(*args, &example_group_block) - describe(*args) - module_eval(&example_group_block) + set_description(*args) + @example_group_block = example_group_block end def included(mod) # :nodoc: - before_each_parts.each { |p| mod.before_each_parts << p } - after_each_parts.each { |p| mod.after_each_parts << p } - before_all_parts.each { |p| mod.before_all_parts << p } - after_all_parts.each { |p| mod.after_all_parts << p } - example_objects.each do |example| - mod.add_example example - end + mod.module_eval(&@example_group_block) end - def register - Spec::Example::SharedExampleGroup.add_shared_example_group(self) + def each_ancestor_example_group_class(superclass_last=false) + yield self end end end vendor/plugins/rspec/lib/spec/example/shared_example_group.rb @@ -2,6 +2,7 @@ require 'spec/matchers' require 'spec/expectations/errors' require 'spec/expectations/extensions' require 'spec/expectations/handler' +require 'spec/expectations/wrap_expectation' module Spec @@ -30,27 +31,31 @@ module Spec # RSpec ships with a standard set of useful matchers, and writing your own # matchers is quite simple. See Spec::Matchers for details. module Expectations - class << self - attr_accessor :differ + def self.differ + @differ + end + + def self.differ=(differ) + @differ = differ + end - # raises a Spec::Expectations::ExpectationNotMetError with message - # - # When a differ has been assigned and fail_with is passed - # <code>expected</code> and <code>target</code>, passes them - # to the differ to append a diff message to the failure message. - def fail_with(message, expected=nil, target=nil) # :nodoc: - if Array === message && message.length == 3 - message, expected, target = message[0], message[1], message[2] - end - unless (differ.nil? || expected.nil? || target.nil?) - if expected.is_a?(String) - message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected) - elsif !target.is_a?(Proc) - message << "\nDiff:" << self.differ.diff_as_object(target, expected) - end + # raises a Spec::Expectations::ExpectationNotMetError with message + # + # When a differ has been assigned and fail_with is passed + # <code>expected</code> and <code>target</code>, passes them + # to the differ to append a diff message to the failure message. + def self.fail_with(message, expected=nil, target=nil) # :nodoc: + if Array === message && message.length == 3 + message, expected, target = message[0], message[1], message[2] + end + unless (differ.nil? || expected.nil? || target.nil?) + if expected.is_a?(String) + message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected) + elsif !target.is_a?(Proc) + message << "\nDiff:" << self.differ.diff_as_object(target, expected) end - Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message)) end + Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message)) end end end vendor/plugins/rspec/lib/spec/expectations.rb @@ -17,7 +17,7 @@ module Spec end # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool) - def diff_as_string(data_old, data_new) + def diff_as_string(data_new, data_old) data_old = data_old.split(/\n/).map! { |e| e.chomp } data_new = data_new.split(/\n/).map! { |e| e.chomp } output = "" vendor/plugins/rspec/lib/spec/expectations/differs/default.rb @@ -1,6 +1,12 @@ module Spec module Expectations - class ExpectationNotMetError < StandardError + # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit + # will report unmet RSpec expectations as failures rather than errors. + superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c| + eval(c) rescue nil + end.compact.first + + class ExpectationNotMetError < superclass end end end vendor/plugins/rspec/lib/spec/expectations/errors.rb @@ -27,12 +27,8 @@ module Spec # # NOTE that this does NOT support receiver.should != expected. # Instead, use receiver.should_not == expected - def should(matcher = :default_parameter, &block) - if :default_parameter == matcher - Spec::Matchers::PositiveOperatorMatcher.new(self) - else - ExpectationMatcherHandler.handle_matcher(self, matcher, &block) - end + def should(matcher=nil, &block) + ExpectationMatcherHandler.handle_matcher(self, matcher, &block) end # :call-seq: @@ -54,12 +50,8 @@ module Spec # => Passes unless (receiver =~ regexp) # # See Spec::Matchers for more information about matchers - def should_not(matcher = :default_parameter, &block) - if :default_parameter == matcher - Spec::Matchers::NegativeOperatorMatcher.new(self) - else - NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) - end + def should_not(matcher=nil, &block) + NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) end end vendor/plugins/rspec/lib/spec/expectations/extensions/object.rb @@ -2,51 +2,46 @@ module Spec module Expectations class InvalidMatcherError < ArgumentError; end - module MatcherHandlerHelper - def describe_matcher(matcher) - matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]" - end - end - class ExpectationMatcherHandler - class << self - include MatcherHandlerHelper - def handle_matcher(actual, matcher, &block) - unless matcher.respond_to?(:matches?) - raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}." - end - - match = matcher.matches?(actual, &block) - ::Spec::Matchers.generated_description = "should #{describe_matcher(matcher)}" - Spec::Expectations.fail_with(matcher.failure_message) unless match + def self.handle_matcher(actual, matcher, &block) + ::Spec::Matchers.last_should = "should" + return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil? + + unless matcher.respond_to?(:matches?) + raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}." end + + match = matcher.matches?(actual, &block) + ::Spec::Matchers.last_matcher = matcher + Spec::Expectations.fail_with(matcher.failure_message) unless match + match end end class NegativeExpectationMatcherHandler - class << self - include MatcherHandlerHelper - def handle_matcher(actual, matcher, &block) - unless matcher.respond_to?(:matches?) - raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}." - end + def self.handle_matcher(actual, matcher, &block) + ::Spec::Matchers.last_should = "should not" + return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil? + + unless matcher.respond_to?(:matches?) + raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}." + end - unless matcher.respond_to?(:negative_failure_message) - Spec::Expectations.fail_with( + unless matcher.respond_to?(:negative_failure_message) + Spec::Expectations.fail_with( <<-EOF Matcher does not support should_not. See Spec::Matchers for more information about matchers. EOF ) - end - match = matcher.matches?(actual, &block) - ::Spec::Matchers.generated_description = "should not #{describe_matcher(matcher)}" - Spec::Expectations.fail_with(matcher.negative_failure_message) if match end + match = matcher.matches?(actual, &block) + ::Spec::Matchers.last_matcher = matcher + Spec::Expectations.fail_with(matcher.negative_failure_message) if match + match end end - end end vendor/plugins/rspec/lib/spec/expectations/handler.rb @@ -1,9 +1,15 @@ +require 'spec/matchers/operator_matcher' +require 'spec/matchers/generated_descriptions' +require 'spec/matchers/errors' +require 'spec/matchers/method_missing' require 'spec/matchers/simple_matcher' require 'spec/matchers/be' require 'spec/matchers/be_close' require 'spec/matchers/change' +require 'spec/matchers/match_array' require 'spec/matchers/eql' require 'spec/matchers/equal' +require 'spec/matchers/exist' require 'spec/matchers/has' require 'spec/matchers/have' require 'spec/matchers/include' @@ -12,7 +18,6 @@ require 'spec/matchers/raise_error' require 'spec/matchers/respond_to' require 'spec/matchers/satisfy' require 'spec/matchers/throw_symbol' -require 'spec/matchers/operator_matcher' module Spec @@ -131,23 +136,5 @@ module Spec # config.include(CustomGameMatchers) # end # - module Matchers - module ModuleMethods - attr_accessor :generated_description - def clear_generated_description - @generated_description = nil - end - end - extend ModuleMethods - - def method_missing(sym, *args, &block) # :nodoc: - return Matchers::Be.new(sym, *args) if sym.starts_with?("be_") - return Matchers::Has.new(sym, *args) if sym.starts_with?("have_") - super - end - - class MatcherError < StandardError - end - - end + module Matchers; end end vendor/plugins/rspec/lib/spec/matchers.rb @@ -3,125 +3,115 @@ module Spec class Be #:nodoc: def initialize(*args) - @expected = parse_expected(args.shift) + @expected = args.empty? ? true : set_expected(args.shift) @args = args - @comparison = "" end def matches?(actual) @actual = actual - return true if match_or_compare unless handling_predicate? - if handling_predicate? - begin - return @result = actual.__send__(predicate, *@args) - rescue => predicate_error - # This clause should be empty, but rcov will not report it as covered - # unless something (anything) is executed within the clause - rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0" - end + handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual) + end + + def run_predicate_on(actual) + begin + return @result = actual.__send__(predicate, *@args) + rescue NameError => predicate_missing_error + "this needs to be here or rcov will not count this branch even though it's executed in a code example" + end - # This supports should_exist > target.exists? in the old world. - # We should consider deprecating that ability as in the new world - # you can't write "should exist" unless you have your own custom matcher. - begin - return @result = actual.__send__(present_tense_predicate, *@args) - rescue - raise predicate_error - end + begin + return @result = actual.__send__(present_tense_predicate, *@args) + rescue NameError + raise predicate_missing_error end - return false end def failure_message - return "expected #{@comparison}#{expected}, got #{@actual.inspect}" unless handling_predicate? - return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" + handling_predicate? ? + "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" : + "expected #{@comparison_method} #{expected}, got #{@actual.inspect}".gsub(' ',' ') end def negative_failure_message - return "expected not #{expected}, got #{@actual.inspect}" unless handling_predicate? - return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}" - end - - def expected - return true if @expected == :true - return false if @expected == :false - return "nil" if @expected == :nil - return @expected.inspect - end - - def match_or_compare - return @actual == true if @expected == :true - return @actual == false if @expected == :false - return @actual.nil? if @expected == :nil - return @actual < @expected if @less_than - return @actual <= @expected if @less_than_or_equal - return @actual >= @expected if @greater_than_or_equal - return @actual > @expected if @greater_than - return @actual == @expected if @double_equal - return @actual === @expected if @triple_equal - return @actual.equal?(@expected) + if handling_predicate? + "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}" + else + message = <<-MESSAGE +'should_not be #{@comparison_method} #{expected}' not only FAILED, +it reads really poorly. + MESSAGE + + raise message << ([:===,:==].include?(@comparison_method) ? + "Why don't you try expressing it without the \"be\"?" : + "Why don't you try expressing it in the positive?") + end end - def ==(expected) - @double_equal = true - @comparison = "== " - @expected = expected - self - end - - def ===(expected) - @triple_equal = true - @comparison = "=== " - @expected = expected - self - end - - def <(expected) - @less_than = true - @comparison = "< " - @expected = expected - self - end - - def <=(expected) - @less_than_or_equal = true - @comparison = "<= " - @expected = expected - self + def description + "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ') end - def >=(expected) - @greater_than_or_equal = true - @comparison = ">= " - @expected = expected - self + [:==, :<, :<=, :>=, :>, :===].each do |method| + define_method method do |expected| + compare_to(expected, :using => method) + self + end end - def >(expected) - @greater_than = true - @comparison = "> " - @expected = expected - self - end + private + def match_or_compare(actual) + case @expected + when TrueClass + @actual + else + @actual.__send__(comparison_method, @expected) + end + end - def description - "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}" - end + def comparison_method + @comparison_method || :equal? + end + + def expected + @expected + end - private + def compare_to(expected, opts) + @expected, @comparison_method = expected, opts[:using] + end + + def set_expected(expected) + Symbol === expected ? parse_expected(expected) : expected + end + def parse_expected(expected) - if Symbol === expected - @handling_predicate = true - ["be_an_","be_a_","be_"].each do |@prefix| - return "#{expected.to_s.sub(@prefix,"")}".to_sym if expected.starts_with?(@prefix) + ["be_an_","be_a_","be_"].each do |prefix| + handling_predicate! + if expected.starts_with?(prefix) + set_prefix(prefix) + expected = expected.to_s.sub(prefix,"") + [true, false, nil].each do |val| + return val if val.to_s == expected + end + return expected.to_sym end end - @prefix = "be " - return expected + end + + def set_prefix(prefix) + @prefix = prefix + end + + def prefix + @prefix + end + + def handling_predicate! + @handling_predicate = true end def handling_predicate? - return false if [:true, :false, :nil].include?(@expected) + return false if [true, false, nil].include?(expected) return @handling_predicate end @@ -134,21 +124,27 @@ module Spec end def args_to_s - return "" if @args.empty? - inspected_args = @args.collect{|a| a.inspect} - return "(#{inspected_args.join(', ')})" + @args.empty? ? "" : parenthesize(inspected_args.join(', ')) + end + + def parenthesize(string) + return "(#{string})" + end + + def inspected_args + @args.collect{|a| a.inspect} end def comparison - @comparison + @comparison_method.nil? ? " " : "be #{@comparison_method.to_s} " end def expected_to_sentence - split_words(@expected) + split_words(expected) end def prefix_to_sentence - split_words(@prefix) + split_words(prefix) end def split_words(sym) @@ -176,8 +172,9 @@ module Spec # should_not be_nil # should_not be_arbitrary_predicate(*args) # - # Given true, false, or nil, will pass if actual is - # true, false or nil (respectively). + # Given true, false, or nil, will pass if actual value is + # true, false or nil (respectively). Given no args means + # the caller should satisfy an if condition (to be or not to be). # # Predicates are any Ruby method that ends in a "?" and returns true or false. # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match vendor/plugins/rspec/lib/spec/matchers/be.rb @@ -1,26 +1,6 @@ module Spec module Matchers - class BeClose #:nodoc: - def initialize(expected, delta) - @expected = expected - @delta = delta - end - - def matches?(actual) - @actual = actual - (@actual - @expected).abs < @delta - end - - def failure_message - "expected #{@expected} +/- (< #{@delta}), got #{@actual}" - end - - def description - "be close to #{@expected} (within +- #{@delta})" - end - end - # :call-seq: # should be_close(expected, delta) # should_not be_close(expected, delta) @@ -31,7 +11,11 @@ module Spec # # result.should be_close(3.0, 0.5) def be_close(expected, delta) - Matchers::BeClose.new(expected, delta) + simple_matcher do |actual, matcher| + matcher.failure_message = "expected #{expected} +/- (< #{delta}), got #{actual}" + matcher.description = "be close to #{expected} (within +- #{delta})" + (actual - expected).abs < delta + end end end end vendor/plugins/rspec/lib/spec/matchers/be_close.rb @@ -4,60 +4,60 @@ module Spec #Based on patch from Wilson Bilkovich class Change #:nodoc: def initialize(receiver=nil, message=nil, &block) - @receiver = receiver - @message = message - @block = block + @message = message || "result" + @value_proc = block || lambda { + receiver.__send__(message) + } end - def matches?(target, &block) - if block - raise MatcherError.new(<<-EOF -block passed to should or should_not change must use {} instead of do/end -EOF -) - end - @target = target - execute_change - return false if @from && (@from != @before) - return false if @to && (@to != @after) + def matches?(event_proc) + raise_block_syntax_error if block_given? + + @before = evaluate_value_proc + event_proc.call + @after = evaluate_value_proc + + return false if @from unless @from == @before + return false if @to unless @to == @after return (@before + @amount == @after) if @amount return ((@after - @before) >= @minimum) if @minimum return ((@after - @before) <= @maximum) if @maximum return @before != @after end - def execute_change - @before = @block.nil? ? @receiver.send(@message) : @block.call - @target.call - @after = @block.nil? ? @receiver.send(@message) : @block.call + def raise_block_syntax_error + raise MatcherError.new(<<-MESSAGE +block passed to should or should_not change must use {} instead of do/end +MESSAGE + ) + end + + def evaluate_value_proc + @value_proc.call end def failure_message if @to - "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}" + "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}" elsif @from - "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}" + "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}" elsif @amount - "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}" + "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}" elsif @minimum - "#{result} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}" + "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}" elsif @maximum - "#{result} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}" + "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}" else - "#{result} should have changed, but is still #{@before.inspect}" + "#{@message} should have changed, but is still #{@before.inspect}" end end - def result - @message || "result" - end - def actual_delta @after - @before end def negative_failure_message - "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}" + "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}" end def by(amount) @@ -114,7 +114,7 @@ EOF # # string = "string" # lambda { - # string.reverse + # string.reverse! # }.should change { string }.from("string").to("gnirts") # # lambda { @@ -125,20 +125,24 @@ EOF # employee.develop_great_new_social_networking_app # }.should change(employee, :title).from("Mail Clerk").to("CEO") # - # Evaluates +receiver.message+ or +block+ before and - # after it evaluates the c object (generated by the lambdas in the examples above). + # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after + # it evaluates the c object (generated by the lambdas in the examples + # above). + # + # Then compares the values before and after the <tt>receiver.message</tt> + # and evaluates the difference compared to the expected difference. # - # Then compares the values before and after the +receiver.message+ and - # evaluates the difference compared to the expected difference. + # == WARNING + # <tt>should_not change</tt> only supports the form with no + # subsequent calls to <tt>by</tt>, <tt>by_at_least</tt>, + # <tt>by_at_most</tt>, <tt>to</tt> or <tt>from</tt>. # - # == Warning - # +should_not+ +change+ only supports the form with no subsequent calls to - # +by+, +by_at_least+, +by_at_most+, +to+ or +from+. + # blocks passed to <tt>should</tt> <tt>change</tt> and <tt>should_not</tt> + # <tt>change</tt> must use the <tt>{}</tt> form (<tt>do/end</tt> is not + # supported). # - # blocks passed to +should+ +change+ and +should_not+ +change+ - # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported) - def change(target=nil, message=nil, &block) - Matchers::Change.new(target, message, &block) + def change(receiver=nil, message=nil, &block) + Matchers::Change.new(receiver, message, &block) end end end vendor/plugins/rspec/lib/spec/matchers/change.rb @@ -1,29 +1,6 @@ module Spec module Matchers - class Eql #:nodoc: - def initialize(expected) - @expected = expected - end - - def matches?(actual) - @actual = actual - @actual.eql?(@expected) - end - - def failure_message - return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual - end - - def negative_failure_message - return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual - end - - def description - "eql #{@expected.inspect}" - end - end - # :call-seq: # should eql(expected) # should_not eql(expected) @@ -37,7 +14,12 @@ module Spec # 5.should eql(5) # 5.should_not eql(3) def eql(expected) - Matchers::Eql.new(expected) + simple_matcher do |actual, matcher| + matcher.failure_message = "expected #{expected.inspect}, got #{actual.inspect} (using .eql?)", expected, actual + matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .eql?)", expected, actual + matcher.description = "eql #{expected.inspect}" + actual.eql?(expected) + end end end end vendor/plugins/rspec/lib/spec/matchers/eql.rb @@ -1,34 +1,11 @@ module Spec module Matchers - class Equal #:nodoc: - def initialize(expected) - @expected = expected - end - - def matches?(actual) - @actual = actual - @actual.equal?(@expected) - end - - def failure_message - return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual - end - - def negative_failure_message - return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual - end - - def description - "equal #{@expected.inspect}" - end - end - # :call-seq: # should equal(expected) # should_not equal(expected) # - # Passes if actual and expected are the same object (object identity). + # Passes if given and expected are the same object (object identity). # # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby. # @@ -37,7 +14,12 @@ module Spec # 5.should equal(5) #Fixnums are equal # "5".should_not equal("5") #Strings that look the same are not the same object def equal(expected) - Matchers::Equal.new(expected) + simple_matcher do |actual, matcher| + matcher.failure_message = "expected #{expected.inspect}, got #{actual.inspect} (using .equal?)", expected, actual + matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .equal?)", expected, actual + matcher.description = "equal #{expected.inspect}" + actual.equal?(expected) + end end end end vendor/plugins/rspec/lib/spec/matchers/equal.rb @@ -1,44 +1,18 @@ module Spec module Matchers - - class Has #:nodoc: - def initialize(sym, *args) - @sym = sym - @args = args - end - - def matches?(target) - @target = target - begin - return target.send(predicate, *@args) - rescue => @error - # This clause should be empty, but rcov will not report it as covered - # unless something (anything) is executed within the clause - rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0" - end - return false - end - - def failure_message - raise @error if @error - "expected ##{predicate}(#{@args[0].inspect}) to return true, got false" - end - - def negative_failure_message - raise @error if @error - "expected ##{predicate}(#{@args[0].inspect}) to return false, got true" + def has(sym, *args) # :nodoc: + simple_matcher do |actual, matcher| + matcher.failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false" + matcher.negative_failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return false, got true" + matcher.description = "have key #{args[0].inspect}" + actual.__send__(predicate(sym), *args) end - - def description - "have key #{@args[0].inspect}" - end - - private - def predicate - "#{@sym.to_s.sub("have_","has_")}?".to_sym - end - end - + + private + def predicate(sym) + "#{sym.to_s.sub("have_","has_")}?".to_sym + end + end end vendor/plugins/rspec/lib/spec/matchers/has.rb @@ -1,6 +1,5 @@ module Spec module Matchers - class Have #:nodoc: def initialize(expected, relativity=:exactly) @expected = (expected == :no ? 0 : expected) @@ -15,27 +14,22 @@ module Spec } end - def method_missing(sym, *args, &block) - @collection_name = sym - @args = args - @block = block - self - end - def matches?(collection_owner) if collection_owner.respond_to?(@collection_name) - collection = collection_owner.send(@collection_name, *@args, &@block) + collection = collection_owner.__send__(@collection_name, *@args, &@block) + elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name)) + collection = collection_owner.__send__(@plural_collection_name, *@args, &@block) elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size)) collection = collection_owner else - collection_owner.send(@collection_name, *@args, &@block) + collection_owner.__send__(@collection_name, *@args, &@block) end - @actual = collection.size if collection.respond_to?(:size) - @actual = collection.length if collection.respond_to?(:length) - raise not_a_collection if @actual.nil? - return @actual >= @expected if @relativity == :at_least - return @actual <= @expected if @relativity == :at_most - return @actual == @expected + @given = collection.size if collection.respond_to?(:size) + @given = collection.length if collection.respond_to?(:length) + raise not_a_collection if @given.nil? + return @given >= @expected if @relativity == :at_least + return @given <= @expected if @relativity == :at_most + return @given == @expected end def not_a_collection @@ -43,12 +37,12 @@ module Spec end def failure_message - "expected #{relative_expectation} #{@collection_name}, got #{@actual}" + "expected #{relative_expectation} #{@collection_name}, got #{@given}" end def negative_failure_message if @relativity == :exactly - return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}" + return "expected target not to have #{@expected} #{@collection_name}, got #{@given}" elsif @relativity == :at_most return <<-EOF Isn't life confusing enough? @@ -72,8 +66,22 @@ EOF "have #{relative_expectation} #{@collection_name}" end + def respond_to?(sym) + @expected.respond_to?(sym) || super + end + private + def method_missing(sym, *args, &block) + @collection_name = sym + if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil)) + @plural_collection_name = inflector.pluralize(sym.to_s) + end + @args = args + @block = block + self + end + def relative_expectation "#{relativities[@relativity]}#{@expected}" end vendor/plugins/rspec/lib/spec/matchers/have.rb @@ -10,7 +10,17 @@ module Spec def matches?(actual) @actual = actual @expecteds.each do |expected| - return false unless actual.include?(expected) + if actual.is_a?(Hash) + if expected.is_a?(Hash) + expected.each_pair do |k,v| + return false unless actual[k] == v + end + else + return false unless actual.has_key?(expected) + end + else + return false unless actual.include?(expected) + end end true end vendor/plugins/rspec/lib/spec/matchers/include.rb @@ -1,30 +1,6 @@ module Spec module Matchers - class Match #:nodoc: - def initialize(expected) - @expected = expected - end - - def matches?(actual) - @actual = actual - return true if actual =~ @expected - return false - end - - def failure_message - return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual - end - - def negative_failure_message - return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual - end - - def description - "match #{@expected.inspect}" - end - end - # :call-seq: # should match(regexp) # should_not match(regexp) @@ -33,9 +9,14 @@ module Spec # # == Examples # - # email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) def match(regexp) - Matchers::Match.new(regexp) + simple_matcher do |actual, matcher| + matcher.failure_message = "expected #{actual.inspect} to match #{regexp.inspect}", regexp, actual + matcher.negative_failure_message = "expected #{actual.inspect} not to match #{regexp.inspect}", regexp, actual + matcher.description = "match #{regexp.inspect}" + actual =~ regexp + end end end end vendor/plugins/rspec/lib/spec/matchers/match.rb @@ -1,70 +1,73 @@ module Spec module Matchers - class BaseOperatorMatcher - attr_reader :generated_description - - def initialize(target) - @target = target - end - def ==(expected) - @expected = expected - __delegate_method_missing_to_target("==", expected) - end + class OperatorMatcher + @operator_registry = {} - def ===(expected) - @expected = expected - __delegate_method_missing_to_target("===", expected) + def self.register(klass, operator, matcher) + @operator_registry[klass] ||= {} + @operator_registry[klass][operator] = matcher end - def =~(expected) - @expected = expected - __delegate_method_missing_to_target("=~", expected) + def self.get(klass, operator) + return @operator_registry[klass][operator] if @operator_registry[klass] + nil end - def >(expected) - @expected = expected - __delegate_method_missing_to_target(">", expected) + def initialize(actual) + @actual = actual end - def >=(expected) - @expected = expected - __delegate_method_missing_to_target(">=", expected) + def self.use_custom_matcher_or_delegate(operator) + define_method(operator) do |expected| + if matcher = OperatorMatcher.get(@actual.class, operator) + return @actual.send(matcher_method, matcher.new(expected)) + else + ::Spec::Matchers.last_matcher = self + @operator, @expected = operator, expected + __delegate_operator(@actual, operator, expected) + end + end end - def <(expected) - @expected = expected - __delegate_method_missing_to_target("<", expected) + ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator| + use_custom_matcher_or_delegate operator end - def <=(expected) - @expected = expected - __delegate_method_missing_to_target("<=", expected) + def fail_with_message(message) + Spec::Expectations.fail_with(message, @expected, @actual) end - def fail_with_message(message) - Spec::Expectations.fail_with(message, @expected, @target) + def description + "#{@operator} #{@expected.inspect}" end end - class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc: + class PositiveOperatorMatcher < OperatorMatcher #:nodoc: + def matcher_method + :should + end - def __delegate_method_missing_to_target(operator, expected) - ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}" - return if @target.send(operator, expected) - return fail_with_message("expected: #{expected.inspect},\n got: #{@target.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator) - return fail_with_message("expected: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{@target.inspect}") + def __delegate_operator(actual, operator, expected) + return true if actual.__send__(operator, expected) + if ['==','===', '=~'].include?(operator) + fail_with_message("expected: #{expected.inspect},\n got: #{actual.inspect} (using #{operator})") + else + fail_with_message("expected: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{actual.inspect}") + end end end - class NegativeOperatorMatcher < BaseOperatorMatcher #:nodoc: + class NegativeOperatorMatcher < OperatorMatcher #:nodoc: + def matcher_method + :should_not + end - def __delegate_method_missing_to_target(operator, expected) - ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}" - return unless @target.send(operator, expected) - return fail_with_message("expected not: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{@target.inspect}") + def __delegate_operator(actual, operator, expected) + return true unless actual.__send__(operator, expected) + return fail_with_message("expected not: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{actual.inspect}") end end vendor/plugins/rspec/lib/spec/matchers/operator_matcher.rb @@ -1,54 +1,66 @@ module Spec module Matchers - class RaiseError #:nodoc: - def initialize(error_or_message=Exception, message=nil) - if String === error_or_message - @expected_error = Exception - @expected_message = error_or_message + def initialize(expected_error_or_message=Exception, expected_message=nil, &block) + @block = block + case expected_error_or_message + when String, Regexp + @expected_error, @expected_message = Exception, expected_error_or_message else - @expected_error = error_or_message - @expected_message = message + @expected_error, @expected_message = expected_error_or_message, expected_message end end - - def matches?(proc) + + def matches?(given_proc) @raised_expected_error = false - @raised_other = false + @with_expected_message = false + @eval_block = false + @eval_block_passed = false begin - proc.call - rescue @expected_error => @actual_error - if @expected_message.nil? - @raised_expected_error = true - else - case @expected_message - when Regexp - if @expected_message =~ @actual_error.message - @raised_expected_error = true - else - @raised_other = true - end - else - if @expected_message == @actual_error.message - @raised_expected_error = true - else - @raised_other = true - end - end - end - rescue => @actual_error - @raised_other = true - ensure - return @raised_expected_error + given_proc.call + rescue @expected_error => @given_error + @raised_expected_error = true + @with_expected_message = verify_message + rescue Exception => @given_error + # This clause should be empty, but rcov will not report it as covered + # unless something (anything) is executed within the clause + rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0" + end + + unless negative_expectation? + eval_block if @raised_expected_error && @with_expected_message && @block + end + ensure + return (@raised_expected_error && @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false + end + + def eval_block + @eval_block = true + begin + @block[@given_error] + @eval_block_passed = true + rescue Exception => err + @given_error = err + end + end + + def verify_message + case @expected_message + when nil + true + when Regexp + @expected_message =~ @given_error.message + else + @expected_message == @given_error.message end end def failure_message - return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error + @eval_block ? @given_error.message : "expected #{expected_error}#{given_error}" end def negative_failure_message - "expected no #{expected_error}#{actual_error}" + "expected no #{expected_error}#{given_error}" end def description @@ -67,8 +79,13 @@ module Spec end end - def actual_error - @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}" + def given_error + @given_error.nil? ? " but nothing was raised" : ", got #{@given_error.inspect}" + end + + def negative_expectation? + # YES - I'm a bad person... help me find a better way - ryand + caller.first(3).find { |s| s =~ /should_not/ } end end @@ -77,6 +94,10 @@ module Spec # should raise_error(NamedError) # should raise_error(NamedError, String) # should raise_error(NamedError, Regexp) + # should raise_error() { |error| ... } + # should raise_error(NamedError) { |error| ... } + # should raise_error(NamedError, String) { |error| ... } + # should raise_error(NamedError, Regexp) { |error| ... } # should_not raise_error() # should_not raise_error(NamedError) # should_not raise_error(NamedError, String) @@ -86,11 +107,13 @@ module Spec # With a named error, matches only if that specific error is raised. # With a named error and messsage specified as a String, matches only if both match. # With a named error and messsage specified as a Regexp, matches only if both match. + # Pass an optional block to perform extra verifications on the exception matched # # == Examples # # lambda { do_something_risky }.should raise_error # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) + # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 } # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky") # lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/) # @@ -98,8 +121,8 @@ module Spec # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError) # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky") # lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/) - def raise_error(error=Exception, message=nil) - Matchers::RaiseError.new(error, message) + def raise_error(error=Exception, message=nil, &block) + Matchers::RaiseError.new(error, message, &block) end end end vendor/plugins/rspec/lib/spec/matchers/raise_error.rb @@ -7,9 +7,10 @@ module Spec @names_not_responded_to = [] end - def matches?(target) + def matches?(given) + @given = given @names.each do |name| - unless target.respond_to?(name) + unless given.respond_to?(name) @names_not_responded_to << name end end @@ -17,15 +18,16 @@ module Spec end def failure_message - "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}" + "expected #{@given.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}" end def negative_failure_message - "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}" + "expected #{@given.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}" end def description - "respond to ##{@names.to_s}" + # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here + "respond to #{@names.inspect}" end end vendor/plugins/rspec/lib/spec/matchers/respond_to.rb @@ -6,18 +6,18 @@ module Spec @block = block end - def matches?(actual, &block) + def matches?(given, &block) @block = block if block - @actual = actual - @block.call(actual) + @given = given + @block.call(given) end def failure_message - "expected #{@actual} to satisfy block" + "expected #{@given} to satisfy block" end def negative_failure_message - "expected #{@actual} not to satisfy block" + "expected #{@given} not to satisfy block" end end vendor/plugins/rspec/lib/spec/matchers/satisfy.rb @@ -1,29 +1,132 @@ module Spec module Matchers class SimpleMatcher - attr_reader :description + attr_writer :failure_message, :negative_failure_message, :description def initialize(description, &match_block) @description = description @match_block = match_block end - def matches?(actual) - @actual = actual - return @match_block.call(@actual) + def matches?(given) + @given = given + case @match_block.arity + when 2 + @match_block.call(@given, self) + else + @match_block.call(@given) + end + end + + def description + @description || explanation end - def failure_message() - return %[expected #{@description.inspect} but got #{@actual.inspect}] + def failure_message + @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}]) end - - def negative_failure_message() - return %[expected not to get #{@description.inspect}, but got #{@actual.inspect}] + + def negative_failure_message + @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}]) + end + + def explanation + "No description provided. See RDoc for simple_matcher()" end end - - def simple_matcher(message, &match_block) - SimpleMatcher.new(message, &match_block) + + # simple_matcher makes it easy for you to create your own custom matchers + # in just a few lines of code when you don't need all the power of a + # completely custom matcher object. + # + # The <tt>description</tt> argument will appear as part of any failure + # message, and is also the source for auto-generated descriptions. + # + # The <tt>match_block</tt> can have an arity of 1 or 2. The first block + # argument will be the given value. The second, if the block accepts it + # will be the matcher itself, giving you access to set custom failure + # messages in favor of the defaults. + # + # The <tt>match_block</tt> should return a boolean: <tt>true</tt> + # indicates a match, which will pass if you use <tt>should</tt> and fail + # if you use <tt>should_not</tt>. false (or nil) indicates no match, + # which will do the reverse: fail if you use <tt>should</tt> and pass if + # you use <tt>should_not</tt>. + # + # An error in the <tt>match_block</tt> will bubble up, resulting in a + # failure. + # + # == Example with default messages + # + # def be_even + # simple_matcher("an even number") { |given| given % 2 == 0 } + # end + # + # describe 2 do + # it "should be even" do + # 2.should be_even + # end + # end + # + # Given an odd number, this example would produce an error message stating: + # expected "an even number", got 3. + # + # Unfortunately, if you're a fan of auto-generated descriptions, this will + # produce "should an even number." Not the most desirable result. You can + # control that using custom messages: + # + # == Example with custom messages + # + # def rhyme_with(expected) + # simple_matcher("rhyme with #{expected.inspect}") do |given, matcher| + # matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}" + # matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}" + # given.rhymes_with? expected + # end + # end + # + # # OR + # + # def rhyme_with(expected) + # simple_matcher do |given, matcher| + # matcher.description = "rhyme with #{expected.inspect}" + # matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}" + # matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}" + # given.rhymes_with? expected + # end + # end + # + # describe "pecan" do + # it "should rhyme with 'be gone'" do + # nut = "pecan" + # nut.extend Rhymer + # nut.should rhyme_with("be gone") + # end + # end + # + # The resulting messages would be: + # description: rhyme with "be gone" + # failure_message: expected "pecan" to rhyme with "be gone" + # negative failure_message: expected "pecan" not to rhyme with "be gone" + # + # == Wrapped Expectations + # + # Because errors will bubble up, it is possible to wrap other expectations + # in a SimpleMatcher. + # + # def be_even + # simple_matcher("an even number") { |given| (given % 2).should == 0 } + # end + # + # BE VERY CAREFUL when you do this. Only use wrapped expectations for + # matchers that will always be used in only the positive + # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both. + # The reason is that is you wrap a <tt>should</tt> and call the wrapper + # with <tt>should_not</tt>, the correct result (the <tt>should</tt> + # failing), will fail when you want it to pass. + # + def simple_matcher(description=nil, &match_block) + SimpleMatcher.new(description, &match_block) end end end \ No newline at end of file vendor/plugins/rspec/lib/spec/matchers/simple_matcher.rb @@ -2,38 +2,60 @@ module Spec module Matchers class ThrowSymbol #:nodoc: - def initialize(expected=nil) - @expected = expected + def initialize(expected_symbol = nil, expected_arg=nil) + @expected_symbol = expected_symbol + @expected_arg = expected_arg + @caught_symbol = nil end - def matches?(proc) + def matches?(given_proc) begin - proc.call - rescue NameError => e - raise e unless e.message =~ /uncaught throw/ - @actual = e.name.to_sym + if @expected_symbol.nil? + given_proc.call + else + @caught_arg = catch :proc_did_not_throw_anything do + catch @expected_symbol do + given_proc.call + throw :proc_did_not_throw_anything, :nothing_thrown + end + end + @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown + end + + # Ruby 1.8 uses NameError with `symbol' + # Ruby 1.9 uses ArgumentError with :symbol + rescue NameError, ArgumentError => e + raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/ + @caught_symbol = $2.to_sym + ensure - if @expected.nil? - return @actual.nil? ? false : true + if @expected_symbol.nil? + return !@caught_symbol.nil? else - return @actual == @expected + if @expected_arg.nil? + return @caught_symbol == @expected_symbol + else + # puts [@caught_symbol, @expected_symbol].inspect + # puts [@caught_arg, @expected_arg].inspect + return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg + end end end end def failure_message - if @actual - "expected #{expected}, got #{@actual.inspect}" + if @caught_symbol + "expected #{expected}, got #{@caught_symbol.inspect}" else "expected #{expected} but nothing was thrown" end end def negative_failure_message - if @expected + if @expected_symbol "expected #{expected} not to be thrown" else - "expected no Symbol, got :#{@actual}" + "expected no Symbol, got :#{@caught_symbol}" end end @@ -44,7 +66,11 @@ module Spec private def expected - @expected.nil? ? "a Symbol" : @expected.inspect + @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}" + end + + def args + @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}" end end @@ -52,20 +78,27 @@ module Spec # :call-seq: # should throw_symbol() # should throw_symbol(:sym) + # should throw_symbol(:sym, arg) # should_not throw_symbol() # should_not throw_symbol(:sym) - # - # Given a Symbol argument, matches if a proc throws the specified Symbol. + # should_not throw_symbol(:sym, arg) # # Given no argument, matches if a proc throws any Symbol. # + # Given a Symbol, matches if the given proc throws the specified Symbol. + # + # Given a Symbol and an arg, matches if the given proc throws the + # specified Symbol with the specified arg. + # # == Examples # # lambda { do_something_risky }.should throw_symbol # lambda { do_something_risky }.should throw_symbol(:that_was_risky) + # lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit) # # lambda { do_something_risky }.should_not throw_symbol # lambda { do_something_risky }.should_not throw_symbol(:that_was_risky) + # lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit) def throw_symbol(sym=nil) Matchers::ThrowSymbol.new(sym) end vendor/plugins/rspec/lib/spec/matchers/throw_symbol.rb @@ -1,16 +1,5 @@ -require 'spec/mocks/methods' -require 'spec/mocks/argument_constraint_matchers' -require 'spec/mocks/spec_methods' -require 'spec/mocks/proxy' -require 'spec/mocks/mock' -require 'spec/mocks/argument_expectation' -require 'spec/mocks/message_expectation' -require 'spec/mocks/order_group' -require 'spec/mocks/errors' -require 'spec/mocks/error_generator' +require 'spec/mocks/framework' require 'spec/mocks/extensions/object' -require 'spec/mocks/space' - module Spec # == Mocks and Stubs vendor/plugins/rspec/lib/spec/mocks.rb @@ -1,182 +1,48 @@ module Spec module Mocks - - class MatcherConstraint - def initialize(matcher) - @matcher = matcher - end - - def matches?(value) - @matcher.matches?(value) - end - end - - class LiteralArgConstraint - def initialize(literal) - @literal_value = literal - end - - def matches?(value) - @literal_value == value - end - end - - class RegexpArgConstraint - def initialize(regexp) - @regexp = regexp - end - - def matches?(value) - return value =~ @regexp unless value.is_a?(Regexp) - value == @regexp - end - end - - class AnyArgConstraint - def initialize(ignore) - end - - def ==(other) - true - end - - # TODO - need this? - def matches?(value) - true - end - end - - class AnyArgsConstraint - def description - "any args" - end - end - - class NoArgsConstraint - def description - "no args" - end - - def ==(args) - args == [] - end - end - class NumericArgConstraint - def initialize(ignore) - end - - def matches?(value) - value.is_a?(Numeric) - end - end - - class BooleanArgConstraint - def initialize(ignore) - end - - def ==(value) - matches?(value) - end - - def matches?(value) - return true if value.is_a?(TrueClass) - return true if value.is_a?(FalseClass) - false - end - end - - class StringArgConstraint - def initialize(ignore) - end - - def matches?(value) - value.is_a?(String) - end - end - - class DuckTypeArgConstraint - def initialize(*methods_to_respond_to) - @methods_to_respond_to = methods_to_respond_to - end - - def matches?(value) - @methods_to_respond_to.all? { |sym| value.respond_to?(sym) } - end - - def description - "duck_type" - end - end - class ArgumentExpectation attr_reader :args - @@constraint_classes = Hash.new { |hash, key| LiteralArgConstraint} - @@constraint_classes[:anything] = AnyArgConstraint - @@constraint_classes[:numeric] = NumericArgConstraint - @@constraint_classes[:boolean] = BooleanArgConstraint - @@constraint_classes[:string] = StringArgConstraint - def initialize(args) + def initialize(args, &block) @args = args - if [:any_args] == args - @expected_params = nil - warn_deprecated(:any_args.inspect, "any_args()") - elsif args.length == 1 && args[0].is_a?(AnyArgsConstraint) then @expected_params = nil - elsif [:no_args] == args - @expected_params = [] - warn_deprecated(:no_args.inspect, "no_args()") - elsif args.length == 1 && args[0].is_a?(NoArgsConstraint) then @expected_params = [] - else @expected_params = process_arg_constraints(args) + @constraints_block = block + + if ArgumentConstraints::AnyArgsConstraint === args.first + @match_any_args = true + elsif ArgumentConstraints::NoArgsConstraint === args.first + @constraints = [] + else + @constraints = args.collect {|arg| constraint_for(arg)} end end - def process_arg_constraints(constraints) - constraints.collect do |constraint| - convert_constraint(constraint) - end + def constraint_for(arg) + return ArgumentConstraints::MatcherConstraint.new(arg) if is_matcher?(arg) + return ArgumentConstraints::RegexpConstraint.new(arg) if arg.is_a?(Regexp) + return ArgumentConstraints::EqualityProxy.new(arg) end - def warn_deprecated(deprecated_method, instead) - Kernel.warn "The #{deprecated_method} constraint is deprecated. Use #{instead} instead." + def is_matcher?(obj) + return obj.respond_to?(:matches?) && obj.respond_to?(:description) end - def convert_constraint(constraint) - if [:anything, :numeric, :boolean, :string].include?(constraint) - case constraint - when :anything - instead = "anything()" - when :boolean - instead = "boolean()" - when :numeric - instead = "an_instance_of(Numeric)" - when :string - instead = "an_instance_of(String)" - end - warn_deprecated(constraint.inspect, instead) - return @@constraint_classes[constraint].new(constraint) - end - return MatcherConstraint.new(constraint) if is_matcher?(constraint) - return RegexpArgConstraint.new(constraint) if constraint.is_a?(Regexp) - return LiteralArgConstraint.new(constraint) + def args_match?(given_args) + match_any_args? || constraints_block_matches?(given_args) || constraints_match?(given_args) end - def is_matcher?(obj) - return obj.respond_to?(:matches?) && obj.respond_to?(:description) + def constraints_block_matches?(given_args) + @constraints_block ? @constraints_block.call(*given_args) : nil end - def check_args(args) - return true if @expected_params.nil? - return true if @expected_params == args - return constraints_match?(args) + def constraints_match?(given_args) + @constraints == given_args end - def constraints_match?(args) - return false if args.length != @expected_params.length - @expected_params.each_index { |i| return false unless @expected_params[i].matches?(args[i]) } - return true + def match_any_args? + @match_any_args end - + end end vendor/plugins/rspec/lib/spec/mocks/argument_expectation.rb @@ -44,7 +44,7 @@ module Spec private def intro - @name ? "Mock '#{@name}'" : @target.inspect + @name ? "Mock '#{@name}'" : @target.class == Class ? "<#{@target.inspect} (class)>" : (@target.nil? ? "nil" : @target.to_s) end def __raise(message) vendor/plugins/rspec/lib/spec/mocks/error_generator.rb @@ -3,6 +3,10 @@ module Spec class BaseExpectation attr_reader :sym + attr_writer :expected_received_count, :method_block, :expected_from + protected :expected_received_count=, :method_block=, :expected_from= + attr_accessor :error_generator + protected :error_generator, :error_generator= def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={}) @error_generator = error_generator @@ -10,10 +14,10 @@ module Spec @expected_from = expected_from @sym = sym @method_block = method_block - @return_block = lambda {} + @return_block = nil @actual_received_count = 0 @expected_received_count = expected_received_count - @args_expectation = ArgumentExpectation.new([AnyArgsConstraint.new]) + @args_expectation = ArgumentExpectation.new([ArgumentConstraints::AnyArgsConstraint.new]) @consecutive = false @exception_to_raise = nil @symbol_to_throw = nil @@ -23,6 +27,18 @@ module Spec @args_to_yield = [] end + def build_child(expected_from, method_block, expected_received_count, opts={}) + child = clone + child.expected_from = expected_from + child.method_block = method_block + child.expected_received_count = expected_received_count + new_gen = error_generator.clone + new_gen.opts = opts + child.error_generator = new_gen + child.clone_args_to_yield @args_to_yield + child + end + def expected_args @args_expectation.args end @@ -39,6 +55,8 @@ module Spec @expected_received_count < values.size end @return_block = block_given? ? return_block : lambda { value } + # Ruby 1.9 - see where this is used below + @ignore_args = !block_given? end # :call-seq: @@ -61,34 +79,57 @@ module Spec end def and_yield(*args) + if @args_to_yield_were_cloned + @args_to_yield.clear + @args_to_yield_were_cloned = false + end + @args_to_yield << args self end def matches(sym, args) - @sym == sym and @args_expectation.check_args(args) + @sym == sym and @args_expectation.args_match?(args) end def invoke(args, block) + if @expected_received_count == 0 + @failed_fast = true + @actual_received_count += 1 + @error_generator.raise_expectation_error @sym, @expected_received_count, @actual_received_count, *args + end + @order_group.handle_order_constraint self begin Kernel::raise @exception_to_raise unless @exception_to_raise.nil? Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil? - + + if !@method_block.nil? - return invoke_method_block(args) + default_return_val = invoke_method_block(args) elsif @args_to_yield.size > 0 - return invoke_with_yield(block) - elsif @consecutive - return invoke_consecutive_return_block(args, block) + default_return_val = invoke_with_yield(block) else + default_return_val = nil + end + + if @consecutive + return invoke_consecutive_return_block(args, block) + elsif @return_block return invoke_return_block(args, block) + else + return default_return_val end ensure @actual_received_count += 1 end end + + def called_max_times? + @expected_received_count != :any && @expected_received_count > 0 && + @actual_received_count >= @expected_received_count + end protected @@ -104,12 +145,14 @@ module Spec if block.nil? @error_generator.raise_missing_block_error @args_to_yield end + value = nil @args_to_yield.each do |args_to_yield_this_time| if block.arity > -1 && args_to_yield_this_time.length != block.arity @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity end - block.call(*args_to_yield_this_time) + value = block.call(*args_to_yield_this_time) end + value end def invoke_consecutive_return_block(args, block) @@ -122,21 +165,34 @@ module Spec def invoke_return_block(args, block) args << block unless block.nil? - value = @return_block.call(*args) - - value + # Ruby 1.9 - when we set @return_block to return values + # regardless of arguments, any arguments will result in + # a "wrong number of arguments" error + if @ignore_args + @return_block.call() + else + @return_block.call(*args) + end + end + + def clone_args_to_yield(args) + @args_to_yield = args.clone + @args_to_yield_were_cloned = true + end + + def failed_fast? + @failed_fast end end class MessageExpectation < BaseExpectation def matches_name_but_not_args(sym, args) - @sym == sym and not @args_expectation.check_args(args) + @sym == sym and not @args_expectation.args_match?(args) end - def verify_messages_received - return if ignoring_args? || matches_exact_count? || - matches_at_least_count? || matches_at_most_count? + def verify_messages_received + return if expected_messages_received? || failed_fast? generate_error rescue Spec::Mocks::MockExpectationError => error @@ -144,6 +200,11 @@ module Spec Kernel::raise error end + def expected_messages_received? + ignoring_args? || matches_exact_count? || + matches_at_least_count? || matches_at_most_count? + end + def ignoring_args? @expected_received_count == :any end @@ -160,13 +221,24 @@ module Spec @expected_received_count == @actual_received_count end + def similar_messages + @similar_messages ||= [] + end + + def advise(args, block) + similar_messages << args + end + def generate_error - @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *@args_expectation.args) + if similar_messages.empty? + @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *@args_expectation.args) + else + @error_generator.raise_unexpected_message_args_error(self, *@similar_messages.first) + end end def with(*args, &block) - @method_block = block if block - @args_expectation = ArgumentExpectation.new(args) + @args_expectation = ArgumentExpectation.new(args, &block) self end vendor/plugins/rspec/lib/spec/mocks/message_expectation.rb @@ -9,8 +9,12 @@ module Spec __mock_proxy.add_negative_message_expectation(caller(1)[0], sym.to_sym, &block) end - def stub!(sym, opts={}) - __mock_proxy.add_stub(caller(1)[0], sym.to_sym, opts) + def stub!(sym_or_hash, opts={}) + if Hash === sym_or_hash + sym_or_hash.each {|method, value| stub!(method).and_return value } + else + __mock_proxy.add_stub(caller(1)[0], sym_or_hash.to_sym, opts) + end end def received_message?(sym, *args, &block) #:nodoc: @@ -24,6 +28,14 @@ module Spec def rspec_reset #:nodoc: __mock_proxy.reset end + + def as_null_object + __mock_proxy.as_null_object + end + + def null_object? + __mock_proxy.null_object? + end private @@ -31,7 +43,7 @@ module Spec if Mock === self @mock_proxy ||= Proxy.new(self, @name, @options) else - @mock_proxy ||= Proxy.new(self, self.class.name) + @mock_proxy ||= Proxy.new(self) end end end vendor/plugins/rspec/lib/spec/mocks/methods.rb @@ -3,18 +3,21 @@ module Spec class Mock include Methods - # Creates a new mock with a +name+ (that will be used in error messages only) - # == Options: - # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it. - def initialize(name, options={}) + # Creates a new mock with a +name+ (that will be used in error messages + # only) == Options: + # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving + # null object allowing any message to be sent to it. + def initialize(name, stubs_and_options={}) @name = name - @options = options + @options = parse_options(stubs_and_options) + assign_stubs(stubs_and_options) end - # This allows for comparing the mock to other objects that proxy - # such as ActiveRecords belongs_to proxy objects - # By making the other object run the comparison, we're sure the call gets delegated to the proxy target - # This is an unfortunate side effect from ActiveRecord, but this should be safe unless the RHS redefines == in a nonsensical manner + # This allows for comparing the mock to other objects that proxy such as + # ActiveRecords belongs_to proxy objects By making the other object run + # the comparison, we're sure the call gets delegated to the proxy target + # This is an unfortunate side effect from ActiveRecord, but this should + # be safe unless the RHS redefines == in a nonsensical manner def ==(other) other == __mock_proxy end @@ -32,6 +35,22 @@ module Spec def inspect "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>" end + + def to_s + inspect.gsub('<','[').gsub('>',']') + end + + private + + def parse_options(options) + options.has_key?(:null_object) ? {:null_object => options.delete(:null_object)} : {} + end + + def assign_stubs(stubs) + stubs.each_pair do |message, response| + stub!(message).and_return(response) + end + end end end end vendor/plugins/rspec/lib/spec/mocks/mock.rb @@ -4,8 +4,18 @@ module Spec DEFAULT_OPTIONS = { :null_object => false, } + + @@warn_about_expectations_on_nil = true + + def self.allow_message_expectations_on_nil + @@warn_about_expectations_on_nil = false + + # ensure nil.rspec_verify is called even if an expectation is not set in the example + # otherwise the allowance would effect subsequent examples + $rspec_mocks.add(nil) unless $rspec_mocks.nil? + end - def initialize(target, name, options={}) + def initialize(target, name=nil, options={}) @target = target @name = name @error_generator = ErrorGenerator.new target, name @@ -20,15 +30,27 @@ module Spec def null_object? @options[:null_object] end + + def as_null_object + @options[:null_object] = true + @target + end - def add_message_expectation(expected_from, sym, opts={}, &block) + def add_message_expectation(expected_from, sym, opts={}, &block) __add sym - @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts) + warn_if_nil_class sym + if existing_stub = @stubs.detect {|s| s.sym == sym } + expectation = existing_stub.build_child(expected_from, block_given?? block : nil, 1, opts) + else + expectation = MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts) + end + @expectations << expectation @expectations.last end def add_negative_message_expectation(expected_from, sym, &block) __add sym + warn_if_nil_class sym @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil) @expectations.last end @@ -50,6 +72,7 @@ module Spec clear_stubs reset_proxied_methods clear_proxied_methods + reset_nil_expectations_warning end def received_message?(sym, *args, &block) @@ -61,14 +84,21 @@ module Spec end def message_received(sym, *args, &block) - if expectation = find_matching_expectation(sym, *args) - expectation.invoke(args, block) - elsif stub = find_matching_method_stub(sym, *args) + expectation = find_matching_expectation(sym, *args) + stub = find_matching_method_stub(sym, *args) + + if (stub && expectation && expectation.called_max_times?) || (stub && !expectation) + if expectation = find_almost_matching_expectation(sym, *args) + expectation.advise(args, block) unless expectation.expected_messages_received? + end stub.invoke([], block) + elsif expectation + expectation.invoke(args, block) elsif expectation = find_almost_matching_expectation(sym, *args) - raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object? + expectation.advise(args, block) if null_object? unless expectation.expected_messages_received? + raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(sym) or null_object?) else - @target.send :method_missing, sym, *args, &block + @target.__send__ :method_missing, sym, *args, &block end end @@ -87,26 +117,48 @@ module Spec define_expected_method(sym) end + def warn_if_nil_class(sym) + if proxy_for_nil_class? && @@warn_about_expectations_on_nil + Kernel.warn("An expectation of :#{sym} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.") + end + end + def define_expected_method(sym) - if target_responds_to?(sym) && !metaclass.method_defined?(munge(sym)) - munged_sym = munge(sym) - metaclass.instance_eval do - alias_method munged_sym, sym if method_defined?(sym.to_s) + visibility_string = "#{visibility(sym)} :#{sym}" + unless @proxied_methods.include?(sym) + if target_responds_to?(sym) + munged_sym = munge(sym) + target_metaclass.instance_eval do + alias_method munged_sym, sym if method_defined?(sym.to_s) + end + @proxied_methods << sym end - @proxied_methods << sym end - - metaclass_eval(<<-EOF, __FILE__, __LINE__) + + target_metaclass.class_eval(<<-EOF, __FILE__, __LINE__) def #{sym}(*args, &block) __mock_proxy.message_received :#{sym}, *args, &block end + #{visibility_string} EOF end def target_responds_to?(sym) - return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to + return @target.__send__(munge(:respond_to?),sym) if @already_proxied_respond_to return @already_proxied_respond_to = true if sym == :respond_to? - return @target.respond_to?(sym) + return @target.respond_to?(sym, true) + end + + def visibility(sym) + if Mock === @target + 'public' + elsif target_metaclass.private_method_defined?(sym) + 'private' + elsif target_metaclass.protected_method_defined?(sym) + 'protected' + else + 'public' + end end def munge(sym) @@ -125,12 +177,8 @@ module Spec @proxied_methods.clear end - def metaclass_eval(str, filename, lineno) - metaclass.class_eval(str, filename, lineno) - end - - def metaclass - (class << @target; self; end) + def target_metaclass + class << @target; self; end end def verify_expectations @@ -142,16 +190,24 @@ module Spec def reset_proxied_methods @proxied_methods.each do |sym| munged_sym = munge(sym) - metaclass.instance_eval do + target_metaclass.instance_eval do if method_defined?(munged_sym.to_s) alias_method sym, munged_sym undef_method munged_sym else - undef_method sym + remove_method sym end end end end + + def proxy_for_nil_class? + @target.nil? + end + + def reset_nil_expectations_warning + @@warn_about_expectations_on_nil = true if proxy_for_nil_class? + end def find_matching_expectation(sym, *args) @expectations.find {|expectation| expectation.matches(sym, args)} vendor/plugins/rspec/lib/spec/mocks/proxy.rb @@ -1,36 +1,45 @@ module Spec module Mocks - module SpecMethods - include Spec::Mocks::ArgumentConstraintMatchers + module ExampleMethods + include Spec::Mocks::ArgumentConstraints # Shortcut for creating an instance of Spec::Mocks::Mock. - def mock(name, options={}) - Spec::Mocks::Mock.new(name, options) - end - - # Shortcut for creating an instance of Spec::Mocks::Mock with - # predefined method stubs. + # + # +name+ is used for failure reporting, so you should use the + # role that the mock is playing in the example. + # + # +stubs_and_options+ lets you assign options and stub values + # at the same time. The only option available is :null_object. + # Anything else is treated as a stub value. # # == Examples # - # stub_thing = stub("thing", :a => "A") + # stub_thing = mock("thing", :a => "A") # stub_thing.a == "A" => true # # stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com") # stub_person.name => "Joe" # stub_person.email => "joe@domain.com" - def stub(name, stubs={}) - object_stub = mock(name) - stubs.each { |key, value| object_stub.stub!(key).and_return(value) } - object_stub + def mock(name, stubs_and_options={}) + Spec::Mocks::Mock.new(name, stubs_and_options) end + alias :stub :mock + # Shortcut for creating a mock object that will return itself in response # to any message it receives that it hasn't been explicitly instructed # to respond to. def stub_everything(name = 'stub') mock(name, :null_object => true) end + + # Disables warning messages about expectations being set on nil. + # + # By default warning messages are issued when expectations are set on nil. This is to + # prevent false-positives and to catch potential bugs early on. + def allow_message_expectations_on_nil + Proxy.allow_message_expectations_on_nil + end end end vendor/plugins/rspec/lib/spec/mocks/spec_methods.rb @@ -11,7 +11,7 @@ module Spec # A Rake task that runs a set of specs. # # Example: - # + # # Spec::Rake::SpecTask.new do |t| # t.warning = true # t.rcov = true @@ -44,13 +44,22 @@ module Spec # Each attribute of this task may be a proc. This allows for lazy evaluation, # which is sometimes handy if you want to defer the evaluation of an attribute value # until the task is run (as opposed to when it is defined). + # + # This task can also be used to run existing Test::Unit tests and get RSpec + # output, for example like this: + # + # require 'rubygems' + # require 'spec/rake/spectask' + # Spec::Rake::SpecTask.new do |t| + # t.ruby_opts = ['-rtest/unit'] + # t.spec_files = FileList['test/**/*_test.rb'] + # end + # class SpecTask < ::Rake::TaskLib - class << self - def attr_accessor(*names) - super(*names) - names.each do |name| - module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs - end + def self.attr_accessor(*names) + super(*names) + names.each do |name| + module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs end end @@ -76,7 +85,7 @@ module Spec # Whether or not to use RCov (default is false) # See http://eigenclass.org/hiki.rb?rcov attr_accessor :rcov - + # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec']. # Ignored if rcov=false # Setting the RCOV_OPTS environment variable overrides this. @@ -96,7 +105,7 @@ module Spec # A message to print to stderr when there are failures. attr_accessor :failure_message - # Where RSpec's output is written. Defaults to STDOUT. + # Where RSpec's output is written. Defaults to $stdout. # DEPRECATED. Use --format FORMAT:WHERE in spec_opts. attr_accessor :out @@ -106,7 +115,7 @@ module Spec # used, then the list of spec files is the union of the two. # Setting the SPEC environment variable overrides this. attr_accessor :spec_files - + # Use verbose output. If this is set to true, the task will print # the executed spec command to stdout. Defaults to false. attr_accessor :verbose @@ -144,30 +153,23 @@ module Spec # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts] # or # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts] - cmd = "ruby " - - rb_opts = ruby_opts.clone - rb_opts << "-I\"#{lib_path}\"" - rb_opts << "-S rcov" if rcov - rb_opts << "-w" if warning - cmd << rb_opts.join(" ") - cmd << " " - cmd << rcov_option_list - cmd << %[ -o "#{rcov_dir}" ] if rcov - cmd << %Q|"#{spec_script}"| - cmd << " " - cmd << "-- " if rcov - cmd << spec_file_list.collect { |fn| %["#{fn}"] }.join(' ') - cmd << " " - cmd << spec_option_list + cmd_parts = [RUBY] + cmd_parts += ruby_opts + cmd_parts << %[-I"#{lib_path}"] + cmd_parts << "-S rcov" if rcov + cmd_parts << "-w" if warning + cmd_parts << rcov_option_list + cmd_parts << %[-o "#{rcov_dir}"] if rcov + cmd_parts << %["#{spec_script}"] + cmd_parts << "--" if rcov + cmd_parts += spec_file_list.collect { |fn| %["#{fn}"] } + cmd_parts << spec_option_list if out - cmd << " " - cmd << %Q| > "#{out}"| + cmd_parts << %[> "#{out}"] STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead." end - if verbose - puts cmd - end + cmd = cmd_parts.join(" ") + puts cmd if verbose unless system(cmd) STDERR.puts failure_message if failure_message raise("Command #{cmd} failed") if fail_on_error @@ -199,7 +201,7 @@ module Spec STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS'] ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || "" end - + def evaluate(o) # :nodoc: case o when Proc then o.call @@ -221,4 +223,3 @@ module Spec end end end - vendor/plugins/rspec/lib/spec/rake/spectask.rb @@ -35,11 +35,11 @@ module RCov def define desc "Verify that rcov coverage is at least #{threshold}%" task @name do - total_coverage = nil + total_coverage = 0 File.open(index_html).each_line do |line| - if line =~ /<tt.*>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/ - total_coverage = eval($1) + if line =~ /<tt class='coverage_total'>\s*(\d+\.\d+)%\s*<\/tt>/ + total_coverage = $1.to_f break end end vendor/plugins/rspec/lib/spec/rake/verify_rcov.rb @@ -1,4 +1,3 @@ -require 'spec/runner/formatter' require 'spec/runner/options' require 'spec/runner/option_parser' require 'spec/runner/example_group_runner' @@ -6,17 +5,16 @@ require 'spec/runner/command_line' require 'spec/runner/drb_command_line' require 'spec/runner/backtrace_tweaker' require 'spec/runner/reporter' -require 'spec/runner/extensions/object' require 'spec/runner/spec_parser' require 'spec/runner/class_and_arguments_parser' module Spec - # == Behaviours and Examples + # == ExampleGroups and Examples # - # Rather than expressing examples in classes, RSpec uses a custom domain specific language to - # describe Behaviours and Examples of those behaviours. + # Rather than expressing examples in classes, RSpec uses a custom DSLL (DSL light) to + # describe groups of examples. # - # A Example is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context + # A ExampleGroup is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context # in which you will run your executable example - a set of known objects in a known starting state. # We begin be describing # @@ -125,11 +123,11 @@ module Spec # end # end # - # == Shared behaviour + # == Shared Example Groups # - # You can define a shared behaviour, that may be used on other behaviours + # You can define a shared Example Group, that may be used on other groups # - # describe "All Editions", :shared => true do + # share_examples_for "All Editions" do # it "all editions behaviour" ... # end # @@ -141,10 +139,10 @@ module Spec # end # end # - # You can also assign the shared behaviour to a module and include that + # You can also assign the shared group to a module and include that # - # AllEditions = describe "All Editions", :shared => true do - # it "all editions behaviour" ... + # share_as :AllEditions do + # it "should do all editions stuff" ... # end # # describe SmallEdition do @@ -166,25 +164,48 @@ module Spec # end # end module Runner - class << self - def configuration # :nodoc: - @configuration ||= Spec::Example::Configuration.new + def self.configuration # :nodoc: + @configuration ||= Spec::Example::Configuration.new + end + + # Use this to configure various configurable aspects of + # RSpec: + # + # Spec::Runner.configure do |configuration| + # # Configure RSpec here + # end + # + # The yielded <tt>configuration</tt> object is a + # Spec::Example::Configuration instance. See its RDoc + # for details about what you can do with it. + # + def self.configure + yield configuration + end + + def self.register_at_exit_hook # :nodoc: + unless @already_registered_at_exit_hook + at_exit do + unless $! || Spec.run? || Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?(options.example_groups) + success = Spec.run + exit success if Spec.exit? + end + end + @already_registered_at_exit_hook = true end - - # Use this to configure various configurable aspects of - # RSpec: - # - # Spec::Runner.configure do |configuration| - # # Configure RSpec here - # end - # - # The yielded <tt>configuration</tt> object is a - # Spec::Example::Configuration instance. See its RDoc - # for details about what you can do with it. - # - def configure - yield configuration + end + + def self.options # :nodoc: + @options ||= begin + parser = ::Spec::Runner::OptionParser.new($stderr, $stdout) + parser.order!(ARGV) + parser.options end end + + def self.use options + @options = options + end + end end vendor/plugins/rspec/lib/spec/runner.rb @@ -7,7 +7,7 @@ module Spec end class NoisyBacktraceTweaker < BacktraceTweaker - def tweak_backtrace(error, spec_name) + def tweak_backtrace(error) return if error.backtrace.nil? error.backtrace.each do |line| clean_up_double_slashes(line) @@ -19,7 +19,7 @@ module Spec class QuietBacktraceTweaker < BacktraceTweaker unless defined?(IGNORE_PATTERNS) root_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', '..')) - spec_files = Dir["#{root_dir}/lib/spec/*"].map do |path| + spec_files = Dir["#{root_dir}/lib/*"].map do |path| subpath = path[root_dir.length..-1] /#{subpath}/ end @@ -27,7 +27,7 @@ module Spec /\/lib\/ruby\//, /bin\/spec:/, /bin\/rcov:/, - /lib\/rspec_on_rails/, + /lib\/rspec-rails/, /vendor\/rails/, # TextMate's Ruby and RSpec plugins /Ruby\.tmbundle\/Support\/tmruby.rb:/, @@ -38,17 +38,16 @@ module Spec ] end - def tweak_backtrace(error, spec_name) + def tweak_backtrace(error) return if error.backtrace.nil? - error.backtrace.collect! do |line| - clean_up_double_slashes(line) - IGNORE_PATTERNS.each do |ignore| - if line =~ ignore - line = nil - break + error.backtrace.collect! do |message| + clean_up_double_slashes(message) + kept_lines = message.split("\n").select do |line| + IGNORE_PATTERNS.each do |ignore| + break if line =~ ignore end end - line + kept_lines.empty?? nil : kept_lines.join("\n") end error.backtrace.compact! end vendor/plugins/rspec/lib/spec/runner/backtrace_tweaker.rb @@ -1,16 +1,14 @@ module Spec module Runner class ClassAndArgumentsParser - class << self - def parse(s) - if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/ - arg = $2 == "" ? nil : $2 - [$1, arg] - else - raise "Couldn't parse #{s.inspect}" - end + def self.parse(s) + if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/ + arg = $2 == "" ? nil : $2 + [$1, arg] + else + raise "Couldn't parse #{s.inspect}" end end end end -end \ No newline at end of file +end vendor/plugins/rspec/lib/spec/runner/class_and_arguments_parser.rb @@ -2,26 +2,13 @@ require 'spec/runner/option_parser' module Spec module Runner - # Facade to run specs without having to fork a new ruby process (using `spec ...`) class CommandLine - class << self - # Runs specs. +argv+ is the commandline args as per the spec commandline API, +err+ - # and +out+ are the streams output will be written to. - def run(instance_rspec_options) - # NOTE - this call to init_rspec_options is not spec'd, but neither is any of this - # swapping of $rspec_options. That is all here to enable rspec to run against itself - # and maintain coverage in a single process. Therefore, DO NOT mess with this stuff - # unless you know what you are doing! - init_rspec_options(instance_rspec_options) - orig_rspec_options = rspec_options - begin - $rspec_options = instance_rspec_options - return $rspec_options.run_examples - ensure - ::Spec.run = true - $rspec_options = orig_rspec_options - end - end + def self.run(tmp_options=Spec::Runner.options) + orig_options = Spec::Runner.options + Spec::Runner.use tmp_options + tmp_options.run_examples + ensure + Spec::Runner.use orig_options end end end vendor/plugins/rspec/lib/spec/runner/command_line.rb @@ -9,7 +9,7 @@ module Spec def self.run(options) begin DRb.start_service - spec_server = DRbObject.new_with_uri("druby://localhost:8989") + spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989") spec_server.run(options.argv, options.error_stream, options.output_stream) rescue DRb::DRbConnError => e options.error_stream.puts "No server is running" vendor/plugins/rspec/lib/spec/runner/drb_command_line.rb @@ -7,7 +7,7 @@ module Spec def load_files(files) # It's important that loading files (or choosing not to) stays the - # responsibility of the BehaviourRunner. Some implementations (like) + # responsibility of the ExampleGroupRunner. Some implementations (like) # the one using DRb may choose *not* to load files, but instead tell # someone else to do it over the wire. files.each do |file| @@ -19,7 +19,7 @@ module Spec prepare success = true example_groups.each do |example_group| - success = success & example_group.suite.run + success = success & example_group.run end return success ensure vendor/plugins/rspec/lib/spec/runner/example_group_runner.rb @@ -3,6 +3,7 @@ module Spec module Formatter # Baseclass for formatters that implements all required methods as no-ops. class BaseFormatter + attr_accessor :example_group, :options, :where def initialize(options, where) @options = options @where = where @@ -17,12 +18,12 @@ module Spec def start(example_count) end - # This method is invoked at the beginning of the execution of each behaviour. - # +name+ is the name of the behaviour and +first+ is true if it is the - # first behaviour - otherwise it's false. + # This method is invoked at the beginning of the execution of each example_group. + # +example_group+ is the example_group. # # The next method to be invoked after this is #example_failed or #example_finished - def add_example_group(name) + def add_example_group(example_group) + @example_group = example_group end # This method is invoked when an +example+ starts. @@ -42,10 +43,11 @@ module Spec # This method is invoked when an example is not yet implemented (i.e. has not # been provided a block), or when an ExamplePendingError is raised. - # +name+ is the name of the example. # +message+ is the message from the ExamplePendingError, if it exists, or the # default value of "Not Yet Implemented" - def example_pending(behaviour_name, example_name, message) + # +pending_caller+ is the file and line number of the spec which + # has called the pending method + def example_pending(example, message, pending_caller) end # This method is invoked after all of the examples have executed. The next method vendor/plugins/rspec/lib/spec/runner/formatter/base_formatter.rb @@ -1,3 +1,5 @@ +require 'spec/runner/formatter/base_formatter' + module Spec module Runner module Formatter @@ -5,27 +7,23 @@ module Spec # non-text based ones too - just ignore the +output+ constructor # argument. class BaseTextFormatter < BaseFormatter + attr_reader :output, :pending_examples # Creates a new instance that will write to +where+. If +where+ is a # String, output will be written to the File with that name, otherwise # +where+ is exected to be an IO (or an object that responds to #puts and #write). def initialize(options, where) super if where.is_a?(String) + FileUtils.mkdir_p(File.dirname(where)) @output = File.open(where, 'w') - elsif where == STDOUT - @output = Kernel - def @output.flush - STDOUT.flush - end else @output = where end - @snippet_extractor = SnippetExtractor.new @pending_examples = [] end - def example_pending(behaviour_name, example_name, message) - @pending_examples << ["#{behaviour_name} #{example_name}", message] + def example_pending(example, message, pending_caller) + @pending_examples << [example.full_description, message, pending_caller] end def dump_failure(counter, failure) @@ -72,14 +70,15 @@ module Spec @output.puts @output.puts "Pending:" @pending_examples.each do |pending_example| - @output.puts "#{pending_example[0]} (#{pending_example[1]})" + @output.puts "\n#{pending_example[0]} (#{pending_example[1]})" + @output.puts "#{pending_example[2]}\n" end end @output.flush end def close - if IO === @output + if IO === @output && @output != $stdout @output.close end end @@ -110,7 +109,7 @@ module Spec def output_to_tty? begin - @output == Kernel || @output.tty? + @output.tty? || ENV.has_key?("AUTOTEST") rescue NoMethodError false end vendor/plugins/rspec/lib/spec/runner/formatter/base_text_formatter.rb @@ -1,13 +1,11 @@ +require 'spec/runner/formatter/base_text_formatter' + module Spec module Runner module Formatter class FailingExamplesFormatter < BaseTextFormatter - def add_example_group(behaviour_name) - @behaviour_name = behaviour_name - end - def example_failed(example, counter, failure) - @output.puts "#{@behaviour_name} #{example.description}" + @output.puts "#{example_group.description} #{example.description}" @output.flush end vendor/plugins/rspec/lib/spec/runner/formatter/failing_examples_formatter.rb @@ -1,4 +1,5 @@ require 'erb' +require 'spec/runner/formatter/base_text_formatter' module Spec module Runner @@ -8,18 +9,22 @@ module Spec def initialize(options, output) super - @current_behaviour_number = 0 - @current_example_number = 0 + @example_group_number = 0 + @example_number = 0 + end + + def method_missing(sym, *args) + # no-op end - # The number of the currently running behaviour - def current_behaviour_number - @current_behaviour_number + # The number of the currently running example_group + def example_group_number + @example_group_number end # The number of the currently running example (a global counter) - def current_example_number - @current_example_number + def example_number + @example_number end def start(example_count) @@ -30,17 +35,18 @@ module Spec @output.flush end - def add_example_group(name) - @behaviour_red = false - @behaviour_red = false - @current_behaviour_number += 1 - unless current_behaviour_number == 1 + def add_example_group(example_group) + super + @example_group_red = false + @example_group_red = false + @example_group_number += 1 + unless example_group_number == 1 @output.puts " </dl>" @output.puts "</div>" end - @output.puts "<div class=\"behaviour\">" + @output.puts "<div class=\"example_group\">" @output.puts " <dl>" - @output.puts " <dt id=\"behaviour_#{current_behaviour_number}\">#{h(name)}</dt>" + @output.puts " <dt id=\"example_group_#{example_group_number}\">#{h(example_group.description)}</dt>" @output.flush end @@ -51,7 +57,7 @@ module Spec end def example_started(example) - @current_example_number += 1 + @example_number += 1 end def example_passed(example) @@ -65,8 +71,8 @@ module Spec failure_style = failure.pending_fixed? ? 'pending_fixed' : 'failed' @output.puts " <script type=\"text/javascript\">makeRed('rspec-header');</script>" unless @header_red @header_red = true - @output.puts " <script type=\"text/javascript\">makeRed('behaviour_#{current_behaviour_number}');</script>" unless @behaviour_red - @behaviour_red = true + @output.puts " <script type=\"text/javascript\">makeRed('example_group_#{example_group_number}');</script>" unless @example_group_red + @example_group_red = true move_progress @output.puts " <dd class=\"spec #{failure_style}\">" @output.puts " <span class=\"failed_spec_name\">#{h(example.description)}</span>" @@ -79,11 +85,11 @@ module Spec @output.flush end - def example_pending(behaviour_name, example_name, message) + def example_pending(example, message, pending_caller) @output.puts " <script type=\"text/javascript\">makeYellow('rspec-header');</script>" unless @header_red - @output.puts " <script type=\"text/javascript\">makeYellow('behaviour_#{current_behaviour_number}');</script>" unless @behaviour_red + @output.puts " <script type=\"text/javascript\">makeYellow('example_group_#{example_group_number}');</script>" unless @example_group_red move_progress - @output.puts " <dd class=\"spec not_implemented\"><span class=\"not_implemented_spec_name\">#{h(example_name)} (PENDING: #{h(message)})</span></dd>" + @output.puts " <dd class=\"spec not_implemented\"><span class=\"not_implemented_spec_name\">#{h(example.description)} (PENDING: #{h(message)})</span></dd>" @output.flush end @@ -91,6 +97,8 @@ module Spec # could output links to images or other files produced during the specs. # def extra_failure_content(failure) + require 'spec/runner/formatter/snippet_extractor' + @snippet_extractor ||= SnippetExtractor.new " <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(failure.exception)}</code></pre>" end @@ -102,7 +110,7 @@ module Spec def percent_done result = 100.0 if @example_count != 0 - result = ((current_example_number).to_f / @example_count.to_f * 1000).to_i / 10.0 + result = ((example_number).to_f / @example_count.to_f * 1000).to_i / 10.0 end result end @@ -231,7 +239,7 @@ EOF font-size: 1.2em; } -.behaviour { +.example_group { margin: 0 10px 5px; background: #fff; } vendor/plugins/rspec/lib/spec/runner/formatter/html_formatter.rb @@ -1,3 +1,5 @@ +require 'spec/runner/formatter/progress_bar_formatter' + module Spec module Runner module Formatter @@ -5,40 +7,44 @@ module Spec def initialize(options, where) super - @examples = [] + @example_times = [] end def start(count) @output.puts "Profiling enabled." end - def add_example_group(example) - @behaviour = example - end - def example_started(example) @time = Time.now end def example_passed(example) super - @examples << [@behaviour, example, Time.now - @time] + @example_times << [ + example_group.description, + example.description, + Time.now - @time + ] end def start_dump super @output.puts "\n\nTop 10 slowest examples:\n" - @examples = @examples.sort_by do |b, e, t| - t + @example_times = @example_times.sort_by do |description, example, time| + time end.reverse - @examples[0..9].each do |e| - @output.print red(sprintf("%.7f", e[2])) - @output.puts " #{e[0]} #{e[1]}" + @example_times[0..9].each do |description, example, time| + @output.print red(sprintf("%.7f", time)) + @output.puts " #{description} #{example}" end @output.flush end + + def method_missing(sym, *args) + # ignore + end end end end vendor/plugins/rspec/lib/spec/runner/formatter/profile_formatter.rb @@ -1,10 +1,9 @@ +require 'spec/runner/formatter/base_text_formatter' + module Spec module Runner module Formatter class ProgressBarFormatter < BaseTextFormatter - def add_example_group(name) - end - def example_failed(example, counter, failure) @output.print colourise('F', failure) @output.flush @@ -15,9 +14,9 @@ module Spec @output.flush end - def example_pending(behaviour_name, example_name, message) + def example_pending(example, message, pending_caller) super - @output.print yellow('P') + @output.print yellow('*') @output.flush end @@ -25,6 +24,10 @@ module Spec @output.puts @output.flush end + + def method_missing(sym, *args) + # ignore + end end end end vendor/plugins/rspec/lib/spec/runner/formatter/progress_bar_formatter.rb @@ -1,11 +1,14 @@ +require 'spec/runner/formatter/base_text_formatter' + module Spec module Runner module Formatter - class SpecdocFormatter < BaseTextFormatter - def add_example_group(name) - @output.puts - @output.puts name - @output.flush + class SpecdocFormatter < BaseTextFormatter + def add_example_group(example_group) + super + output.puts + output.puts example_group.description + output.flush end def example_failed(example, counter, failure) @@ -15,20 +18,20 @@ module Spec "- #{example.description} (ERROR - #{counter})" end - @output.puts(failure.expectation_not_met? ? red(message) : magenta(message)) - @output.flush + output.puts(failure.expectation_not_met? ? red(message) : magenta(message)) + output.flush end def example_passed(example) message = "- #{example.description}" - @output.puts green(message) - @output.flush + output.puts green(message) + output.flush end - def example_pending(behaviour_name, example_name, message) + def example_pending(example, message, pending_caller) super - @output.puts yellow("- #{example_name} (PENDING: #{message})") - @output.flush + output.puts yellow("- #{example.description} (PENDING: #{message})") + output.flush end end end vendor/plugins/rspec/lib/spec/runner/formatter/specdoc_formatter.rb @@ -1,4 +1,5 @@ require 'erb' +require 'spec/runner/formatter/base_text_formatter' module Spec module Runner @@ -7,6 +8,15 @@ module Spec class HtmlFormatter < BaseTextFormatter include ERB::Util + def initialize(options, where) + super + @previous_type = nil + @scenario_text = "" + @story_text = "" + @scenario_failed = false + @story_failed = false + end + def run_started(count) @output.puts <<-EOF <?xml version="1.0" encoding="UTF-8"?> @@ -21,8 +31,8 @@ module Spec <meta http-equiv="Pragma" content="no-cache" /> <script src="javascripts/prototype.js" type="text/javascript"></script> <script src="javascripts/scriptaculous.js" type="text/javascript"></script> - <script src="javascripts/application.js" type="text/javascript"></script> - <link href="stylesheets/style.css" rel="stylesheet" type="text/css" /> + <script src="javascripts/rspec.js" type="text/javascript"></script> + <link href="stylesheets/rspec.css" rel="stylesheet" type="text/css" /> </head> <body> <div id="container"> @@ -48,9 +58,9 @@ EOF end def story_started(title, narrative) - @output.puts <<-EOF - <dl class="story passed"> - <dt>#{h title}</dt> + @story_failed = false + @story_text = <<-EOF + <dt>Story: #{h title}</dt> <dd> <p> #{h(narrative).split("\n").join("<br />")} @@ -58,27 +68,49 @@ EOF EOF end - def story_ended(title, narrative) - @output.puts <<-EOF + def story_ended(title, narrative) + if @story_failed + @output.puts <<-EOF + <dl class="story failed"> +EOF + else + @output.puts <<-EOF + <dl class="story passed"> +EOF + end + @output.puts <<-EOF +#{@story_text} </dd> </dl> EOF end - + def scenario_started(story_title, scenario_name) - @output.puts <<-EOF - <dl class="passed"> - <dt>#{h scenario_name}</dt> - <dd> - <ul class="steps"> + @previous_type = nil + @scenario_failed = false + @scenario_text = <<-EOF + <dt>Scenario: #{h scenario_name}</dt> + <dd> + <ul class="steps"> EOF end def scenario_ended - @output.puts <<-EOF - </ul> - </dd> - </dl> + if @scenario_failed + @story_text += <<-EOF + <dl class="failed"> +EOF + else + @story_text += <<-EOF + <dl class="passed"> +EOF + end + + @story_text += <<-EOF +#{@scenario_text} + </ul> + </dd> + </dl> EOF end @@ -94,9 +126,14 @@ EOF end def scenario_failed(story_title, scenario_name, err) + @scenario_failed = true + @story_failed = true scenario_ended end + def step_upcoming(type, description, *args) + end + def step_succeeded(type, description, *args) print_step('passed', type, description, *args) # TODO: uses succeeded CSS class end @@ -111,11 +148,25 @@ EOF def print_step(klass, type, description, *args) spans = args.map { |arg| "<span class=\"param\">#{arg}</span>" } + desc_string = description.step_name + arg_regexp = description.arg_regexp + inner = if(type == @previous_type) + "And " + else + "#{type.to_s.capitalize} " + end i = -1 - inner = type.to_s.capitalize + ' ' + description.gsub(::Spec::Story::Step::PARAM_PATTERN) { |param| spans[i+=1] } - @output.puts " <li class=\"#{klass}\">#{inner}</li>" + inner += desc_string.gsub(arg_regexp) { |param| spans[i+=1] } + + @scenario_text += " <li class=\"#{klass}\">#{inner}</li>\n" + + if type == :'given scenario' + @previous_type = :given + else + @previous_type = type + end + end - end end end vendor/plugins/rspec/lib/spec/runner/formatter/story/html_formatter.rb @@ -1,3 +1,5 @@ +require 'spec/runner/formatter/base_text_formatter' + module Spec module Runner module Formatter @@ -7,102 +9,177 @@ module Spec super @successful_scenario_count = 0 @pending_scenario_count = 0 + + @pre_story_pending_count = 0 + @pre_story_successful_count = 0 + @failed_scenarios = [] @pending_steps = [] - @previous_type = nil + @previous_type = nil + + @scenario_body_text = "" + @story_body_text = "" + + @scenario_head_text = "" + @story_head_text = "" + + @scenario_failed = false + @story_failed = false end def run_started(count) @count = count - @output.puts "Running #@count scenarios:\n" + @output.puts "Running #@count scenarios\n\n" end def story_started(title, narrative) - @output.puts "Story: #{title}\n\n" + @pre_story_pending_count = @pending_scenario_count + @pre_story_successful_count = @successful_scenario_count + + @current_story_title = title + @story_failed = false + @story_body_text = "" + @story_head_text = "Story: #{title}\n\n" + narrative.each_line do |line| - @output.print " " - @output.print line + @story_head_text += " " + @story_head_text += line end end def story_ended(title, narrative) + if @story_failed + @output.print red(@story_head_text) + elsif @pre_story_successful_count == @successful_scenario_count && + @pending_scenario_count >= @pre_story_pending_count + @output.print yellow(@story_head_text) + else + @output.print green(@story_head_text) + end + @output.print @story_body_text @output.puts @output.puts end def scenario_started(story_title, scenario_name) + @current_scenario_name = scenario_name @scenario_already_failed = false - @output.print "\n\nScenario: #{scenario_name}" + @scenario_head_text = "\n\n Scenario: #{scenario_name}" + @scenario_body_text = "" @scenario_ok = true + @scenario_pending = false + @scenario_failed = false end def scenario_succeeded(story_title, scenario_name) @successful_scenario_count += 1 + scenario_ended end def scenario_failed(story_title, scenario_name, err) + @options.backtrace_tweaker.tweak_backtrace(err) @failed_scenarios << [story_title, scenario_name, err] unless @scenario_already_failed @scenario_already_failed = true + @story_failed = true + @scenario_failed = true + scenario_ended end def scenario_pending(story_title, scenario_name, msg) - @pending_steps << [story_title, scenario_name, msg] @pending_scenario_count += 1 unless @scenario_already_failed + @scenario_pending = true @scenario_already_failed = true + scenario_ended end + def scenario_ended + if @scenario_failed + @story_body_text += red(@scenario_head_text) + elsif @scenario_pending + @story_body_text += yellow(@scenario_head_text) + else + @story_body_text += green(@scenario_head_text) + end + @story_body_text += @scenario_body_text + end + def run_ended - @output.puts "\n\n#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending" + summary_text = "#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending" + if !@failed_scenarios.empty? + @output.puts red(summary_text) + elsif !@pending_steps.empty? + @output.puts yellow(summary_text) + else + @output.puts green(summary_text) + end unless @pending_steps.empty? @output.puts "\nPending Steps:" @pending_steps.each_with_index do |pending, i| - title, scenario_name, msg = pending - @output.puts "#{i+1}) #{title} (#{scenario_name}): #{msg}" + story_name, scenario_name, msg = pending + @output.puts "#{i+1}) #{story_name} (#{scenario_name}): #{msg}" end end unless @failed_scenarios.empty? @output.print "\nFAILURES:" @failed_scenarios.each_with_index do |failure, i| title, scenario_name, err = failure - @output.print %[ - #{i+1}) #{title} (#{scenario_name}) FAILED - #{err.class}: #{err.message} - #{err.backtrace.join("\n")} - ] + @output.print "\n #{i+1}) " + @output.print red("#{title} (#{scenario_name}) FAILED") + @output.print red("\n #{err.class}: #{err.message}") + @output.print "\n #{err.backtrace.join("\n")}\n" end - end + end end - + + def step_upcoming(type, description, *args) + end + def step_succeeded(type, description, *args) - found_step(type, description, false, *args) + found_step(type, description, false, false, *args) end def step_pending(type, description, *args) - found_step(type, description, false, *args) - @output.print " (PENDING)" + found_step(type, description, false, true, *args) + @pending_steps << [@current_story_title, @current_scenario_name, description] + @scenario_body_text += yellow(" (PENDING)") + @scenario_pending = true @scenario_ok = false end def step_failed(type, description, *args) - found_step(type, description, true, *args) - @output.print red(@scenario_ok ? " (FAILED)" : " (SKIPPED)") + found_step(type, description, true, @scenario_pending, *args) + if @scenario_pending + @scenario_body_text += yellow(" (SKIPPED)") + else + @scenario_body_text += red(@scenario_ok ? " (FAILED)" : " (SKIPPED)") + end @scenario_ok = false end def collected_steps(steps) end + + def method_missing(sym, *args, &block) #:nodoc: + # noop - ignore unknown messages + end private - def found_step(type, description, failed, *args) + def found_step(type, description, failed, pending, *args) + desc_string = description.step_name + arg_regexp = description.arg_regexp text = if(type == @previous_type) - "\n And " + "\n And " else - "\n\n #{type.to_s.capitalize} " + "\n\n #{type.to_s.capitalize} " end i = -1 - text << description.gsub(::Spec::Story::Step::PARAM_PATTERN) { |param| args[i+=1] } - @output.print(failed ? red(text) : green(text)) + text << desc_string.gsub(arg_regexp) { |param| args[i+=1] } + if pending + @scenario_body_text += yellow(text) + else + @scenario_body_text += (failed ? red(text) : green(text)) + end if type == :'given scenario' @previous_type = :given vendor/plugins/rspec/lib/spec/runner/formatter/story/plain_text_formatter.rb @@ -13,7 +13,7 @@ module Spec @heckle_class = heckle_class end - # Runs all the behaviours held by +rspec_options+ once for each of the + # Runs all the example groups held by +rspec_options+ once for each of the # methods in the matched classes. def heckle_with if @filter =~ /(.*)[#\.](.*)/ @@ -25,7 +25,7 @@ module Spec def heckle_method(class_name, method_name) verify_constant(class_name) - heckle = @heckle_class.new(class_name, method_name, rspec_options) + heckle = @heckle_class.new(class_name, method_name, Spec::Runner.options) heckle.validate end @@ -39,7 +39,7 @@ module Spec classes.each do |klass| klass.instance_methods(false).each do |method_name| - heckle = @heckle_class.new(klass.name, method_name, rspec_options) + heckle = @heckle_class.new(klass.name, method_name, Spec::Runner.options) heckle.validate end end vendor/plugins/rspec/lib/spec/runner/heckle_runner.rb @@ -4,18 +4,20 @@ require 'stringio' module Spec module Runner class OptionParser < ::OptionParser - class << self - def parse(args, err, out) - parser = new(err, out) - parser.parse(args) - parser.options - end + def self.parse(args, err, out) + parser = new(err, out) + parser.parse(args) + parser.options end attr_reader :options OPTIONS = { - :diff => ["-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not", + :pattern => ["-p", "--pattern [PATTERN]","Limit files loaded to those matching this pattern. Defaults to '**/*_spec.rb'", + "Separate multiple patterns with commas.", + "Applies only to directories named on the command line (files", + "named explicitly on the command line will be loaded regardless)."], + :diff => ["-D", "--diff [FORMAT]","Show diff of objects that are expected to be equal when they are not", "Builtin formats: unified|u|context|c", "You can also specify a custom differ class", "(in which case you should also specify --require)"], @@ -30,32 +32,38 @@ module Spec "an example name directly, causing RSpec to run just the example", "matching that name"], :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"], - :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviout or specification at given line.", - "(does not work for dynamically generated specs)"], - :format => ["-f", "--format FORMAT[:WHERE]", "Specifies what format to use for output. Specify WHERE to tell", + :line => ["-l", "--line LINE_NUMBER", Integer, "Execute example group or example at given line.", + "(does not work for dynamically generated examples)"], + :format => ["-f", "--format FORMAT[:WHERE]","Specifies what format to use for output. Specify WHERE to tell", "the formatter where to write the output. All built-in formats", - "expect WHERE to be a file name, and will write to STDOUT if it's", + "expect WHERE to be a file name, and will write to $stdout if it's", "not specified. The --format option may be specified several times", "if you want several outputs", " ", - "Builtin formats: ", - "progress|p : Text progress", - "profile|o : Text progress with profiling of 10 slowest examples", - "specdoc|s : Example doc as text", - "html|h : A nice HTML report", - "failing_examples|e : Write all failing examples - input for --example", - "failing_behaviours|b : Write all failing behaviours - input for --example", + "Builtin formats for code examples:", + "progress|p : Text-based progress bar", + "profile|o : Text-based progress bar with profiling of 10 slowest examples", + "specdoc|s : Code example doc strings", + "nested|n : Code example doc strings with nested groups intented", + "html|h : A nice HTML report", + "failing_examples|e : Write all failing examples - input for --example", + "failing_example_groups|g : Write all failing example groups - input for --example", + " ", + "Builtin formats for stories:", + "plain|p : Plain Text", + "html|h : A nice HTML report", + "progress|r : Text progress", " ", "FORMAT can also be the name of a custom formatter class", "(in which case you should also specify --require to load it)"], :require => ["-r", "--require FILE", "Require FILE before running specs", - "Useful for loading custom formatters or other extensions.", - "If this option is used it must come before the others"], + "Useful for loading custom formatters or other extensions.", + "If this option is used it must come before the others"], :backtrace => ["-b", "--backtrace", "Output full backtrace"], :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.", - "STRATEGY can currently only be 'mtime' (File modification time)", - "By default, spec files are loaded in alphabetical order if --loadby", - "is not specified."], + "STRATEGY can currently only be 'mtime' (File modification time)", + "By default, spec files are loaded in alphabetical order if --loadby", + "is not specified."], :reverse => ["-R", "--reverse", "Run examples in reverse order"], :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the", "specified time"], @@ -80,37 +88,35 @@ module Spec @out_stream = out @options = Options.new(@error_stream, @out_stream) - @spec_parser = SpecParser.new @file_factory = File self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]" self.separator "" - on(*OPTIONS[:diff]) {|diff| @options.parse_diff(diff)} - on(*OPTIONS[:colour]) {@options.colour = true} - on(*OPTIONS[:example]) {|example| @options.parse_example(example)} - on(*OPTIONS[:specification]) {|example| @options.parse_example(example)} - on(*OPTIONS[:line]) {|line_number| @options.line_number = line_number.to_i} - on(*OPTIONS[:format]) {|format| @options.parse_format(format)} - on(*OPTIONS[:require]) {|requires| invoke_requires(requires)} - on(*OPTIONS[:backtrace]) {@options.backtrace_tweaker = NoisyBacktraceTweaker.new} - on(*OPTIONS[:loadby]) {|loadby| @options.loadby = loadby} - on(*OPTIONS[:reverse]) {@options.reverse = true} - on(*OPTIONS[:timeout]) {|timeout| @options.timeout = timeout.to_f} - on(*OPTIONS[:heckle]) {|heckle| @options.load_heckle_runner(heckle)} - on(*OPTIONS[:dry_run]) {@options.dry_run = true} - on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)} - on(*OPTIONS[:generate_options]) do |options_file| - end - on(*OPTIONS[:runner]) do |runner| - @options.user_input_for_runner = runner - end - on(*OPTIONS[:drb]) {} - on(*OPTIONS[:version]) {parse_version} - on_tail(*OPTIONS[:help]) {parse_help} + on(*OPTIONS[:pattern]) {|pattern| @options.filename_pattern = pattern} + on(*OPTIONS[:diff]) {|diff| @options.parse_diff(diff)} + on(*OPTIONS[:colour]) {@options.colour = true} + on(*OPTIONS[:example]) {|example| @options.parse_example(example)} + on(*OPTIONS[:specification]) {|example| @options.parse_example(example)} + on(*OPTIONS[:line]) {|line_number| @options.line_number = line_number.to_i} + on(*OPTIONS[:format]) {|format| @options.parse_format(format)} + on(*OPTIONS[:require]) {|requires| invoke_requires(requires)} + on(*OPTIONS[:backtrace]) {@options.backtrace_tweaker = NoisyBacktraceTweaker.new} + on(*OPTIONS[:loadby]) {|loadby| @options.loadby = loadby} + on(*OPTIONS[:reverse]) {@options.reverse = true} + on(*OPTIONS[:timeout]) {|timeout| @options.timeout = timeout.to_f} + on(*OPTIONS[:heckle]) {|heckle| @options.load_heckle_runner(heckle)} + on(*OPTIONS[:dry_run]) {@options.dry_run = true} + on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)} + on(*OPTIONS[:generate_options]) {|options_file|} + on(*OPTIONS[:runner]) {|runner| @options.user_input_for_runner = runner} + on(*OPTIONS[:drb]) {} + on(*OPTIONS[:version]) {parse_version} + on_tail(*OPTIONS[:help]) {parse_help} end def order!(argv, &blk) - @argv = argv + @argv = argv.dup + @argv = (@argv.empty? && Spec.spec_command?) ? ['--help'] : @argv @options.argv = @argv.dup return if parse_generate_options return if parse_drb @@ -120,13 +126,9 @@ module Spec blk.call(file) if blk end - if @options.line_number - set_spec_from_line_number - end - @options end - + protected def invoke_requires(requires) requires.split(",").each do |file| @@ -137,6 +139,10 @@ module Spec def parse_options_file(options_file) option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten @argv.push(*option_file_args) + # TODO - this is a brute force solution to http://rspec.lighthouseapp.com/projects/5645/tickets/293. + # Let's look for a cleaner way. Might not be one. But let's look. If not, perhaps + # this can be moved to a different method to indicate the special handling for drb? + parse_drb(@argv) end def parse_generate_options @@ -166,12 +172,12 @@ module Spec @options.examples_should_not_be_run end - def parse_drb + def parse_drb(argv = nil) + argv ||= @options.argv # TODO - see note about about http://rspec.lighthouseapp.com/projects/5645/tickets/293 is_drb = false - argv = @options.argv is_drb ||= argv.delete(OPTIONS[:drb][0]) is_drb ||= argv.delete(OPTIONS[:drb][1]) - return nil unless is_drb + return false unless is_drb @options.examples_should_not_be_run DrbCommandLine.run( self.class.parse(argv, @error_stream, @out_stream) @@ -180,7 +186,7 @@ module Spec end def parse_version - @out_stream.puts ::Spec::VERSION::DESCRIPTION + @out_stream.puts ::Spec::VERSION::SUMMARY exit if stdout? end @@ -189,37 +195,9 @@ module Spec exit if stdout? end - def set_spec_from_line_number - if @options.examples.empty? - if @options.files.length == 1 - if @file_factory.file?(@options.files[0]) - source = @file_factory.open(@options.files[0]) - example = @spec_parser.spec_name_for(source, @options.line_number) - @options.parse_example(example) - elsif @file_factory.directory?(@options.files[0]) - @error_stream.puts "You must specify one file, not a directory when using the --line option" - exit(1) if stderr? - else - @error_stream.puts "#{@options.files[0]} does not exist" - exit(2) if stderr? - end - else - @error_stream.puts "Only one file can be specified when using the --line option: #{@options.files.inspect}" - exit(3) if stderr? - end - else - @error_stream.puts "You cannot use both --line and --example" - exit(4) if stderr? - end - end - def stdout? @out_stream == $stdout end - - def stderr? - @error_stream == $stderr - end end end end vendor/plugins/rspec/lib/spec/runner/option_parser.rb @@ -5,29 +5,36 @@ module Spec 'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)} } - EXAMPLE_FORMATTERS = { - 'specdoc' => Formatter::SpecdocFormatter, - 's' => Formatter::SpecdocFormatter, - 'html' => Formatter::HtmlFormatter, - 'h' => Formatter::HtmlFormatter, - 'progress' => Formatter::ProgressBarFormatter, - 'p' => Formatter::ProgressBarFormatter, - 'failing_examples' => Formatter::FailingExamplesFormatter, - 'e' => Formatter::FailingExamplesFormatter, - 'failing_behaviours' => Formatter::FailingBehavioursFormatter, - 'b' => Formatter::FailingBehavioursFormatter, - 'profile' => Formatter::ProfileFormatter, - 'o' => Formatter::ProfileFormatter, - 'textmate' => Formatter::TextMateFormatter, + EXAMPLE_FORMATTERS = { # Load these lazily for better speed + 'specdoc' => ['spec/runner/formatter/specdoc_formatter', 'Formatter::SpecdocFormatter'], + 's' => ['spec/runner/formatter/specdoc_formatter', 'Formatter::SpecdocFormatter'], + 'nested' => ['spec/runner/formatter/nested_text_formatter', 'Formatter::NestedTextFormatter'], + 'n' => ['spec/runner/formatter/nested_text_formatter', 'Formatter::NestedTextFormatter'], + 'html' => ['spec/runner/formatter/html_formatter', 'Formatter::HtmlFormatter'], + 'h' => ['spec/runner/formatter/html_formatter', 'Formatter::HtmlFormatter'], + 'progress' => ['spec/runner/formatter/progress_bar_formatter', 'Formatter::ProgressBarFormatter'], + 'p' => ['spec/runner/formatter/progress_bar_formatter', 'Formatter::ProgressBarFormatter'], + 'failing_examples' => ['spec/runner/formatter/failing_examples_formatter', 'Formatter::FailingExamplesFormatter'], + 'e' => ['spec/runner/formatter/failing_examples_formatter', 'Formatter::FailingExamplesFormatter'], +'failing_example_groups' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'], + 'g' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'], + 'profile' => ['spec/runner/formatter/profile_formatter', 'Formatter::ProfileFormatter'], + 'o' => ['spec/runner/formatter/profile_formatter', 'Formatter::ProfileFormatter'], + 'textmate' => ['spec/runner/formatter/text_mate_formatter', 'Formatter::TextMateFormatter'] } STORY_FORMATTERS = { - 'plain' => Formatter::Story::PlainTextFormatter, - 'html' => Formatter::Story::HtmlFormatter, - 'h' => Formatter::Story::HtmlFormatter + 'plain' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'], + 'p' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'], + 'html' => ['spec/runner/formatter/story/html_formatter', 'Formatter::Story::HtmlFormatter'], + 'h' => ['spec/runner/formatter/story/html_formatter', 'Formatter::Story::HtmlFormatter'], + 'progress' => ['spec/runner/formatter/story/progress_bar_formatter', 'Formatter::Story::ProgressBarFormatter'], + 'r' => ['spec/runner/formatter/story/progress_bar_formatter', 'Formatter::Story::ProgressBarFormatter'] + } attr_accessor( + :filename_pattern, :backtrace_tweaker, :context_lines, :diff_format, @@ -44,14 +51,17 @@ module Spec :user_input_for_runner, :error_stream, :output_stream, + :before_suite_parts, + :after_suite_parts, # TODO: BT - Figure out a better name :argv ) attr_reader :colour, :differ_class, :files, :example_groups - + def initialize(error_stream, output_stream) @error_stream = error_stream @output_stream = output_stream + @filename_pattern = "**/*_spec.rb" @backtrace_tweaker = QuietBacktraceTweaker.new @examples = [] @colour = false @@ -62,8 +72,12 @@ module Spec @diff_format = :unified @files = [] @example_groups = [] - @user_input_for_runner = nil + @result = nil @examples_run = false + @examples_should_be_run = nil + @user_input_for_runner = nil + @before_suite_parts = [] + @after_suite_parts = [] end def add_example_group(example_group) @@ -76,16 +90,37 @@ module Spec def run_examples return true unless examples_should_be_run? - runner = custom_runner || ExampleGroupRunner.new(self) + success = true + begin + runner = custom_runner || ExampleGroupRunner.new(self) - runner.load_files(files_to_load) - if example_groups.empty? - true - else - success = runner.run - @examples_run = true - heckle if heckle_runner - success + unless @files_loaded + runner.load_files(files_to_load) + @files_loaded = true + end + + # TODO - this has to happen after the files get loaded, + # otherwise the before_suite_parts are not populated + # from the configuration. There is no spec for this + # directly, but stories/configuration/before_blocks.story + # will fail if this happens before the files are loaded. + before_suite_parts.each do |part| + part.call + end + + if example_groups.empty? + true + else + set_spec_from_line_number if line_number + success = runner.run + @examples_run = true + heckle if heckle_runner + success + end + ensure + after_suite_parts.each do |part| + part.call(success) + end end end @@ -99,10 +134,16 @@ module Spec def colour=(colour) @colour = colour - begin; \ - require 'Win32/Console/ANSI' if @colour && PLATFORM =~ /win32/; \ - rescue LoadError ; \ - raise "You must gem install win32console to use colour on Windows" ; \ + if @colour && RUBY_PLATFORM =~ /mswin|mingw/ ;\ + begin ;\ + replace_output = @output_stream.equal?($stdout) ;\ + require 'rubygems' ;\ + require 'Win32/Console/ANSI' ;\ + @output_stream = $stdout if replace_output ;\ + rescue LoadError ;\ + warn "You must 'gem install win32console' to use colour on Windows" ;\ + @colour = false ;\ + end end end @@ -141,16 +182,22 @@ module Spec def formatters @format_options ||= [['progress', @output_stream]] - @formatters ||= @format_options.map do |format, where| - formatter_type = EXAMPLE_FORMATTERS[format] || load_class(format, 'formatter', '--format') - formatter_type.new(self, where) - end + @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS) end def story_formatters @format_options ||= [['plain', @output_stream]] - @story_formatters ||= @format_options.map do |format, where| - formatter_type = STORY_FORMATTERS[format] || load_class(format, 'formatter', '--format') + @formatters ||= load_formatters(@format_options, STORY_FORMATTERS) + end + + def load_formatters(format_options, formatters) + format_options.map do |format, where| + formatter_type = if formatters[format] + require formatters[format][0] + eval(formatters[format][1], binding, __FILE__, __LINE__) + else + load_class(format, 'formatter', '--format') + end formatter_type.new(self, where) end end @@ -162,11 +209,29 @@ module Spec end def number_of_examples - @example_groups.inject(0) do |sum, example_group| - sum + example_group.number_of_examples + total = 0 + @example_groups.each do |example_group| + total += example_group.number_of_examples end + total end + def files_to_load + result = [] + sorted_files.each do |file| + if File.directory?(file) + filename_pattern.split(",").each do |pattern| + result += Dir[File.expand_path("#{file}/#{pattern.strip}")] + end + elsif File.file?(file) + result << file + else + raise "File or directory not found: #{file}" + end + end + result + end + protected def examples_should_be_run? return @examples_should_be_run unless @examples_should_be_run.nil? @@ -197,20 +262,6 @@ module Spec end end - def files_to_load - result = [] - sorted_files.each do |file| - if test ?d, file - result += Dir[File.expand_path("#{file}/**/*.rb")] - elsif test ?f, file - result << file - else - raise "File or directory not found: #{file}" - end - end - result - end - def custom_runner return nil unless custom_runner? klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner) @@ -223,9 +274,9 @@ module Spec end def heckle - returns = self.heckle_runner.heckle_with + heckle_runner = self.heckle_runner self.heckle_runner = nil - returns + heckle_runner.heckle_with end def sorted_files @@ -240,6 +291,30 @@ module Spec require 'spec/expectations/differs/default' self.differ_class = Spec::Expectations::Differs::Default end + + def set_spec_from_line_number + if examples.empty? + if files.length == 1 + if File.directory?(files[0]) + error_stream.puts "You must specify one file, not a directory when using the --line option" + exit(1) if stderr? + else + example = SpecParser.new.spec_name_for(files[0], line_number) + @examples = [example] + end + else + error_stream.puts "Only one file can be specified when using the --line option: #{files.inspect}" + exit(3) if stderr? + end + else + error_stream.puts "You cannot use both --line and --example" + exit(4) if stderr? + end + end + + def stderr? + @error_stream == $stderr + end end end end vendor/plugins/rspec/lib/spec/runner/options.rb @@ -1,7 +1,7 @@ module Spec module Runner class Reporter - attr_reader :options + attr_reader :options, :example_groups def initialize(options) @options = options @@ -9,26 +9,38 @@ module Spec clear end - def add_example_group(name) - formatters.each{|f| f.add_example_group(name)} - @example_group_names << name + def add_example_group(example_group) + formatters.each do |f| + f.add_example_group(example_group) + end + example_groups << example_group end def example_started(example) formatters.each{|f| f.example_started(example)} end - def example_finished(example, error=nil, failure_location=nil, pending=false) + def example_finished(example, error=nil) @examples << example if error.nil? example_passed(example) elsif Spec::Example::ExamplePendingError === error - example_pending(@example_group_names.last, example, error.message) + example_pending(example, error.pending_caller, error.message) else - example_failed(example, error, failure_location) + example_failed(example, error) + end + end + + def failure(example, error) + backtrace_tweaker.tweak_backtrace(error) + failure = Failure.new(example, error) + @failures << failure + formatters.each do |f| + f.example_failed(example, @failures.length, failure) end end + alias_method :example_failed, :failure def start(number_of_examples) clear @@ -63,7 +75,7 @@ module Spec end def clear - @example_group_names = [] + @example_groups = [] @failures = [] @pending_count = 0 @examples = [] @@ -78,6 +90,7 @@ module Spec index + 1 end end + def dump_pending formatters.each{|f| f.dump_pending} end @@ -87,38 +100,52 @@ module Spec return "0.0" end - def example_passed(name) - formatters.each{|f| f.example_passed(name)} + def example_passed(example) + formatters.each{|f| f.example_passed(example)} end - def example_failed(name, error, failure_location) - backtrace_tweaker.tweak_backtrace(error, failure_location) - example_name = "#{@example_group_names.last} #{name}" - failure = Failure.new(example_name, error) - @failures << failure - formatters.each{|f| f.example_failed(name, @failures.length, failure)} - end + EXAMPLE_PENDING_DEPRECATION_WARNING = <<-WARNING + DEPRECATION NOTICE: RSpec's formatters have changed example_pending + to accept three arguments instead of just two. Please see the rdoc + for Spec::Runner::Formatter::BaseFormatter#example_pending + for more information. + + Please update any custom formatters to accept the third argument + to example_pending. Support for example_pending with two arguments + and this warning message will be removed after the RSpec 1.1.5 release. + WARNING - def example_pending(behaviour_name, example_name, message="Not Yet Implemented") + def example_pending(example, pending_caller, message="Not Yet Implemented") @pending_count += 1 - formatters.each{|f| f.example_pending(behaviour_name, example_name, message)} + formatters.each do |formatter| + if formatter_uses_deprecated_example_pending_method?(formatter) + Kernel.warn EXAMPLE_PENDING_DEPRECATION_WARNING + formatter.example_pending(example, message) + else + formatter.example_pending(example, message, pending_caller) + end + end + end + + def formatter_uses_deprecated_example_pending_method?(formatter) + formatter.method(:example_pending).arity == 2 end class Failure - attr_reader :exception + attr_reader :example, :exception - def initialize(example_name, exception) - @example_name = example_name + def initialize(example, exception) + @example = example @exception = exception end def header if expectation_not_met? - "'#{@example_name}' FAILED" + "'#{example_name}' FAILED" elsif pending_fixed? - "'#{@example_name}' FIXED" + "'#{example_name}' FIXED" else - "#{@exception.class.name} in '#{@example_name}'" + "#{@exception.class.name} in '#{example_name}'" end end @@ -130,6 +157,10 @@ module Spec @exception.is_a?(Spec::Expectations::ExpectationNotMetError) end + protected + def example_name + @example.full_description + end end end end vendor/plugins/rspec/lib/spec/runner/reporter.rb @@ -2,14 +2,28 @@ module Spec module Runner # Parses a spec file and finds the nearest example for a given line number. class SpecParser - def spec_name_for(io, line_number) - source = io.read - behaviour, behaviour_line = behaviour_at_line(source, line_number) - example, example_line = example_at_line(source, line_number) - if behaviour && example && (behaviour_line < example_line) - "#{behaviour} #{example}" - elsif behaviour - behaviour + attr_reader :best_match + + def initialize + @best_match = {} + end + + def spec_name_for(file, line_number) + best_match.clear + file = File.expand_path(file) + Spec::Runner.options.example_groups.each do |example_group| + consider_example_group_for_best_match example_group, file, line_number + + example_group.examples.each do |example| + consider_example_for_best_match example, example_group, file, line_number + end + end + if best_match[:example_group] + if best_match[:example] + "#{best_match[:example_group].description} #{best_match[:example].description}" + else + best_match[:example_group].description + end else nil end @@ -17,36 +31,41 @@ module Spec protected - def behaviour_at_line(source, line_number) - find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/) - end - - def example_at_line(source, line_number) - find_above(source, line_number, /^\s*(specify|it)\s+(.*)\s+do/) + def consider_example_group_for_best_match(example_group, file, line_number) + parsed_backtrace = parse_backtrace(example_group.backtrace) + parsed_backtrace.each do |example_file, example_line| + if is_best_match?(file, line_number, example_file, example_line) + best_match.clear + best_match[:example_group] = example_group + best_match[:line] = example_line + end + end end - # Returns the context/describe or specify/it name and the line number - def find_above(source, line_number, pattern) - lines_above_reversed(source, line_number).each_with_index do |line, n| - return [parse_description($2), line_number-n] if line =~ pattern + def consider_example_for_best_match(example, example_group, file, line_number) + parsed_backtrace = parse_backtrace(example.backtrace) + parsed_backtrace.each do |example_file, example_line| + if is_best_match?(file, line_number, example_file, example_line) + best_match.clear + best_match[:example_group] = example_group + best_match[:example] = example + best_match[:line] = example_line + end end - nil end - def lines_above_reversed(source, line_number) - lines = source.split("\n") - lines[0...line_number].reverse + def is_best_match?(file, line_number, example_file, example_line) + file == File.expand_path(example_file) && + example_line <= line_number && + example_line > best_match[:line].to_i end - - def parse_description(str) - return str[1..-2] if str =~ /^['"].*['"]$/ - if matches = /^['"](.*)['"](,.*)?$/.match(str) - return ::Spec::Example::ExampleGroupDescription.generate_description(matches[1]) - end - if matches = /^(.*)\s*,\s*['"](.*)['"](,.*)?$/.match(str) - return ::Spec::Example::ExampleGroupDescription.generate_description(matches[1], matches[2]) + + def parse_backtrace(backtrace) + Array(backtrace).collect do |trace_line| + trace_line =~ /(.*)\:(\d*)(\:|$)/ + file, number = $1, $2 + [file, Integer(number)] end - return str end end end vendor/plugins/rspec/lib/spec/runner/spec_parser.rb @@ -1,3 +1,4 @@ +require 'spec' require 'spec/story/extensions' require 'spec/story/given_scenario' require 'spec/story/runner' vendor/plugins/rspec/lib/spec/story.rb @@ -1 +1,3 @@ require 'spec/story/extensions/main' +require 'spec/story/extensions/string' +require 'spec/story/extensions/regexp' vendor/plugins/rspec/lib/spec/story/extensions.rb @@ -1,12 +1,12 @@ module Spec module Story class GivenScenario - def initialize name + def initialize(name) @name = name end def perform(instance, ignore_name) - scenario = Runner::StoryRunner.scenario_from_current_story @name + scenario = Runner::StoryRunner.scenario_from_current_story(@name) Runner::ScenarioRunner.new.run(scenario, instance) end end vendor/plugins/rspec/lib/spec/story/given_scenario.rb @@ -8,51 +8,50 @@ require 'spec/story/runner/plain_text_story_runner.rb' module Spec module Story module Runner - class << self - def run_options # :nodoc: - @run_options ||= ::Spec::Runner::OptionParser.parse(ARGV, $stderr, $stdout) - end - - def story_runner # :nodoc: - unless @story_runner - @story_runner = StoryRunner.new(scenario_runner, world_creator) - run_options.story_formatters.each do |formatter| - register_listener(formatter) - end - Runner.register_exit_hook - end - @story_runner - end - - def scenario_runner # :nodoc: - @scenario_runner ||= ScenarioRunner.new - end - - def world_creator # :nodoc: - @world_creator ||= World - end - - # Use this to register a customer output formatter. - def register_listener(listener) - story_runner.add_listener(listener) # run_started, story_started, story_ended, #run_ended - world_creator.add_listener(listener) # found_scenario, step_succeeded, step_failed, step_failed - scenario_runner.add_listener(listener) # scenario_started, scenario_succeeded, scenario_pending, scenario_failed - end - - def register_exit_hook # :nodoc: - # TODO - when story runner uses test/unit runners like example runner does we can kill - # this and also the assorted Kernel.stub!(:at_exit) in examples - at_exit do - Runner.story_runner.run_stories unless $! + def self.run_options # :nodoc: + Spec::Runner.options + end + + def self.story_runner # :nodoc: + unless @story_runner + @story_runner = create_story_runner + run_options.story_formatters.each do |formatter| + register_listener(formatter) end - # TODO exit with non-zero status if run fails + self.register_exit_hook end - - def dry_run - run_options.dry_run + @story_runner + end + + def self.scenario_runner # :nodoc: + @scenario_runner ||= ScenarioRunner.new + end + + def self.world_creator # :nodoc: + @world_creator ||= World + end + + def self.create_story_runner + Runner::StoryRunner.new(scenario_runner, world_creator) + end + + # Use this to register a customer output formatter. + def self.register_listener(listener) + story_runner.add_listener(listener) # run_started, story_started, story_ended, #run_ended + world_creator.add_listener(listener) # found_scenario, step_succeeded, step_failed, step_failed + scenario_runner.add_listener(listener) # scenario_started, scenario_succeeded, scenario_pending, scenario_failed + end + + def self.register_exit_hook # :nodoc: + at_exit do + exit Runner.story_runner.run_stories unless $! end - end + + def self.dry_run + run_options.dry_run + end + end end end vendor/plugins/rspec/lib/spec/story/runner.rb @@ -26,10 +26,10 @@ module Spec @story_file = path end - def run + def run(story_runner=Spec::Story::Runner.story_runner) raise "You must set a path to the file with the story. See the RDoc." if @story_file.nil? - mediator = Spec::Story::Runner::StoryMediator.new steps, Spec::Story::Runner.story_runner, @options - parser = Spec::Story::Runner::StoryParser.new mediator + mediator = Spec::Story::Runner::StoryMediator.new(steps, story_runner, @options) + parser = Spec::Story::Runner::StoryParser.new(mediator) story_text = File.read(@story_file) parser.parse(story_text.split("\n")) vendor/plugins/rspec/lib/spec/story/runner/plain_text_story_runner.rb @@ -11,19 +11,24 @@ module Spec run_story_ignoring_scenarios(scenario.story, world) world.start_collecting_errors + + unless scenario.body + @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, '') } + return true + end + world.instance_eval(&scenario.body) if world.errors.empty? @listeners.each { |l| l.scenario_succeeded(scenario.story.title, scenario.name) } else - world.errors.each do |e| - case e - when Spec::Example::ExamplePendingError - @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, e.message) } - else - @listeners.each { |l| l.scenario_failed(scenario.story.title, scenario.name, e) } - end + if Spec::Example::ExamplePendingError === (e = world.errors.first) + @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, e.message) } + else + @listeners.each { |l| l.scenario_failed(scenario.story.title, scenario.name, e) } + return false end end + true end def add_listener(listener) vendor/plugins/rspec/lib/spec/story/runner/scenario_runner.rb @@ -38,6 +38,14 @@ current_scenario.add_step Step.new('Then', name) end + def last_step + current_scenario.last_step + end + + def add_to_last(name) + last_step.name << name + end + def run_stories stories.each { |story| @runner.instance_eval(&story) } end @@ -64,7 +72,7 @@ title = @title narrative = @narrative scenarios = @scenarios.collect { |scenario| scenario.to_proc } - options = @options.merge(:steps => @step_group) + options = @options.merge(:steps_for => @step_group) lambda do Story title, narrative, options do scenarios.each { |scenario| instance_eval(&scenario) } @@ -100,9 +108,15 @@ def add_step(step) @steps << step end + + def last_step + @steps.last + end end class Step + attr_reader :name + def initialize(type, name) @type = type @name = name vendor/plugins/rspec/lib/spec/story/runner/story_mediator.rb @@ -26,14 +26,15 @@ module Spec def process_line(line) line.strip! case line - when /^Story: / : @state.story(line) - when /^Scenario: / : @state.scenario(line) - when /^Given:? / : @state.given(line) - when /^GivenScenario:? / : @state.given_scenario(line) - when /^When:? / : @state.event(line) - when /^Then:? / : @state.outcome(line) - when /^And:? / : @state.one_more_of_the_same(line) - else @state.other(line) + when /^#/ then @state.comment(line) + when /^Story: / then @state.story(line) + when /^Scenario: / then @state.scenario(line) + when /^Given:? / then @state.given(line) + when /^GivenScenario:? / then @state.given_scenario(line) + when /^When:? / then @state.event(line) + when /^Then:? / then @state.outcome(line) + when /^And:? / then @state.one_more_of_the_same(line) + else @state.other(line) end end @@ -72,6 +73,10 @@ module Spec def create_then(name) @story_mediator.create_then(name) end + + def add_to_last(line) + @story_mediator.add_to_last("\n#{line}") + end def transition_to(key) @state = states[key] @@ -136,6 +141,9 @@ module Spec def other(line) # no-op - supports header text before the first story in a file end + + def comment(line) + end end class StartingState < State @@ -199,6 +207,10 @@ module Spec def given(line) @parser.create_given(remove_tag_from(:given, line)) end + + def other(line) + @parser.add_to_last(line) + end end class WhenState < State @@ -209,6 +221,10 @@ module Spec def event(line) @parser.create_when(remove_tag_from(:when ,line)) end + + def other(line) + @parser.add_to_last(line) + end end class ThenState < State @@ -219,6 +235,10 @@ module Spec def outcome(line) @parser.create_then(remove_tag_from(:then ,line)) end + + def other(line) + @parser.add_to_last(line) + end end end vendor/plugins/rspec/lib/spec/story/runner/story_parser.rb @@ -2,12 +2,16 @@ module Spec module Story module Runner class StoryRunner - class << self - attr_accessor :current_story_runner - - def scenario_from_current_story(scenario_name) - current_story_runner.scenario_from_current_story(scenario_name) - end + def self.current_story_runner + @current_story_runner + end + + def self.current_story_runner=(current_story_runner) + @current_story_runner = current_story_runner + end + + def self.scenario_from_current_story(scenario_name) + current_story_runner.scenario_from_current_story(scenario_name) end attr_accessor :stories, :scenarios, :current_story @@ -36,6 +40,7 @@ module Spec def run_stories return if @stories.empty? @listeners.each { |l| l.run_started(scenarios.size) } + success = true @stories.each do |story| story.assign_steps_to(World) @current_story = story @@ -45,13 +50,15 @@ module Spec type = story[:type] || Object args = story[:args] || [] world = @world_creator.create(type, *args) - @scenario_runner.run(scenario, world) + success = success & @scenario_runner.run(scenario, world) end @listeners.each { |l| l.story_ended(story.title, story.narrative) } + World.step_mother.clear end - unique_steps = World.step_names.uniq.sort + unique_steps = (World.step_names.collect {|n| Regexp === n ? n.source : n.to_s}).uniq.sort @listeners.each { |l| l.collected_steps(unique_steps) } @listeners.each { |l| l.run_ended } + return success end def add_listener(listener) vendor/plugins/rspec/lib/spec/story/runner/story_runner.rb @@ -1,48 +1,70 @@ module Spec module Story class Step - PARAM_PATTERN = /(\$\w*)/ + PARAM_PATTERN = /([^\\]|^)(\$(?!\$)\w*)/ + PARAM_OR_GROUP_PATTERN = /(\$(?!\$)\w*)|\(.*?\)/ attr_reader :name + def initialize(name, &block) - @name = name - assign_expression(name) - init_module(name, &block) + init_name(name) + init_expression(name) + block_given? ? init_module(name, &block) : set_pending end def perform(instance, *args) + raise Spec::Example::ExamplePendingError.new("Not Yet Implemented") if pending? instance.extend(@mod) - instance.__send__(@name, *args) - end - - def init_module(name, &block) - @mod = Module.new do - define_method(name.to_s, &block) - end + instance.__send__(sanitize(@name), *args) end def matches?(name) - !(matches = name.match(@expression)).nil? + !(name.strip =~ @expression).nil? end def parse_args(name) - name.match(@expression)[1..-1] + name.strip.match(@expression)[1..-1] end private - def assign_expression(name) - expression = name.dup - if String === expression - expression.gsub! '(', '\(' - expression.gsub! ')', '\)' - while expression =~ PARAM_PATTERN - expression.gsub!($1, "(.*)") - end - end - @expression = Regexp.new("^#{expression}$") + def sanitize(a_string_or_regexp) + return a_string_or_regexp.source if Regexp == a_string_or_regexp + a_string_or_regexp.to_s + end + + def init_module(name, &block) + sanitized_name = sanitize(name) + @mod = Module.new do + define_method(sanitized_name, &block) end + end + + def set_pending + @pending = true + end + + def pending? + @pending == true + end + + def init_name(name) + @name = name + end + + def init_expression(string_or_regexp) + if String === string_or_regexp + expression = string_or_regexp.dup + %w<? ( ) [ ] { } ^ !>.each {|c| expression.gsub! c, "\\#{c}"} + elsif Regexp === string_or_regexp + expression = string_or_regexp.source + end + while expression =~ PARAM_PATTERN + expression.sub!($2, "(.*?)") + end + @expression = Regexp.new("\\A#{expression}\\Z", Regexp::MULTILINE) + end end end -end \ No newline at end of file +end vendor/plugins/rspec/lib/spec/story/step.rb @@ -16,7 +16,7 @@ module Spec @step_group end - def initialize(init_defaults=true,&block) + def initialize(init_defaults=true, &block) @hash_of_lists_of_steps = Hash.new {|h, k| h[k] = []} if init_defaults self.class.steps.add_to(self) @@ -52,7 +52,6 @@ module Spec alias :when :When alias :then :Then - def add(type, steps) (@hash_of_lists_of_steps[type] << steps).flatten! end vendor/plugins/rspec/lib/spec/story/step_group.rb @@ -13,7 +13,8 @@ module Spec @steps.add(type, step) end - def find(type, name) + def find(type, unstripped_name) + name = unstripped_name.strip if @steps.find(type, name).nil? @steps.add(type, Step.new(name) do vendor/plugins/rspec/lib/spec/story/step_mother.rb @@ -19,17 +19,14 @@ module Spec end def assign_steps_to(assignee) - if @params[:steps] - assignee.use(@params[:steps]) - else - case keys = @params[:steps_for] - when Symbol - keys = [keys] - when nil - keys = [] - end - keys.each do |key| - assignee.use(steps_for(key)) + if steps=@params[:steps_for] + steps = [steps] unless steps.is_a?(Array) + steps.each do |step| + if step.is_a?(StepGroup) + assignee.use(step) + else + assignee.use(steps_for(step)) + end end end end vendor/plugins/rspec/lib/spec/story/story.rb @@ -1,4 +1,3 @@ -require 'rubygems' require 'spec/expectations' require 'spec/matchers' require 'spec/example/pending' @@ -16,77 +15,78 @@ module Spec module World include ::Spec::Example::Pending include ::Spec::Matchers - # store steps and listeners in the singleton metaclass. - # This serves both to keep them out of the way of runtime Worlds - # and to make them available to all instances. - class << self - def create(cls = Object, *args) - cls.new(*args).extend(World) - end - - def listeners - @listeners ||= [] - end - - def add_listener(listener) - listeners() << listener - end - - def step_mother - @step_mother ||= StepMother.new - end - - def use(steps) - step_mother.use(steps) + + def self.create(cls = Object, *args) + cls.new(*args).extend(World) + end + + def self.listeners + @listeners ||= [] + end + + def self.add_listener(listener) + listeners() << listener + end + + def self.step_mother + @step_mother ||= StepMother.new + end + + def self.use(steps) + step_mother.use(steps) + end + + def self.step_names + @step_names ||= [] + end + + def self.run_given_scenario_with_suspended_listeners(world, type, name, scenario) + current_listeners = Array.new(listeners) + begin + listeners.each { |l| l.found_scenario(type, name) } + @listeners.clear + scenario.perform(world, name) unless dry_run + ensure + @listeners.replace(current_listeners) end - - def step_names - @step_names ||= [] + end + + def self.store_and_call(world, type, name, *args, &block) + if block_given? + step_mother.store(type, Step.new(name, &block)) end + step = step_mother.find(type, name) - def run_given_scenario_with_suspended_listeners(world, type, name, scenario) - current_listeners = Array.new(listeners) - begin - listeners.each { |l| l.found_scenario(type, name) } - @listeners.clear - scenario.perform(world, name) unless ::Spec::Story::Runner.dry_run - ensure - @listeners.replace(current_listeners) - end - end + step_name = step.name + step_names << step_name - def store_and_call(world, type, name, *args, &block) - if block_given? - step_mother.store(type, Step.new(name, &block)) - end - step = step_mother.find(type, name) - - step_name = step.name - step_names << step_name - - # It's important to have access to the parsed args here, so - # we can give them to the listeners. The HTML reporter needs - # the args so it can style them. See the generated output in - # story_server/prototype/rspec_stories.html (generated by rake stories) - args = step.parse_args(name) if args.empty? - begin - step.perform(world, *args) unless ::Spec::Story::Runner.dry_run - listeners.each { |l| l.step_succeeded(type, step_name, *args) } - rescue Exception => e - case e - when Spec::Example::ExamplePendingError - @listeners.each { |l| l.step_pending(type, step_name, *args) } - else - @listeners.each { |l| l.step_failed(type, step_name, *args) } - end - errors << e + # It's important to have access to the parsed args here, so + # we can give them to the listeners. The HTML reporter needs + # the args so it can style them. See the generated output in + # story_server/prototype/rspec_stories.html (generated by rake stories) + args = step.parse_args(name) if args.empty? + begin + listeners.each { |l| l.step_upcoming(type, step_name, *args) } + step.perform(world, *args) unless dry_run + listeners.each { |l| l.step_succeeded(type, step_name, *args) } + rescue Exception => e + case e + when Spec::Example::ExamplePendingError + @listeners.each { |l| l.step_pending(type, step_name, *args) } + else + @listeners.each { |l| l.step_failed(type, step_name, *args) } end + errors << e end - - def errors - @errors ||= [] - end - end # end of class << self + end + + def self.errors + @errors ||= [] + end + + def self.dry_run + ::Spec::Story::Runner.dry_run + end def start_collecting_errors errors.clear vendor/plugins/rspec/lib/spec/story/world.rb @@ -3,21 +3,13 @@ module Spec unless defined? MAJOR MAJOR = 1 MINOR = 1 - TINY = 0 - RELEASE_CANDIDATE = nil + TINY = 11 + MINESCULE = 1 + - # RANDOM_TOKEN: 0.885013695004692 - REV = "$LastChangedRevision: 2958 $".match(/LastChangedRevision: (\d+)/)[1] + STRING = [MAJOR, MINOR, TINY, MINESCULE].join('.') - STRING = [MAJOR, MINOR, TINY].join('.') - TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_') - FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (r#{REV})" - - NAME = "RSpec" - URL = "http://rspec.rubyforge.org/" - - DESCRIPTION = "#{NAME}-#{FULL_VERSION} - BDD for Ruby\n#{URL}" + SUMMARY = "rspec #{STRING}" end end -end - +end \ No newline at end of file vendor/plugins/rspec/lib/spec/version.rb @@ -1,9 +1,11 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "spec", "mocks")) +require 'spec/mocks/framework' +require 'spec/mocks/extensions' module Spec module Plugins module MockFramework - include Spec::Mocks::SpecMethods + include Spec::Mocks::ExampleMethods def setup_mocks_for_rspec $rspec_mocks ||= Spec::Mocks::Space.new end vendor/plugins/rspec/plugins/mock_frameworks/rspec.rb @@ -4,6 +4,6 @@ require 'spec/rake/spectask' desc "Generate HTML report for failing examples" Spec::Rake::SpecTask.new('failing_examples_with_html') do |t| t.spec_files = FileList['failing_examples/**/*.rb'] - t.spec_opts = ["--format", "html:../doc/output/documentation/tools/failing_examples.html", "--diff"] + t.spec_opts = ["--format", "html:doc/reports/tools/failing_examples.html", "--diff"] t.fail_on_error = false end \ No newline at end of file vendor/plugins/rspec/rake_tasks/failing_examples_with_html.rake @@ -2,6 +2,6 @@ require 'rake' require 'spec/rake/verify_rcov' RCov::VerifyTask.new(:verify_rcov => :spec) do |t| - t.threshold = 100.0 # Make sure you have rcov 0.7 or higher! - t.index_html = '../doc/output/coverage/index.html' + t.threshold = 100.0 + t.index_html = 'coverage/index.html' end vendor/plugins/rspec/rake_tasks/verify_rcov.rake @@ -7,6 +7,7 @@ ant # put JRuby's bin dir on your PATH jruby -S gem install rake --no-ri --no-rdoc jruby -S gem install diff-lcs +jruby -S gem install syntax cd ../testsuites/rspec mkdir target jruby -S rake checkout_code vendor/plugins/rspec/spec/README.jruby @@ -1,19 +1,8 @@ -require File.dirname(__FILE__) + "/../autotest_helper" +require File.dirname(__FILE__) + "/autotest_helper" -module DiscoveryHelper - def load_discovery +describe Autotest::Rspec, "discovery" do + it "adds the rspec autotest plugin" do + Autotest.should_receive(:add_discovery) require File.dirname(__FILE__) + "/../../lib/autotest/discover" end -end - - -class Autotest - describe Rspec, "discovery" do - include DiscoveryHelper - - it "should add the rspec autotest plugin" do - Autotest.should_receive(:add_discovery).and_yield - load_discovery - end - end -end +end vendor/plugins/rspec/spec/autotest/discover_spec.rb @@ -1,264 +1,114 @@ -require File.dirname(__FILE__) + "/../autotest_helper" +require File.dirname(__FILE__) + "/autotest_helper" class Autotest - module AutotestHelper - def rspec_output - <<-HERE -.............PPF - -1) -'false should be false' FAILED -expected: true, - got: false (using ==) -./spec/autotest/rspec_spec.rb:203: - -Finished in 0.158674 seconds - -16 examples, 1 failure, 2 pending - -Pending: -Autotest::Rspec handling failed results should return an array of failed examples and errors (TODO) -Autotest::Rspec tests/specs for a given file should find all the specs for a given file (TODO) -HERE - end - - - def common_setup - @proc = mock Proc - @kernel = mock Kernel - @kernel.stub!(:proc).and_return @proc - - File.stub!(:exists).and_return true - @windows_alt_separator = "\\" - @posix_separator = '/' + describe Rspec do + describe "adding spec.opts --options" do + before(:each) do + @rspec_autotest = Rspec.new + end - @rspec_output = rspec_output - end - end + it "should return the command line option to add spec.opts if the options file exists" do + File.stub!(:exist?).and_return true + @rspec_autotest.add_options_if_present.should == "-O spec/spec.opts " + end - describe Rspec, "rspec_commands" do - it "should contain the various commands, ordered by preference" do - Rspec.new.spec_commands.should == [ - File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec"), - "#{Config::CONFIG['bindir']}/spec" - ] - end - end + it "should return an empty string if no spec.opts exists" do + File.stub!(:exist?).and_return false + Rspec.new.add_options_if_present.should == "" + end + end - describe Rspec, "selection of rspec command" do - include AutotestHelper - - before :each do - common_setup - @rspec_autotest = Rspec.new(@kernel) - end - - it "should try to find the spec command if it exists in ./bin and use it above everything else" do - File.stub!(:exists?).and_return true - - spec_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec") - File.should_receive(:exists?).with(spec_path).and_return true - @rspec_autotest.spec_command.should == spec_path - end - - it "should otherwise select the default spec command in gem_dir/bin/spec" do - @rspec_autotest.stub!(:spec_commands).and_return ["/foo/spec"] - Config::CONFIG.stub!(:[]).and_return "/foo" - File.should_receive(:exists?).with("/foo/spec").and_return(true) - - @rspec_autotest.spec_command.should == "/foo/spec" - end - - it "should raise an error if no spec command is found at all" do - File.stub!(:exists?).and_return false + describe "commands" do + before(:each) do + @rspec_autotest = Rspec.new + @rspec_autotest.stub!(:ruby).and_return "ruby" + @rspec_autotest.stub!(:add_options_if_present).and_return "-O spec/spec.opts" - lambda { - @rspec_autotest.spec_command - }.should raise_error(RspecCommandError, "No spec command could be found!") - end - - end - - describe Rspec, "selection of rspec command (windows compatibility issues)" do - include AutotestHelper - - before :each do - common_setup - end - - it "should use the ALT_SEPARATOR if it is non-nil" do - @rspec_autotest = Rspec.new(@kernel, @posix_separator, @windows_alt_separator) - spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec") - @rspec_autotest.stub!(:spec_commands).and_return [spec_command] - @rspec_autotest.spec_command.should == spec_command.gsub('/', '\\') - end - - it "should not use the ALT_SEPATOR if it is nil" do - @windows_alt_separator = nil - @rspec_autotest = Rspec.new(@kernel, @posix_separator, @windows_alt_separator) - spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec") - @rspec_autotest.stub!(:spec_commands).and_return [spec_command] - @rspec_autotest.spec_command.should == spec_command - end - end - - describe Rspec, "adding spec.opts --options" do - before :each do - @rspec_autotest = Rspec.new - end + @ruby = @rspec_autotest.ruby + @spec_cmd = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')) + @options = @rspec_autotest.add_options_if_present + @files_to_test = { + :spec => ["file_one", "file_two"] + } + # this is not the inner representation of Autotest! + @rspec_autotest.stub!(:files_to_test).and_return @files_to_test + @files_to_test.stub!(:keys).and_return @files_to_test[:spec] + @to_test = @files_to_test.keys.flatten.join ' ' + end + + it "should make the appropriate test command" do + @rspec_autotest.make_test_cmd(@files_to_test).should == "#{@ruby} #{@spec_cmd} #{@to_test} #{@options}" + end - it "should return the command line option to add spec.opts if the options file exists" do - File.stub!(:exist?).and_return true - @rspec_autotest.add_options_if_present.should == "-O spec/spec.opts " - end - - it "should return an empty string if no spec.opts exists" do - File.stub!(:exist?).and_return false - Rspec.new.add_options_if_present.should == "" - end - end - - describe Rspec do - before :each do - @rspec_autotest = Rspec.new - @rspec_autotest.stub!(:ruby).and_return "ruby" - @rspec_autotest.stub!(:add_options_if_present).and_return "-O spec/spec.opts" - - @ruby = @rspec_autotest.ruby - @spec_command = @rspec_autotest.spec_command - @options = @rspec_autotest.add_options_if_present - @files_to_test = { - :spec => ["file_one", "file_two"] - } - # this is not the inner representation of Autotest! - @rspec_autotest.stub!(:files_to_test).and_return @files_to_test - @files_to_test.stub!(:keys).and_return @files_to_test[:spec] - @to_test = @files_to_test.keys.flatten.join ' ' - end - - it "should make the apropriate test command" do - @rspec_autotest.make_test_cmd(@files_to_test).should == "#{@ruby} -S #{@spec_command} #{@options} #{@to_test}" - end - end - - describe Rspec, "test mappings" do - before :each do - @proc = mock Proc - @kernel = mock Kernel - @kernel.stub!(:proc).and_return @proc - @rspec_autotest = Rspec.new(@kernel) - end - - it "should map all filenames in spec/ which end in .rb" do - @rspec_autotest.test_mappings[%r%^spec/.*\.rb$%].should == @proc - end - - it "should map all names in lib which end in .rb to the corresponding ones in spec/" do - @rspec_autotest.test_mappings[%r%^lib/(.*)\.rb$%].should == @proc - end - - it "should find all files in spec/shares/* and the spec helper in spec/spec_helper" do - @rspec_autotest.test_mappings[%r%^spec/(spec_helper|shared/.*)\.rb$%].should == @proc - end - end - - describe Rspec, "handling results" do - include AutotestHelper - - before :each do - common_setup - @rspec_autotest = Rspec.new(@kernel, @posix_separator, @windows_alt_separator) - @rspec_autotest.stub!(:hook) - - @results = mock String - @results.stub!(:scan).and_return "" - end - - it "should call hook(:red) if there are failures" do - @rspec_autotest.stub!(:consolidate_failures).and_return ["spec/some_spec.rb"] - - @rspec_autotest.should_receive(:hook).with(:red) - @rspec_autotest.handle_results(@results) + it "should return a blank command for no files" do + @rspec_autotest.make_test_cmd({}).should == '' + end end - - it "should call hook(:green) if there are no failures" do - @rspec_autotest.stub!(:consolidate_failures).and_return [] - @rspec_autotest.should_receive(:hook).with(:green) - @rspec_autotest.handle_results(@results) - end - end - describe Rspec, "handling failed results" do - include AutotestHelper + describe "mappings" do - before :each do - common_setup - end + before(:each) do + @lib_file = "lib/something.rb" + @spec_file = "spec/something_spec.rb" + @rspec_autotest = Rspec.new + @rspec_autotest.hook :initialize + end - it %(should scan the output into a multi-dimensional array, - consisting of the failing spec's name as the first element, - and the failure as the second) do - @rspec_autotest = Rspec.new - @rspec_autotest.failed_results(@rspec_output).should == [ - [ - "false should be false", - "expected: true,\n got: false (using ==)\n./spec/autotest/rspec_spec.rb:203:" - ] - ] - end - end - - describe Rspec, "specs for a given file" do - before :each do - @lib_file = "lib/something.rb" - @spec_file = "spec/something_spec.rb" - @rspec_autotest = Rspec.new - - @rspec_autotest.instance_variable_set("@files", {@lib_file => Time.now, @spec_file => Time.now}) - @rspec_autotest.stub!(:find_files_to_test).and_return true - end + it "should find the spec file for a given lib file" do + @rspec_autotest.should map_specs([@spec_file]).to(@lib_file) + end - it "should find the spec file for a given lib file" do - @rspec_autotest.specs_for_file(@lib_file).should == [@spec_file] - end + it "should find the spec file if given a spec file" do + @rspec_autotest.should map_specs([@spec_file]).to(@spec_file) + end - it "should find the spec file if given a spec file" do - @rspec_autotest.specs_for_file(@spec_file).should == [@spec_file] - end + it "should ignore files in spec dir that aren't specs" do + @rspec_autotest.should map_specs([]).to("spec/spec_helper.rb") + end - it "should only find the file if the file is being tracked (in @file)" do - @other_file = "lib/some_non_tracked_file" - @rspec_autotest.specs_for_file(@other_file).should == [] + it "should ignore untracked files (in @file)" do + @rspec_autotest.should map_specs([]).to("lib/untracked_file") + end end - end - describe Rspec, "consolidating failures" do - include AutotestHelper - - before :each do - common_setup - @rspec_autotest = Rspec.new + describe "consolidating failures" do + before(:each) do + @rspec_autotest = Rspec.new - @spec_file = "./spec/autotest/rspec_spec.rb" - @rspec_autotest.instance_variable_set("@files", {@spec_file => Time.now}) - @rspec_autotest.stub!(:find_files_to_test).and_return true - end - - it "should return no failures if no failures were given in the output" do - @rspec_autotest.stub!(:failed_results).and_return [[]] - @rspec_autotest.consolidate_failures(@rspec_autotest.failed_results).should == {} - end - - it "should return a hash with the spec filename => spec name for each failure or error" do - @rspec_autotest.stub!(:failed_results).and_return([ - [ - "false should be false", - "expected: true,\n got: false (using ==)\n./spec/autotest/rspec_spec.rb:203:" + @spec_file = "spec/autotest/some_spec.rb" + @rspec_autotest.instance_variable_set("@files", {@spec_file => Time.now}) + @rspec_autotest.stub!(:find_files_to_test).and_return true + end + + it "should return no failures if no failures were given in the output" do + @rspec_autotest.consolidate_failures([[]]).should == {} + end + + it "should return a hash with the spec filename => spec name for each failure or error" do + @rspec_autotest.stub!(:test_files_for).and_return "spec/autotest/some_spec.rb" + failures = [ + [ + "false should be false", + "expected: true,\n got: false (using ==)\n#{@spec_file}:203:" + ] ] - ]) - @rspec_autotest.consolidate_failures(@rspec_autotest.failed_results).should == {@spec_file => ["false should be false"]} + @rspec_autotest.consolidate_failures(failures).should == { + @spec_file => ["false should be false"] + } + end + + it "should not include the subject file" do + subject_file = "lib/autotest/some.rb" + @rspec_autotest.stub!(:test_files_for).and_return "spec/autotest/some_spec.rb" + failures = [ + [ + "false should be false", + "expected: true,\n got: false (using ==)\n#{subject_file}:143:\n#{@spec_file}:203:" + ] + ] + @rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file) + end end - end end vendor/plugins/rspec/spec/autotest/rspec_spec.rb @@ -1,7 +1,6 @@ if __FILE__ == $0 dir = File.dirname(__FILE__) - Dir["#{dir}/**/*_spec.rb"].each do |file| -# puts "require '#{file}'" + Dir["#{dir}/**/*_spec.rb"].reverse.each do |file| require file end end vendor/plugins/rspec/spec/rspec_suite.rb @@ -2,288 +2,294 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Example - ConfigurationSpec = - describe Configuration, :shared => true do + describe Configuration do + + describe "#mock_with" do + before(:each) do @config = Configuration.new - @behaviour = mock("behaviour") + @example_group = mock("example_group") end - end - - describe Configuration, "#mock_with" do - include ConfigurationSpec - it "should default mock framework to rspec" do - @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/ - end - it "should let you set rspec mocking explicitly" do - @config.mock_with(:rspec) - @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/ - end + it "should default mock framework to rspec" do + @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/ + end - it "should let you set mocha" do - @config.mock_with(:mocha) - @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/ - end + it "should set rspec mocking explicitly" do + @config.mock_with(:rspec) + @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/ + end - it "should let you set flexmock" do - @config.mock_with(:flexmock) - @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/ - end + it "should set mocha" do + @config.mock_with(:mocha) + @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/ + end - it "should let you set rr" do - @config.mock_with(:rr) - @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/ - end + it "should set flexmock" do + @config.mock_with(:flexmock) + @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/ + end - it "should let you set an arbitrary adapter module" do - adapter = Module.new - @config.mock_with(adapter) - @config.mock_framework.should == adapter + it "should set rr" do + @config.mock_with(:rr) + @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/ + end + + it "should set an arbitrary adapter module" do + adapter = Module.new + @config.mock_with(adapter) + @config.mock_framework.should == adapter + end end - end - describe Configuration, "#include" do - include ConfigurationSpec + with_sandboxed_config do - before do - @original_configuration = Spec::Runner.configuration - spec_configuration = @config - Spec::Runner.instance_eval {@configuration = spec_configuration} - @example_group_class = Class.new(ExampleGroup) do - class << self - def this_class_has_special_methods - end + describe "#include" do + + before(:each) do + @example_group_class = Class.new(ExampleGroup) {} + ExampleGroupFactory.register(:foobar, @example_group_class) end - end - ExampleGroupFactory.register(:foobar, @example_group_class) - end - after do - original_configuration = @original_configuration - Spec::Runner.instance_eval {@configuration = original_configuration} - ExampleGroupFactory.reset - end + it "should include the submitted module in ExampleGroup subclasses" do + mod = Module.new + config.include mod + Class.new(@example_group_class).included_modules.should include(mod) + end - it "should include the submitted module in ExampleGroup subclasses" do - mod = Module.new - @config.include mod - Class.new(@example_group_class).included_modules.should include(mod) - end + it "should scope modules to be included for a specific type" do + mod = Module.new + config.include mod, :type => :foobar + Class.new(@example_group_class).included_modules.should include(mod) + end - it "should let you define modules to be included for a specific type" do - mod = Module.new - @config.include mod, :behaviour_type => :foobar - Class.new(@example_group_class).included_modules.should include(mod) - end + it "should not include modules in a type they are not intended for" do + mod = Module.new + @other_example_group_class = Class.new(ExampleGroup) + ExampleGroupFactory.register(:baz, @other_example_group_class) - it "should not include modules in a type they are not intended for" do - mod = Module.new - @other_example_group_class = Class.new(ExampleGroup) - ExampleGroupFactory.register(:baz, @other_example_group_class) + config.include mod, :type => :foobar - @config.include mod, :behaviour_type => :foobar + Class.new(@other_example_group_class).included_modules.should_not include(mod) + end - Class.new(@other_example_group_class).included_modules.should_not include(mod) - end + end - it "should not extend the ExampleGroup baseclass (to enable the included hook to work properly)" do - pending("need to figure out how to best express this one") - end - end + describe "#extend" do + + before(:each) do + @example_group_class = Class.new(ExampleGroup) {} + ExampleGroupFactory.register(:foobar, @example_group_class) + end - ConfigurationCallbacksSpec = - describe Configuration, " callbacks", :shared => true do - before do - @config = Configuration.new - @special_behaviour = Class.new(ExampleGroup) - @special_child_behaviour = Class.new(@special_behaviour) - @nonspecial_behaviour = Class.new(ExampleGroup) - ExampleGroupFactory.register(:special, @special_behaviour) - ExampleGroupFactory.register(:special_child, @special_child_behaviour) - ExampleGroupFactory.register(:non_special, @nonspecial_behaviour) - @behaviour = @special_child_behaviour.describe "Special Example Group" - @unselected_behaviour = Class.new(@nonspecial_behaviour).describe "Non Special Example Group" - end + it "should extend all groups" do + mod = Module.new + ExampleGroup.should_receive(:extend).with(mod) + Spec::Runner.configuration.extend mod + end + + it "should extend specified groups" do + mod = Module.new + @example_group_class.should_receive(:extend).with(mod) + Spec::Runner.configuration.extend mod, :type => :foobar + end + + it "should not extend non-specified groups" do + @other_example_group_class = Class.new(ExampleGroup) + ExampleGroupFactory.register(:baz, @other_example_group_class) - after do - ExampleGroupFactory.reset + mod = Module.new + @other_example_group_class.should_not_receive(:extend) + + Spec::Runner.configuration.extend mod, :type => :foobar + end + end end - describe Configuration, "#prepend_before" do - include ConfigurationCallbacksSpec - - it "prepends the before block on all instances of the passed in behaviour_type" do - order = [] - @config.prepend_before(:all) do - order << :prepend__before_all - end - @config.prepend_before(:all, :behaviour_type => :special) do - order << :special_prepend__before_all - end - @config.prepend_before(:all, :behaviour_type => :special_child) do - order << :special_child_prepend__before_all - end - @config.prepend_before(:each) do - order << :prepend__before_each - end - @config.prepend_before(:each, :behaviour_type => :special) do - order << :special_prepend__before_each - end - @config.prepend_before(:each, :behaviour_type => :special_child) do - order << :special_child_prepend__before_each - end - @config.prepend_before(:all, :behaviour_type => :non_special) do - order << :special_prepend__before_all - end - @config.prepend_before(:each, :behaviour_type => :non_special) do - order << :special_prepend__before_each - end - @behaviour.it "calls prepend_before" do + describe Configuration do + + before(:each) do + @special_example_group = Class.new(ExampleGroup).describe("special_example_group") + @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group") + @nonspecial_example_group = Class.new(ExampleGroup).describe("nonspecial_example_group") + ExampleGroupFactory.register(:special, @special_example_group) + ExampleGroupFactory.register(:special_child, @special_child_example_group) + ExampleGroupFactory.register(:non_special, @nonspecial_example_group) + @example_group = @special_child_example_group.describe "Special Example Group" + @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group" end + + describe "#prepend_before" do + it "prepends the before block on all instances of the passed in type" do + order = [] + config.prepend_before(:all) do + order << :prepend__before_all + end + config.prepend_before(:all, :type => :special) do + order << :special_prepend__before_all + end + config.prepend_before(:all, :type => :special_child) do + order << :special_child_prepend__before_all + end + config.prepend_before(:each) do + order << :prepend__before_each + end + config.prepend_before(:each, :type => :special) do + order << :special_prepend__before_each + end + config.prepend_before(:each, :type => :special_child) do + order << :special_child_prepend__before_each + end + config.prepend_before(:all, :type => :non_special) do + order << :special_prepend__before_all + end + config.prepend_before(:each, :type => :non_special) do + order << :special_prepend__before_each + end + @example_group.it "calls prepend_before" do + end - @behaviour.suite.run - order.should == [ - :prepend__before_all, - :special_prepend__before_all, - :special_child_prepend__before_all, - :prepend__before_each, - :special_prepend__before_each, - :special_child_prepend__before_each - ] - end - end + @example_group.run + order.should == [ + :prepend__before_all, + :special_prepend__before_all, + :special_child_prepend__before_all, + :prepend__before_each, + :special_prepend__before_each, + :special_child_prepend__before_each + ] + end + end - describe Configuration, "#append_before" do - include ConfigurationCallbacksSpec + describe "#append_before" do - it "calls append_before on the behaviour_type" do - order = [] - @config.append_before(:all) do - order << :append_before_all - end - @config.append_before(:all, :behaviour_type => :special) do - order << :special_append_before_all - end - @config.append_before(:all, :behaviour_type => :special_child) do - order << :special_child_append_before_all - end - @config.append_before(:each) do - order << :append_before_each - end - @config.append_before(:each, :behaviour_type => :special) do - order << :special_append_before_each - end - @config.append_before(:each, :behaviour_type => :special_child) do - order << :special_child_append_before_each - end - @config.append_before(:all, :behaviour_type => :non_special) do - order << :special_append_before_all - end - @config.append_before(:each, :behaviour_type => :non_special) do - order << :special_append_before_each - end - @behaviour.it "calls append_before" do + it "calls append_before on the type" do + order = [] + config.append_before(:all) do + order << :append_before_all + end + config.append_before(:all, :type => :special) do + order << :special_append_before_all + end + config.append_before(:all, :type => :special_child) do + order << :special_child_append_before_all + end + config.append_before(:each) do + order << :append_before_each + end + config.append_before(:each, :type => :special) do + order << :special_append_before_each + end + config.append_before(:each, :type => :special_child) do + order << :special_child_append_before_each + end + config.append_before(:all, :type => :non_special) do + order << :special_append_before_all + end + config.append_before(:each, :type => :non_special) do + order << :special_append_before_each + end + @example_group.it "calls append_before" do + end + + @example_group.run + order.should == [ + :append_before_all, + :special_append_before_all, + :special_child_append_before_all, + :append_before_each, + :special_append_before_each, + :special_child_append_before_each + ] + end end - @behaviour.suite.run - order.should == [ - :append_before_all, - :special_append_before_all, - :special_child_append_before_all, - :append_before_each, - :special_append_before_each, - :special_child_append_before_each - ] - end - end + describe "#prepend_after" do - describe Configuration, "#prepend_after" do - include ConfigurationCallbacksSpec + it "prepends the after block on all instances of the passed in type" do + order = [] + config.prepend_after(:all) do + order << :prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_child_prepend__after_all + end + config.prepend_after(:each) do + order << :prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_child_prepend__after_each + end + config.prepend_after(:all, :type => :non_special) do + order << :special_prepend__after_all + end + config.prepend_after(:each, :type => :non_special) do + order << :special_prepend__after_each + end + @example_group.it "calls prepend_after" do + end - it "prepends the after block on all instances of the passed in behaviour_type" do - order = [] - @config.prepend_after(:all) do - order << :prepend__after_all - end - @config.prepend_after(:all, :behaviour_type => :special) do - order << :special_prepend__after_all - end - @config.prepend_after(:all, :behaviour_type => :special) do - order << :special_child_prepend__after_all - end - @config.prepend_after(:each) do - order << :prepend__after_each - end - @config.prepend_after(:each, :behaviour_type => :special) do - order << :special_prepend__after_each - end - @config.prepend_after(:each, :behaviour_type => :special) do - order << :special_child_prepend__after_each - end - @config.prepend_after(:all, :behaviour_type => :non_special) do - order << :special_prepend__after_all - end - @config.prepend_after(:each, :behaviour_type => :non_special) do - order << :special_prepend__after_each - end - @behaviour.it "calls prepend_after" do + @example_group.run + order.should == [ + :special_child_prepend__after_each, + :special_prepend__after_each, + :prepend__after_each, + :special_child_prepend__after_all, + :special_prepend__after_all, + :prepend__after_all + ] + end end - @behaviour.suite.run - order.should == [ - :special_child_prepend__after_each, - :special_prepend__after_each, - :prepend__after_each, - :special_child_prepend__after_all, - :special_prepend__after_all, - :prepend__after_all - ] - end - end + describe "#append_after" do - describe Configuration, "#append_after" do - include ConfigurationCallbacksSpec + it "calls append_after on the type" do + order = [] + config.append_after(:all) do + order << :append__after_all + end + config.append_after(:all, :type => :special) do + order << :special_append__after_all + end + config.append_after(:all, :type => :special_child) do + order << :special_child_append__after_all + end + config.append_after(:each) do + order << :append__after_each + end + config.append_after(:each, :type => :special) do + order << :special_append__after_each + end + config.append_after(:each, :type => :special_child) do + order << :special_child_append__after_each + end + config.append_after(:all, :type => :non_special) do + order << :non_special_append_after_all + end + config.append_after(:each, :type => :non_special) do + order << :non_special_append_after_each + end + @example_group.it "calls append_after" do + end - it "calls append_after on the behaviour_type" do - order = [] - @config.append_after(:all) do - order << :append__after_all - end - @config.append_after(:all, :behaviour_type => :special) do - order << :special_append__after_all - end - @config.append_after(:all, :behaviour_type => :special_child) do - order << :special_child_append__after_all - end - @config.append_after(:each) do - order << :append__after_each - end - @config.append_after(:each, :behaviour_type => :special) do - order << :special_append__after_each - end - @config.append_after(:each, :behaviour_type => :special_child) do - order << :special_child_append__after_each - end - @config.append_after(:all, :behaviour_type => :non_special) do - order << :non_special_append_after_all - end - @config.append_after(:each, :behaviour_type => :non_special) do - order << :non_special_append_after_each - end - @behaviour.it "calls append_after" do + @example_group.run + order.should == [ + :special_child_append__after_each, + :special_append__after_each, + :append__after_each, + :special_child_append__after_all, + :special_append__after_all, + :append__after_all + ] + end end - - @behaviour.suite.run - order.should == [ - :special_child_append__after_each, - :special_append__after_each, - :append__after_each, - :special_child_append__after_all, - :special_append__after_all, - :append__after_all - ] end end end vendor/plugins/rspec/spec/spec/example/configuration_spec.rb @@ -3,37 +3,41 @@ require File.dirname(__FILE__) + '/../../spec_helper' module Spec module Example class ExampleGroupSubclass < ExampleGroup - class << self - attr_accessor :examples_ran + def self.examples_ran + @examples_ran end - @@klass_variable_set = true - CONSTANT = :foobar + def self.examples_ran=(examples_ran) + @examples_ran = examples_ran + end + + @@class_variable = :class_variable + CONSTANT = :constant before do - @instance_variable = :hello + @instance_variable = :instance_variable end - - it "should run" do + + after(:all) do self.class.examples_ran = true end it "should have access to instance variables" do - @instance_variable.should == :hello + @instance_variable.should == :instance_variable end it "should have access to class variables" do - @@klass_variable_set.should == true + @@class_variable.should == :class_variable end it "should have access to constants" do - CONSTANT.should == :foobar + CONSTANT.should == :constant end it "should have access to methods defined in the Example Group" do a_method.should == 22 end - + def a_method 22 end vendor/plugins/rspec/spec/spec/example/example_group_class_definition_spec.rb @@ -1,144 +1,185 @@ -require File.dirname(__FILE__) + '/../../spec_helper' +require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper') module Spec module Example - describe ExampleGroupFactory, "with :foobar registered as custom type" do + describe ExampleGroupFactory do + describe "#get" do + attr_reader :example_group + before(:each) do + @example_group_class = Class.new(ExampleGroup) + ExampleGroupFactory.register(:registered_type, @example_group_class) + end - before do - @behaviour = Class.new(ExampleGroup) - ExampleGroupFactory.register(:foobar, @behaviour) - end + after(:each) do + ExampleGroupFactory.reset + end - after do - ExampleGroupFactory.reset - end + it "should return the default ExampleGroup type for nil" do + ExampleGroupFactory.get(nil).should == ExampleGroup + end - it "should #get the default behaviour type when passed nil" do - ExampleGroupFactory.get(nil).should == ExampleGroup - end + it "should return the default ExampleGroup for an unregistered non-nil value" do + ExampleGroupFactory.get(:does_not_exist).should == ExampleGroup + end - it "should #get custom type for :foobar" do - ExampleGroupFactory.get(:foobar).should == @behaviour - end + it "should return custom type if registered" do + ExampleGroupFactory.get(:registered_type).should == @example_group_class + end - it "should #get the actual type when that is passed in" do - ExampleGroupFactory.get(@behaviour).should == @behaviour - end + it "should return the actual type when that is what is submitted" do + ExampleGroupFactory.get(@example_group_class).should == @example_group_class + end - it "should #get nil for unregistered non-nil values" do - ExampleGroupFactory.get(:does_not_exist).should be_nil + it "should get the custom type after setting the default" do + @alternate_example_group_class = Class.new(ExampleGroup) + ExampleGroupFactory.default(@alternate_example_group_class) + ExampleGroupFactory.get(:registered_type).should == @example_group_class + end end - it "should raise error for #get! with unknown key" do - proc do - ExampleGroupFactory.get!(:does_not_exist) - end.should raise_error - end - end + describe "#create_example_group" do + attr_reader :parent_example_group + before do + @parent_example_group = Class.new(ExampleGroup) do + def initialize(*args, &block) + ; + end + end + end - describe ExampleGroupFactory, "#create_example_group" do - it "should create a uniquely named class" do - behaviour = Spec::Example::ExampleGroupFactory.create_example_group("behaviour") {} - behaviour.name.should =~ /Spec::Example::ExampleGroup::Subclass_\d+/ - end + it "should create a uniquely named class" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {} + example_group.name.should =~ /Spec::Example::ExampleGroup::Subclass_\d+/ + end - it "should create a Spec::Example::Example subclass by default" do - behaviour = Spec::Example::ExampleGroupFactory.create_example_group("behaviour") {} - behaviour.superclass.should == Spec::Example::ExampleGroup - end + it "should create a Spec::Example::Example subclass by default" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {} + example_group.superclass.should == Spec::Example::ExampleGroup + end - it "should create a Spec::Example::Example when :type => :default" do - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :type => :default - ) {} - behaviour.superclass.should == Spec::Example::ExampleGroup - end + it "should raise when no description is given" do + lambda { + Spec::Example::ExampleGroupFactory.create_example_group do; end + }.should raise_error(ArgumentError) + end + + it "should raise when no block is given" do + lambda { Spec::Example::ExampleGroupFactory.create_example_group "foo" }.should raise_error(ArgumentError) + end - it "should create a Spec::Example::Example when :behaviour_type => :default" do - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :behaviour_type => :default - ) {} - behaviour.superclass.should == Spec::Example::ExampleGroup - end + it "should run registered ExampleGroups" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group "The ExampleGroup" do end + Spec::Runner.options.example_groups.should include(example_group) + end - it "should create specified type when :type => :something_other_than_default" do - klass = Class.new(ExampleGroup) do - def initialize(*args, &block); end + it "should not run unregistered ExampleGroups" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group "The ExampleGroup" do unregister; end + Spec::Runner.options.example_groups.should_not include(example_group) end - Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass) - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :type => :something_other_than_default - ) {} - behaviour.superclass.should == klass - end - it "should create specified type when :behaviour_type => :something_other_than_default" do - klass = Class.new(ExampleGroup) do - def initialize(*args, &block); end + describe "with :type => :default" do + it "should create a Spec::Example::ExampleGroup" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :type => :default + ) {} + example_group.superclass.should == Spec::Example::ExampleGroup + end end - Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass) - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :behaviour_type => :something_other_than_default - ) {} - behaviour.superclass.should == klass - end - - it "should create a type indicated by :spec_path" do - klass = Class.new(ExampleGroup) do - def initialize(*args, &block); end - end - Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass) - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :spec_path => "./spec/something_other_than_default/some_spec.rb" - ) {} - behaviour.superclass.should == klass - end - - it "should create a type indicated by :spec_path (with spec_path generated by caller on windows)" do - klass = Class.new(ExampleGroup) do - def initialize(*args, &block); end - end - Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass) - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "behaviour", :spec_path => "./spec\\something_other_than_default\\some_spec.rb" - ) {} - behaviour.superclass.should == klass - end - - it "should create and register a Spec::Example::Example if :shared => true" do - shared_example_group = Spec::Example::ExampleGroupFactory.create_example_group( - "name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :controller, :shared => true - ) {} - shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup) - SharedExampleGroup.shared_example_groups.should include(shared_example_group) - end - it "should favor the :behaviour_type over the :spec_path" do - klass = Class.new(ExampleGroup) do - def initialize(*args, &block); end + describe "with :type => :something_other_than_default" do + it "should create the specified type" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + non_default_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :type => :something_other_than_default + ) {} + non_default_example_group.superclass.should == parent_example_group + end end - Spec::Example::ExampleGroupFactory.register(:something_other_than_default, klass) - behaviour = Spec::Example::ExampleGroupFactory.create_example_group( - "name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :something_other_than_default - ) {} - behaviour.superclass.should == klass - end - it "should register ExampleGroup by default" do - example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do + it "should create a type indicated by :spec_path" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :spec_path => "./spec/something_other_than_default/some_spec.rb" + ) {} + custom_example_group.superclass.should == parent_example_group + end + + it "should create a type indicated by :spec_path (with spec_path generated by caller on windows)" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", + :spec_path => "./spec\\something_other_than_default\\some_spec.rb" + ) {} + custom_example_group.superclass.should == parent_example_group + end + + describe "with :shared => true" do + def shared_example_group + @shared_example_group ||= Spec::Example::ExampleGroupFactory.create_example_group( + "name", :spec_path => '/blah/spec/models/blah.rb', :type => :controller, :shared => true + ) {} + end + + it "should create and register a Spec::Example::SharedExampleGroup" do + shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup) + SharedExampleGroup.should include(shared_example_group) + end + end + + it "should favor the :type over the :spec_path" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "name", :spec_path => '/blah/spec/models/blah.rb', :type => :something_other_than_default + ) {} + custom_example_group.superclass.should == parent_example_group end - rspec_options.example_groups.should include(example_group) - end - it "should enable unregistering of ExampleGroups" do - example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do - unregister + it "should register ExampleGroup by default" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do + end + Spec::Runner.options.example_groups.should include(example_group) + end + + it "should enable unregistering of ExampleGroups" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do + unregister + end + Spec::Runner.options.example_groups.should_not include(example_group) + end + + + after(:each) do + Spec::Example::ExampleGroupFactory.reset end - rspec_options.example_groups.should_not include(example_group) end - after(:each) do - Spec::Example::ExampleGroupFactory.reset + describe "#registered_or_ancestor_of_registered?" do + before(:each) do + @unregistered_parent = Class.new(ExampleGroup) + @registered_child = Class.new(@unregistered_parent) + @unregistered_grandchild = Class.new(@registered_child) + Spec::Example::ExampleGroupFactory.register :registered_child, @registered_child + end + + it "should return true for empty list" do + Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?([]).should be_true + end + + it "should return true for a registered example group class" do + Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?([@registered_child]).should be_true + end + + it "should return true for an ancestor of a registered example_group_classes" do + Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?([@unregistered_parent]).should be_true + end + + it "should return false for a subclass of a registered example_group_class" do + Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?([@unregistered_grandchild]).should be_false + end + + after(:each) do + Spec::Example::ExampleGroupFactory.reset + end end end end vendor/plugins/rspec/spec/spec/example/example_group_factory_spec.rb @@ -2,424 +2,648 @@ require File.dirname(__FILE__) + '/../../spec_helper' module Spec module Example - describe ExampleGroup do - attr_reader :options, :example_group, :result, :reporter - before(:all) do - @original_rspec_options = $rspec_options - end + class ExampleModuleScopingSpec < ExampleGroup + describe ExampleGroup, "via a class definition" - before(:each) do - @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) - $rspec_options = @options - options.formatters << mock("formatter", :null_object => true) - options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true) - @reporter = FakeReporter.new(@options) - options.reporter = reporter - @example_group = Class.new(ExampleGroup) do - describe("example") - it "does nothing" - end - class << example_group - public :include + module Foo + module Bar + def self.loaded? + true + end end - @result = nil end + include Foo - after(:each) do - $rspec_options = @original_rspec_options - ExampleGroup.reset + it "should understand module scoping" do + Bar.should be_loaded end - describe ExampleGroup, ".describe" do - attr_reader :child_example_group - before do - @child_example_group = @example_group.describe("Another ExampleGroup") do - it "should pass" do - true.should be_true - end - end - end + @@foo = 1 - it "should create a subclass of the ExampleGroup when passed a block" do - child_example_group.superclass.should == @example_group - @options.example_groups.should include(child_example_group) - end + it "should allow class variables to be defined" do + @@foo.should == 1 + end + end - it "should not inherit examples" do - child_example_group.examples.length.should == 1 - end + class ExampleClassVariablePollutionSpec < ExampleGroup + describe ExampleGroup, "via a class definition without a class variable" + + it "should not retain class variables from other Example classes" do + proc do + @@foo + end.should raise_error end + end - describe ExampleGroup, ".it" do - it "should should create an example instance" do - lambda { - @example_group.it("") - }.should change { @example_group.examples.length }.by(1) - end + describe ExampleGroup, "#pending" do + it "should raise a Pending error when its block fails" do + block_ran = false + lambda { + pending("something") do + block_ran = true + raise "something wrong with my example" + end + }.should raise_error(Spec::Example::ExamplePendingError, "something") + block_ran.should == true end - describe ExampleGroup, ".xit" do - before(:each) do - Kernel.stub!(:warn) - end + it "should raise Spec::Example::PendingExampleFixedError when its block does not fail" do + block_ran = false + lambda { + pending("something") do + block_ran = true + end + }.should raise_error(Spec::Example::PendingExampleFixedError, "Expected pending 'something' to fail. No Error was raised.") + block_ran.should == true + end + end + + describe ExampleGroup, "#run with failure in example", :shared => true do + it "should add an example failure to the TestResult" do + example_group.run.should be_false + end + end - it "should NOT should create an example instance" do - lambda { - @example_group.xit("") - }.should_not change(@example_group.examples, :length) + describe ExampleGroup, "#run" do + with_sandboxed_options do + attr_reader :example_group, :formatter, :reporter + before :each do + method_with_three_args = lambda { |arg1, arg2, arg3| } + @formatter = mock("formatter", :null_object => true, :example_pending => method_with_three_args) + options.formatters << formatter + options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true) + @reporter = FakeReporter.new(options) + options.reporter = reporter + @example_group = Class.new(ExampleGroup) do + describe("example") + it "does nothing" do + end + end + class << example_group + public :include + end end - it "should warn that it is disabled" do - Kernel.should_receive(:warn).with("Example disabled: foo") - @example_group.xit("foo") + after :each do + ExampleGroup.reset end - end - describe ExampleGroup, ".suite" do - it "should return an empty ExampleSuite when there is no description" do - ExampleGroup.description.should be_nil - ExampleGroup.suite.should be_instance_of(ExampleSuite) - ExampleGroup.suite.tests.should be_empty + it "should not run when there are no examples" do + example_group = Class.new(ExampleGroup) do + describe("Foobar") + end + example_group.examples.should be_empty + + reporter = mock("Reporter") + reporter.should_not_receive(:add_example_group) + example_group.run end + + describe "when before_each fails" do + before(:each) do + $example_ran = $after_each_ran = false + @example_group = describe("Foobar") do + before(:each) {raise} + it "should not be run" do + $example_ran = true + end + after(:each) do + $after_each_ran = true + end + end + end - it "should return an ExampleSuite with Examples" do - behaviour = Class.new(ExampleGroup) do - describe('example') - it "should pass" do - 1.should == 1 + it "should not run example block" do + example_group.run + $example_ran.should be_false + end + + it "should run after_each" do + example_group.run + $after_each_ran.should be_true + end + + it "should report failure location when in before_each" do + reporter.should_receive(:example_finished) do |example_group, error| + error.message.should eql("in before_each") end + example_group.run end - suite = behaviour.suite - suite.tests.length.should == 1 - suite.tests.first._example.description.should == "should pass" end - it "should include methods that begin with test and has an arity of 0 in suite" do - behaviour = Class.new(ExampleGroup) do - describe('example') - def test_any_args(*args) - true.should be_true - end - def test_something - 1.should == 1 - end - def test - raise "This is not a real test" - end - def testify - raise "This is not a real test" - end + describe ExampleGroup, "#run on dry run" do + before do + @options.dry_run = true + end + + it "should not run before(:all) or after(:all)" do + before_all_ran = false + after_all_ran = false + ExampleGroup.before(:all) { before_all_ran = true } + ExampleGroup.after(:all) { after_all_ran = true } + example_group.it("should") {} + example_group.run + before_all_ran.should be_false + after_all_ran.should be_false + end + + it "should not run example" do + example_ran = false + example_group.it("should") {example_ran = true} + example_group.run + example_ran.should be_false end - suite = behaviour.suite - suite.tests.length.should == 2 - descriptions = suite.tests.collect {|test| test._example.description}.sort - descriptions.should == ["test_any_args", "test_something"] - suite.run.should be_true end - it "should include methods that begin with should and has an arity of 0 in suite" do - behaviour = Class.new(ExampleGroup) do - describe('example') - def shouldCamelCase - true.should be_true + describe ExampleGroup, "#run with specified examples" do + attr_reader :examples_that_were_run + before do + @examples_that_were_run = [] + end + + describe "when specified_examples matches entire ExampleGroup" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroup) do + describe("the ExampleGroup") + it("should be run") do + examples_that_were_run << 'should be run' + end + + it("should also be run") do + examples_that_were_run << 'should also be run' + end + end + options.examples = ["the ExampleGroup"] end - def should_any_args(*args) - true.should be_true + + it "should not run the Examples in the ExampleGroup" do + example_group.run + examples_that_were_run.should == ['should be run', 'should also be run'] end - def should_something - 1.should == 1 + end + + describe ExampleGroup, "#run when specified_examples matches only Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroup) do + describe("example") + it("should be run") do + examples_that_were_run << 'should be run' + end + end + options.examples = ["should be run"] end - def should_not_something - 1.should_not == 2 + + it "should not run the example" do + example_group.run + examples_that_were_run.should == ['should be run'] end - def should - raise "This is not a real example" + end + + describe ExampleGroup, "#run when specified_examples does not match an Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroup) do + describe("example") + it("should be something else") do + examples_that_were_run << 'should be something else' + end + end + options.examples = ["does not match anything"] end - def should_not - raise "This is not a real example" + + it "should not run the example" do + example_group.run + examples_that_were_run.should == [] end end - behaviour = behaviour.dup - suite = behaviour.suite - suite.tests.length.should == 4 - descriptions = suite.tests.collect {|test| test._example.description}.sort - descriptions.should include("shouldCamelCase") - descriptions.should include("should_any_args") - descriptions.should include("should_something") - descriptions.should include("should_not_something") - end - it "should not include methods that begin with test_ and has an arity > 0 in suite" do - behaviour = Class.new(ExampleGroup) do - describe('example') - def test_invalid(foo) - 1.should == 1 + describe ExampleGroup, "#run when specified_examples matches an Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroup) do + describe("example") + it("should be run") do + examples_that_were_run << 'should be run' + end + it("should not be run") do + examples_that_were_run << 'should not be run' + end + end + options.examples = ["should be run"] end - def testInvalidCamelCase(foo) - 1.should == 1 + + it "should run only the example, when there is only one" do + example_group.run + examples_that_were_run.should == ["should be run"] end + + it "should run only the one example" do + example_group.run + examples_that_were_run.should == ["should be run"] end end - suite = behaviour.suite - suite.tests.length.should == 0 end - it "should not include methods that begin with should_ and has an arity > 0 in suite" do - behaviour = Class.new(ExampleGroup) do - describe('example') - def should_invalid(foo) - 1.should == 1 - end - def shouldInvalidCamelCase(foo) - 1.should == 1 - end - def should_not_invalid(foo) - 1.should == 1 + describe ExampleGroup, "#run with success" do + before do + @special_example_group = Class.new(ExampleGroup) + ExampleGroupFactory.register(:special, @special_example_group) + @not_special_example_group = Class.new(ExampleGroup) + ExampleGroupFactory.register(:not_special, @not_special_example_group) + end + + after do + ExampleGroupFactory.reset + end + + it "should send reporter add_example_group" do + example_group.run + reporter.example_groups.should == [example_group] + end + + it "should run example on run" do + example_ran = false + example_group.it("should") {example_ran = true} + example_group.run + example_ran.should be_true + end + + it "should run before(:all) block only once" do + before_all_run_count_run_count = 0 + example_group.before(:all) {before_all_run_count_run_count += 1} + example_group.it("test") {true} + example_group.it("test2") {true} + example_group.run + before_all_run_count_run_count.should == 1 + end + + it "should run after(:all) block only once" do + after_all_run_count = 0 + example_group.after(:all) {after_all_run_count += 1} + example_group.it("test") {true} + example_group.it("test2") {true} + example_group.run + after_all_run_count.should == 1 + @reporter.rspec_verify + end + + it "after(:all) should have access to all instance variables defined in before(:all)" do + context_instance_value_in = "Hello there" + context_instance_value_out = "" + example_group.before(:all) { @instance_var = context_instance_value_in } + example_group.after(:all) { context_instance_value_out = @instance_var } + example_group.it("test") {true} + example_group.run + context_instance_value_in.should == context_instance_value_out + end + + it "should copy instance variables from before(:all)'s execution context into spec's execution context" do + context_instance_value_in = "Hello there" + context_instance_value_out = "" + example_group.before(:all) { @instance_var = context_instance_value_in } + example_group.it("test") {context_instance_value_out = @instance_var} + example_group.run + context_instance_value_in.should == context_instance_value_out + end + + it "should not add global before callbacks for untargetted example_group" do + fiddle = [] + + ExampleGroup.before(:all) { fiddle << "Example.before(:all)" } + ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" } + @special_example_group.before(:each) { fiddle << "Example.before(:each, :type => :special)" } + @special_example_group.prepend_before(:each) { fiddle << "Example.prepend_before(:each, :type => :special)" } + @special_example_group.before(:all) { fiddle << "Example.before(:all, :type => :special)" } + @special_example_group.prepend_before(:all) { fiddle << "Example.prepend_before(:all, :type => :special)" } + + example_group = Class.new(ExampleGroup) do + describe("I'm not special", :type => :not_special) + it "does nothing" end + example_group.run + fiddle.should == [ + 'Example.prepend_before(:all)', + 'Example.before(:all)', + ] end - suite = behaviour.suite - suite.tests.length.should == 0 - end - end - describe ExampleGroup, ".description" do - it "should return the same description instance for each call" do - @example_group.description.should eql(@example_group.description) - end - end + it "should add global before callbacks for targetted example_groups" do + fiddle = [] + + ExampleGroup.before(:all) { fiddle << "Example.before(:all)" } + ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" } + @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" } + @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" } + @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" } + @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" } + @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" } + + example_group = Class.new(@special_example_group).describe("I'm a special example_group") {} + example_group.it("test") {true} + example_group.run + fiddle.should == [ + 'Example.prepend_before(:all)', + 'Example.before(:all)', + 'special.prepend_before(:all, :type => :special)', + 'special.before(:all, :type => :special)', + 'special.prepend_before(:each, :type => :special)', + 'special.before(:each, :type => :special)', + 'special.append_before(:each, :type => :special)', + ] + end - describe ExampleGroup, ".remove_after" do - it "should unregister a given after(:each) block" do - after_all_ran = false - @example_group.it("example") {} - proc = Proc.new { after_all_ran = true } - ExampleGroup.after(:each, &proc) - suite = @example_group.suite - suite.run - after_all_ran.should be_true - - after_all_ran = false - ExampleGroup.remove_after(:each, &proc) - suite = @example_group.suite - suite.run - after_all_ran.should be_false - end - end + it "should order before callbacks from global to local" do + fiddle = [] + ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" } + ExampleGroup.before(:all) { fiddle << "Example.before(:all)" } + example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" } + example_group.before(:all) { fiddle << "before(:all)" } + example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" } + example_group.before(:each) { fiddle << "before(:each)" } + example_group.run + fiddle.should == [ + 'Example.prepend_before(:all)', + 'Example.before(:all)', + 'prepend_before(:all)', + 'before(:all)', + 'prepend_before(:each)', + 'before(:each)' + ] + end + + it "should order after callbacks from local to global" do + fiddle = [] + example_group.after(:each) { fiddle << "after(:each)" } + example_group.append_after(:each) { fiddle << "append_after(:each)" } + example_group.after(:all) { fiddle << "after(:all)" } + example_group.append_after(:all) { fiddle << "append_after(:all)" } + ExampleGroup.after(:all) { fiddle << "Example.after(:all)" } + ExampleGroup.append_after(:all) { fiddle << "Example.append_after(:all)" } + example_group.run + fiddle.should == [ + 'after(:each)', + 'append_after(:each)', + 'after(:all)', + 'append_after(:all)', + 'Example.after(:all)', + 'Example.append_after(:all)' + ] + end - describe ExampleGroup, ".include" do - it "should have accessible class methods from included module" do - mod1_method_called = false - mod1 = Module.new do - class_methods = Module.new do + it "should have accessible instance methods from included module" do + mod1_method_called = false + mod1 = Module.new do define_method :mod1_method do mod1_method_called = true end end - metaclass.class_eval do - define_method(:included) do |receiver| - receiver.extend class_methods + mod2_method_called = false + mod2 = Module.new do + define_method :mod2_method do + mod2_method_called = true end end + + example_group.include mod1, mod2 + + example_group.it("test") do + mod1_method + mod2_method + end + example_group.run + mod1_method_called.should be_true + mod2_method_called.should be_true end - mod2_method_called = false - mod2 = Module.new do - class_methods = Module.new do - define_method :mod2_method do - mod2_method_called = true - end + it "should include targetted modules included using configuration" do + mod1 = Module.new + mod2 = Module.new + mod3 = Module.new + Spec::Runner.configuration.include(mod1, mod2) + Spec::Runner.configuration.include(mod3, :type => :not_special) + + example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do + it "does nothing" end + example_group.run + + example_group.included_modules.should include(mod1) + example_group.included_modules.should include(mod2) + example_group.included_modules.should_not include(mod3) + end - metaclass.class_eval do - define_method(:included) do |receiver| - receiver.extend class_methods + it "should include any predicate_matchers included using configuration" do + $included_predicate_matcher_found = false + Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something? + example_group = Class.new(ExampleGroup) do + describe('example') + it "should respond to do_something" do + $included_predicate_matcher_found = respond_to?(:do_something) end end + example_group.run + $included_predicate_matcher_found.should be(true) end - @example_group.include mod1, mod2 + it "should use a mock framework set up in config" do + mod = Module.new do + def self.included(mod) + $included_module = mod + end - @example_group.mod1_method - @example_group.mod2_method - mod1_method_called.should be_true - mod2_method_called.should be_true - end - end + def teardown_mocks_for_rspec + $torn_down = true + end + end - describe ExampleGroup, ".number_of_examples" do - it "should count number of specs" do - proc do - @example_group.it("one") {} - @example_group.it("two") {} - @example_group.it("three") {} - @example_group.it("four") {} - end.should change {@example_group.number_of_examples}.by(4) - end - end + begin + $included_module = nil + $torn_down = true + Spec::Runner.configuration.mock_with mod + + example_group = Class.new(ExampleGroup) do + describe('example') + it "does nothing" + end + example_group.run - describe ExampleGroup, ".class_eval" do - it "should allow constants to be defined" do - behaviour = Class.new(ExampleGroup) do - describe('example') - FOO = 1 - it "should reference FOO" do - FOO.should == 1 + $included_module.should_not be_nil + $torn_down.should == true + ensure + Spec::Runner.configuration.mock_with :rspec end end - suite = behaviour.suite - suite.run - Object.const_defined?(:FOO).should == false end - end - describe ExampleGroup, '.register' do - it "should add ExampleGroup to set of ExampleGroups to be run" do - example_group.register - options.example_groups.should include(example_group) - end - end + describe ExampleGroup, "#run with pending example that has a failing assertion" do + before do + example_group.it("should be pending") do + pending("Example fails") {false.should be_true} + end + end - describe ExampleGroup, '.unregister' do - before do - example_group.register - options.example_groups.should include(example_group) + it "should send example_pending to formatter" do + @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails") + example_group.run + end end - it "should remove ExampleGroup from set of ExampleGroups to be run" do - example_group.unregister - options.example_groups.should_not include(example_group) - end - end - end + describe ExampleGroup, "#run with pending example that does not have a failing assertion" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - class ExampleModuleScopingSpec < ExampleGroup - describe ExampleGroup, " via a class definition" + before do + example_group.it("should be pending") do + pending("Example passes") {true.should be_true} + end + end - module Foo - module Bar - def self.loaded? - true + it "should send example_pending to formatter" do + @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes") + example_group.run end end - end - include Foo - - it "should understand module scoping" do - Bar.should be_loaded - end - @@foo = 1 + describe ExampleGroup, "#run when before(:all) fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - it "should allow class variables to be defined" do - @@foo.should == 1 - end - end + before do + ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" } + end - class ExampleClassVariablePollutionSpec < ExampleGroup - describe ExampleGroup, " via a class definition without a class variable" + it "should not run any example" do + spec_ran = false + example_group.it("test") {spec_ran = true} + example_group.run + spec_ran.should be_false + end - it "should not retain class variables from other Example classes" do - proc do - @@foo - end.should raise_error - end - end + it "should run ExampleGroup after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run + after_all_ran.should be_true + end - describe ExampleGroup, '.run functional example' do - def count - @count ||= 0 - @count = @count + 1 - @count - end + it "should run example_group after(:all)" do + after_all_ran = false + example_group.after(:all) { after_all_ran = true } + example_group.run + after_all_ran.should be_true + end - before(:all) do - count.should == 1 - end + it "should supply before(:all) as description" do + @reporter.should_receive(:failure) do |example, error| + example.description.should eql("before(:all)") + error.message.should eql("before(:all) failure") + end - before(:all) do - count.should == 2 - end + example_group.it("test") {true} + example_group.run + end + end - before(:each) do - count.should == 3 - end + describe ExampleGroup, "#run when before(:each) fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - before(:each) do - count.should == 4 - end + before do + ExampleGroup.before(:each) { raise NonStandardError } + end - it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do - count.should == 5 - end + it "should run after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run + after_all_ran.should be_true + end + end - after(:each) do - count.should == 7 - end + describe ExampleGroup, "#run when any example fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - after(:each) do - count.should == 6 - end + before do + example_group.it("should") { raise NonStandardError } + end - after(:all) do - count.should == 9 - end + it "should run after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run + after_all_ran.should be_true + end + end - after(:all) do - count.should == 8 - end - end + describe ExampleGroup, "#run when first after(:each) block fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - describe ExampleGroup, "#initialize" do - the_behaviour = self - it "should have copy of behaviour" do - the_behaviour.superclass.should == ExampleGroup - end - end + before do + class << example_group + attr_accessor :first_after_ran, :second_after_ran + end + example_group.first_after_ran = false + example_group.second_after_ran = false - describe ExampleGroup, "#pending" do - it "should raise a Pending error when its block fails" do - block_ran = false - lambda { - pending("something") do - block_ran = true - raise "something wrong with my example" + example_group.after(:each) do + self.class.second_after_ran = true + end + example_group.after(:each) do + self.class.first_after_ran = true + raise "first" + end end - }.should raise_error(Spec::Example::ExamplePendingError, "something") - block_ran.should == true - end - it "should raise Spec::Example::PendingExampleFixedError when its block does not fail" do - block_ran = false - lambda { - pending("something") do - block_ran = true + it "should run second after(:each) block" do + reporter.should_receive(:example_finished) do |example, error| + example.should equal(example) + error.message.should eql("first") + end + example_group.run + example_group.first_after_ran.should be_true + example_group.second_after_ran.should be_true end - }.should raise_error(Spec::Example::PendingExampleFixedError, "Expected pending 'something' to fail. No Error was raised.") - block_ran.should == true - end - end + end - describe ExampleGroup, "#run" do - before do - @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) - @original_rspec_options = $rspec_options - $rspec_options = @options - end + describe ExampleGroup, "#run when first before(:each) block fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" - after do - $rspec_options = @original_rspec_options - end + before do + class << example_group + attr_accessor :first_before_ran, :second_before_ran + end + example_group.first_before_ran = false + example_group.second_before_ran = false + + example_group.before(:each) do + self.class.first_before_ran = true + raise "first" + end + example_group.before(:each) do + self.class.second_before_ran = true + end + end - it "should not run when there are no examples" do - behaviour = Class.new(ExampleGroup) do - describe("Foobar") + it "should not run second before(:each)" do + reporter.should_receive(:example_finished) do |name, error| + error.message.should eql("first") + end + example_group.run + example_group.first_before_ran.should be_true + example_group.second_before_ran.should be_false + end end - behaviour.examples.should be_empty - reporter = mock("Reporter") - reporter.should_not_receive(:add_example_group) - suite = behaviour.suite - suite.run + describe ExampleGroup, "#run when failure in after(:all)" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + ExampleGroup.after(:all) { raise NonStandardError, "in after(:all)" } + end + + it "should return false" do + example_group.run.should be_false + end + end end end @@ -432,36 +656,19 @@ module Spec end it "should have access to the described_type" do - behaviour = Class.new(ExampleSubclass) do + example_group = Class.new(ExampleSubclass) do describe(Array) end - behaviour.send(:described_type).should == Array - end - end - - describe Enumerable do - def each(&block) - ["4", "2", "1"].each(&block) + example_group.__send__(:described_type).should == Array end - it "should be included in examples because it is a module" do - map{|e| e.to_i}.should == [4,2,1] - end - end - - describe "An", Enumerable, "as a second argument" do - def each(&block) - ["4", "2", "1"].each(&block) - end - - it "should be included in examples because it is a module" do - map{|e| e.to_i}.should == [4,2,1] - end - end - - describe String do - it "should not be included in examples because it is not a module" do - lambda{self.map}.should raise_error(NoMethodError, /undefined method `map' for/) + it "should concat descriptions when nested" do + example_group = Class.new(ExampleSubclass) do + describe(Array) + $nested_group = describe("when empty") do + end + end + $nested_group.description.to_s.should == "Array when empty" end end end vendor/plugins/rspec/spec/spec/example/example_group_spec.rb @@ -2,60 +2,43 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Example - module ExampleMatcherSpecHelper - class MatchDescription - def initialize(description) - @description = description - end - - def matches?(matcher) - matcher.matches?(@description) - end - - def failure_message - "expected matcher.matches?(#{@description.inspect}) to return true, got false" - end - - def negative_failure_message - "expected matcher.matches?(#{@description.inspect}) to return false, got true" - end - end + describe ExampleMatcher, "#matches?" do def match_description(description) - MatchDescription.new(description) + simple_matcher do |actual, matcher| + matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false" + matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true" + actual.matches?(description) + end end - end - - describe ExampleMatcher, "#matches?" do - include ExampleMatcherSpecHelper - it "should match correct behaviour and example" do - matcher = ExampleMatcher.new("behaviour", "example") - matcher.should match_description("behaviour example") + it "should match correct example_group and example" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_description("example_group example") end it "should not match wrong example" do - matcher = ExampleMatcher.new("behaviour", "other example") - matcher.should_not match_description("behaviour example") + matcher = ExampleMatcher.new("example_group", "other example") + matcher.should_not match_description("example_group example") end - it "should not match wrong behaviour" do - matcher = ExampleMatcher.new("other behaviour", "example") - matcher.should_not match_description("behaviour example") + it "should not match wrong example_group" do + matcher = ExampleMatcher.new("other example_group", "example") + matcher.should_not match_description("example_group example") end it "should match example only" do - matcher = ExampleMatcher.new("behaviour", "example") + matcher = ExampleMatcher.new("example_group", "example") matcher.should match_description("example") end - it "should match behaviour only" do - matcher = ExampleMatcher.new("behaviour", "example") - matcher.should match_description("behaviour") + it "should match example_group only" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_description("example_group") end - it "should match behaviour ending with before(:all)" do - matcher = ExampleMatcher.new("behaviour", "example") - matcher.should match_description("behaviour before(:all)") + it "should match example_group ending with before(:all)" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_description("example_group before(:all)") end it "should escape regexp chars" do @@ -63,7 +46,7 @@ module Spec matcher.should_not match_description("con p") end - it "should match when behaviour is modularized" do + it "should match when example_group is modularized" do matcher = ExampleMatcher.new("MyModule::MyClass", "example") matcher.should match_description("MyClass example") end vendor/plugins/rspec/spec/spec/example/example_matcher_spec.rb @@ -14,62 +14,308 @@ module Spec end end - describe "ExampleMethods with an included module that is reopened" do - it "should have repoened methods" do - method(:module_that_is_reopened_method).should_not be_nil + describe ExampleMethods do + describe "with an included module that is reopened" do + it "should have repoened methods" do + method(:module_that_is_reopened_method).should_not be_nil + end end - end - describe ExampleMethods, " lifecycle" do - before do - @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) - @options.formatters << mock("formatter", :null_object => true) - @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true) - @reporter = FakeReporter.new(@options) - @options.reporter = @reporter - - ExampleMethods.before_all_parts.should == [] - ExampleMethods.before_each_parts.should == [] - ExampleMethods.after_each_parts.should == [] - ExampleMethods.after_all_parts.should == [] - def ExampleMethods.count - @count ||= 0 - @count = @count + 1 - @count + describe "lifecycle" do + with_sandboxed_options do + before do + @options.formatters << mock("formatter", :null_object => true) + @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true) + @reporter = FakeReporter.new(@options) + @options.reporter = @reporter + + ExampleGroup.before_all_parts.should == [] + ExampleGroup.before_each_parts.should == [] + ExampleGroup.after_each_parts.should == [] + ExampleGroup.after_all_parts.should == [] + def ExampleGroup.count + @count ||= 0 + @count = @count + 1 + @count + end + end + + after do + ExampleGroup.instance_variable_set("@before_all_parts", []) + ExampleGroup.instance_variable_set("@before_each_parts", []) + ExampleGroup.instance_variable_set("@after_each_parts", []) + ExampleGroup.instance_variable_set("@after_all_parts", []) + end + + it "should pass before and after callbacks to all ExampleGroup subclasses" do + ExampleGroup.before(:suite) do + ExampleGroup.count.should == 1 + end + + ExampleGroup.before(:all) do + ExampleGroup.count.should == 2 + end + + ExampleGroup.before(:each) do + ExampleGroup.count.should == 3 + end + + ExampleGroup.after(:each) do + ExampleGroup.count.should == 4 + end + + ExampleGroup.after(:all) do + ExampleGroup.count.should == 5 + end + + ExampleGroup.after(:suite) do + ExampleGroup.count.should == 6 + end + + Class.new(ExampleGroup) do + it "should use ExampleMethods callbacks" do end + end + @options.run_examples + ExampleGroup.count.should == 7 + end + + describe "eval_block" do + before(:each) do + @example_group = Class.new(ExampleGroup) + end + + describe "with a given description" do + it "should provide the given description" do + @example = @example_group.it("given description") { 2.should == 2 } + @example.eval_block + @example.description.should == "given description" + end + end + + describe "with no given description" do + it "should provide the generated description" do + @example = @example_group.it { 2.should == 2 } + @example.eval_block + @example.description.should == "should == 2" + end + end + + describe "with no implementation" do + it "should raise an NotYetImplementedError" do + lambda { + @example = @example_group.it + @example.eval_block + }.should raise_error(Spec::Example::NotYetImplementedError, "Not Yet Implemented") + end + + def extract_error(&blk) + begin + blk.call + rescue Exception => e + return e + end + + nil + end + + it "should use the proper file and line number for the NotYetImplementedError" do + file = __FILE__ + line_number = __LINE__ + 3 + + error = extract_error do + @example = @example_group.it + @example.eval_block + end + + error.pending_caller.should == "#{file}:#{line_number}" + end + end + end end end - after do - ExampleMethods.instance_variable_set("@before_all_parts", []) - ExampleMethods.instance_variable_set("@before_each_parts", []) - ExampleMethods.instance_variable_set("@after_each_parts", []) - ExampleMethods.instance_variable_set("@after_all_parts", []) + describe "#backtrace" do + with_sandboxed_options do + it "returns the backtrace from where the example was defined" do + example_group = Class.new(ExampleGroup) do + example "of something" do; end + end + + example = example_group.examples.first + example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}") + end + end end + + describe "#implementation_backtrace (deprecated)" do + with_sandboxed_options do + before(:each) do + Kernel.stub!(:warn) + end - it "should pass before and after callbacks to all ExampleGroup subclasses" do - ExampleMethods.before(:all) do - ExampleMethods.count.should == 1 + it "sends a deprecation warning" do + example_group = Class.new(ExampleGroup) {} + example = example_group.example("") {} + Kernel.should_receive(:warn).with(/#implementation_backtrace.*deprecated.*#backtrace instead/m) + example.implementation_backtrace + end + + it "returns the backtrace from where the example was defined" do + example_group = Class.new(ExampleGroup) do + example "of something" do; end + end + + example = example_group.examples.first + example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}") + end end + end - ExampleMethods.before(:each) do - ExampleMethods.count.should == 2 + describe "#full_description" do + it "should return the full description of the ExampleGroup and Example" do + example_group = Class.new(ExampleGroup).describe("An ExampleGroup") do + it "should do something" do + end + end + example = example_group.examples.first + example.full_description.should == "An ExampleGroup should do something" end - - ExampleMethods.after(:each) do - ExampleMethods.count.should == 3 + end + + describe "#subject" do + with_sandboxed_options do + it "should return an instance variable named after the described type" do + example_group = Class.new(ExampleGroup).describe(Array) do + example {} + end + example = example_group.examples.first + example.subject.should == [] + end + + it "should not barf on a module (as opposed to a class)" do + example_group = Class.new(ExampleGroup).describe(ObjectSpace) do + example {} + end + example_group.examples.first.subject.should be_nil + end + + it "should not barf on a string" do + example_group = Class.new(ExampleGroup).describe('foo') do + example {} + end + example_group.examples.first.subject.should be_nil + end + + it "should interact with the same scope as the before block" do + example_group = Class.new(ExampleGroup) do + subject { @foo = 'foo'} + example { should == @foo} + it { should == 'foo'} + end + example_group.run.should be_true + end end + end + + describe "#should" do + with_sandboxed_options do + class Thing + def ==(other) + true + end + end + + describe "in an ExampleGroup with the ivar defined in before" do + attr_reader :example, :success + + before(:each) do + example_group = describe(Thing, "1") do + before(:each) { @spec_example_thing = 'expected' } + it { should eql('expected') } + end + @example = example_group.examples.first + @success = example_group.run + end + + it "should create an example using the description from the matcher" do + example.description.should == 'should eql "expected"' + end - ExampleMethods.after(:all) do - ExampleMethods.count.should == 4 + it "should test the matcher returned from the block" do + success.should be_true + end + end + + describe "in an ExampleGroup with the subject defined using #subject" do + it "should create an example using the description from the matcher" do + example_group = describe(Thing, "2") do + subject {'this is the subject'} + it { should eql('this is the subject') } + end + example = example_group.examples.first + example_group.run + example.description.should =~ /should eql "this is the subject"/ + end + end + + describe "in an ExampleGroup using an implicit ivar" do + it "should create an example using the description from the matcher" do + example_group = describe(Thing, "3") do + it { should == Thing.new } + end + example = example_group.examples.first + success = example_group.run + example.description.should =~ /should == #<Spec::Example::Thing/ + success.should be_true + end + end + + after(:each) do + ExampleGroup.reset + end + end + end + + describe "#should_not" do + with_sandboxed_options do - @example_group = Class.new(ExampleGroup) do - it "should use ExampleMethods callbacks" do + attr_reader :example_group, :example, :success + + before do + @example_group = Class.new(ExampleGroup) do + def subject; @actual; end + before(:each) { @actual = 'expected' } + it { should_not eql('unexpected') } + end + @example = @example_group.examples.first + + @success = example_group.run + end + + it "should create an example using the description from the matcher" do + example.description.should == 'should not eql "unexpected"' end + + it "should test the matcher returned from the block" do + success.should be_true + end + + after do + ExampleGroup.reset + end + end - @example_group.suite.run - ExampleMethods.count.should == 5 end end + + describe "#options" do + it "should expose the options hash" do + example_group = Class.new(ExampleGroup) + example = example_group.example "name", :this => 'that' do; end + example.options[:this].should == 'that' + end + end + end -end \ No newline at end of file +end vendor/plugins/rspec/spec/spec/example/example_methods_spec.rb @@ -2,249 +2,193 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Example - describe ExampleRunner, "#run", :shared => true do - before(:each) do - @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) - @reporter = ::Spec::Runner::Reporter.new(@options) - @options.reporter = @reporter - @example_group_class = Class.new(ExampleGroup) do - describe("Some Examples") - end - end - - def create_runner(example_definition) - example = @example_group_class.new(example_definition) - runner = ExampleRunner.new(@options, example) - runner.stub!(:verify_mocks) - runner.stub!(:teardown_mocks) - runner - end - end - - describe ExampleRunner, "#run with blank passing example" do - it_should_behave_like "Spec::Example::ExampleRunner#run" - - before do - @e = @example_group_class.it("example") {} - @runner = create_runner(@e) - end - - it "should send reporter example_started" do - @reporter.should_receive(:example_started).with(equal(@e)) - @runner.run - end - - it "should report its name for dry run" do - @options.dry_run = true - @reporter.should_receive(:example_finished).with(equal(@e), nil, "example") - @runner.run - end - - it "should report success" do - @reporter.should_receive(:example_finished).with(equal(@e), nil, nil) - @runner.run - end - end - - describe ExampleRunner, "#run with a failing example" do - predicate_matchers[:is_a] = [:is_a?] - it_should_behave_like "Spec::Example::ExampleRunner#run" - - before do - @e = @example_group_class.it("example") do - (2+2).should == 5 - end - @runner = create_runner(@e) - end - - it "should report failure due to failure" do - @reporter.should_receive(:example_finished).with( - equal(@e), - is_a(Spec::Expectations::ExpectationNotMetError), - "example" - ) - @runner.run - end - end - - describe ExampleRunner, "#run with a erroring example" do - it_should_behave_like "Spec::Example::ExampleRunner#run" - - before do - @error = error = NonStandardError.new("in body") - @example_definition = @example_group_class.it("example") do - raise(error) - end - @runner = create_runner(@example_definition) - end - - it "should report failure due to error" do - @reporter.should_receive(:example_finished).with( - equal(@example_definition), - @error, - "example" - ) - @runner.run - end - - it "should run after_each block" do - @example_group_class.after(:each) do - raise("in after_each") - end - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.should equal(@example_definition) - location.should eql("example") - error.message.should eql("in body") - end - @runner.run - end - end - - describe ExampleRunner, "#run where before_each fails" do - it_should_behave_like "Spec::Example::ExampleRunner#run" - - before do - @example_ran = example_ran = false - @example_definition = @example_group_class.it("should not run") do - example_ran = true - end - @runner = create_runner(@example_definition) - @example_group_class.before(:each) {raise NonStandardError, "in before_each"} - end - - it "should not run example block if before_each fails" do - @runner.run - @example_ran.should == false - end - - it "should run after_each block" do - after_each_ran = false - @example_group_class.after(:each) {after_each_ran = true} - @runner.run - after_each_ran.should == true - end - - it "should report failure location when in before_each" do - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.should equal(@example_definition) - error.message.should eql("in before_each") - location.should eql("before(:each)") - end - @runner.run - end - end - - describe ExampleRunner, "#run where after_each fails" do - it_should_behave_like "Spec::Example::ExampleRunner#run" - - before do - @example_ran = example_ran = false - @example_definition = @example_group_class.it("should not run") do - example_ran = true - end - @runner = create_runner(@example_definition) - @example_group_class.after(:each) { raise(NonStandardError.new("in after_each")) } - end - - it "should report failure location when in after_each" do - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.should equal(@example_definition) - error.message.should eql("in after_each") - location.should eql("after(:each)") - end - @runner.run - end - end - - describe ExampleRunner, "#run with use cases" do - predicate_matchers[:is_a] = [:is_a?] - it_should_behave_like "Spec::Example::ExampleRunner#run" - - it "should run example block in scope of example" do - scope_object = nil - @example_definition = @example_group_class.it("should pass") do - self.instance_of?(Example).should == false - scope_object = self - end - @runner = create_runner(@example_definition) - @example_group_instance = @runner.example_group_instance - - @reporter.should_receive(:example_finished).with(equal(@example_definition), nil, nil) - @runner.run - - scope_object.should == @example_group_instance - scope_object.should be_instance_of(@example_group_class) - end - - it "should report NO NAME when told to use generated description with --dry-run" do - @options.dry_run = true - example_definition = @example_group_class.it(:__generate_docstring) do - 5.should == 5 - end - runner = create_runner(example_definition) - - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.description.should == "NO NAME (Because of --dry-run)" - location.should == "NO NAME (Because of --dry-run)" - end - runner.run - end - - it "should report given name if present with --dry-run" do - @options.dry_run = true - example_definition = @example_group_class.it("example name") do - 5.should == 5 - end - runner = create_runner(example_definition) - - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.description.should == "example name" - location.should == "example name" - end - runner.run - end - - it "should report NO NAME when told to use generated description with no expectations" do - example_definition = @example_group_class.it(:__generate_docstring) {} - runner = create_runner(example_definition) - @reporter.should_receive(:example_finished) do |example, error, location| - example.description.should == "NO NAME (Because there were no expectations)" - end - runner.run - end - - it "should report NO NAME when told to use generated description and matcher fails" do - example_definition = @example_group_class.it(:__generate_docstring) do - 5.should "" # Has no matches? method.. - end - runner = create_runner(example_definition) - - @reporter.should_receive(:example_finished) do |example, error, location| - example_definition.description.should == "NO NAME (Because of Error raised in matcher)" - location.should == "NO NAME (Because of Error raised in matcher)" - end - runner.run - end - - it "should report generated description when told to and it is available" do - example_definition = @example_group_class.it(:__generate_docstring) { - 5.should == 5 - } - runner = create_runner(example_definition) - - @reporter.should_receive(:example_finished) do |example_definition, error, location| - example_definition.description.should == "should == 5" - end - runner.run - end - - it "should unregister description_generated callback (lest a memory leak should build up)" do - example_definition = @example_group_class.it("something") - runner = create_runner(example_definition) - - Spec::Matchers.should_receive(:clear_generated_description) - runner.run - end - end + # describe "Spec::Example::ExampleRunner", "#run", :shared => true do + # before(:each) do + # @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) + # @reporter = ::Spec::Runner::Reporter.new(@options) + # @options.reporter = @reporter + # @example_group_class = Class.new(ExampleGroup) do + # plugin_mock_framework + # describe("Some Examples") + # end + # end + # + # def create_runner(example_definition) + # example = @example_group_class.new(example_definition) + # runner = ExampleGroup.new(@options, example) + # runner.stub!(:verify_mocks) + # runner.stub!(:teardown_mocks) + # runner + # end + # end + # + # describe ExampleRunner, "#run with blank passing example" do + # it_should_behave_like "Spec::Example::ExampleRunner#run" + # + # before do + # @e = @example_group_class.it("example") {} + # @runner = create_runner(@e) + # end + # + # it "should send reporter example_started" do + # @reporter.should_receive(:example_started).with(equal(@e)) + # @runner.run + # end + # + # it "should report its name for dry run" do + # @options.dry_run = true + # @reporter.should_receive(:example_finished).with(equal(@e), nil) + # @runner.run + # end + # + # it "should report success" do + # @reporter.should_receive(:example_finished).with(equal(@e), nil) + # @runner.run + # end + # end + # + # describe ExampleRunner, "#run with a failing example" do + # predicate_matchers[:is_a] = [:is_a?] + # it_should_behave_like "Spec::Example::ExampleRunner#run" + # + # before do + # @e = @example_group_class.it("example") do + # (2+2).should == 5 + # end + # @runner = create_runner(@e) + # end + # + # it "should report failure due to failure" do + # @reporter.should_receive(:example_finished).with( + # equal(@e), + # is_a(Spec::Expectations::ExpectationNotMetError) + # ) + # @runner.run + # end + # end + # + # describe ExampleRunner, "#run with a erroring example" do + # it_should_behave_like "Spec::Example::ExampleRunner#run" + # + # before do + # @error = error = NonStandardError.new("in body") + # @example_definition = @example_group_class.it("example") do + # raise(error) + # end + # @runner = create_runner(@example_definition) + # end + # + # it "should report failure due to error" do + # @reporter.should_receive(:example_finished).with( + # equal(@example_definition), + # @error + # ) + # @runner.run + # end + # + # it "should run after_each block" do + # @example_group_class.after(:each) do + # raise("in after_each") + # end + # @reporter.should_receive(:example_finished) do |example_definition, error| + # example_definition.should equal(@example_definition) + # error.message.should eql("in body") + # end + # @runner.run + # end + # end + # + # describe ExampleRunner, "#run where after_each fails" do + # it_should_behave_like "Spec::Example::ExampleRunner#run" + # + # before do + # @example_ran = example_ran = false + # @example_definition = @example_group_class.it("should not run") do + # example_ran = true + # end + # @runner = create_runner(@example_definition) + # @example_group_class.after(:each) { raise(NonStandardError.new("in after_each")) } + # end + # + # it "should report failure location when in after_each" do + # @reporter.should_receive(:example_finished) do |example_definition, error| + # example_definition.should equal(@example_definition) + # error.message.should eql("in after_each") + # end + # @runner.run + # end + # end + # + # describe ExampleRunner, "#run with use cases" do + # predicate_matchers[:is_a] = [:is_a?] + # it_should_behave_like "Spec::Example::ExampleRunner#run" + # + # it "should report NO NAME when told to use generated description with --dry-run" do + # @options.dry_run = true + # example_definition = @example_group_class.it() do + # 5.should == 5 + # end + # runner = create_runner(example_definition) + # + # @reporter.should_receive(:example_finished) do |example_definition, error| + # example_definition.description.should == "NO NAME (Because of --dry-run)" + # end + # runner.run + # end + # + # it "should report given name if present with --dry-run" do + # @options.dry_run = true + # example_definition = @example_group_class.it("example name") do + # 5.should == 5 + # end + # runner = create_runner(example_definition) + # + # @reporter.should_receive(:example_finished) do |example_definition, error| + # example_definition.description.should == "example name" + # end + # runner.run + # end + # + # it "should report NO NAME when told to use generated description with no expectations" do + # example_definition = @example_group_class.it() {} + # runner = create_runner(example_definition) + # @reporter.should_receive(:example_finished) do |example, error| + # example.description.should == "NO NAME (Because there were no expectations)" + # end + # runner.run + # end + # + # it "should report NO NAME when told to use generated description and matcher fails" do + # example_definition = @example_group_class.it() do + # 5.should "" # Has no matches? method.. + # end + # runner = create_runner(example_definition) + # + # @reporter.should_receive(:example_finished) do |example, error| + # example_definition.description.should == "NO NAME (Because of Error raised in matcher)" + # end + # runner.run + # end + # + # it "should report generated description when told to and it is available" do + # example_definition = @example_group_class.it() { + # 5.should == 5 + # } + # runner = create_runner(example_definition) + # + # @reporter.should_receive(:example_finished) do |example_definition, error| + # example_definition.description.should == "should == 5" + # end + # runner.run + # end + # + # it "should unregister description_generated callback (lest a memory leak should build up)" do + # example_definition = @example_group_class.it("something") + # runner = create_runner(example_definition) + # + # Spec::Matchers.should_receive(:example_finished) + # runner.run + # end + # end end end vendor/plugins/rspec/spec/spec/example/example_runner_spec.rb @@ -55,5 +55,17 @@ module Spec end end end + + describe "Nested Example Groups" do + describe "description options", :other_options => "other options" do + it "should have a spec_path" do + self.class.description_options[:spec_path].should match(/#{__FILE__}/) + end + + it "should pass other options" do + self.class.description_options[:other_options].should == "other options" + end + end + end end end vendor/plugins/rspec/spec/spec/example/nested_example_group_spec.rb @@ -4,28 +4,136 @@ module Spec it 'should raise an ExamplePendingError if no block is supplied' do lambda { - include Pending pending "TODO" }.should raise_error(ExamplePendingError, /TODO/) end it 'should raise an ExamplePendingError if a supplied block fails as expected' do lambda { - include Pending pending "TODO" do raise "oops" end }.should raise_error(ExamplePendingError, /TODO/) end + it 'should raise an ExamplePendingError if a supplied block fails as expected with a mock' do + lambda { + pending "TODO" do + m = mock('thing') + m.should_receive(:foo) + m.rspec_verify + end + }.should raise_error(ExamplePendingError, /TODO/) + end + it 'should raise a PendingExampleFixedError if a supplied block starts working' do lambda { - include Pending pending "TODO" do # success! end }.should raise_error(PendingExampleFixedError, /TODO/) end + + it "should have the correct file and line number for pending given with a block which fails" do + file = __FILE__ + line_number = __LINE__ + 2 + begin + pending do + raise + end + rescue => error + error.pending_caller.should == "#{file}:#{line_number}" + end + end + + it "should have the correct file and line number for pending given with no block" do + file = __FILE__ + line_number = __LINE__ + 2 + begin + pending("TODO") + rescue => error + error.pending_caller.should == "#{file}:#{line_number}" + end + end + end + + describe ExamplePendingError do + it "should have the caller (from two calls from initialization)" do + two_calls_ago = caller[0] + ExamplePendingError.new("a message").pending_caller.should == two_calls_ago + end + + it "should keep the trace information from initialization" do + two_calls_ago = caller[0] + obj = ExamplePendingError.new("a message") + obj.pending_caller + def another_caller(obj) + obj.pending_caller + end + + another_caller(obj).should == two_calls_ago + end + + it "should have the message provided" do + ExamplePendingError.new("a message").message.should == "a message" + end + + it "should use a 'ExamplePendingError' as it's default message" do + ExamplePendingError.new.message.should == "Spec::Example::ExamplePendingError" + end + end + + describe NotYetImplementedError do + def rspec_root + File.expand_path(__FILE__.gsub("/spec/spec/example/pending_module_spec.rb", "/lib")) + end + + it "should have the root rspec path" do + NotYetImplementedError::RSPEC_ROOT_LIB.should == rspec_root + end + + it "should always have the error 'Not Yet Implemented'" do + NotYetImplementedError.new([]).message.should == "Not Yet Implemented" + end + + describe "pending_caller" do + it "should select an element out of the backtrace" do + error = NotYetImplementedError.new(["foo/bar.rb:18"]) + + error.pending_caller.should == "foo/bar.rb:18" + end + + it "should actually report the element from the backtrace" do + error = NotYetImplementedError.new(["bar.rb:18"]) + + error.pending_caller.should == "bar.rb:18" + end + + it "should not use an element with the rspec root path" do + error = NotYetImplementedError.new(["#{rspec_root}:8"]) + + error.pending_caller.should be_nil + end + + it "should select the first line in the backtrace which isn't in the rspec root" do + error = NotYetImplementedError.new([ + "#{rspec_root}/foo.rb:2", + "#{rspec_root}/foo/bar.rb:18", + "path1.rb:22", + "path2.rb:33" + ]) + + error.pending_caller.should == "path1.rb:22" + end + + it "should cache the caller" do + backtrace = mock('backtrace') + backtrace.should_receive(:detect).once + + error = NotYetImplementedError.new(backtrace) + error.pending_caller.should == error.pending_caller + end + end end end end vendor/plugins/rspec/spec/spec/example/pending_module_spec.rb @@ -3,269 +3,254 @@ require File.dirname(__FILE__) + '/../../spec_helper' module Spec module Example describe ExampleGroup, "with :shared => true" do - before(:each) do - @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) - @original_rspec_options = $rspec_options - $rspec_options = @options - @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true) - @options.formatters << @formatter - @behaviour = Class.new(ExampleGroup).describe("behaviour") - class << @behaviour - public :include + with_sandboxed_options do + attr_reader :formatter, :example_group + before(:each) do + @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true) + options.formatters << formatter + @example_group = Class.new(ExampleGroup).describe("example_group") + class << example_group + public :include + end end - end - - after(:each) do - $rspec_options = @original_rspec_options - @formatter.rspec_verify - @behaviour = nil - $shared_example_groups.clear unless $shared_example_groups.nil? - end - - def make_shared_example_group(name, opts=nil, &block) - behaviour = SharedExampleGroup.new(name, :shared => true, &block) - SharedExampleGroup.add_shared_example_group(behaviour) - behaviour - end - - def non_shared_example_group() - @non_shared_example_group ||= Class.new(ExampleGroup).describe("behaviour") - end - - it "should accept an optional options hash" do - lambda { Class.new(ExampleGroup).describe("context") }.should_not raise_error(Exception) - lambda { Class.new(ExampleGroup).describe("context", :shared => true) }.should_not raise_error(Exception) - end - - it "should return all shared behaviours" do - b1 = make_shared_example_group("b1", :shared => true) {} - b2 = make_shared_example_group("b2", :shared => true) {} - - b1.should_not be(nil) - b2.should_not be(nil) - - SharedExampleGroup.find_shared_example_group("b1").should equal(b1) - SharedExampleGroup.find_shared_example_group("b2").should equal(b2) - end - - it "should register as shared behaviour" do - behaviour = make_shared_example_group("behaviour") {} - SharedExampleGroup.shared_example_groups.should include(behaviour) - end - - it "should not be shared when not configured as shared" do - behaviour = non_shared_example_group - SharedExampleGroup.shared_example_groups.should_not include(behaviour) - end - - it "should raise if run when shared" do - behaviour = make_shared_example_group("context") {} - $example_ran = false - behaviour.it("test") {$example_ran = true} - lambda { behaviour.run(@formatter) }.should raise_error - $example_ran.should be_false - end - - it "should contain examples when shared" do - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.it("shared example") {} - shared_example_group.number_of_examples.should == 1 - end - it "should complain when adding a second shared behaviour with the same description" do - describe "shared behaviour", :shared => true do + after(:each) do + @formatter.rspec_verify + @example_group = nil + Spec::Example::SharedExampleGroup.clear end - lambda do - describe "shared behaviour", :shared => true do + + describe "#register" do + it "creates a new shared example group with the submitted args" do + block = lambda {} + group = SharedExampleGroup.new("shared group") do end + Spec::Example::SharedExampleGroup.should_receive(:new).with("share me", &block).and_return(group) + Spec::Example::SharedExampleGroup.register("share me", &block) end - end.should raise_error(ArgumentError) - end - it "should NOT complain when adding the same shared behaviour instance again" do - shared_example_group = Class.new(ExampleGroup).describe("shared behaviour", :shared => true) - SharedExampleGroup.add_shared_example_group(shared_example_group) - SharedExampleGroup.add_shared_example_group(shared_example_group) - end - - it "should NOT complain when adding the same shared behaviour again (i.e. file gets reloaded)" do - lambda do - 2.times do - describe "shared behaviour which gets loaded twice", :shared => true do - end + it "registers the shared example group" do + lambda do + Spec::Example::SharedExampleGroup.register "share me" do end + end.should change {Spec::Example::SharedExampleGroup.count}.by(1) end - end.should_not raise_error(ArgumentError) - end + end - it "should NOT complain when adding the same shared behaviour in same file with different absolute path" do - shared_example_group_1 = Class.new(ExampleGroup).describe("shared behaviour", :shared => true) - shared_example_group_2 = Class.new(ExampleGroup).describe("shared behaviour", :shared => true) + it "complains when adding a second shared example_group with the same description" do + describe "shared example_group", :shared => true do + end + lambda do + describe "shared example_group", :shared => true do + end + end.should raise_error(ArgumentError) + end + + it "does NOT add the same group twice" do + lambda do + 2.times do + describe "shared example_group which gets loaded twice", :shared => true do + end + end + end.should change {Spec::Example::SharedExampleGroup.count}.by(1) + end - shared_example_group_1.description[:spec_path] = "/my/spec/a/../shared.rb" - shared_example_group_2.description[:spec_path] = "/my/spec/b/../shared.rb" + it "does NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do + lambda do + 2.times do + describe "shared example_group which gets loaded twice", :shared => true do + end + end + end.should_not raise_error(ArgumentError) + end - SharedExampleGroup.add_shared_example_group(shared_example_group_1) - SharedExampleGroup.add_shared_example_group(shared_example_group_2) - end + it "does NOT complain when adding the same shared example_group in same file with different absolute path" do + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :spec_path => "/my/spec/a/../shared.rb" + ) + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :spec_path => "/my/spec/b/../shared.rb" + ) + end - it "should complain when adding a different shared behaviour with the same name in a different file with the same basename" do - shared_example_group_1 = Class.new(ExampleGroup).describe("shared behaviour", :shared => true) - shared_example_group_2 = Class.new(ExampleGroup).describe("shared behaviour", :shared => true) + it "complains when adding a different shared example_group with the same name in a different file with the same basename" do + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :spec_path => "/my/spec/a/shared.rb" + ) + lambda do + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :spec_path => "/my/spec/b/shared.rb" + ) + end.should raise_error(ArgumentError, /already exists/) + end - shared_example_group_1.description[:spec_path] = "/my/spec/a/shared.rb" - shared_example_group_2.description[:spec_path] = "/my/spec/b/shared.rb" + it "adds examples to current example_group using it_should_behave_like" do + shared_example_group = SharedExampleGroup.register("shared example_group") do + it("shared example") {} + it("shared example 2") {} + end - SharedExampleGroup.add_shared_example_group(shared_example_group_1) - lambda do - SharedExampleGroup.add_shared_example_group(shared_example_group_2) - end.should raise_error(ArgumentError, /already exists/) - end + example_group.it("example") {} + example_group.number_of_examples.should == 1 + example_group.it_should_behave_like("shared example_group") + example_group.number_of_examples.should == 3 + end - it "should add examples to current behaviour using it_should_behave_like" do - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.it("shared example") {} - shared_example_group.it("shared example 2") {} + it "adds examples to from two shared groups" do + shared_example_group_1 = SharedExampleGroup.register("shared example_group 1") do + it("shared example 1") {} + end - @behaviour.it("example") {} - @behaviour.number_of_examples.should == 1 - @behaviour.it_should_behave_like("shared behaviour") - @behaviour.number_of_examples.should == 3 - end + shared_example_group_1 = SharedExampleGroup.register("shared example_group 2") do + it("shared example 2") {} + end - it "should add examples to current behaviour using include" do - shared_example_group = describe "all things", :shared => true do - it "should do stuff" do end + example_group.it("example") {} + example_group.number_of_examples.should == 1 + example_group.it_should_behave_like("shared example_group 1", "shared example_group 2") + example_group.number_of_examples.should == 3 end + + it "adds examples to current example_group using include" do + shared_example_group = describe "all things", :shared => true do + it "should do stuff" do end + end - behaviour = describe "one thing" do - include shared_example_group - end + example_group = describe "one thing" do + include shared_example_group + end - behaviour.number_of_examples.should == 1 - end - - it "should add examples to current behaviour using it_should_behave_like with a module" do - AllThings = describe "all things", :shared => true do - it "should do stuff" do end + example_group.number_of_examples.should == 1 end + + it "adds examples to current example_group using it_should_behave_like with a module" do + AllThings = describe "all things", :shared => true do + it "should do stuff" do end + end - behaviour = describe "one thing" do - it_should_behave_like AllThings - end + example_group = describe "one thing" do + it_should_behave_like AllThings + end - behaviour.number_of_examples.should == 1 - end - - it "should run shared examples" do - shared_example_ran = false - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.it("shared example") { shared_example_ran = true } + example_group.number_of_examples.should == 1 + end - example_ran = false + it "runs shared examples" do + shared_example_ran = false + shared_example_group = SharedExampleGroup.register("shared example_group") do + it("shared example") { shared_example_ran = true } + end - @behaviour.it_should_behave_like("shared behaviour") - @behaviour.it("example") {example_ran = true} - suite = @behaviour.suite - suite.run - example_ran.should be_true - shared_example_ran.should be_true - end + example_ran = false - it "should run setup and teardown from shared behaviour" do - shared_setup_ran = false - shared_teardown_ran = false - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.before { shared_setup_ran = true } - shared_example_group.after { shared_teardown_ran = true } - shared_example_group.it("shared example") { shared_example_ran = true } - - example_ran = false - - @behaviour.it_should_behave_like("shared behaviour") - @behaviour.it("example") {example_ran = true} - suite = @behaviour.suite - suite.run - example_ran.should be_true - shared_setup_ran.should be_true - shared_teardown_ran.should be_true - end + example_group.it_should_behave_like("shared example_group") + example_group.it("example") {example_ran = true} + example_group.run + example_ran.should be_true + shared_example_ran.should be_true + end - it "should run before(:all) and after(:all) only once from shared behaviour" do - shared_before_all_run_count = 0 - shared_after_all_run_count = 0 - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.before(:all) { shared_before_all_run_count += 1} - shared_example_group.after(:all) { shared_after_all_run_count += 1} - shared_example_group.it("shared example") { shared_example_ran = true } - - example_ran = false - - @behaviour.it_should_behave_like("shared behaviour") - @behaviour.it("example") {example_ran = true} - suite = @behaviour.suite - suite.run - example_ran.should be_true - shared_before_all_run_count.should == 1 - shared_after_all_run_count.should == 1 - end + it "runs before(:each) and after(:each) from shared example_group" do + shared_setup_ran = false + shared_teardown_ran = false + shared_example_group = SharedExampleGroup.register("shared example_group") do + before(:each) { shared_setup_ran = true } + after(:each) { shared_teardown_ran = true } + it("shared example") { shared_example_ran = true } + end - it "should include modules, included into shared behaviour, into current behaviour" do - @formatter.should_receive(:add_example_group).with(any_args) - @formatter.should_receive(:example_finished).twice.with(any_args) + example_ran = false - shared_example_group = make_shared_example_group("shared behaviour") {} - shared_example_group.it("shared example") { shared_example_ran = true } + example_group.it_should_behave_like("shared example_group") + example_group.it("example") {example_ran = true} + example_group.run + example_ran.should be_true + shared_setup_ran.should be_true + shared_teardown_ran.should be_true + end - mod1_method_called = false - mod1 = Module.new do - define_method :mod1_method do - mod1_method_called = true + it "should run before(:all) and after(:all) only once from shared example_group" do + shared_before_all_run_count = 0 + shared_after_all_run_count = 0 + shared_example_group = SharedExampleGroup.register("shared example_group") do + before(:all) { shared_before_all_run_count += 1} + after(:all) { shared_after_all_run_count += 1} + it("shared example") { shared_example_ran = true } end + + example_ran = false + + example_group.it_should_behave_like("shared example_group") + example_group.it("example") {example_ran = true} + example_group.run + example_ran.should be_true + shared_before_all_run_count.should == 1 + shared_after_all_run_count.should == 1 end - mod2_method_called = false - mod2 = Module.new do - define_method :mod2_method do - mod2_method_called = true + it "should include modules, included into shared example_group, into current example_group" do + @formatter.should_receive(:add_example_group).with(any_args) + + shared_example_group = SharedExampleGroup.register("shared example_group") do + it("shared example") { shared_example_ran = true } + end + + mod1_method_called = false + mod1 = Module.new do + define_method :mod1_method do + mod1_method_called = true + end end - end - shared_example_group.include mod2 + mod2_method_called = false + mod2 = Module.new do + define_method :mod2_method do + mod2_method_called = true + end + end - @behaviour.it_should_behave_like("shared behaviour") - @behaviour.include mod1 + shared_example_group.__send__ :include, mod2 - @behaviour.it("test") do - mod1_method - mod2_method - end - suite = @behaviour.suite - suite.run - mod1_method_called.should be_true - mod2_method_called.should be_true - end + example_group.it_should_behave_like("shared example_group") + example_group.include mod1 - it "should make methods defined in the shared behaviour available in consuming behaviour" do - shared_example_group = make_shared_example_group("shared behaviour xyz") do - def a_shared_helper_method - "this got defined in a shared behaviour" + example_group.it("test") do + mod1_method + mod2_method end + example_group.run + mod1_method_called.should be_true + mod2_method_called.should be_true end - @behaviour.it_should_behave_like("shared behaviour xyz") - success = false - @behaviour.it("should access a_shared_helper_method") do - a_shared_helper_method - success = true + + it "should make methods defined in the shared example_group available in consuming example_group" do + shared_example_group = SharedExampleGroup.register("shared example_group xyz") do + def a_shared_helper_method + "this got defined in a shared example_group" + end + end + example_group.it_should_behave_like("shared example_group xyz") + success = false + example_group.it("should access a_shared_helper_method") do + a_shared_helper_method + success = true + end + example_group.run + success.should be_true end - suite = @behaviour.suite - suite.run - success.should be_true - end - it "should raise when named shared behaviour can not be found" do - lambda { - @behaviour.it_should_behave_like("non-existent shared example group") - violated - }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found") + it "should raise when named shared example_group can not be found" do + lambda { + example_group.it_should_behave_like("non-existent shared example group") + violated + }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found") + end end end end vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb @@ -28,7 +28,25 @@ describe "Diff" do it "should output unified diff of two strings" do expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n" actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n" - expected_diff="\n\n@@ -1,6 +1,6 @@\n foo\n-bar\n zap\n+bar\n this\n is\n soo\n@@ -9,5 +9,6 @@\n equal\n insert\n a\n+another\n line\n" + expected_diff= <<'EOD' + + +@@ -1,6 +1,6 @@ + foo +-zap + bar ++zap + this + is + soo +@@ -9,6 +9,5 @@ + equal + insert + a +-another + line +EOD + diff = @differ.diff_as_string(expected, actual) diff.should eql(expected_diff) end @@ -44,11 +62,11 @@ describe "Diff" do :metasyntactic, "variable", :delta, -- "charlie", -+ "tango", +- "tango", ++ "charlie", :width, -- "quite wide"] -+ "very wide"] +- "very wide"] ++ "quite wide"] EOD @@ -65,8 +83,8 @@ EOD @@ -1,5 +1,5 @@ <Animal name=bob, -- species=giraffe -+ species=tortoise +- species=tortoise ++ species=giraffe > EOD @@ -94,12 +112,12 @@ describe "Diff in context format" do *** 1,5 **** <Animal name=bob, -! species=giraffe +! species=tortoise > --- 1,5 ---- <Animal name=bob, -! species=tortoise +! species=giraffe > EOD vendor/plugins/rspec/spec/spec/expectations/differs/default_spec.rb @@ -39,12 +39,6 @@ describe Object, "#should" do }.should raise_error(Spec::Expectations::InvalidMatcherError) end - it "should raise error if it receives nil" do - lambda { - @target.should nil - }.should raise_error(Spec::Expectations::InvalidMatcherError) - end - it "should raise error if it receives no argument and it is not used as a left side of an operator" do pending "Is it even possible to catch this?" lambda { @@ -92,12 +86,6 @@ describe Object, "#should_not" do }.should raise_error(Spec::Expectations::InvalidMatcherError) end - it "should raise error if it receives nil" do - lambda { - @target.should_not nil - }.should raise_error(Spec::Expectations::InvalidMatcherError) - end - it "should raise error if it receives no argument and it is not used as a left side of an operator" do pending "Is it even possible to catch this?" lambda { vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb @@ -1,38 +1,40 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Matchers - describe BeClose do + describe "be_close" do it "should match when value == target" do - BeClose.new(5.0, 0.5).matches?(5.0).should be_true + be_close(5.0, 0.5).matches?(5.0).should be_true end it "should match when value < (target + delta)" do - BeClose.new(5.0, 0.5).matches?(5.49).should be_true + be_close(5.0, 0.5).matches?(5.49).should be_true end it "should match when value > (target - delta)" do - BeClose.new(5.0, 0.5).matches?(4.51).should be_true + be_close(5.0, 0.5).matches?(4.51).should be_true end it "should not match when value == (target - delta)" do - BeClose.new(5.0, 0.5).matches?(4.5).should be_false + be_close(5.0, 0.5).matches?(4.5).should be_false end it "should not match when value < (target - delta)" do - BeClose.new(5.0, 0.5).matches?(4.49).should be_false + be_close(5.0, 0.5).matches?(4.49).should be_false end it "should not match when value == (target + delta)" do - BeClose.new(5.0, 0.5).matches?(5.5).should be_false + be_close(5.0, 0.5).matches?(5.5).should be_false end it "should not match when value > (target + delta)" do - BeClose.new(5.0, 0.5).matches?(5.51).should be_false + be_close(5.0, 0.5).matches?(5.51).should be_false end it "should provide a useful failure message" do #given - matcher = BeClose.new(5.0, 0.5) + matcher = be_close(5.0, 0.5) #when matcher.matches?(5.51) #then matcher.failure_message.should == "expected 5.0 +/- (< 0.5), got 5.51" end it "should describe itself" do - BeClose.new(5.0, 0.5).description.should == "be close to 5.0 (within +- 0.5)" + matcher = be_close(5.0, 0.5) + matcher.matches?(5.1) + matcher.description.should == "be close to 5.0 (within +- 0.5)" end end end vendor/plugins/rspec/spec/spec/matchers/be_close_spec.rb @@ -7,7 +7,7 @@ describe "should be_predicate" do end it "should pass when actual returns true for :predicates? (present tense)" do - actual = stub("actual", :exists? => true) + actual = stub("actual", :exists? => true, :exist? => true) actual.should be_exist end @@ -21,7 +21,23 @@ describe "should be_predicate" do it "should fail when actual does not respond to :predicate?" do lambda { Object.new.should be_happy - }.should raise_error(NameError) + }.should raise_error(NameError, /happy\?/) + end + + it "should fail on error other than NameError" do + actual = stub("actual") + actual.should_receive(:foo?).and_raise("aaaah") + lambda { + actual.should be_foo + }.should raise_error(/aaaah/) + end + + it "should fail on error other than NameError (with the present tense predicate)" do + actual = Object.new + actual.should_receive(:foos?).and_raise("aaaah") + lambda { + actual.should be_foo + }.should raise_error(/aaaah/) end end @@ -121,7 +137,7 @@ describe "should be_nil" do it "should fail when actual is not nil" do lambda { :not_nil.should be_nil - }.should fail_with("expected nil, got :not_nil") + }.should fail_with("expected nil? to return true, got false") end end @@ -133,7 +149,7 @@ describe "should_not be_nil" do it "should fail when actual is nil" do lambda { nil.should_not be_nil - }.should fail_with("expected not nil, got nil") + }.should fail_with("expected nil? to return false, got true") end end @@ -195,7 +211,30 @@ describe "should be ===" do end it "should fail when === operator returns false" do - lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === "not a hash", got Hash]) + lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === not a hash, got Hash]) + end +end + +describe "should_not with operators" do + it "should coach user to stop using operators with should_not" do + lambda { + 5.should_not be < 6 + }.should raise_error(/not only FAILED,\nit reads really poorly./m) + end +end + +describe "should be" do + it "should pass if actual is true or a set value" do + true.should be + 1.should be + end + + it "should fail if actual is false" do + lambda {false.should be}.should fail_with("expected true, got false") + end + + it "should fail if actual is nil" do + lambda {nil.should be}.should fail_with("expected true, got nil") end end @@ -207,3 +246,36 @@ describe "should be(value)" do lambda { 5.should be(6) }.should fail_with("expected 6, got 5") end end + +describe "'should be' with operator" do + it "should include 'be' in the description" do + (be > 6).description.should =~ /be > 6/ + (be >= 6).description.should =~ /be >= 6/ + (be <= 6).description.should =~ /be <= 6/ + (be < 6).description.should =~ /be < 6/ + end +end + + +describe "arbitrary predicate with DelegateClass" do + it "should access methods defined in the delegating class (LH[#48])" do + pending(%{ + Looks like DelegateClass is delegating #should to the + delegate. Not sure how to fix this one. Or if we even should." + }) + require 'delegate' + class ArrayDelegate < DelegateClass(Array) + def initialize(array) + @internal_array = array + super(@internal_array) + end + + def large? + @internal_array.size >= 5 + end + end + + delegate = ArrayDelegate.new([1,2,3,4,5,6]) + delegate.should be_large + end +end vendor/plugins/rspec/spec/spec/matchers/be_spec.rb @@ -55,10 +55,9 @@ describe "should change { block }" do end.should fail_with("result should have changed, but is still 5") end - it "should warn if passed a block using do/end" do + it "should warn if passed a block using do/end instead of {}" do lambda do - lambda {}.should change do - end + lambda {}.should change do; end end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/) end end @@ -79,10 +78,9 @@ describe "should_not change { block }" do end.should fail_with("result should not have changed, but did change from 5 to 6") end - it "should warn if passed a block using do/end" do + it "should warn if passed a block using do/end instead of {}" do lambda do - lambda {}.should_not change do - end + lambda {}.should_not change do; end end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/) end end @@ -317,3 +315,15 @@ describe "should change{ block }.from(old).to(new)" do lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("cat") end end + +describe Spec::Matchers::Change do + it "should work when the receiver has implemented #send" do + @instance = SomethingExpected.new + @instance.some_value = "string" + def @instance.send(*args); raise "DOH! Library developers shouldn't use #send!" end + + lambda { + lambda { @instance.some_value = "cat" }.should change(@instance, :some_value) + }.should_not raise_error + end +end vendor/plugins/rspec/spec/spec/matchers/change_spec.rb @@ -1,14 +1,10 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' describe "Matchers should be able to generate their own descriptions" do - before(:each) do - Spec::Matchers.clear_generated_description - end - after(:each) do Spec::Matchers.clear_generated_description end - + it "should == expected" do "this".should == "this" Spec::Matchers.generated_description.should == "should == \"this\"" @@ -111,6 +107,11 @@ describe "Matchers should be able to generate their own descriptions" do [1,2,3].should include(3) Spec::Matchers.generated_description.should == "should include 3" end + + it "array.should =~ [1,2,3]" do + [1,2,3].should =~ [1,2,3] + Spec::Matchers.generated_description.should == "should contain exactly 1, 2 and 3" + end it "should match" do "this string".should match(/this string/) @@ -134,7 +135,7 @@ describe "Matchers should be able to generate their own descriptions" do it "should respond_to" do [].should respond_to(:insert) - Spec::Matchers.generated_description.should == "should respond to #insert" + Spec::Matchers.generated_description.should == "should respond to [:insert]" end it "should throw symbol" do @@ -155,3 +156,17 @@ describe "Matchers should be able to generate their own descriptions" do end.new end end + +describe "a Matcher with no description" do + def matcher + Class.new do + def matches?(ignore); true; end + def failure_message; ""; end + end.new + end + + it "should provide a helpful message when used in a string-less example block" do + 5.should matcher + Spec::Matchers.generated_description.should =~ /When you call.*description method/m + end +end vendor/plugins/rspec/spec/spec/matchers/description_generation_spec.rb @@ -2,24 +2,25 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Matchers - describe Eql do + describe "eql" do it "should match when actual.eql?(expected)" do - Eql.new(1).matches?(1).should be_true + eql(1).matches?(1).should be_true end it "should not match when !actual.eql?(expected)" do - Eql.new(1).matches?(2).should be_false + eql(1).matches?(2).should be_false end it "should describe itself" do - matcher = Eql.new(1) + matcher = eql(1) + matcher.matches?(1) matcher.description.should == "eql 1" end it "should provide message, expected and actual on #failure_message" do - matcher = Eql.new("1") + matcher = eql("1") matcher.matches?(1) matcher.failure_message.should == ["expected \"1\", got 1 (using .eql?)", "1", 1] end it "should provide message, expected and actual on #negative_failure_message" do - matcher = Eql.new(1) + matcher = eql(1) matcher.matches?(1) matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .eql?)", 1, 1] end vendor/plugins/rspec/spec/spec/matchers/eql_spec.rb @@ -2,24 +2,25 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Matchers - describe Equal do + describe "equal" do it "should match when actual.equal?(expected)" do - Equal.new(1).matches?(1).should be_true + equal(1).matches?(1).should be_true end it "should not match when !actual.equal?(expected)" do - Equal.new("1").matches?("1").should be_false + equal("1").matches?("1").should be_false end it "should describe itself" do - matcher = Equal.new(1) + matcher = equal(1) + matcher.matches?(1) matcher.description.should == "equal 1" end it "should provide message, expected and actual on #failure_message" do - matcher = Equal.new("1") + matcher = equal("1") matcher.matches?(1) matcher.failure_message.should == ["expected \"1\", got 1 (using .equal?)", "1", 1] end it "should provide message, expected and actual on #negative_failure_message" do - matcher = Equal.new(1) + matcher = equal(1) matcher.matches?(1) matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .equal?)", 1, 1] end vendor/plugins/rspec/spec/spec/matchers/equal_spec.rb @@ -1,27 +1,5 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' -# NOTE - this was initially handled by an explicit matcher, but is now -# handled by a default set of predicate_matchers. - -# module Spec -# module Matchers -# class Exist -# def matches? actual -# @actual = actual -# @actual.exist? -# end -# def failure_message -# "expected #{@actual.inspect} to exist, but it doesn't." -# end -# def negative_failure_message -# "expected #{@actual.inspect} to not exist, but it does." -# end -# end -# def exist; Exist.new; end -# end -# end - - class Substance def initialize exists, description @exists = exists @@ -45,31 +23,35 @@ class SubstanceTester end end -describe "should exist" do +describe "should exist," do + before(:each) do @real = Substance.new true, 'something real' @imaginary = Substance.new false, 'something imaginary' end + + describe "within an example group" do - it "should pass if target exists" do - @real.should exist - end + it "should pass if target exists" do + @real.should exist + end - it "should fail if target does not exist" do - lambda { @imaginary.should exist }. - should fail + it "should fail if target does not exist" do + lambda { @imaginary.should exist }.should fail + end + + it "should pass if target doesn't exist" do + lambda { @real.should_not exist }.should fail + end end -end -describe "should exist, outside of a behavior" do - before(:each) do - @real = Substance.new true, 'something real' - @imaginary = Substance.new false, 'something imaginary' - end - it "should pass if target exists" do - pending("need to either find a way to include stock predicate matchers in Spec::Matchers or add Bret's Exist matcher") do + describe "outside of an example group" do + + it "should pass if target exists" do real_tester = SubstanceTester.new @real real_tester.should_exist end + end + end vendor/plugins/rspec/spec/spec/matchers/exist_spec.rb @@ -48,53 +48,73 @@ end module Spec module Expectations - describe ExpectationMatcherHandler, ".handle_matcher" do - it "should ask the matcher if it matches" do - matcher = mock("matcher") - actual = Object.new - matcher.should_receive(:matches?).with(actual).and_return(true) - ExpectationMatcherHandler.handle_matcher(actual, matcher) - end - - it "should explain when the matcher parameter is not a matcher" do - begin - nonmatcher = mock("nonmatcher") + describe ExpectationMatcherHandler do + describe "#handle_matcher" do + it "should ask the matcher if it matches" do + matcher = mock("matcher") actual = Object.new - ExpectationMatcherHandler.handle_matcher(actual, nonmatcher) - rescue Spec::Expectations::InvalidMatcherError => e + matcher.should_receive(:matches?).with(actual).and_return(true) + Spec::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher) end + + it "should explain when the matcher parameter is not a matcher" do + begin + nonmatcher = mock("nonmatcher") + actual = Object.new + Spec::Expectations::ExpectationMatcherHandler.handle_matcher(actual, nonmatcher) + rescue Spec::Expectations::InvalidMatcherError => e + end - e.message.should =~ /^Expected a matcher, got / + e.message.should =~ /^Expected a matcher, got / + end + + it "should return the match value" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(:this_value) + Spec::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher).should == :this_value + end end end - describe NegativeExpectationMatcherHandler, ".handle_matcher" do - it "should explain when matcher does not support should_not" do - matcher = mock("matcher") - matcher.stub!(:matches?) - actual = Object.new - lambda { - NegativeExpectationMatcherHandler.handle_matcher(actual, matcher) - }.should fail_with(/Matcher does not support should_not.\n/) - end - - it "should ask the matcher if it matches" do - matcher = mock("matcher") - actual = Object.new - matcher.stub!(:negative_failure_message) - matcher.should_receive(:matches?).with(actual).and_return(false) - NegativeExpectationMatcherHandler.handle_matcher(actual, matcher) - end + describe NegativeExpectationMatcherHandler do + describe "#handle_matcher" do + it "should explain when matcher does not support should_not" do + matcher = mock("matcher") + matcher.stub!(:matches?) + actual = Object.new + lambda { + Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher) + }.should fail_with(/Matcher does not support should_not.\n/) + end - it "should explain when the matcher parameter is not a matcher" do - begin - nonmatcher = mock("nonmatcher") + it "should ask the matcher if it matches" do + matcher = mock("matcher") actual = Object.new - NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher) - rescue Spec::Expectations::InvalidMatcherError => e + matcher.stub!(:negative_failure_message) + matcher.should_receive(:matches?).with(actual).and_return(false) + Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher) end + + it "should explain when the matcher parameter is not a matcher" do + begin + nonmatcher = mock("nonmatcher") + actual = Object.new + Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher) + rescue Spec::Expectations::InvalidMatcherError => e + end - e.message.should =~ /^Expected a matcher, got / + e.message.should =~ /^Expected a matcher, got / + end + + + it "should return the match value" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(false) + matcher.stub!(:negative_failure_message).and_return("ignore") + Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher).should be_false + end end end @@ -124,6 +144,7 @@ module Spec }.should fail_with(/Matcher does not support should_not.\n/) end + end end end vendor/plugins/rspec/spec/spec/matchers/handler_spec.rb @@ -16,6 +16,14 @@ describe "should have_sym(*args)" do Object.new.should have_key(:a) }.should raise_error(NoMethodError) end + + it "should reraise an exception thrown in #has_sym?(*args)" do + o = Object.new + def o.has_sym?(*args) + raise "Funky exception" + end + lambda { o.should have_sym(:foo) }.should raise_error("Funky exception") + end end describe "should_not have_sym(*args)" do @@ -34,4 +42,22 @@ describe "should_not have_sym(*args)" do Object.new.should have_key(:a) }.should raise_error(NoMethodError) end + + it "should reraise an exception thrown in #has_sym?(*args)" do + o = Object.new + def o.has_sym?(*args) + raise "Funky exception" + end + lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception") + end +end + +describe "has" do + it "should work when the target implements #send" do + o = {:a => "A"} + def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end + lambda { + o.should have_key(:a) + }.should_not raise_error + end end vendor/plugins/rspec/spec/spec/matchers/has_spec.rb @@ -1,6 +1,6 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' -module HaveSpecHelper +share_as :HaveSpecHelper do def create_collection_owner_with(n) owner = Spec::Expectations::Helper::CollectionOwner.new (1..n).each do |n| @@ -9,8 +9,21 @@ module HaveSpecHelper end owner end + before(:each) do + unless defined?(ActiveSupport::Inflector) + @active_support_was_not_defined + module ActiveSupport + class Inflector + def self.pluralize(string) + string.to_s + 's' + end + end + end + end + end end + describe "should have(n).items" do include HaveSpecHelper @@ -47,6 +60,47 @@ describe "should have(n).items" do end end +describe 'should have(1).item when ActiveSupport::Inflector is defined' do + include HaveSpecHelper + + it 'should pluralize the collection name' do + owner = create_collection_owner_with(1) + owner.should have(1).item + end + + after(:each) do + if @active_support_was_not_defined + Object.__send__ :remove_const, :ActiveSupport + end + end +end + +describe 'should have(1).item when Inflector is defined' do + include HaveSpecHelper + + before(:each) do + unless defined?(Inflector) + @inflector_was_not_defined + class Inflector + def self.pluralize(string) + string.to_s + 's' + end + end + end + end + + it 'should pluralize the collection name' do + owner = create_collection_owner_with(1) + owner.should have(1).item + end + + after(:each) do + if @inflector_was_not_defined + Object.__send__ :remove_const, :Inflector + end + end +end + describe "should have(n).items where result responds to items but returns something other than a collection" do it "should provide a meaningful error" do owner = Class.new do @@ -270,3 +324,76 @@ describe "have(n).things on an object which is not a collection nor contains one lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/) end end + +describe Spec::Matchers::Have, "for a collection owner that implements #send" do + include HaveSpecHelper + + before(:each) do + @collection = Object.new + def @collection.floozles; [1,2] end + def @collection.send(*args); raise "DOH! Library developers shouldn't use #send!" end + end + + it "should work in the straightforward case" do + lambda { + @collection.should have(2).floozles + }.should_not raise_error + end + + it "should work when doing automatic pluralization" do + lambda { + @collection.should have_at_least(1).floozle + }.should_not raise_error + end + + it "should blow up when the owner doesn't respond to that method" do + lambda { + @collection.should have(99).problems + }.should raise_error(NoMethodError, /problems/) + end +end + +module Spec + module Matchers + describe Have do + it "should have method_missing as private" do + with_ruby '1.8' do + Have.private_instance_methods.should include("method_missing") + end + with_ruby '1.9' do + Have.private_instance_methods.should include(:method_missing) + end + end + + describe "respond_to?" do + before :each do + @have = Have.new(:foo) + @a_method_which_have_defines = Have.instance_methods.first + @a_method_which_object_defines = Object.instance_methods.first + end + + it "should be true for a method which Have defines" do + @have.should respond_to(@a_method_which_have_defines) + end + + it "should be true for a method that it's superclass (Object) defines" do + @have.should respond_to(@a_method_which_object_defines) + end + + it "should be false for a method which neither Object nor nor Have defines" do + @have.should_not respond_to(:foo_bar_baz) + end + + it "should be false if the owner doesn't respond to the method" do + have = Have.new(99) + have.should_not respond_to(:problems) + end + + it "should be true if the owner responds to the method" do + have = Have.new(:a_symbol) + have.should respond_to(:to_sym) + end + end + end + end +end vendor/plugins/rspec/spec/spec/matchers/have_spec.rb @@ -5,6 +5,10 @@ describe "should include(expected)" do [1,2,3].should include(3) "abc".should include("a") end + + it 'should pass if target is a Hash and has the expected as a key' do + {:key => 'value'}.should include(:key) + end it "should fail if target does not include expected" do lambda { @@ -13,6 +17,9 @@ describe "should include(expected)" do lambda { "abc".should include("d") }.should fail_with("expected \"abc\" to include \"d\"") + lambda { + {:key => 'value'}.should include(:other) + }.should fail_with(%Q|expected {:key=>"value"} to include :other|) end end @@ -20,12 +27,22 @@ describe "should include(with, multiple, args)" do it "should pass if target includes all items" do [1,2,3].should include(1,2,3) end + + it 'should pass if target is a Hash including all items as keys' do + {:key => 'value', :other => 'value'}.should include(:key, :other) + end it "should fail if target does not include any one of the items" do lambda { [1,2,3].should include(1,2,4) }.should fail_with("expected [1, 2, 3] to include 1, 2 and 4") end + + it 'should pass if target is a Hash missing any item as a key' do + lambda { + {:key => 'value'}.should include(:key, :other) + }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|) + end end describe "should_not include(expected)" do @@ -33,6 +50,10 @@ describe "should_not include(expected)" do [1,2,3].should_not include(4) "abc".should_not include("d") end + + it 'should pass if target is a Hash and does not have the expected as a key' do + {:other => 'value'}.should_not include(:key) + end it "should fail if target includes expected" do lambda { @@ -41,5 +62,27 @@ describe "should_not include(expected)" do lambda { "abc".should_not include("c") }.should fail_with("expected \"abc\" not to include \"c\"") + lambda { + {:key => 'value'}.should_not include(:key) + }.should fail_with(%Q|expected {:key=>"value"} not to include :key|) + end +end + +describe "should include(:key => value)" do + it "should pass if target is a Hash and includes the key/value pair" do + {:key => 'value'}.should include(:key => 'value') + end + it "should pass if target is a Hash and includes the key/value pair among others" do + {:key => 'value', :other => 'different'}.should include(:key => 'value') + end + it "should fail if target is a Hash and has a different value for key" do + lambda { + {:key => 'different'}.should include(:key => 'value') + }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|) + end + it "should fail if target is a Hash and has a different key" do + lambda { + {:other => 'value'}.should include(:key => 'value') + }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|) end end vendor/plugins/rspec/spec/spec/matchers/include_spec.rb @@ -5,12 +5,12 @@ describe "should match(expected)" do "string".should match(/tri/) end - it "should fail when target (String) matches expected (Regexp)" do + it "should fail when target (String) does not match expected (Regexp)" do lambda { "string".should match(/rings/) }.should fail end - + it "should provide message, expected and actual on failure" do matcher = match(/rings/) matcher.matches?("string") @@ -19,7 +19,7 @@ describe "should match(expected)" do end describe "should_not match(expected)" do - it "should pass when target (String) matches expected (Regexp)" do + it "should pass when target (String) matches does not match (Regexp)" do "string".should_not match(/rings/) end vendor/plugins/rspec/spec/spec/matchers/match_spec.rb @@ -16,18 +16,9 @@ This module should provide the following methods, each of which returns a Matche it "be_arbitrary_predicate" do be_arbitrary_predicate.should be_an_instance_of(Be) end - it "be_close" do - be_close(1,2).should be_an_instance_of(BeClose) - end it "change" do change("target", :message).should be_an_instance_of(Change) end - it "eql" do - eql(:expected).should be_an_instance_of(Eql) - end - it "equal" do - equal(:expected).should be_an_instance_of(Equal) - end it "have" do have(0).should be_an_instance_of(Have) end @@ -43,9 +34,6 @@ This module should provide the following methods, each of which returns a Matche it "include" do include(:value).should be_an_instance_of(Include) end - it "match" do - match(:value).should be_an_instance_of(Match) - end it "raise_error" do raise_error.should be_an_instance_of(RaiseError) raise_error(NoMethodError).should be_an_instance_of(RaiseError) @@ -70,7 +58,7 @@ This module should provide the following methods, each of which returns a Matche end it "should convert have_xyz to Has(:have_xyz)" do - Has.should_receive(:new).with(:have_whatever) + self.should_receive(:has).with(:have_whatever) have_whatever end end vendor/plugins/rspec/spec/spec/matchers/matcher_methods_spec.rb @@ -19,6 +19,6 @@ describe "The boolean() mock argument constraint matcher" do end describe "The an_instance_of() mock argument constraint matcher" do - # NOTE - this is implemented as a predicate_matcher - see behaviour.rb + # NOTE - this is implemented as a predicate_matcher - see example_group_methods.rb specify { an_instance_of(String).should == "string" } end vendor/plugins/rspec/spec/spec/matchers/mock_constraint_matchers_spec.rb @@ -10,12 +10,17 @@ describe "should ==" do subject.should == "apple" end + it "should return true on success" do + subject = "apple" + (subject.should == "apple").should be_true + end + it "should fail when target.==(actual) returns false" do subject = "apple" Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n got: "apple" (using ==)], "orange", "apple") subject.should == "orange" end - + end describe "should_not ==" do @@ -26,12 +31,17 @@ describe "should_not ==" do subject.should_not == "apple" end + it "should return true on success" do + subject = "apple" + (subject.should_not == "orange").should be_true + end + it "should fail when target.==(actual) returns false" do subject = "apple" Spec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n got: "apple"], "apple", "apple") subject.should_not == "apple" end - + end describe "should ===" do @@ -156,3 +166,26 @@ describe "should <=" do end +describe Spec::Matchers::PositiveOperatorMatcher do + + it "should work when the target has implemented #send" do + o = Object.new + def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end + lambda { + o.should == o + }.should_not raise_error + end + +end + +describe Spec::Matchers::NegativeOperatorMatcher do + + it "should work when the target has implemented #send" do + o = Object.new + def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end + lambda { + o.should_not == :foo + }.should_not raise_error + end + +end vendor/plugins/rspec/spec/spec/matchers/operator_matcher_spec.rb @@ -12,6 +12,24 @@ describe "should raise_error" do end end +describe "should raise_error {|err| ... }" do + it "passes if there is an error" do + ran = false + lambda { non_existent_method }.should raise_error {|e| + ran = true + } + ran.should be_true + end + + it "passes the error to the block" do + error = nil + lambda { non_existent_method }.should raise_error {|e| + error = e + } + error.should be_an_instance_of(NameError) + end +end + describe "should_not raise_error" do it "should pass if nothing is raised" do lambda {}.should_not raise_error @@ -28,6 +46,9 @@ describe "should raise_error(message)" do it "should pass if RuntimeError is raised with the right message" do lambda {raise 'blah'}.should raise_error('blah') end + it "should pass if RuntimeError is raised with a matching message" do + lambda {raise 'blah'}.should raise_error(/blah/) + end it "should pass if any other error is raised with the right message" do lambda {raise NameError.new('blah')}.should raise_error('blah') end @@ -73,11 +94,17 @@ describe "should raise_error(NamedError)" do }.should fail_with("expected NameError but nothing was raised") end - it "should fail if another error is raised" do + it "should fail if another error is raised (NameError)" do lambda { lambda { raise }.should raise_error(NameError) }.should fail_with("expected NameError, got RuntimeError") end + + it "should fail if another error is raised (NameError)" do + lambda { + lambda { load "non/existent/file" }.should raise_error(NameError) + }.should fail_with(/expected NameError, got #<LoadError/) + end end describe "should_not raise_error(NamedError)" do @@ -120,6 +147,127 @@ describe "should raise_error(NamedError, error_message) with String" do end end +describe "should raise_error(NamedError, error_message) { |err| ... }" do + it "should yield exception if named error is raised with same message" do + ran = false + + lambda { + raise "example message" + }.should raise_error(RuntimeError, "example message") { |err| + ran = true + err.class.should == RuntimeError + err.message.should == "example message" + } + + ran.should == true + end + + it "yielded block should be able to fail on it's own right" do + ran, passed = false, false + + lambda { + lambda { + raise "example message" + }.should raise_error(RuntimeError, "example message") { |err| + ran = true + 5.should == 4 + passed = true + } + }.should fail_with(/expected: 4/m) + + ran.should == true + passed.should == false + end + + it "should NOT yield exception if no error was thrown" do + ran = false + + lambda { + lambda {}.should raise_error(RuntimeError, "example message") { |err| + ran = true + } + }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised") + + ran.should == false + end + + it "should not yield exception if error class is not matched" do + ran = false + + lambda { + lambda { + raise "example message" + }.should raise_error(SyntaxError, "example message") { |err| + ran = true + } + }.should fail_with("expected SyntaxError with \"example message\", got #<RuntimeError: example message>") + + ran.should == false + end + + it "should NOT yield exception if error message is not matched" do + ran = false + + lambda { + lambda { + raise "example message" + }.should raise_error(RuntimeError, "different message") { |err| + ran = true + } + }.should fail_with("expected RuntimeError with \"different message\", got #<RuntimeError: example message>") + + ran.should == false + end +end + +describe "should_not raise_error(NamedError, error_message) { |err| ... }" do + it "should pass if nothing is raised" do + ran = false + + lambda {}.should_not raise_error(RuntimeError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should pass if a different error is raised" do + ran = false + + lambda { raise }.should_not raise_error(NameError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should pass if same error is raised with different message" do + ran = false + + lambda { + raise RuntimeError.new("not the example message") + }.should_not raise_error(RuntimeError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should fail if named error is raised with same message" do + ran = false + + lambda { + lambda { + raise "example message" + }.should_not raise_error(RuntimeError, "example message") { |err| + ran = true + } + }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>") + + ran.should == false + end +end + describe "should_not raise_error(NamedError, error_message) with String" do it "should pass if nothing is raised" do lambda {}.should_not raise_error(RuntimeError, "example message") vendor/plugins/rspec/spec/spec/matchers/raise_error_spec.rb @@ -8,8 +8,8 @@ describe "should respond_to(:sym)" do it "should fail target does not respond to :sym" do lambda { - Object.new.should respond_to(:some_method) - }.should fail_with("expected target to respond to :some_method") + "this string".should respond_to(:some_method) + }.should fail_with("expected \"this string\" to respond to :some_method") end end @@ -23,19 +23,19 @@ describe "should respond_to(message1, message2)" do it "should fail target does not respond to first message" do lambda { Object.new.should respond_to('method_one', 'inspect') - }.should fail_with('expected target to respond to "method_one"') + }.should fail_with(/expected #<Object:.*> to respond to "method_one"/) end it "should fail target does not respond to second message" do lambda { Object.new.should respond_to('inspect', 'method_one') - }.should fail_with('expected target to respond to "method_one"') + }.should fail_with(/expected #<Object:.*> to respond to "method_one"/) end it "should fail target does not respond to either message" do lambda { Object.new.should respond_to('method_one', 'method_two') - }.should fail_with('expected target to respond to "method_one", "method_two"') + }.should fail_with(/expected #<Object:.*> to respond to "method_one", "method_two"/) end end @@ -48,7 +48,7 @@ describe "should_not respond_to(:sym)" do it "should fail target responds to :sym" do lambda { Object.new.should_not respond_to(:methods) - }.should fail_with("expected target not to respond to :methods") + }.should fail_with(/expected #<Object:.*> not to respond to :methods/) end end vendor/plugins/rspec/spec/spec/matchers/respond_to_spec.rb @@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../spec_helper' module Spec module Matchers describe SimpleMatcher do - it "should match pass match arg to block" do + it "should pass match arg to block" do actual = nil matcher = simple_matcher("message") do |given| actual = given end matcher.matches?("foo") @@ -22,10 +22,72 @@ module Spec matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/ end - it "should provide a description" do + it "should provide the given description" do matcher = simple_matcher("thing") do end matcher.description.should =="thing" end + + it "should fail if a wrapped 'should' fails" do + matcher = simple_matcher("should fail") do + 2.should == 3 + end + lambda do + matcher.matches?("anything").should be_true + end.should fail_with(/expected: 3/) + end + end + + describe "with arity of 2" do + it "should provide the matcher so you can access its messages" do + provided_matcher = nil + matcher = simple_matcher("thing") do |given, matcher| + provided_matcher = matcher + end + matcher.matches?("anything") + provided_matcher.should equal(matcher) + end + + it "should support a custom failure message" do + matcher = simple_matcher("thing") do |given, matcher| + matcher.failure_message = "custom message" + end + matcher.matches?("other") + matcher.failure_message.should == "custom message" + end + + it "should complain when asked for a failure message if you don't give it a description or a message" do + matcher = simple_matcher do |given, matcher| end + matcher.matches?("other") + matcher.failure_message.should =~ /No description provided/ + end + + it "should support a custom negative failure message" do + matcher = simple_matcher("thing") do |given, matcher| + matcher.negative_failure_message = "custom message" + end + matcher.matches?("other") + matcher.negative_failure_message.should == "custom message" + end + + it "should complain when asked for a negative failure message if you don't give it a description or a message" do + matcher = simple_matcher do |given, matcher| end + matcher.matches?("other") + matcher.negative_failure_message.should =~ /No description provided/ + end + + it "should support a custom description" do + matcher = simple_matcher("thing") do |given, matcher| + matcher.description = "custom message" + end + matcher.matches?("description") + matcher.description.should == "custom message" + end + + it "should tell you no description was provided when it doesn't receive one" do + matcher = simple_matcher do end + matcher.description.should =~ /No description provided/ + end end + end end \ No newline at end of file vendor/plugins/rspec/spec/spec/matchers/simple_matcher_spec.rb @@ -2,52 +2,94 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' module Spec module Matchers - describe ThrowSymbol, "(constructed with no Symbol)" do - before(:each) { @matcher = ThrowSymbol.new } - - it "should match if any Symbol is thrown" do - @matcher.matches?(lambda{ throw :sym }).should be_true - end - it "should not match if no Symbol is thrown" do - @matcher.matches?(lambda{ }).should be_false - end - it "should provide a failure message" do - @matcher.matches?(lambda{}) - @matcher.failure_message.should == "expected a Symbol but nothing was thrown" - end - it "should provide a negative failure message" do - @matcher.matches?(lambda{ throw :sym}) - @matcher.negative_failure_message.should == "expected no Symbol, got :sym" - end - end - - describe ThrowSymbol, "(constructed with a Symbol)" do - before(:each) { @matcher = ThrowSymbol.new(:sym) } + describe ThrowSymbol do + describe "with no args" do + before(:each) { @matcher = ThrowSymbol.new } - it "should match if correct Symbol is thrown" do - @matcher.matches?(lambda{ throw :sym }).should be_true + it "should match if any Symbol is thrown" do + @matcher.matches?(lambda{ throw :sym }).should be_true + end + it "should match if any Symbol is thrown with an arg" do + @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true + end + it "should not match if no Symbol is thrown" do + @matcher.matches?(lambda{ }).should be_false + end + it "should provide a failure message" do + @matcher.matches?(lambda{}) + @matcher.failure_message.should == "expected a Symbol but nothing was thrown" + end + it "should provide a negative failure message" do + @matcher.matches?(lambda{ throw :sym}) + @matcher.negative_failure_message.should == "expected no Symbol, got :sym" + end end - it "should not match if no Symbol is thrown" do - @matcher.matches?(lambda{ }).should be_false - end - it "should not match if correct Symbol is thrown" do - @matcher.matches?(lambda{ throw :other_sym }).should be_false - @matcher.failure_message.should == "expected :sym, got :other_sym" - end - it "should provide a failure message when no Symbol is thrown" do - @matcher.matches?(lambda{}) - @matcher.failure_message.should == "expected :sym but nothing was thrown" - end - it "should provide a failure message when wrong Symbol is thrown" do - @matcher.matches?(lambda{ throw :other_sym }) - @matcher.failure_message.should == "expected :sym, got :other_sym" - end - it "should provide a negative failure message" do - @matcher.matches?(lambda{ throw :sym }) - @matcher.negative_failure_message.should == "expected :sym not to be thrown" + + describe "with a symbol" do + before(:each) { @matcher = ThrowSymbol.new(:sym) } + + it "should match if correct Symbol is thrown" do + @matcher.matches?(lambda{ throw :sym }).should be_true + end + it "should match if correct Symbol is thrown with an arg" do + @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true + end + it "should not match if no Symbol is thrown" do + @matcher.matches?(lambda{ }).should be_false + end + it "should not match if correct Symbol is thrown" do + @matcher.matches?(lambda{ throw :other_sym }).should be_false + end + it "should provide a failure message when no Symbol is thrown" do + @matcher.matches?(lambda{}) + @matcher.failure_message.should == "expected :sym but nothing was thrown" + end + it "should provide a failure message when wrong Symbol is thrown" do + @matcher.matches?(lambda{ throw :other_sym }) + @matcher.failure_message.should == "expected :sym, got :other_sym" + end + it "should provide a negative failure message" do + @matcher.matches?(lambda{ throw :sym }) + @matcher.negative_failure_message.should == "expected :sym not to be thrown" + end + it "should only match NameErrors raised by uncaught throws" do + @matcher.matches?(lambda{ sym }).should be_false + end end - it "should only match NameErrors raised by uncaught throws" do - @matcher.matches?(lambda{ sym }).should be_false + + describe "with a symbol and an arg" do + before(:each) { @matcher = ThrowSymbol.new(:sym, "a") } + + it "should match if correct Symbol and args are thrown" do + @matcher.matches?(lambda{ throw :sym, "a" }).should be_true + end + it "should not match if nothing is thrown" do + @matcher.matches?(lambda{ }).should be_false + end + it "should not match if other Symbol is thrown" do + @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false + end + it "should not match if no arg is thrown" do + @matcher.matches?(lambda{ throw :sym }).should be_false + end + it "should not match if wrong arg is thrown" do + @matcher.matches?(lambda{ throw :sym, "b" }).should be_false + end + it "should provide a failure message when no Symbol is thrown" do + @matcher.matches?(lambda{}) + @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown] + end + it "should provide a failure message when wrong Symbol is thrown" do + @matcher.matches?(lambda{ throw :other_sym }) + @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym] + end + it "should provide a negative failure message" do + @matcher.matches?(lambda{ throw :sym }) + @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown] + end + it "should only match NameErrors raised by uncaught throws" do + @matcher.matches?(lambda{ sym }).should be_false + end end end end vendor/plugins/rspec/spec/spec/matchers/throw_symbol_spec.rb @@ -23,6 +23,13 @@ module Spec it "should pass if any number of times method is not called" do @mock.should_receive(:random_call).any_number_of_times end + + it "should return the mocked value when called after a similar stub" do + @mock.stub!(:message).and_return :stub_value + @mock.should_receive(:message).any_number_of_times.and_return(:mock_value) + @mock.message.should == :mock_value + @mock.message.should == :mock_value + end end end vendor/plugins/rspec/spec/spec/mocks/any_number_of_times_spec.rb @@ -1,11 +1,11 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb' class LiarLiarPantsOnFire - def respond_to?(sym) + def respond_to?(sym, incl_private=false) true end - def self.respond_to?(sym) + def self.respond_to?(sym, incl_private=false) true end end @@ -26,6 +26,7 @@ describe 'should_receive' do end it 'should cleanup after itself' do - LiarLiarPantsOnFire.metaclass.instance_methods.should_not include("something") + (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something") end end + vendor/plugins/rspec/spec/spec/mocks/bug_report_11545_spec.rb @@ -75,41 +75,21 @@ module Spec @mock.msg(37) end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)") end - end - describe "failing deprecated MockArgumentConstraints" do - before(:each) do - @mock = mock("test mock") - @reporter = Mock.new("reporter", :null_object => true) - Kernel.stub!(:warn) + it "should fail hash_including with missing key" do + lambda do + @mock.should_receive(:msg).with(hash_including(:a => 1)) + @mock.msg({}) + end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (hash_including(:a=>1)) but received it with ({})") end - after(:each) do - @mock.rspec_reset - end - - it "should reject non boolean" do - @mock.should_receive(:random_call).with(:boolean) + it "should fail with block constraints" do lambda do - @mock.random_call("false") - end.should raise_error(MockExpectationError) + @mock.should_receive(:msg).with {|arg| arg.should == :received } + @mock.msg :no_msg_for_you + end.should raise_error(Spec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/) end - - it "should reject non numeric" do - @mock.should_receive(:random_call).with(:numeric) - lambda do - @mock.random_call("1") - end.should raise_error(MockExpectationError) - end - - it "should reject non string" do - @mock.should_receive(:random_call).with(:string) - lambda do - @mock.random_call(123) - end.should raise_error(MockExpectationError) - end - - + end end end