diff options
385 files changed, 31899 insertions, 0 deletions
diff --git a/vendor/gems/rspec-1.3.1/.document b/vendor/gems/rspec-1.3.1/.document new file mode 100644 index 000000000..c845fd37d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/.document @@ -0,0 +1,7 @@ +features/**/*.feature +lib/**/*.rb +History.rdoc +License.txt +README.rdoc +Ruby1.9.rdoc +Upgrade.rdoc diff --git a/vendor/gems/rspec-1.3.1/.specification b/vendor/gems/rspec-1.3.1/.specification new file mode 100644 index 000000000..bdc08e236 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/.specification @@ -0,0 +1,574 @@ +--- !ruby/object:Gem::Specification +name: rspec +version: !ruby/object:Gem::Version + hash: 25 + prerelease: false + segments: + - 1 + - 3 + - 1 + version: 1.3.1 +platform: ruby +authors: +- RSpec Development Team +autorequire: +bindir: bin +cert_chain: [] + +date: 2010-10-09 00:00:00 +01:00 +default_executable: +dependencies: +- !ruby/object:Gem::Dependency + name: rubyforge + prerelease: false + requirement: &id001 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 7 + segments: + - 2 + - 0 + - 4 + version: 2.0.4 + type: :development + version_requirements: *id001 +- !ruby/object:Gem::Dependency + name: cucumber + prerelease: false + requirement: &id002 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 13 + segments: + - 0 + - 3 + version: "0.3" + type: :development + version_requirements: *id002 +- !ruby/object:Gem::Dependency + name: fakefs + prerelease: false + requirement: &id003 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 21 + segments: + - 0 + - 2 + - 1 + version: 0.2.1 + type: :development + version_requirements: *id003 +- !ruby/object:Gem::Dependency + name: syntax + prerelease: false + requirement: &id004 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 15 + segments: + - 1 + - 0 + version: "1.0" + type: :development + version_requirements: *id004 +- !ruby/object:Gem::Dependency + name: diff-lcs + prerelease: false + requirement: &id005 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 23 + segments: + - 1 + - 1 + - 2 + version: 1.1.2 + type: :development + version_requirements: *id005 +- !ruby/object:Gem::Dependency + name: heckle + prerelease: false + requirement: &id006 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 1 + segments: + - 1 + - 4 + - 3 + version: 1.4.3 + type: :development + version_requirements: *id006 +- !ruby/object:Gem::Dependency + name: hoe + prerelease: false + requirement: &id007 !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 19 + segments: + - 2 + - 6 + - 2 + version: 2.6.2 + type: :development + version_requirements: *id007 +description: Behaviour Driven Development for Ruby. +email: +- rspec-devel@rubyforge.org +executables: +- autospec +- spec +extensions: [] + +extra_rdoc_files: +- License.txt +- Manifest.txt +- TODO.txt +- examples/failing/README.txt +files: +- .document +- History.rdoc +- License.txt +- Manifest.txt +- README.rdoc +- Rakefile +- Ruby1.9.rdoc +- TODO.txt +- Upgrade.rdoc +- bin/autospec +- bin/spec +- cucumber.yml +- examples/failing/README.txt +- examples/failing/diffing_spec.rb +- examples/failing/failing_implicit_docstrings_example.rb +- examples/failing/failure_in_after.rb +- examples/failing/failure_in_before.rb +- examples/failing/mocking_example.rb +- examples/failing/mocking_with_flexmock.rb +- examples/failing/mocking_with_mocha.rb +- examples/failing/mocking_with_rr.rb +- examples/failing/partial_mock_example.rb +- examples/failing/pending_example.rb +- examples/failing/predicate_example.rb +- examples/failing/raising_example.rb +- examples/failing/syntax_error_example.rb +- examples/failing/team_spec.rb +- examples/failing/timeout_behaviour.rb +- examples/passing/custom_formatter.rb +- examples/passing/custom_matchers.rb +- examples/passing/dynamic_spec.rb +- examples/passing/file_accessor.rb +- examples/passing/file_accessor_spec.rb +- examples/passing/filtered_formatter.rb +- examples/passing/filtered_formatter_example.rb +- examples/passing/greeter_spec.rb +- examples/passing/helper_method_example.rb +- examples/passing/implicit_docstrings_example.rb +- examples/passing/io_processor.rb +- examples/passing/io_processor_spec.rb +- examples/passing/mocking_example.rb +- examples/passing/multi_threaded_example_group_runner.rb +- examples/passing/nested_classes_example.rb +- examples/passing/options_example.rb +- examples/passing/options_formatter.rb +- examples/passing/partial_mock_example.rb +- examples/passing/pending_example.rb +- examples/passing/predicate_example.rb +- examples/passing/shared_example_group_example.rb +- examples/passing/shared_stack_examples.rb +- examples/passing/simple_matcher_example.rb +- examples/passing/stack.rb +- examples/passing/stack_spec.rb +- examples/passing/stack_spec_with_nested_example_groups.rb +- examples/passing/stubbing_example.rb +- examples/passing/yielding_example.rb +- examples/ruby1.9.compatibility/access_to_constants_spec.rb +- features/before_and_after_blocks/before_and_after_blocks.feature +- features/command_line/line_number_option.feature +- features/command_line/line_number_option_with_example_with_no_name.feature +- features/example_groups/define_example_attribute.feature +- features/example_groups/example_group_with_should_methods.feature +- features/example_groups/implicit_docstrings.feature +- features/example_groups/nested_groups.feature +- features/expectations/customized_message.feature +- features/expectations/expect_change.feature +- features/expectations/expect_error.feature +- features/extensions/custom_example_group.feature +- features/formatters/custom_formatter.feature +- features/formatters/nested_formatter.feature +- features/interop/cucumber_stubs_dont_leak.feature +- features/interop/examples_and_tests_together.feature +- features/interop/rspec_output.feature +- features/interop/test_but_not_test_unit.feature +- features/interop/test_case_with_should_methods.feature +- features/load_paths/add_lib_to_load_path.feature +- features/load_paths/add_spec_to_load_path.feature +- features/matchers/define_diffable_matcher.feature +- features/matchers/define_matcher.feature +- features/matchers/define_matcher_outside_rspec.feature +- features/matchers/define_matcher_with_fluent_interface.feature +- features/matchers/define_wrapped_matcher.feature +- features/matchers/match_unless_raises.feature +- features/matchers/match_unless_raises_unexpected_error.feature +- features/mock_framework_integration/use_flexmock.feature +- features/mock_framework_integration/use_mocha.feature +- features/mock_framework_integration/use_rr.feature +- features/mocks/block_local_expectations.feature +- features/mocks/mix_stubs_and_mocks.feature +- features/mocks/stub_implementation.feature +- features/pending/pending_examples.feature +- features/runner/specify_line_number.feature +- features/spec_helper/spec_helper.feature +- features/step_definitions/running_rspec_steps.rb +- features/step_definitions/stubbing_steps.rb +- features/subject/explicit_subject.feature +- features/subject/implicit_subject.feature +- features/support/env.rb +- features/support/matchers/smart_match.rb +- geminstaller.yml +- init.rb +- lib/autotest/discover.rb +- lib/autotest/rspec.rb +- lib/spec.rb +- lib/spec/adapters/mock_frameworks/flexmock.rb +- lib/spec/adapters/mock_frameworks/mocha.rb +- lib/spec/adapters/mock_frameworks/rr.rb +- lib/spec/adapters/mock_frameworks/rspec.rb +- lib/spec/autorun.rb +- lib/spec/deprecation.rb +- lib/spec/dsl.rb +- lib/spec/dsl/main.rb +- lib/spec/example.rb +- lib/spec/example/args_and_options.rb +- lib/spec/example/before_and_after_hooks.rb +- lib/spec/example/errors.rb +- lib/spec/example/example_group.rb +- lib/spec/example/example_group_factory.rb +- lib/spec/example/example_group_hierarchy.rb +- lib/spec/example/example_group_methods.rb +- lib/spec/example/example_group_proxy.rb +- lib/spec/example/example_matcher.rb +- lib/spec/example/example_methods.rb +- lib/spec/example/example_proxy.rb +- lib/spec/example/module_reopening_fix.rb +- lib/spec/example/pending.rb +- lib/spec/example/predicate_matchers.rb +- lib/spec/example/shared_example_group.rb +- lib/spec/example/subject.rb +- lib/spec/expectations.rb +- lib/spec/expectations/errors.rb +- lib/spec/expectations/extensions.rb +- lib/spec/expectations/extensions/kernel.rb +- lib/spec/expectations/fail_with.rb +- lib/spec/expectations/handler.rb +- lib/spec/extensions/instance_exec.rb +- lib/spec/interop/test.rb +- lib/spec/interop/test/unit/autorunner.rb +- lib/spec/interop/test/unit/testcase.rb +- lib/spec/interop/test/unit/testresult.rb +- lib/spec/interop/test/unit/testsuite_adapter.rb +- lib/spec/interop/test/unit/ui/console/testrunner.rb +- lib/spec/matchers.rb +- lib/spec/matchers/be.rb +- lib/spec/matchers/be_close.rb +- lib/spec/matchers/be_instance_of.rb +- lib/spec/matchers/be_kind_of.rb +- lib/spec/matchers/change.rb +- lib/spec/matchers/compatibility.rb +- lib/spec/matchers/dsl.rb +- lib/spec/matchers/eql.rb +- lib/spec/matchers/equal.rb +- lib/spec/matchers/errors.rb +- lib/spec/matchers/exist.rb +- lib/spec/matchers/generated_descriptions.rb +- lib/spec/matchers/has.rb +- lib/spec/matchers/have.rb +- lib/spec/matchers/include.rb +- lib/spec/matchers/match.rb +- lib/spec/matchers/match_array.rb +- lib/spec/matchers/matcher.rb +- lib/spec/matchers/method_missing.rb +- lib/spec/matchers/operator_matcher.rb +- lib/spec/matchers/pretty.rb +- lib/spec/matchers/raise_exception.rb +- lib/spec/matchers/respond_to.rb +- lib/spec/matchers/satisfy.rb +- lib/spec/matchers/simple_matcher.rb +- lib/spec/matchers/throw_symbol.rb +- lib/spec/matchers/wrap_expectation.rb +- lib/spec/mocks.rb +- lib/spec/mocks/argument_expectation.rb +- lib/spec/mocks/argument_matchers.rb +- lib/spec/mocks/error_generator.rb +- lib/spec/mocks/errors.rb +- lib/spec/mocks/example_methods.rb +- lib/spec/mocks/extensions.rb +- lib/spec/mocks/extensions/object.rb +- lib/spec/mocks/framework.rb +- lib/spec/mocks/message_expectation.rb +- lib/spec/mocks/methods.rb +- lib/spec/mocks/mock.rb +- lib/spec/mocks/order_group.rb +- lib/spec/mocks/proxy.rb +- lib/spec/mocks/space.rb +- lib/spec/rake/spectask.rb +- lib/spec/rake/verify_rcov.rb +- lib/spec/ruby.rb +- lib/spec/runner.rb +- lib/spec/runner/backtrace_tweaker.rb +- lib/spec/runner/class_and_arguments_parser.rb +- lib/spec/runner/command_line.rb +- lib/spec/runner/configuration.rb +- lib/spec/runner/differs/default.rb +- lib/spec/runner/differs/load-diff-lcs.rb +- lib/spec/runner/drb_command_line.rb +- lib/spec/runner/example_group_runner.rb +- lib/spec/runner/extensions/kernel.rb +- lib/spec/runner/formatter/base_formatter.rb +- lib/spec/runner/formatter/base_text_formatter.rb +- lib/spec/runner/formatter/failing_example_groups_formatter.rb +- lib/spec/runner/formatter/failing_examples_formatter.rb +- lib/spec/runner/formatter/html_formatter.rb +- lib/spec/runner/formatter/nested_text_formatter.rb +- lib/spec/runner/formatter/no_op_method_missing.rb +- lib/spec/runner/formatter/profile_formatter.rb +- lib/spec/runner/formatter/progress_bar_formatter.rb +- lib/spec/runner/formatter/silent_formatter.rb +- lib/spec/runner/formatter/snippet_extractor.rb +- lib/spec/runner/formatter/specdoc_formatter.rb +- lib/spec/runner/formatter/text_mate_formatter.rb +- lib/spec/runner/heckle_runner.rb +- lib/spec/runner/heckle_runner_unsupported.rb +- lib/spec/runner/line_number_query.rb +- lib/spec/runner/option_parser.rb +- lib/spec/runner/options.rb +- lib/spec/runner/reporter.rb +- lib/spec/stubs/cucumber.rb +- lib/spec/test/unit.rb +- lib/spec/version.rb +- resources/helpers/cmdline.rb +- resources/rake/examples.rake +- resources/rake/examples_with_rcov.rake +- resources/rake/failing_examples_with_html.rake +- resources/rake/verify_rcov.rake +- spec/README.jruby +- spec/autotest/autotest_helper.rb +- spec/autotest/autotest_matchers.rb +- spec/autotest/discover_spec.rb +- spec/autotest/failed_results_re_spec.rb +- spec/autotest/rspec_spec.rb +- spec/ruby_forker.rb +- spec/spec.opts +- spec/spec/dsl/main_spec.rb +- spec/spec/example/example_group_class_definition_spec.rb +- spec/spec/example/example_group_factory_spec.rb +- spec/spec/example/example_group_methods_spec.rb +- spec/spec/example/example_group_proxy_spec.rb +- spec/spec/example/example_group_spec.rb +- spec/spec/example/example_matcher_spec.rb +- spec/spec/example/example_methods_spec.rb +- spec/spec/example/example_proxy_spec.rb +- spec/spec/example/helper_method_spec.rb +- spec/spec/example/nested_example_group_spec.rb +- spec/spec/example/pending_module_spec.rb +- spec/spec/example/predicate_matcher_spec.rb +- spec/spec/example/shared_example_group_spec.rb +- spec/spec/example/subclassing_example_group_spec.rb +- spec/spec/example/subject_spec.rb +- spec/spec/expectations/differs/default_spec.rb +- spec/spec/expectations/extensions/kernel_spec.rb +- spec/spec/expectations/fail_with_spec.rb +- spec/spec/expectations/handler_spec.rb +- spec/spec/expectations/wrap_expectation_spec.rb +- spec/spec/interop/test/unit/resources/spec_that_fails.rb +- spec/spec/interop/test/unit/resources/spec_that_passes.rb +- spec/spec/interop/test/unit/resources/spec_with_errors.rb +- spec/spec/interop/test/unit/resources/spec_with_options_hash.rb +- spec/spec/interop/test/unit/resources/test_case_that_fails.rb +- spec/spec/interop/test/unit/resources/test_case_that_passes.rb +- spec/spec/interop/test/unit/resources/test_case_with_errors.rb +- spec/spec/interop/test/unit/resources/test_case_with_various_names.rb +- spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb +- spec/spec/interop/test/unit/spec_spec.rb +- spec/spec/interop/test/unit/test_unit_spec_helper.rb +- spec/spec/interop/test/unit/testcase_spec.rb +- spec/spec/interop/test/unit/testsuite_adapter_spec.rb +- spec/spec/matchers/be_close_spec.rb +- spec/spec/matchers/be_instance_of_spec.rb +- spec/spec/matchers/be_kind_of_spec.rb +- spec/spec/matchers/be_spec.rb +- spec/spec/matchers/change_spec.rb +- spec/spec/matchers/compatibility_spec.rb +- spec/spec/matchers/description_generation_spec.rb +- spec/spec/matchers/dsl_spec.rb +- spec/spec/matchers/eql_spec.rb +- spec/spec/matchers/equal_spec.rb +- spec/spec/matchers/exist_spec.rb +- spec/spec/matchers/has_spec.rb +- spec/spec/matchers/have_spec.rb +- spec/spec/matchers/include_spec.rb +- spec/spec/matchers/match_array_spec.rb +- spec/spec/matchers/match_spec.rb +- spec/spec/matchers/matcher_spec.rb +- spec/spec/matchers/matchers_spec.rb +- spec/spec/matchers/operator_matcher_spec.rb +- spec/spec/matchers/raise_exception_spec.rb +- spec/spec/matchers/respond_to_spec.rb +- spec/spec/matchers/satisfy_spec.rb +- spec/spec/matchers/simple_matcher_spec.rb +- spec/spec/matchers/throw_symbol_spec.rb +- spec/spec/mocks/and_yield_spec.rb +- spec/spec/mocks/any_number_of_times_spec.rb +- spec/spec/mocks/argument_expectation_spec.rb +- spec/spec/mocks/argument_matchers_spec.rb +- spec/spec/mocks/at_least_spec.rb +- spec/spec/mocks/at_most_spec.rb +- spec/spec/mocks/bug_report_10260_spec.rb +- spec/spec/mocks/bug_report_10263_spec.rb +- spec/spec/mocks/bug_report_11545_spec.rb +- spec/spec/mocks/bug_report_15719_spec.rb +- spec/spec/mocks/bug_report_496_spec.rb +- spec/spec/mocks/bug_report_600_spec.rb +- spec/spec/mocks/bug_report_7611_spec.rb +- spec/spec/mocks/bug_report_7805_spec.rb +- spec/spec/mocks/bug_report_8165_spec.rb +- spec/spec/mocks/bug_report_8302_spec.rb +- spec/spec/mocks/bug_report_830_spec.rb +- spec/spec/mocks/double_spec.rb +- spec/spec/mocks/failing_argument_matchers_spec.rb +- spec/spec/mocks/hash_including_matcher_spec.rb +- spec/spec/mocks/hash_not_including_matcher_spec.rb +- spec/spec/mocks/mock_ordering_spec.rb +- spec/spec/mocks/mock_space_spec.rb +- spec/spec/mocks/mock_spec.rb +- spec/spec/mocks/multiple_return_value_spec.rb +- spec/spec/mocks/nil_expectation_warning_spec.rb +- spec/spec/mocks/null_object_mock_spec.rb +- spec/spec/mocks/once_counts_spec.rb +- spec/spec/mocks/options_hash_spec.rb +- spec/spec/mocks/partial_mock_spec.rb +- spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb +- spec/spec/mocks/passing_argument_matchers_spec.rb +- spec/spec/mocks/precise_counts_spec.rb +- spec/spec/mocks/record_messages_spec.rb +- spec/spec/mocks/stub_chain_spec.rb +- spec/spec/mocks/stub_implementation_spec.rb +- spec/spec/mocks/stub_spec.rb +- spec/spec/mocks/stubbed_message_expectations_spec.rb +- spec/spec/mocks/twice_counts_spec.rb +- spec/spec/mocks/unstub_spec.rb +- spec/spec/package/bin_spec_spec.rb +- spec/spec/rake/spectask_spec.rb +- spec/spec/runner/class_and_argument_parser_spec.rb +- spec/spec/runner/command_line_spec.rb +- spec/spec/runner/configuration_spec.rb +- spec/spec/runner/drb_command_line_spec.rb +- spec/spec/runner/empty_file.txt +- spec/spec/runner/example_group_runner_spec.rb +- spec/spec/runner/examples.txt +- spec/spec/runner/failed.txt +- spec/spec/runner/formatter/base_formatter_spec.rb +- spec/spec/runner/formatter/base_text_formatter_spec.rb +- spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb +- spec/spec/runner/formatter/failing_examples_formatter_spec.rb +- spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html +- spec/spec/runner/formatter/html_formatted-1.8.6.html +- spec/spec/runner/formatter/html_formatted-1.8.7.html +- spec/spec/runner/formatter/html_formatted-1.9.1.html +- spec/spec/runner/formatter/html_formatter_spec.rb +- spec/spec/runner/formatter/nested_text_formatter_spec.rb +- spec/spec/runner/formatter/profile_formatter_spec.rb +- spec/spec/runner/formatter/progress_bar_formatter_spec.rb +- spec/spec/runner/formatter/snippet_extractor_spec.rb +- spec/spec/runner/formatter/specdoc_formatter_spec.rb +- spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html +- spec/spec/runner/formatter/text_mate_formatted-1.8.6.html +- spec/spec/runner/formatter/text_mate_formatted-1.8.7.html +- spec/spec/runner/formatter/text_mate_formatted-1.9.1.html +- spec/spec/runner/formatter/text_mate_formatter_spec.rb +- spec/spec/runner/heckle_runner_spec.rb +- spec/spec/runner/heckler_spec.rb +- spec/spec/runner/line_number_query/line_number_query_fixture.rb +- spec/spec/runner/line_number_query_spec.rb +- spec/spec/runner/noisy_backtrace_tweaker_spec.rb +- spec/spec/runner/option_parser_spec.rb +- spec/spec/runner/options_spec.rb +- spec/spec/runner/output_one_time_fixture.rb +- spec/spec/runner/output_one_time_fixture_runner.rb +- spec/spec/runner/output_one_time_spec.rb +- spec/spec/runner/quiet_backtrace_tweaker_spec.rb +- spec/spec/runner/reporter_spec.rb +- spec/spec/runner/resources/a_bar.rb +- spec/spec/runner/resources/a_foo.rb +- spec/spec/runner/resources/a_spec.rb +- spec/spec/runner/resources/custom_example_group_runner.rb +- spec/spec/runner/resources/utf8_encoded.rb +- spec/spec/runner/spec.opts +- spec/spec/runner/spec_drb.opts +- spec/spec/runner/spec_spaced.opts +- spec/spec/runner_spec.rb +- spec/spec_helper.rb +- spec/support/macros.rb +- spec/support/spec_classes.rb +has_rdoc: true +homepage: http://rspec.info +licenses: [] + +post_install_message: | + ************************************************** + + Thank you for installing rspec-1.3.1 + + Please be sure to read History.rdoc and Upgrade.rdoc + for useful information about this release. + + ************************************************** + +rdoc_options: +- --main +- README.rdoc +require_paths: +- lib +required_ruby_version: !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 3 + segments: + - 0 + version: "0" +required_rubygems_version: !ruby/object:Gem::Requirement + none: false + requirements: + - - ">=" + - !ruby/object:Gem::Version + hash: 3 + segments: + - 0 + version: "0" +requirements: [] + +rubyforge_project: rspec +rubygems_version: 1.3.7 +signing_key: +specification_version: 3 +summary: rspec 1.3.1 +test_files: [] + diff --git a/vendor/gems/rspec-1.3.1/History.rdoc b/vendor/gems/rspec-1.3.1/History.rdoc new file mode 100644 index 000000000..380ac7f18 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/History.rdoc @@ -0,0 +1,1546 @@ +=== Version 1.3.1 / 2010-10-09 + +* enhancements + * Array =~ matcher works with subclasses of Array (Matthew Peychich & Pat Maddox) + * config.suppress_deprecation_warnings! + +* bug fixes + * QuitBacktraceTweaker no longer eats all paths with 'lib' + (Tim Harper - #912) + * Fix delegation of stubbed values on superclass class-level methods. + (Scott Taylor - #496 - #957) + * Fix pending to work with ruby-1.9 + +* deprecations + * share_as (will be removed from rspec-core-2.0) + * simple_matcher (will be removed from rspec-core-2.0) + +=== Version 1.3.0 / 2010-01-11 + +* enhancements + * capture ExpectationNotMet error by default in matcher DSL + * supports wrapping other expectations + * added match_unless_raises to matcher DSL + * supports easy wrapping of t/u assertions in matchers + * thanks to Chad Fowler and Glenn Vanderburg for the name + * add chain to matcher DSL (Joe Ferris - #935) + * see rdoc for Spec::Matchers + * and_yield provides configurable eval_context + * Eric Meyer & David Chelimsky + * CTRL-C actually stops execution! (Bryan Helmkamp - #911) + * make drb port configurable (Chris Flipse - #875) + * changed raise_error to raise_exception (#933) + * kept raise_error aliased, so this is completely + backwards compatible + +* bug fixes + * don't define top-level context() method when running in IRB (#899) + * remove Ruby warning for uninitialized ivar (Bryan Helmkamp - #892) + * fully qualify reference to Default (Alex Sharp - #895) + * use runtime version of Test::Unit::VERSION in incompatibility message + (Ryan Bigg - #916) + * quote paths in RSpec's own specs so people running in paths with + spaces in them can achieve green too (Ryan Bigg - #917) + * ensure drb specs run when EADDRNOTAVAIL (Michael Klett - #881) + * throw_symbol matcher correctly bubbles errors up (#918) + * make Rakefile work without Cucumber installed (#919 - devrandom) + * escape . in regexp (#925) + * align be_true and be_false with Ruby's conditional semantics (#931) + * print duplicate nested descriptions (when appropriate) (#936) + +=== Version 1.2.9 / 2009-10-05 + +* enhancements + * manage backtrace-ignore patterns with Spec::Runner.configure (Martin + Emde). Closes #870. + * friendly mock argument expectation failure message (Tim Harper). Closes + #868. + * added double() as alias for stub() and mock() + * failure messages for doubles, mocks and stubs use the right name + * add let() method to assign memoized attributes (suggestion from Stuart + Halloway). Closes #857. + * add its method so you can say: + describe Array do + its(:length) { should == 0 } + (Stephen Touset). Closes #833 + * spec command automatically uses spec/spec.opts if it is present + (suggestion from Yehuda Katz) + * rspec now adds PROJECT_ROOT/lib and PROJECT_ROOT/spec to the load path + * determines PROJECT_ROOT by recursing up until it finds a directory + that has a ./spec directory (thanks to Scott Taylor) + * supports require 'spec_helper' + * supports running specs from the PROJECT_ROOT or any directory + below it + * closes #733 + * better handling of determining test names in test/unit/interop mode + * Joe Ferris + * closes #854 + +* bug fixes + + * Fixed problem with colorized output when writing to a file + * Corey Ehmke + * closes #777 + +* not really a bug fix or enhancement + * temporarily moved heckle feature to features-pending (waiting to see what + happens with + http://rubyforge.org/tracker/index.php?func=detail&aid=26786&group_id=1513&atid=5921) + +=== Version 1.2.8 / 2009-07-16 + +* enhancements + * better messages for should[_not] be_nil (Chad Humphries and Rob Sanheim) + * should and should_not accept optional custom message + (suggestion from Rob Sanheim) + * result.should be_nil, "expected result to be nil" + * added 'spec/stubs/cucumber' to plug RSpec's stubbing framework into + Cucumber scenarios. + * added unstub method to remove a stub mid-example (Scott Taylor). Closes + #853. + * add more readable diff when expected and actual are hashes (Ryan Bigg). + Closes #848. + +* bug fixes + * fixed --line option for ruby 1.9.1 + * fix stub_chain conflict between two chains starting with the same message + (Mike Rohland). Closes #846. + +=== Version 1.2.7 / 2009-06-22 + +* enhancments + * added support for fakes using obj.stub(:method) { # implementation } + * allow subject { self } (Jarmo Pertman). Closes #816. + * friendly error message when a matcher returns nil on a failure message + * add ruby_cmd option to SpecTask (Rick DeNatale). Closes #823. + * also added missing specs for SpecTask - thanks Rick! + * add support for generating matchers with fluent interfaces with the + Matcher DSL + +* bug fixes + * NegativeOperatorMatcher now returns false (Wesley Beary). Closes #812. + * derive MockExpectationError from Exception rather than StandardError + (Kerry Buckley). Closes #830. + * fix bug where multi-line failure messages weren't getting picked up by + autotest (Jarmo Pertman). Closes #832. + * --line_number now works for it { should xxx } format (assist from Fred + Lee) + * warn instead of raise when there is no description supplied for an + example. Closes #840. + +=== Version 1.2.6 / 2009-04-30 + +* bug fixes + * gem actually built with spec executable + +=== Version 1.2.5 / 2009-04-29 + +* enhancements + + * name argument to mock/stub is now optional (closes #782) + * you can do mock(:foo => "woo", :bar => "car") + * expect { this_block }.to change{this.expression}.from(old_value).to(new_value) + * expect { this_block }.to raise_error + * better failiure messages for equal matcher (James Byrne). Closes #804. + * add stub_chain method + * also alias_method :stub, :stub!, so you can stub with less bang + * added options to example_group_proxy + +* bug fixes + + * ensure correct handling of ordered message expectations with duplicate + expectations (NigelThorne). Closes #793. + * get matcher backwards compat working w/ ruby 19 + * don't define instance_exec unless it is not defined + * was doing a version check, but turns out that didn't cover alternative + implementations like JRuby + * fix bug where in some circumstances, loading lib/spec/interop/test.rb + raised an error (tsechingho). Closes #803. + * make sure specs only run against spec server when using drb (patch from Chuck Grindel). Closes #797. + * remove deprecation warning in example_pending when using FailingExamplesFormatter. Closes #794. + * Access explicit subject from nested groups of arbitrary depth. Closes #756. + +=== Version 1.2.4 / 2009-04-13 + +* bug fix + + * just one - update the manifest + +=== Version 1.2.3 / 2009-04-13 + +* deprecations + + * BaseFormatter#add_example_group (use #example_group_started instead) + * ExampleGroupProxy#backtrace (use #location instead) + * ExampleProxy#backtrace (use #location instead) + * BaseFormatter#example_pending now expects two arguments. The third + argument is deprecated. + * ExampleGroupProxy#filtered_description. This was only used in one place + internally, and was a confusing solution to the problem. If you've got a + custom formatter that uses it, you can just use + ExampleGroupProxy#description and modify it directly. + * predicate_matchers (use the new Matcher DSL instead) + * Spec::Matchers.create (use Spec::Matchers.define instead) + +* enhancements + + * support for specifying single examples with colon syntax. Closes #712. + (Ben Mabey) + * you can now say "spec some_spec.rb:12" in addition to "spec some_spec.rb + --line 12" + * run specs locally with --drb if no drb server is running. Closes #780. + * still prints "No server running" to stderr + +* bug fixes + + * support expectations on DelegateClass (Clifford T. Matthews). Closes #48. + * Fixed match_array blows up if elements can't be sorted (Jeff Dean). Closes #779. + +=== Version 1.2.2 / 2009-03-22 + +Bug-fix release (fixes regression introduced in 1.2.1) + +* bug fixes + + * fixed bug in which spec_parser raised an error for custom example group + base classes + +=== Version 1.2.1 / 2009-03-22 + +This is a bug-fix release, recommended for anybody who has already upgraded to +rspec-1.2.0. + +See Upgrade.rdoc for information about upgrading to rspec-1.2.1 + +* enhancements + + * matchers, including the new DSL, easily added to your test/unit tests + * added support for 0 to n args in matcher DSL + * restored loading rubygems when necessary + * if you really don't want to use rubygems, you + can set an NO_RUBYGEMS environment + variable, and RSpec won't force it on you. + * added -u/--debugger option (Rick DeNatale) #262. + * just add "debugger" anywhere in your code and run spec path/to/code --debugger + * rename ExampleDescription to ExampleProxy + * pass ExampleProxy to example_started(). Closes #738, #743 + * thanks to Tobias Grimm (Eclipse) fort the patch and Roman Chernyatchik + (JetBrains, RubyMine) for the assist + +* bug fixes + + * subject (implicit or explicit) is now properly inherited by nested groups. Closes #744. + +=== Version 1.2.0 / 2009-03-15 + +* warnings: + + * If you use the ruby command to run specs instead of the spec command, you'll + need to require 'spec/autorun' or they won't run. This won't affect you if + you use the spec command or the Spec::Rake::SpecTask that ships with RSpec. + + * require 'spec/test/unit' to invoke test/unit interop if you're using + RSpec's core (this is handled implicitly with spec-rails) + + * setup and teardown are gone - use before and after instead + + * you can still use setup and teardown if you're using + Test::Unit::TestCase as the base ExampleGroup class (which is implicit + in rspec-rails) + + * The matcher protocol has been improved. The old protocol is still + supported, so as long as you're not monkey patching rspec's built-in + matchers, or using extension libraries that do, this should not affect + you. If you run into trouble, you'll just need to change: + + failure_message => failure_message_for_should + negative_failure_message => failure_message_for_should_not + + * All references to rubygems have been removed from within rspec's code. + + * NOTE that they have been restored in 1.2.1, above + + * See http://gist.github.com/54177 for rationale and suggestions on + alternative approaches to loading rubygems + +* deprecations + + * BaseTextFormatter#colourize - use colorize_failure instead. + * BaseTextFormatter#magenta - use red instead. + +* enhancements + + * cleaner integration with with heckle-1.4.2 + * allow registering example groups with a path-like key (Pat Maddox) + * start DRb service at "druby://localhost:0" (Hongli Lai) - See http://redmine.ruby-lang.org/issues/show/496 + * consistent reporting of errors as failures + * added spec/test/unit as more intuitive path to loading test/unit interop lib + * added explicit autorun feature for running specs with ruby command + * added handling for does_not_match? for matchers that want to know the context in which they were called + * lots of ruby 1.9.1 compatibility fixes from Chad Humprhies + * improved feedback from be_kind_of/be_a_kind_of/be_instance_of/be_an_instance_of (Jakub Šťastný) + * added --format silent (l) option, which is now the default when running --heckle (Bob Aman) + * sexy new custom matcher creation (Corey Haines & David Chelimsky - initial concept by Yehuda Katz) + * improved matcher protocol - old one is still supported, but new one is cleaner and prefered + +* bug fixes + + * support delegating operator matchers to subject with should_not + * all arguments are included if --drb is specified in spec.opts (Neil Buckley). Closes #671. + * added --autospec option hack (used internally) to get --color to work when using --drb and autospec. + * Fixed mock framework failure message bug in which similar calls were excluded from the output + * cryptic error message on change.rb when the from value is wrong (Michael Murray). Closes #706. + +=== Version 1.1.12 / 2009-01-11 + +WARNING: there was a stub/mock bug in 1.1.11 that allowed a structure that was +not intended: + + obj.stub!(:msg) + obj.msg + obj.should_receive(:msg) + +That would pass in 1.1.11, but should not have been allowed to, since the +message is received before the expectation is set. This was reported (#637) +and fixed for release 1.1.12, but may cause unexpected failures if you had +examples set up as above. + +WARNING: mock.should_receive(:msg).with(an_instance_of(klass)) now correctly uses instance_of? instead of kind_of?. This may break some existing code examples, but the fix is to just use kind_of instead of an_instance_of + +* 3 deprecations + + * deprecated ExampleMethods#implementation_backtrace - use ExampleMethods#backtrace instead + * deprecated ExampleGroupMethods#example_group_backtrace - use ExampleGroupMethods#backtrace instead + * deprecated Spec::Example::BehaviourRunner class (likely that nobody is using this) + +* 6 major enhancements + + * it { should matcher } - support for implicit receiver of #should (Joe Ferris of thoughtbot) + * subject { ... } - works in conjunction with implicit receiver of #should + * wrap_expectation (for wrapping multiple expectations and/or t/u assertions) + * added array.should =~ [1,2,3] # passes if array contains exactly the same elements in any order (Jeff Dean and Pat Maddox) + * hash_including mock argument matcher can now accept just keys, key/value pairs, or both (David Krmpotic) + * added hash_not_including mock argument matcher (David Krmpotic). Closes #634. + +* 9 minor enhancements + + * should throw_symbol accepts an optional argument: should throw_symbol(:sym, arg) + * fixed --line for jruby (Zach Moazeni) + * assorted small changes to support Ruby 1.9 (got a way to go) + * removed all instances of class << self - I do know who I am + * SpecParser can't handle backtrace paths with colons (John-Mason P. Shackelford). Closes #505. + * html formatter (and subsequently the textmate formatter) header fills in completely when running a single example + * config.include now accepts an array of types (config.include(Helpers, :type => [:view, :controller])) + * added be_a and be_an expectation matchers + * added instance_of and kind_of mock argument matchers + +* 9 bug fixes + + * fixed bug where {:a => 1, :b => 2}.should include(:a, :b) failed (Yossef Mendelssohn) + * only try to load Test::Unit if Test::Unit is defined (not just Test) + * Allow stubs on parent and child classes simultaneously (Jim Lindley). Fixes #600. + * BaseTextFormatter will now create the directory in a WHERE string (Adam Anderson). Fixes #616. + * Removed incorrect -S flag on autospec commands. Added explicit spec command for ruby to run, guarantee running rspec (raggi). Closes #507. + * Check whether test/unit has really been loaded before calling a method it defines (Brian Donovan). Closes #503. + * Fix spec_path for shared groups (Zach Dennis). Closes #615. + * stubbed message expectation not verified if it has been called *before* the expectation (Matthias Hennemeyer). Closes #637. + * stubs calculate return value by executing block passed to #and_return (hint from Aisha Fenton). Closes #642. + +=== Version 1.1.11 / 2008-10-24 + +* 1 major enhancement + + * eliminate ALL gem dependencies (as they were causing trouble for people on different platforms/environments) + +=== Version 1.1.10 / 2008-10-24 + +* 1 minor enhancement + + * hash.should include(:key => 'value') #when you don't care about the whole hash + +* 2 bug fixes + + * fix --help output (had inaccurate info about 'nested' formatter) + * eliminate spicycode-rcov dev dependency for rubygems < 1.3 + +=== Version 1.1.9 / 2008-10-20 + +WARNING: This release removes implicit inclusion of modules in example groups. +This means that if you have 'describe MyModule do', MyModule will not be +included in the group. + +* 2 major enhancements + + * Add extend to configuration (thanks to advice from Chad Fowler) + * Modules are no longer implicitly included in example groups + +* 4 minor enhancements + + * mingw indicates windows too (thanks to Luis Lavena for the tip) + * improved output for partial mock expecation failures + * it_should_behave_like now accepts n names of shared groups + * eliminated redundant inclusion/extension of ExampleGroupMethods + +* 6 bug fixes + + * spec command with no arguments prints help + * fixed typo in help. Fixes #73. + * fixed bug where should_receive..and_yield after similar stub added the args_to_yield to the stub's original args_to_yield (Pat Maddox) + * fixed bug where rspec-autotest (autospec) was loading non-spec files in spec directory. Fixes #559. + * fixed bug where should_not_receive was reporting twice + * fixed bug where rspec tries to run examples just because it is required (even if there are no examples loaded). Fixes #575. + +=== Version 1.1.8 / 2008-10-03 + +* 2 bug fixes + + * restore colorized output in linux and windows w/ autotest (Tim Pope). Fixes #413. + * autospec no longer hangs on windows. Fixes #554. + +=== Version 1.1.7 / 2008-10-02 + +* no changes since 1.1.6, but releasing rspec-1.1.7 to align versions with rspec-rails-1.1.7 + +=== Version 1.1.6 / 2008-10-02 + +* 2 bug fixes + + * fixed bug where negative message expectations following stubs resulted in false (negative) positives (Mathias Meyer). Closes #548. + * fixed bug where Not Yet Implemented examples report incorrect caller (Scott Taylor). Closes #547. + +* 1 minor enhancement + + * removed deprecated mock argument constraint symbols + +=== Version 1.1.5 / 2008-09-28 + +IMPORTANT: use the new 'autospec' command instead of 'autotest'. We changed +the way autotest discovers rspec so the autotest executable won't +automatically load rspec anymore. This allows rspec to live side by side other +spec frameworks without always co-opting autotest through autotest's discovery +mechanism. + +ALSO IMPORTANT: $rspec_options is gone. If you were using this for anything +(like your own runners), use Spec::Runner.options instead. + +ADDITIONALLY IMPORTANT: If you have any custom formatters, you'll need to +modify #example_pending to accept three arguments instead of just two. See the +rdoc for Spec::Runner::Formatter::BaseFormatter#example_pending for more +information. + +* Consider MinGW as valid RUBY_PLATFORM for --colour option. (patch from Luis Lavena). Closes #406. +* Added additional characters to be escaped in step strings (patch from Jake Cahoon). Closes #417. +* Disable color codes on STDOUT when STDOUT.tty? is false (patch from Tim Pope). Closes #413. +* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser). Closes #230. +* a step definition with no block is treated as pending +* make sure consolidate_failures only grabs _spec files. Closes #369 +* Simplifying ExampleGroupMethods#registration_backtrace. (From Wilson Bilkovich - http://metaclass.org/2008/6/7/calling-in-the-dark) +* Use 127.0.0.1 instead of localhost for drb (thanks Ola Bini) +* html story formatter correctly colors story/scenario red if step fails (Patch from Joseph Wilk). Closes #300 +* plain text story formatter correctly colors story/scenario red if step fails (Patch from Joseph Wilk). Closes #439 +* quiet deprecation warning on inflector - patch from RSL. Closes #430 +* added autospec executable +* added configurable messages to simple_matcher +* should and should_not return true on success +* use hoe for build/release +* bye, bye translator +* autotest/rspec uses ruby command instead of spec command (no need for spec command unless loading directories) +* Avoid 'invalid option -O' in autotest (patch from Jonathan del Strother). Closes #486. +* Fix: Unimplemented step with new line throws error (patch from Ben Mabey). Closes #494. +* Only use color codes on tty; override for autospec (patch from Tim Pope). Closes #413. +* Warn when setting mock expectations on nil (patch from Ben Mabey). Closes #521. +* Support argument constraints as values in the hash_including contstraint. Thanks to Pirkka Hartikainen for failing code examples and the fix. Buttons up #501. +* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser) +* Consider MinGW as valid RUBY_PLATFORM for --colour option. (patch from Luis Lavena). Closes #406. +* Add 2nd arg to respond_to? to align w/ core Ruby rdoc: http://www.ruby-doc.org/core/classes/Object.html#M000604 +* quiet backtrace tweaker filters individual lines out of multiline (ala Rails) error messages (Pat Maddox) +* added ability to stub multiple methods in one stub! call (Pat Maddox) +* story progress bar formatter and more colourful summaries from the plain text story formatter (Joseph Wilk) +* Avoid ruby invocation errors when autotesting (Jonathan del Strother) +* added mock('foo').as_null_object +* add file and line number to pending_example for formatters (Scott Taylor) +* return last stubbed value for mock expectation with no explicit return (Pat Maddox) +* Fixed bug when should_receive(:foo).any_number_of_times is called after similar stub (Pat Maddox) +* Warning messages now issued when expectations are set on nil (Ben Mabey) + +=== Version 1.1.4 + +Maintenance release. + +Note: we've removed the metaclass method from Object. There were some +generated specs that used it, and they will now break. Just replace the +metaclass call with (class << self; self; end) and all will be well. + +* added hash_including mock argument matcher. Closes #332 (patch from Rick DeNatale) +* pending steps print out yellow in stories (patch from Kyle Hargraves) +* Deprecation warnings for specs that assume auto-inclusion of modules. Closes #326 (patch from Scott Taylor) +* mock.should_not_receive(:anything) fails fast (once again) +* Patch from Antti Tarvainen to stop files from being loaded repeatedly when running heckle. Closes #333. +* Fixed bug in which session object in example was not the same instance used in the controller. Closes #331. +* Applied patch from Antti Tarvainen to fix bug where heckle runs rspec runs heckle runs rspec etc. Closes #280. +* Applied patch from Zach Dennis to merge :steps functionality to :steps_for. Closes #324. +* Applied patch from Ryan Davis to add eval of block passed to raise_error matcher. Closes #321. +* alias :context :describe in example_group_methods. Closes #312. +* Applied patch from Ben Mabey to make the Story runner exit with a non-0 exit code on failing stories. Closes #228. +* Applied patch from Coda Hale to get the :red hook called in autotest. Closes #279. +* Applied patch from Patrick Ritchie to support --drb in spec.opts. Closes #274, #293. +* Moved metaclass method from Object to an internal module which gets included where it is needed. +* Applied patch from Dayo Esho: and_yield clobbers return value from block. Closes #217. +* Applied patch from Bob Cotton: ExampleGroupFactory.default resets previously registered types. Closes #222. +* Applied patch from Mike Williams to support the lib directory in rails apps with the Textmate Alternate File command. Closes #276. +* ExampleGroupMethods#xspecify aliases #xit +* A SharedExampleGroup can be created within another ExampleGroup. +* Applied patch from Bob Cotton: Nested ExampleGroups do not have a spec_path. Closes #224. +* Add before_suite and after_suite callbacks to ExampleGroupMethods and Options. Closes #210. +* The after(:suite) callback lambda is passed a boolean representing whether the suite passed or failed +* Added NestedTextFormatter. Closes #366. +* decoupled mock framework from global extensions used by rspec - supports use of flexmock or mocha w/ rails +* Applied patch from Roman Chernyatchik to allow the user to pass in the ruby version into spectask. Closes #325, #370 + +=== Version 1.1.3 + +Maintenance release. +Notice to autotest users: you must also upgrade to ZenTest-3.9.0. + +* Tightened up exceptions list in autotest/rails_spec. Closes #264. +* Applied patch from Ryan Davis for ZenTest-3.9.0 compatibility +* Applied patch from Kero to add step_upcoming to story listeners. Closes #253. +* Fixed bug where the wrong named error was not always caught by "should raise_error" +* Applied patch from Luis Lavena: No coloured output on Windows due missing RUBYOPT. Closes #244. +* Applied patch from Craig Demyanovich to add support for "should_not render_template" to rspec_on_rails. Closes #241. +* Added --pattern (-p for short) option to control what files get loaded. Defaults to '**/*_spec.rb' +* Exit with non-0 exit code if examples *or tests* (in test/unit interop mode) fail. Closes #203. +* Moved at_exit hook to a method in Spec::Runner which only runs if specs get loaded. Closes #242. +* Applied patch from kakutani ensuring that base_view_path gets cleared after each view example. Closes #235. +* More tweaks to regexp step names +* Fixed focused specs in nested ExampleGroups. Closes #225. + +=== Version 1.1.2 + +Minor bug fixes/enhancements. +Notice to autotest users: you must also upgrade to ZenTest-3.8.0. + +* RSpec's Autotest subclasses compatible with ZenTest-3.8.0 (thanks to Ryan Davis for making it easier on Autotest subs). +* Applied patch from idl to add spec/lib to rake stats. Closes #226. +* calling setup_fixtures and teardown_fixtures for Rails >= r8570. Closes #219. +* Applied patch from Josh Knowles using ActiveSupport's Inflector (when available) to make 'should have' read a bit better. Closes #197. +* Fixed regression in 1.1 that caused failing examples to fail to generate their own names. Closes #209. +* Applied doc patch from Jens Krämer for capturing content_for +* Applied patch from Alexander Lang to clean up story steps after each story. Closes #198. +* Applied patch from Josh Knowles to support 'string_or_response.should have_text(...)'. Closes #193. +* Applied patch from Ian Dees to quiet the Story Runner backtrace. Closes #183. +* Complete support for defining steps with regexp 'names'. + +=== Version 1.1.1 + +Bug fix release. + +* Fix regression in 1.1.0 that caused transactions to not get rolled back between examples. +* Applied patch from Bob Cotton to reintroduce ExampleGroup.description_options. Closes LH[#186] + +=== Version 1.1.0 + +The "tell me a story and go nest yourself" release. + +* Applied patch from Mike Vincent to handle generators rails > 2.0.1. Closes LH[#181] +* Formatter.pending signature changed so it gets passed an ExampleGroup instance instead of the name ( LH[#180]) +* Fixed LH[#180] Spec::Rails::Example::ModelExampleGroup and friends show up in rspec/rails output +* Spec::Rails no longer loads ActiveRecord extensions if it's disabled in config/boot.rb +* Applied LH[#178] small annoyances running specs with warnings enabled (Patch from Mikko Lehtonen) +* Tighter integration with Rails fixtures. Take advantage of fixture caching to get performance improvements (Thanks to Pat Maddox, Nick Kallen, Jonathan Barnes, and Curtis) + +=== Version 1.1.0-RC1 + +Textmate Bundle users - this release adds a new RSpec bundle that highlights describe, it, before and after and +provides navigation to descriptions and examples (rather than classes and methods). When you first install this, +it is going to try to hijack all of your .rb files. All you need to do is open a .rb file that does not end with +'spec.rb' and change the bundle selection from RSpec to Ruby. TextMate will do the right thing from then on. + +Shortcuts for tab-activated snippets all follow the TextMate convention of 2 or 3 letters of the first word, followed by the first letter of each subsequent word. So "should have_at_least" would be triggered by shhal. + +We reduced the scope for running spec directories, files, a single file or individual spec in TextMate to source.ruby.rspec. This allowed us to restore the standard Ruby shortcuts: + +CMD-R runs all the specs in one file +CMD-SHIFT-R runs an individual spec +CMD-OPT-R runs any files or directories selected in the TextMate drawer + +rspec_on_rails users - don't forget to run script/generate rspec + +* Added shared_examples_for method, which you can (should) use instead of describe Foo, :shared => true +* Applied LH[#168] Fix describe Object, "description contains a # in it" (Patch from Martin Emde) +* Applied LH[#15] Reverse loading of ActionView::Base helper modules (Patch from Mark Van Holstyn) +* Applied LH[#149] Update contribute page to point towards lighthouse (Patch from Josh Knowles) +* Applied LH[#142] verify_rcov fails with latest rcov (Patch from Kyle Hargraves) +* Applied LH[#10] Allow stubs to yield and return values (Patch from Pat Maddox) +* Fixed LH[#139] version.rb in trunk missing svn last changed number +* Applied LH[#14] Adding support for by_at_least/by_at_most in Change matcher (Patch from Saimon Moore) +* Applied LH[#12] Fix for TM when switching to alternate file (Patch from Trevor Squires) +* Applied LH[#133] ExampleMatcher should match against before(:all) (Patch from Bob Cotton) +* Applied LH[#134] Only load spec inside spec_helper.rb (Patch from Mark Van Holstyn) +* RSpec now bails immediately if there are examples with identical names. +* Applied LH[#132] Plain Text stories should support Given and Given: (Patch from Jarkko Laine) +* Applied patch from Pat Maddox: Story Mediator - the glue that binds the plain text story parser with the rest of the system +* Applied LH[#16] Have SimpleMatchers expose their description for specdocs (Patch from Bryan Helmkamp) +* Stories now support --colour +* Changed the DSL modules to Example (i.e. Spec::Example instead of Spec::DSL) +* Applied [#15608] Story problem if parenthesis used in Given, When, Then or And (Patch from Sinclair Bain) +* Applied [#15659] GivenScenario fails when it is a RailsStory (Patch from Nathan Sutton) +* Fixed [#15639] rcov exclusion configuration. (Spec::Rails projects can configure rcov with spec/rcov.opts) +* The rdoc formatter (--format rdoc) is gone. It was buggy and noone was using it. +* Changed Spec::DSL::Behaviour to Spec::DSL::ExampleGroup +* Changed Spec::DSL::SharedBehaviour to Spec::DSL::SharedExampleGroup +* Applied [#14023] Small optimization for heavily proxied objects. (Patch from Ian Leitch) +* Applied [#13943] ProfileFormatter (Top 10 slowest examples) (Patch from Ian Leitch) +* Fixed [#15232] heckle is not working correctly in trunk (as of r2801) +* Applied [#14399] Show pending reasons in HTML report (Patch from Bryan Helmkamp) +* Discovered fixed: [#10263] mock "leak" when setting an expectation in a block passed to mock#should_receive +* Fixed [#14671] Spec::DSL::ExampleRunner gives "NO NAME because of --dry-run" for every example for 'rake spec:doc' +* Fixed [#14543] rspec_scaffold broken with Rails 2.0 +* Removed Patch [#10577] Rails with Oracle breaks 0.9.2 - was no longer necessary since we moved describe to the Main object (instead of Object) +* Fixed [#14527] specs run twice on rails 1.2.4 and rspec/rspec_on_rails trunk +* Applied [#14043] Change output ordering to show pending before errors (Patch from Mike Mangino) +* Applied [#14095] Don't have ./script/generate rspec create previous_failures.txt (Patch from Bryan Helmkamp) +* Applied [#14254] Improved error handling for Object#should and Object#should_not (Patch from Antti Tarvainen) +* Applied [#14186] Remove dead code from message_expecation.rb (Patch from Antti Tarvainen) +* Applied [#14183] Tiny improvement on mock_spec.rb (Patch from Antti Tarvainen) +* Applied [#14208] Fix to Mock#method_missing raising NameErrors instead of MockExpectationErrors (Patch from Antti Tarvainen) +* Applied [#14255] Fixed examples in mock_spec.rb and shared_behaviour_spec.rb (Patch from Antti Tarvainen) +* Applied [#14362] partially mocking objects that define == can blow up (Patch from Pat Maddox) +* test_ methods with an arity of 0 defined in a describe block or Example object will be run as an Example, providing a seamless transition from Test::Unit +* Removed BehaviourRunner +* Fixed [#13969] Spec Failures on Trunk w/ Autotest +* Applied [#14156] False positives with should_not (Patch from Antti Tarvainen) +* Applied [#14170] route_for and params_from internal specs fixed (Patch from Antti Tarvainen) +* Fixed [#14166] Cannot build trunk +* Applied [#14142] Fix for bug #11602: Nested #have_tag specifications fails on the wrong line number (Patch from Antti Tarvainen) +* Removed warn_if_no_files argument and feature +* Steps (Given/When/Then) with no blocks are treated as pending +* Applied [#13913] Scenario should treat no code block as pending (Patch from Evan Light) +* Fixed [#13370] Weird mock expectation error (Patch from Mike Mangino) +* Applied [#13952] Fix for performance regression introduced in r2096 (Patch from Ian Leitch) +* Applied [#13881] Dynamically include Helpers that are included on ActionView::Base (Patch from Brandon Keepers) +* Applied [#13833] ActionView::Helpers::JavaScriptMacrosHelper removed after 1.2.3 (Patch from Yurii Rashkovskii) +* Applied [#13814] RSpec on Rails w/ fixture-scenarios (Patch from Shintaro Kakutani) +* Add ability to define Example subclass instead of using describe +* Applied Patch from James Edward Gray II to improve syntax highlighting in TextMate +* Fixed [#13579] NoMethodError not raised for missing helper methods +* Fixed [#13713] form helper method 'select' can not be called when calling custom helper methods from specs +* Example subclasses Test::Unit::TestCase +* Added stub_everything method to create a stub that will return itself for any message it doesn't understand +* Added stories directory with stories/all.rb and stories/helper.rb when you script/generate rspec +* Applied [#13554] Add "And" so you can say Given... And... When... Then... And... +* Applied [#11254] RSpec syntax coloring and function pop-up integration in TextMate (Patch from Wincent Colaiuta) +* Applied [#13143] ActionView::Helpers::RecordIdentificationHelper should be included if present (Patch from Jay Levitt) +* Applied [#13567] patch to allow stubs to yield consecutive values (Patch from Rupert Voelcker) +* Applied [#13559] reverse version of route_for (Patch from Rupert Voelcker) +* Added [#13532] /lib specs should get base EvalContext +* Applied [#13451] Add a null_object option to mock_model (Patch from James Deville) +* Applied [#11919] Making non-implemented specs easy in textmate (Patch from Scott Taylor) +* Applied [#13274] ThrowSymbol recognized a NameError triggered by Kernel#method_missing as a thrown Symbol +* Applied [#12722] the alternate file command does not work in rails views due to scope (Patch from Carl Porth) +* Behaviour is now a Module that is used by Example class methods and SharedBehaviour +* Added ExampleDefinition +* Added story runner framework based on rbehave [#12628] +* Applied [#13336] Helper directory incorrect for rake stats in statsetup task (Patch from Curtis Miller) +* Applied [#13339] Add the ability for spec_parser to parse describes with :behaviour_type set (Patch from Will Leinweber and Dav Yaginuma) +* Fixed [#13271] incorrect behaviour with expect_render and stub_render +* Applied [#13129] Fix failing specs in spec_distributed (Patch from Bob Cotton) +* Applied [#13118] Rinda support for Spec::Distributed (Patch from Bob Cotton) +* Removed BehaviourEval +* Removed Behaviour#inherit +* Moved implementation of install_dependencies to example_rails_app +* Renamed RSPEC_DEPS to VENDOR_DEPS +* Added Example#not_implemented? +* You can now stub!(:msg).with(specific args) +* describe("A", Hash, "with one element") will generate description "A Hash with one element" (Tip from Ola Bini) +* Applied [#13016] [DOC] Point out that view specs render, well, a view (Patch from Jay Levitt) +* Applied [#13078] Develop rspec with autotest (Patch from Scott Taylor) +* Fixed [#13065] Named routes throw a NoMethodError in Helper specs (Patches from James Deville and Mike Mangino) +* Added (back) the verbose attribute in Spec::Rake::SpecTask +* Changed documentation to point at the new http svn URL, which is more accessible. + +=== Version 1.0.8 + +Another bugfix release - this time to resolve the version mismatch + +=== Version 1.0.7 + +Quick bugfix release to ensure that you don't have to have the rspec gem installed +in order to use autotest with rspec_on_rails. + +* Fixed [#13015] autotest gives failure in 'spec_command' after upgrade 1.0.5 to 1.0.6 + +=== Version 1.0.6 + +The "holy cow, batman, it's been a long time since we released and there are a ton of bug +fixes, patches and even new features" release. + +Warning: Spec::Rails users: In fixing 11508, we've removed the raise_controller_errors method. As long as you +follow the upgrade instructions and run 'script/generate rspec' you'll be fine, but if you skip this +step you need to manually go into spec_helper.rb and remove the call to that method (if present - it +might not be if you haven't upgraded in a while). + +Warning: Implementors of custom formatters. Formatters will now be sent an Example object instead of just a +String for #example_started, #example_passed and #example_failed. In certain scenarios +(Spec::Ui with Spec::Distributed), the formatter must ask the Example for its sequence number instead of +keeping track of a sequence number internal to the formatter. Most of you shouldn't need to upgrade +your formatters though - the Example#to_s method returns the example name/description, so you should be +able to use the passed Example instance as if it were a String. + +* Applied [#12986] Autotest Specs + Refactoring (Patch from Scott Tayler) +* Added a #close method to formatters, which allows them to gracefully close streams. +* Applied [#12935] Remove requirement that mocha must be installed as a gem when used as mocking framework. (Patch from Ryan Kinderman). +* Fixed [#12893] RSpec's Autotest should work with rspec's trunk +* Fixed [#12865] Partial mock error when object has an @options instance var +* Applied [#12701] Allow checking of content captured with content_for in view specs (Patch from Jens Kr�mer) +* Applied [#12817] Cannot include same shared behaviour when required with absolute paths (Patch from Ian Leitch) +* Applied [#12719] rspec_on_rails should not include pagination helper (Patch from Matthijs Langenberg) +* Fixed [#12714] helper spec not finding rails core helpers +* Applied [#12611] should_not redirect_to implementation (Patch from Yurii Rashkovskii) +* Applied [#12682] Not correctly aliasing original 'stub!' and 'should_receive' methods for ApplicationController (Patch from Matthijs Langenberg) +* Disabled controller.should_receive(:render) and controller.stub!(:render). Use expect_render or stub_render instead. +* Applied [#12484] Allow a Behaviour's Description to flow through to the Formatter (Patch from Bob Cotton) +* Fixed [#12448] The spec:plugins rake task from rspec_on_rails should ignore specs from the rspec_on_rails plugin +* Applied [#12300] rr integration (patch from Kyle Hargraves) +* Implemented [#12284] mock_with :rr (integration with RR mock framework: http://rubyforge.org/projects/pivotalrb/) +* Applied [#12237] (tiny) added full path to mate in switch_command (Patch from Carl Porth) +* Formatters will now be sent an Example object instead of just a String for certain methods +* All Spec::Rake::SpecTask attributes can now be procs, which allows for lazy evaluation. +* Changed the Spec::Ui interfaces slightly. See examples. +* Applied [#12174] mishandling of paths with spaces in spec_mate switch_command (Patch from Carl Porth) +* Implemented [#8315] File "Go to..." functionality +* Applied [#11917] Cleaner Spec::Ui error for failed Selenium connection (Patch from Ian Dees) +* Applied [#11888] rspec_on_rails spews out warnings when assert_select is used with an XML response (Patch from Ian Leitch) +* Applied [#12010] Nicer failure message formatting (Patch from Wincent Colaiuta) +* Applied [#12156] smooth open mate patch (Patch from Ienaga Eiji) +* Applied [#10577] Rails with Oracle breaks 0.9.2. (Patch from Sinclair Bain) +* Fixed [#12079] auto-generated example name incomplete: should have 1 error on ....] +* Applied [#12066] Docfix for mocks/mocks.page (Patch from Kyle Hargraves) +* Fixed [#11891] script/generate rspec_controller fails to create appropriate views (from templates) on edge rails +* Applied [#11921] Adds the correct controller_name from derived_controller_name() to the ViewExampleGroupController (Patch from Eloy Duran) +* Fixed [#11903] config.include with behaviour_type 'hash' does not work +* Examples without blocks and pending is now reported with a P instead of a * +* Pending blocks that now pass are rendered blue +* New behaviour for after: If an after block raises an error, the other ones will still run instead of bailing at the first. +* Made it possible to run spec from RSpec.tmbundle with --drb against a Rails spec_server. +* Applied [#11868] Add ability for pending to optionally hold a failing block and to fail when it passes (Patch from Bob Cotton) +* Fixed [#11843] watir_behaviour missing from spec_ui gem +* Added 'switch between source and spec file' command in Spec::Mate (based on code from Ruy Asan) +* Applied [#11509] Documentation - RSpec requires hpricot +* Applied [#11807] Daemonize spec_server and rake tasks to manage them. (patch from Kyosuke MOROHASHI) +* Added pending(message) method +* Fixed [#11777] should render_template doesn't check paths correctly +* Fixed [#11749] Use of 'rescue => e' does not catch all exceptions +* Fixed [#11793] should raise_error('with a message') does not work correctly +* Fixed [#11774] Mocks should respond to :kind_of? in the same way they respond to :is_a? +* Fixed [#11508] Exceptions are not raised for Controller Specs (removed experimental raise_controller_errors) +* Applied [#11615] Partial mock methods give ambiguous failures when given a method name as a String (Patch from Jay Phillips) +* Fixed [#11545] Rspec doesn't handle should_receive on ActiveRecord associations (Patch from Ian White) +* Fixed [#11514] configuration.use_transactional_fixtures is ALWAYS true, regardless of assignment +* Improved generated RESTful controller examples to cover both successful and unsuccessful POST and PUT +* Changed TextMate snippets for controllers to pass controller class names to #describe rather than controller_name. +* Changed TextMate snippets for mocks to use no_args() and any_args() instead of the deprecated Symbols. +* Applied [#11500] Documentation: no rails integration specs in 1.0 +* Renamed SpecMate's shortcuts for running all examples and focused examples to avoid conflicts (CMD-d and CMD-i) +* Added a TextMate snippet for custom matchers, lifted from Geoffrey Grosenbach's RSpec peepcode show. +* The translator translates mock constraints to the new matchers that were introduced in 1.0.4 +* Documented environment variables for Spec::Rake::SpecTask. Renamed SPECOPTS and RCOVOPTS to SPEC_OPTS and RCOV_OPTS. +* Fixed [#10534] Windows: undefined method 'controller_name' + +=== Version 1.0.5 +Bug fixes. Autotest plugin tweaks. + +* Fixed [#11378] fix to 10814 broke drb (re-opened #10814) +* Fixed [#11223] Unable to access flash from rails helper specs +* Fixed [#11337] autotest runs specs redundantly +* Fixed [#11258] windows: autotest won't run +* Applied [#11253] Tweaks to autotest file mappings (Patch from Wincent Colaiuta) +* Applied [#11252] Should be able to re-load file containing shared behaviours without raising an exception (Patch from Wincent Colaiuta) +* Fixed [#11247] standalone autotest doesn't work because of unneeded autotest.rb +* Applied [#11221] Autotest support does not work w/o Rails Gem installed (Patch from Josh Knowles) + +=== Version 1.0.4 +The getting ready for JRuby release. + +* Fixed [#11181] behaviour_type scoping of config.before(:each) is not working +* added mock argument constraint matchers (anything(), boolean(), an_instance_of(Type)) which work with rspec or mocha +* added mock argument constraint matchers (any_args(), no_args()) which only work with rspec +* deprecated rspec's symbol mock argument constraint matchers (:any_args, :no_args, :anything, :boolean, :numeric, :string) +* Added tarball of rspec_on_rails to the release build to support folks working behind a firewall that blocks svn access. +* Fixed [#11137] rspec incorrectly handles flash after resetting the session +* Fixed [#11143] Views code for ActionController::Base#render broke between 1.0.0 and 1.0.3 on Rails Edge r6731 +* Added raise_controller_errors for controller examples in Spec::Rails + +=== Version 1.0.3 +Bug fixes. + +* Fixed [#11104] Website uses old specify notation +* Applied [#11101] StringHelpers.starts_with?(prefix) assumes a string parameter for _prefix_ +* Removed 'rescue nil' which was hiding errors in controller examples. +* Fixed [#11075] controller specs fail when using mocha without integrated_views +* Fixed problem with redirect_to failing incorrectly against edge rails. +* Fixed [#11082] RspecResourceGenerator should be RspecScaffoldGenerator +* Fixed [#10959] Focused Examples do not work for Behaviour defined with constant with modules + +=== Version 1.0.2 +This is just to align the version numbers in rspec and rspec_on_rails. + +=== Version 1.0.1 +This is a maintenance release with mostly cleaning up, and one minor enhancement - +Modules are automatically included when described directly. + +* Renamed Spec::Rails' rspec_resource generator to rspec_scaffold. +* Removed Spec::Rails' be_feed matcher since it's based on assert_select_feed which is not part of Rails (despite that docs for assert_select_encoded says it is). +* describe(SomeModule) will include that module in the examples. Like for Spec::Rails helpers, but now also in core. +* Header in HTML report will be yellow instead of red if there is one failed example +* Applied [#10951] Odd instance variable name in rspec_model template (patch from Kyle Hargraves) +* Improved integration with autotest (Patches from Ryan Davis and David Goodland) +* Some small fixes to make all specs run on JRuby. + +=== Version 1.0.0 +The stake in the ground release. This represents a commitment to the API as it is. No significant +backwards compatibility changes in the API are expected after this release. + +* Fixed [#10923] have_text matcher does not support should_not +* Fixed [#10673] should > and should >= broken +* Applied [#10921] Allow verify_rcov to accept greater than threshold coverage %'s via configuration +* Applied [#10920] Added support for not implemented examples (Patch from Chad Humphries and Ken Barker) +* Patch to allow not implemented examples. This works by not providing a block to the example. (Patch from Chad Humphries, Ken Barker) +* Yanked support for Rails 1.1.6 in Spec::Rails +* RSpec.tmbundle uses CMD-SHIFT-R to run focused examples now. +* Spec::Rails now bundles a spec:rcov task by default (suggestion from Kurt Schrader) +* Fixed [#10814] Runner loads shared code, test cases require them again +* Fixed [#10753] Global before and after +* Fixed [#10774] Allow before and after to be specified in config II +* Refactored Spec::Ui examples to use new global before and after blocks. +* Added instructions about how to get Selenium working with Spec::Ui (spec_ui/examples/selenium/README.txt) +* Fixed [#10805] selenium.rb missing from gem? +* Added rdocs explaining how to deal with errors in Rails' controller actions +* Applied [#10770] Finer grained includes. +* Fixed [#10747] Helper methods defined in shared specs are not visible when shared spec is used +* Fixed [#10748] Shared descriptions in separate files causes 'already exists' error +* Applied [#10698] Running with --drb executes specs twice (patch from Ruy Asan) +* Fixed [#10871] 0.9.4 - Focussed spec runner fails to run specs in descriptions with type and string when there is no leading space in the string + +=== Version 0.9.4 +This release introduces massive improvements to Spec::Ui - the user interface functional testing +extension to RSpec. There are also some minor bug fixes to the RSpec core. + +* Massive improvements to Spec::Ui. Complete support for all Watir's ie.xxx(how, what) methods. Inline screenshots and HTML. +* Reactivated --timeout, which had mysteriously been deactivated in a recent release. +* Fixed [#10669] Kernel#describe override does not cover Kernel#context +* Applied [#10636] Added spec for OptionParser in Runner (Patch from Scott Taylor) +* Added [#10516] should_include should be able to accept multiple items +* Applied [#10631] redirect_to matcher doesn't respect request.host (Patch from Tim Lucas) +* Each formatter now flushes their own IO. This is to avoid buffering of output. +* Fixed [#10670] IVarProxy#delete raises exception when instance variable does not exist + +=== Version 0.9.3 +This is a bugfix release. + +* Fixed [#10594] Failing Custom Matcher show NAME NOT GENERATED description +* describe(SomeType, "#message") will not add a space: "SomeType#message" (likewise for '.') +* describe(SomeType, "message") will have a decription with a space: "SomeType message" +* Applied [#10566] prepend_before and prepend_after callbacks +* Applied [#10567] Call setup and teardown using before and after callbacks + +=== Version 0.9.2 +This is a quick maintenance release. + +* Added some website love +* Fixed [#10542] reverse predicate matcher syntax +* Added a spec:translate Rake task to make 0.9 translation easier with Spec:Rails +* Better translation of should_redirect_to +* Fixed --colour support for Windows. This is a regression that was introduced in 0.9.1 +* Applied [#10460] Make SpecRunner easier to instantiate without using commandline args + +=== Version 0.9.1 + +This release introduces #describe and #it (aliased as #context and #specify for +backwards compatibility). This allows you to express specs like this: + + describe SomeClass do # Creates a Behaviour + it "should do something" do # Creates an Example + end + end + +The command line features four new options that give you more control over what specs +are being run and in what order. This can be used to verify that your specs are +independent (by running in opposite order with --reverse). It can also be used to cut +down feedback time by running the most recently modified specs first (--loadby mtime --reverse). + +Further, --example replaces the old --spec option, and it can now take a file name of +spec names as an alternative to just a spec name. The --format failing_examples:file.txt +option allows you to output an --example compatible file, which makes it possible to only +rerun the specs that failed in the last run. Spec::Rails uses all of these four options +by default to optimise your RSpec experience. + +There is now a simple configuration model. For Spec::Rails, you do something like this: + + Spec::Runner.configure do |config| + config.use_transactional_fixtures = true + config.use_instantiated_fixtures = false + config.fixture_path = RAILS_ROOT + '/spec/fixtures' + end + +You can now use mocha or flexmock with RSpec if you prefer either to +RSpec's own mock framework. Just put this: + + Spec::Runner.configure do |config| + config.mock_with :mocha + end + +or this: + + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + +in a file that is loaded before your specs. You can also +configure included modules and predicate_matchers: + + Spec::Runner.configure do |config| + config.include SomeModule + config.predicate_matchers[:does_something?] = :do_something + end + +See Spec::DSL::Behaviour for more on predicate_matchers + +* Sugar FREE! +* Added [10434 ] Please Make -s synonymous with -e for autotest compat. This is temporary until autotest uses -e instead of -s. +* Fixed [#10133] custom predicate matchers +* Applied [#10473] Add should exist (new matcher) - Patch from Bret Pettichord +* Added another formatter: failing_behaviours. Writes the names of the failing behaviours for use with --example. +* Applied [#10315] Patch to fix pre_commit bug 10313 - pre_commit_rails: doesn't always build correctly (Patch from Antii Tarvainen) +* Applied [#10245] Patch to HTML escape the behavior name when using HTML Formatter (Patch from Josh Knowles) +* Applied [#10410] redirect_to does not behave consistently with regards to query string parameter ordering (Patch from Nicholas Evans) +* Applied [#9605] Patch for ER 9472, shared behaviour (Patch by Bob Cotton) +* The '--format rdoc' option no longer causes a dry-run by default. --dry-run must be used explicitly. +* It's possible to specify the output file in the --format option (See explanation in --help) +* Several --format options may be specified to output several formats in one run. +* The --out option is gone. Use --format html:path/to/my.html instead (or similar). +* Spec::Runner::Formatter::BaseTextFormatter#initialize only takes one argument - an IO. dry_run and color are setters. +* Made Spec::Ui *much* easier to install. It will be released separately. Check out trunk/spec_ui/examples +* HTML reports now include a syntax highlighted snippet of the source code where the spec failed (needs the syntax gem) +* Added [#10262] Better Helper testing of Erb evaluation block helpers +* Added [#9735] support flexmock (thanks to Jim Weirich for his modifications to flexmock to support this) +* Spec::Rails controller specs will no longer let mock exception ripple through to the response. +* Fixed [#9260] IvarProxy does not act like a hash. +* Applied [#9458] The rspec_scaffold generator does not take into account class nesting (Patch from Steve Tendon) +* Applied [#9132] Rakefile spec:doc can fail without preparing database (Patch from Steve Ross) +* Applied [#9678] Custom runner command line switch, and multi-threaded runner (Patch from Bob Cotton) +* Applied [#9926] Rakefile - RSPEC_DEPS constant as an Array of Hashes instead of an Array of Arrays (Patch from Scott Taylor) +* Applied [#9925] Changed ".rhtml" to "template" in REST spec generator (Patch from Scott Taylor) +* Applied [#9852] Patch for RSpec's Website using Webgen 0.4.2 (Patch from Scott Taylor) +* Fixed [#6523] Run rspec on rails without a db +* Fixed [#9295] rake spec should run anything in the spec directory (not just rspec's standard dirs) +* Added [#9786] infer controller and helper names from the described type +* Fixed [#7795] form_tag renders action='/view_spec' in view specs +* Fixed [#9767] rspec_on_rails should not define rescue_action on controllers +* Fixed [#9421] --line doesn't work with behaviours that use class names +* Fixed [#9760] rspec generators incompatible with changes to edge rails +* Added [#9786] infer controller and helper names from the described type +* Applied a simplified version of [#9282] Change to allow running specs from textmate with rspec installed as a rails plugin (and no rspec gem installed) +* Applied [#9700] Make Spec::DSL::Example#name public / Add a --timeout switch. A great way to prevent specs from getting slow. +* In Rails, script/generate rspec will generate a spec.opts file that optimises faster/more efficient running of specs. +* Added [#9522] support using rspec's expectations with test/unit +* Moved rspec_on_rails up to the project root, simplifying the download url +* Fixed [#8103] RSpec not installing spec script correctly. +* The --spec option is replaced by the --example option. +* The --loadby option no longer supports a file argument. Use --example file_name instead. +* The --example option can now take a file name as an argument. The file should contain example names. +* Internal classes are named Behaviour/Example (rather than Context/Specification). +* You can now use mocha by saying config.mock_with :mocha in a spec_helper +* before_context_eval is replaced by before_eval. +* Applied [#9509] allow spaced options in spec.opts +* Applied [#9510] Added File for Ruby 1.8.6 +* Applied [#9511] Clarification to README file in spec/ +* Moved all of the Spec::Rails specs down to the plugins directory - now you can run the specs after you install. +* Updated RSpec.tmbundle to the 0.9 syntax and replaced context/specify with describe/it. +* Applied [#9232] ActionController::Base#render is sometimes protected (patch from Dan Manges) +* Added --reverse option, allowing contexts/specs to be run in reverse order. +* Added --loadby option, allowing better control over load order for spec files. mtime and file.txt supported. +* Implemented [#8696] --order option (see --reverse and --loadby) +* Added describe/it as aliases for context/specify - suggestion from Dan North. +* Applied [#7637] [PATCH] add skip-migration option to rspec_scaffold generator +* Added [#9167] string.should have_tag +* Changed script/rails_spec_server to script/spec_server and added script/spec (w/ path to vendor/plugins/rspec) +* Fixed [#8897] Error when mixing controller spec with/without integrated views and using template system other than rhtml +* Updated sample app specs to 0.9 syntax +* Updated generated specs to 0.9 syntax +* Applied [#8994] trunk: generated names for be_ specs (Multiple patches from Yurii Rashkovskii) +* Applied [#9983]: Allow before and after to be called in BehaviourEval. This is useful for shared examples. + +=== Version 0.8.2 + +Replaced assert_select fork with an assert_select wrapper for have_tag. This means that "should have_rjs" no longer supports :hide or :effect, but you can still use should_have_rjs for those. + +=== Version 0.8.1 + +Quick "in house" bug-fix + +=== Version 0.8.0 + +This release introduces a new approach to handling expectations using Expression Matchers. + +See Upgrade[http://rspec.rubyforge.org/upgrade.html], Spec::Expectations, Spec::Matchers and RELEASE-PLAN for more info. + +This release also improves the spec command line by adding DRb support and making it possible to +store command line options in a file. This means a more flexible RSpec experience with Rails, +Rake and editor plugins like TextMate. + +It also sports myriad new features, bug fixes, patches and general goodness: + +* Fixed [#8928] rspec_on_rails 0.8.0-RC1 controller tests make double call to setup_with_fixtures +* Fixed [#8925] Documentation bug in 0.8.0RC1 rspec website +* Applied [#8132] [PATCH] RSpec breaks "rake db:sessions:create" in a rails project that has the rspec_on_rails plugin (Patch from Erik Kastner) +* Fixed [#8789] --line and --spec not working when the context has parenhesis in the name +* Added [#8783] auto generate spec names from last expectation +* --heckle now fails if the heckled class or module is not found. +* Fixed [#8771] Spec::Mocks::BaseExpectation#with converts hash params to array of arrays with #collect +* Fixed [#8750] should[_not]_include backwards compatibility between 0.8.0-RC1 and 0.7.5.1 broken +* Fixed [#8646] Context Runner does not report on Non standard exceptions and return a 0 return code +* RSpec on Rails' spec_helper.rb will only force RAILS_ENV to test if it was not specified on the command line. +* Fixed [#5485] proc#should_raise and proc#should_not_raise output +* Added [#8484] should_receive with blocks +* Applied [#8218] heckle_runner.rb doesn't work with heckle >= 1.2.0 (Patch from Michal Kwiatkowski) +* Fixed [#8240] Cryptic error message when no controller_name +* Applied [#7461] [PATCH] Contexts don't call Module::included when they include a module +* Removed unintended block of test/unit assertions in rspec_on_rails - they should all, in theory, now be accessible +* Added mock_model method to RSpec on Rails, which stubs common methods. Based on http://metaclass.org/2006/12/22/making-a-mockery-of-activerecord +* Fixed [#8165] Partial Mock Errors when respond_to? is true but the method is not in the object +* Fixed [#7611] Partial Mocks override Subclass methods +* Fixed [#8302] Strange side effect when mocking a class method +* Applied [#8316] to_param should return a stringified key in resource generator's controller spec (Patch from Chris Anderson) +* Applied [#8216] shortcut for creating object stub +* Applied [#8008] Correct generated specs for view when calling resource generator (Patch from Jonathan Tron) +* Fixed [#7754] Command-R fails to run spec in TextMate (added instruction from Luke Redpath to the website) +* Fixed [#7826] RSpect.tmbundle web page out of date. +* RSpec on Rails specs are now running against RoR 1.2.1 and 1.2.2 +* rspec_scaffold now generates specs for views +* In a Rails app, RSpec core is only loaded when RAILS_ENV==test (init.rb) +* Added support for target.should arbitrary_expectation_handler and target.should_not arbitrary_expectation_handler +* Fixed [#7533] Spec suite fails and the process exits with a code 0 +* Fixed [#7565] Subsequent stub! calls for method fail to override the first call to method +* Applied [#7524] Incorrect Documentation for 'pattern' in Rake task (patch from Stephen Duncan) +* Fixed [#7409] default fixtures do not appear to run. +* Fixed [#7507] "render..and return" doesn't return +* Fixed [#7509] rcov/rspec incorrectly includes boot.rb (Patch from Courtenay) +* Fixed [#7506] unnecessary complex output on failure of response.should be_redirect +* Applied [#6098] Make scaffold_resource generator. Based on code from Pat Maddox. +* The drbspec command is gone. Use spec --drb instead. +* The drb option is gone from the Rake task. Pass --drb to spec_opts instead. +* New -X/--drb option for running specs against a server like spec/rails' script/rails_spec_server +* New -O/--options and -G/--generate flags for file-based options (handy for spec/rails) +* Applied [#7339] Turn off caching in HTML reports +* Applied [#7419] "c option for colorizing output does not work with rails_spec" (Patch from Shintaro Kakutani) +* Applied [#7406] [PATCH] 0.7.5 rspec_on_rails loads fixtures into development database (Patch from Wilson Bilkovich) +* Applied [#7387] Allow stubs to return consecutive values (Patch from Pat Maddox) +* Applied [#7393] Fix for rake task (Patch from Pat Maddox) +* Reinstated support for response.should_render (in addition to controller.should_render) + +=== Version 0.7.5.1 + +Bug fix release to allow downloads of rspec gem using rubygems 0.9.1. + +=== Version 0.7.5 +This release adds support for Heckle - Seattle'rb's code mutation tool. +There are also several bug fixes to the RSpec core and the RSpec on Rails plugin. + +* Removed svn:externals on rails versions and plugins +* Applied [#7345] Adding context_setup and context_teardown, with specs and 100% rcov +* Applied [#7320] [PATCH] Allow XHR requests in controller specs to render RJS templates +* Applied [#7319] Migration code uses drop_column when it should use remove_column (patch from Pat Maddox) +* Added support for Heckle +* Applied [#7282] dump results even if spec is interrupted (patch from Kouhei Sutou) +* Applied [#7277] model.should_have(n).errors_on(:attribute) (patch from Wilson Bilkovich) +* Applied [#7270] RSpec render_partial colliding with simply_helpful (patch from David Goodlad) +* Added [#7250] stubs should support throwing +* Added [#7249] stubs should support yielding +* Fixed [#6760] fatal error when accessing nested finders in rspec +* Fixed [#7179] script/generate rspec_scaffold generates incorrect helper name +* Added preliminary support for assert_select (response.should_have) +* Fixed [#6971] and_yield does not work when the arity is -1 +* Fixed [#6898] Can we separate rspec from the plugins? +* Added [#7025] should_change should accept a block +* Applied [#6989] partials with locals (patch from Micah Martin) +* Applied [#7023] Typo in team.page + +=== Version 0.7.4 + +This release features a complete redesign of the reports generated with --format html. +As usual there are many bug fixes - mostly related to spec/rails. + +* Applied [#7010] Fixes :spacer_template does not work w/ view spec (patch from Shintaro Kakutani) +* Applied [#6798] ensure two ':' in the first backtrace line for Emacs's 'next-error' command (patch from Kouhei Sutou) +* Added Much nicer reports to generated website +* Much nicer reports with --format --html (patch from Luke Redpath) +* Applied [#6959] Calls to render and redirect in controllers should return true +* Fixed [#6981] helper method is not available in partial template. +* Added [#6978] mock should tell you the expected and actual args when receiving the right message with the wrong args +* Added the possibility to tweak the output of the HtmlFormatter (by overriding extra_failure_content). +* Fixed [#6936] View specs don't include ApplicationHelper by default +* Fixed [#6903] Rendering a partial in a view makes the view spec blow up +* Added callback library from Brian Takita +* Added [#6925] support controller.should_render :action_name +* Fixed [#6884] intermittent errors related to method binding +* Fixed [#6870] rspec on edge rails spec:controller fixture loading fails +* Using obj.inspect for all messages +* Improved performance by getting rid of instance_exec (instance_eval is good enough because we never need to pass it args) + +=== Version 0.7.3 + +Almost normal bug fix/new feature release. + +A couple of things you need to change in your rails specs: +# spec_helper.rb is a little different (see http://rspec.rubyforge.org/upgrade.html) +# use controller.should_render before OR after the action (controller.should_have_rendered is deprecated) + +* Applied [#6577] messy mock backtrace when frozen to edge rails (patch from Jay Levitt) +* Fixed [#6674] rspec_on_rails fails on @session deprecation warning +* Fixed [#6780] routing() was failing...fix included - works for 1.1.6 and edge (1.2) +* Fixed [#6835] bad message with arbitrary predicate +* Added [#6731] Partial templates rendered +* Fixed [#6713] helper methods not rendered in view tests? +* Fixed [#6707] cannot run controller / helper tests via rails_spec or spec only works with rake +* Applied [#6417] lambda {...}.should_change(receiver, :message) (patch from Wilson Bilkovich) +* Eliminated dependency on ZenTest +* Fixed [#6650] Reserved characters in the TextMate bundle break svn on Win32 +* Fixed [#6643] script/generate rspec_controller: invalid symbol generation for 'controller_name' for *modularized* controllers +* The script/rails_spec command has been moved to bin/drbspec in RSpec core (installed by the gem) + +=== Version 0.7.2 + +This release introduces a brand new RSpec bundle for TextMate, plus some small bugfixes. + +* Packaged RSpec.tmbundle.tgz as part of the distro +* Fixed [#6593] Add moving progress bar to HtmlFormatter using Javascript +* Applied [#6265] should_raise should accept an Exception object +* Fixed [#6616] Can't run Rails specs with RSpec.tmbundle +* Fixed [#6411] Can't run Rails specs with ruby +* Added [#6589] New -l --line option. This is useful for IDE/editor runners/extensions. +* Fixed [#6615] controller.should_render_rjs should support :partial => 'path/to/template' + +=== Version 0.7.1 + +Bug fixes and a couple o' new features. + +* Fixed [#6575] Parse error in aliasing the partial mock original method (patch by Brian Takita) +* Fixed [#6277] debris left by stubbing (trunk) [submitted by dastels] (fixed by fix to [#6575]) +* Fixed [#6575] Parse error in aliasing the partial mock original method +* Fixed [#6555] should_have_tag does not match documentation +* Fixed [#6567] SyntaxError should not stop entire run +* Fixed [#6558] integrated views look for template even when redirected +* Fixed [#6547] response.should be_redirect broken in 0.7.0 +* Applied [#6471] Easy way to spec routes +* Applied [#6587] Rspec on Rails displays "Spec::Rails::ContextFactory" as context name +* Applied [#6514] Document has trivial typos. +* Added [#6560] controller.session should be available before the action +* Added support for should_have_rjs :visual_effect +* Different printing and colours for unmet expectations (red) and other exceptions (magenta) +* Simplified method_missing on mock_methods to make it less invasive on partial mocks. + +=== Version 0.7.0 + +This is the "Grow up and eat your own dog food release". RSpec is now used on itself and +we're no longer using Test::Unit to test it. Although, we are still extending Test::Unit +for the rails plugin (indirectly - through ZenTest) + +IMPORTANT NOTE: THIS RELEASE IS NOT 100% BACKWARDS COMPATIBLE TO 0.6.x + +There are a few changes that will require that you change your existing specs. + +RSpec now handles equality exactly like ruby does: + +# actual.should_equal(expected) will pass if actual.equal?(expected) returns true +# actual.should eql(expected) will pass if actual.eql?(expected) returns true +# actual.should == expected will pass if actual == expected) returns true + +At the high level, eql? implies equivalence, while equal? implies object identity. For more +information on how ruby deals w/ equality, you should do this: + +ri equal? + +or look at this: + +http://www.ruby-doc.org/core/classes/Object.html#M001057 + +Also, we left in should_be as a synonym for should_equal, so the only specs that should break are the +ones using should_equal (which used to use <code>==</code> instead of <code>.equal?</code>). + +Lastly, should_be used to handle true and false differently from any other values. We've removed +this special handling, so now actual.should_be true will fail for any value other than true (it +used to pass for any non-nil, non-false value), and actual.should_be false will fail for any +value other than false (it used to pass for nil or false). + +Here's what you'll need to do to update your specs: +# search for "should_equal" and replace with "should_eql" +# run specs + +If any specs still fail, they are probably related to should be_true or should_be_false using +non-boolean values. Those you'll just have to inspect manually and adjust appropriately (sorry!). + +-------------------------------------------------- +Specifying multiple return values in mocks now works like this: + +mock.should_receive(:message).and_return(1,2,3) + +It used to work like this: + +mock.should_receive(:message).and_return([1,2,3]) + +but we decided that was counter intuitive and otherwise lame. + +Here's what you'll need to do to update your specs: +# search for "and_return([" +# get rid of the "[" and "]" + +-------------------------------------------------- +RSpec on Rails now supports the following (thanks to ZenTest upon which it is built): + +# Separate specs for models, views, controllers and helpers +# Controller specs are completely decoupled from the views by default (though you can tell them to couple themselves if you prefer) +# View specs are completely decoupled from app-specific controllers + +See http://rspec.rubyforge.org/documentation/rails/index.html for more information +-------------------------------------------------- +As usual, there are also other new features and bug fixes: + +* Added lots of documentation on mocks/stubs and the rails plugin. +* Added support for assigns[key] syntax for controller specs (to align w/ pre-existing syntax for view specs) +* Added support for controller.should_redirect_to +* RSpec on Rails automatically checks whether it's compatible with the installed RSpec +* Applied [#6393] rspec_on_rails uses deprecated '@response' instead of the accessor +* RSpec now has 100% spec coverage(!) +* Added support for stubbing and partial mocking +* Progress (....F..F.) is now coloured. Tweaked patch from KAKUTANI Shintaro. +* Backtrace now excludes the rcov runner (/usr/local/bin/rcov) +* Fixed [#5539] predicates do not work w/ rails +* Added [#6091] support for Regexp matching messages sent to should_raise +* Added [#6333] support for Regexp matching in mock arguments +* Applied [#6283] refactoring of diff support to allow selectable formats and custom differs +* Fixed [#5564] "ruby spec_file.rb" doesn't work the same way as "spec spec_file.rb" +* Fixed [#6056] Multiple output of failing-spec notice +* Fixed [#6233] Colours in specdoc +* Applied [#6207] Allows --diff option to diff target and expected's #inspect output (Patch by Lachie Cox) +* Fixed [#6203] Failure messages are misleading - consider using inspect. +* Added [#6334] subject.should_have_xyz will try to call subject.has_xyz? - use this for hash.should_have_key(key) +* Fixed [#6017] Rake task should ignore empty or non-existent spec-dirs + +=== Version 0.6.4 + +In addition to a number of bug fixes and patches, this release begins to formalize the support for +RSpec on Rails. + +* Added Christopher Petrilli's TextMate bundle to vendor/textmate/RSpec.tmbundle +* Fixed [#5909], once again supporting multi_word_predicates +* Applied [#5873] - response.should_have_rjs (initial patch from Jake Howerton, based on ARTS by Kevin Clark) +* Added generation of view specs for rspec_on_rails +* Applied [#5815] active_record_subclass.should_have(3).records +* Added support in "rake stats" for view specs (in spec/views) +* Applied [#5801] QuickRef.pdf should say RSpec, not rSpec +* Applied [#5728] rails_spec_runner fails on Windows (Patch from Lindsay Evans). +* Applied [#5708] RSpec Rails plugin rspec_controller generator makes specs that do not parse. +* Cleaned up RSpec on Rails so it doesn't pollute as much during bootstrapping. +* Added support for response.should_have_tag and response.should_not_have_tag (works just like assert_tag in rails) +* Added new -c, --colour, --color option for colourful (red/green) output. Inspired from Pat Eyler's Redgreen gem. +* Added examples for Watir and Selenium under the gem's vendor directory. +* Renamed rails_spec_runner to rails_spec_server (as referred to in the docs) +* Added support for trying a plural for arbitrary predicates. E.g. Album.should_exist(:name => "Hey Jude") will call Album.exists?(:name => "Hey Jude") +* Added support for should_have to work with methods taking args returning a collection. E.g. @dave.should_have(3).albums_i_have_that_this_guy_doesnt(@aslak) +* Added [#5570] should_not_receive(:msg).with(:specific, "args") +* Applied [#5065] to support using define_method rather than method_missing to capture expected messages on mocks. Thanks to Eero Saynatkari for the tip that made it work. +* Restructured directories and Modules in order to separate rspec into three distinct Modules: Spec::Expectations, Spec::Runner and Spec::Mocks. This will allow us to more easily integrate other mock frameworks and/or allow test/unit users to take advantage of the expectation API. +* Applied [#5620] support any boolean method and arbitrary comparisons (5.should_be < 6) (Patch from Mike Williams) + +=== Version 0.6.3 + +This release fixes some minor bugs related to RSpec on Rails +Note that if you upgrade a rails app with this version of the rspec_on_rails plugin +you should remove your lib/tasks/rspec.rake if it exists. + +* Backtraces from drb (and other standard ruby libraries) are now stripped from backtraces. +* Applied [#5557] Put rspec.rake into the task directory of the RSpec on Rails plugin (Patch from Daniel Siemssen) +* Applied [#5556] rails_spec_server loads environment.rb twice (Patch from Daniel Siemssen) + +=== Version 0.6.2 +This release fixes a couple of regressions with the rake task that were introduced in the previous version (0.6.1) + +* Fixed [#5518] ruby -w: warnings in 0.6.1 +* Applied [#5525] fix rake task path to spec tool for gem-installed rspec (patch from Riley Lynch) +* Fixed a teensey regression with the rake task - introduced in 0.6.1. The spec command is now quoted so it works on windows. + +=== Version 0.6.1 +This is the "fix the most annoying bugs release" of RSpec. There are 9 bugfixes this time. +Things that may break backwards compatibility: +1) Spec::Rake::SpecTask no longer has the options attribute. Use ruby_opts, spec_opts and rcov_opts instead. + +* Fixed [#4891] RCOV task failing on windows +* Fixed [#4896] Shouldn't modify user's $LOAD_PATH (Tip from Gavin Sinclair) +* Fixed [#5369] ruby -w: warnings in RSpec 0.5.16 (Tip from Suraj Kurapati) +* Applied [#5141] ExampleMatcher doesn't escape strings before matching (Patch from Nikolai Weibull). +* Fixed [#5224] Move 'require diff-lcs' from test_helper.rb to diff_test.rb (Tip from Chris Roos) +* Applied [#5449] Rake stats for specs (Patch from Nick Sieger) +* Applied [#5468, #5058] Fix spec runner to correctly run controller specs (Patch from Daniel Siemssen) +* Applied fixes to rails_spec_server to improve its ability to run several times. (Patch from Daniel Siemssen) +* Changed RCov::VerifyTask to fail if the coverage is above the threshold. This is to ensure it gets bumped when coverage improves. + +=== Version 0.6.0 +This release makes an official commitment to underscore_syntax (with no more support for dot.syntax) + +* Fixed bug (5292) that caused mock argument matching to fail +* Converted ALL tests to use underscore syntax +* Fixed all remaining problems with underscores revealed by converting all the tests to underscores +* Enhanced sugar to support combinations of methods (i.e. once.and_return) +* Simplified helper structure taking advantage of dot/underscore combos (i.e. should.be.an_instance_of, which can be expressed as should be_an_instance_of) +* Added support for at_most in mocks +* Added support for should_not_receive(:msg) (will be removing should_receive(:msg).never some time soon) +* Added support for should_have_exactly(5).items_in_collection + +=== Version 0.5.16 +This release improves Rails support and test2spec translation. + +* Fixed underscore problems that occurred when RSpec was used in Rails +* Simplified the Rails support by packaging it as a plugin instead of a generator gem. +* Fixed [#5063] 'rspec_on_rails' require line in spec_helper.rb +* Added pre_commit rake task to reduce risk of regressions. Useful for RSpec developers and patchers. +* Added failure_message to RSpec Rake task +* test2spec now defines converted helper methods outside of the setup block (bug #5057). + +=== Version 0.5.15 +This release removes a prematurely added feature that shouldn't have been added. + +* Removed support for differences that was added in 0.5.14. The functionality is not aligned with RSpec's vision. + +=== Version 0.5.14 +This release introduces better ways to extend specs, improves some of the core API and +a experimental support for faster rails specs. + +* Added proc methods for specifying differences (increments and decrements). See difference_test.rb +* Methods can now be defined alongside specs. This obsoletes the need for defining methods in setup. (Patch #5002 from Brian Takita) +* Sugar (underscores) now works correctly with should be_a_kind_of and should be_an_instance_of +* Added support for include and inherit in contexts. (Patch #4971 from Brian Takita) +* Added rails_spec and rails_spec_server for faster specs on rails (still buggy - help needed) +* Fixed bug that caused should_render to break if given a :symbol (in Rails) +* Added support for comparing exception message in should_raise and should_not_raise + +=== Version 0.5.13 +This release fixes some subtle bugs in the mock API. + +* Use fully-qualified class name of Exceptions in failure message. Easier to debug that way. +* Fixed a bug that caused mocks to yield a one-element array (rather than the element) when one yield arg specified. +* Mocks not raise AmbiguousReturnError if an explicit return is used at the same time as an expectation block. +* Blocks passed to yielding mocks can now raise without causing mock verification to fail. + +=== Version 0.5.12 +This release adds diff support for failure messages, a HTML formatter plus some other +minor enhancements. + +* Added HTML formatter. +* Added fail_on_error option to spectask. +* Added support for diffing, using the diff-lcs Rubygem (#2648). +* Remove RSpec on Rails files from backtrace (#4694). +* All of RSpec's own tests run successfully after translation with test2spec. +* Added --verbose mode for test2spec - useful for debugging when classes fail to translate. +* Output of various formatters is now flushed - to get more continuous output. + +=== Version 0.5.11 +This release makes test2spec usable with Rails (with some manual steps). +See http://rspec.rubyforge.org/tools/rails.html for more details + +* test2spec now correctly translates bodies of helper methods (non- test_*, setup and teardown ones). +* Added more documentation about how to get test2spec to work with Rails. + +=== Version 0.5.10 +This version features a second rewrite of test2spec - hopefully better than the previous one. + +* Improved test2spec's internals. It now transforms the syntax tree before writing out the code. + +=== Version 0.5.9 +This release improves test2spec by allowing more control over the output + +* Added --template option to test2spec, which allows for custom output driven by ERB +* Added --quiet option to test2spec +* Removed unnecessary dependency on RubyToC + +=== Version 0.5.8 +This release features a new Test::Unit to RSpec translation tool. +Also note that the RubyGem of the previous release (0.5.7) was corrupt. +We're close to being able to translate all of RSpec's own Test::Unit +tests and have them run successfully! + +* Updated test2spec documentation. +* Replaced old test2rspec with a new test2spec, which is based on ParseTree and RubyInline. + +=== Version 0.5.7 +This release changes examples and documentation to recommend underscores rather than dots, +and addresses some bugfixes and changes to the spec commandline. + +* spec DIR now works correctly, recursing down and slurping all *.rb files +* All documentation and examples are now using '_' instead of '.' +* Custom external formatters can now be specified via --require and --format. + +=== Version 0.5.6 +This release fixes a bug in the Rails controller generator + +* The controller generator did not write correct source code (missing 'do'). Fixed. + +=== Version 0.5.5 +This release adds initial support for Ruby on Rails in the rspec_generator gem. + +* [Rails] Reorganised Lachie's original code to be a generator packaged as a gem rather than a plugin. +* [Rails] Imported code from http://lachie.info/svn/projects/rails_plugins/rspec_on_rails (Written by Lachie Cox) +* Remove stack trace lines from TextMate's Ruby bundle +* Better error message from spectask when no spec files are found. + +=== Version 0.5.4 +The "the tutorial is ahead of the gem" release + +* Support for running a single spec with --spec +* Exitcode is now 1 unless all specs pass, in which case it's 0. +* -v, --version now both mean the same thing +* For what was verbose output (-v), use --format specdoc or -f s +* --format rdoc always runs in dry-run mode +* Removed --doc and added --format and --dry-run +* Refactored towards more pluggable formatters +* Use webgen's execute tag when generating website (more accurate) +* Fixed incorrect quoting of spec_opts in SpecTask +* Added patch to enable underscored shoulds like 1.should_equal(1) - patch from Rich Kilmer +* Removed most inherited instance method from Mock, making more methods mockable. +* Made the RCovVerify task part of the standard toolset. +* Documented Rake task and how to use it with Rcov +* Implemented <ruby></ruby> tags for website (hooking into ERB, RedCloth and syntax) +* RSpec Rake task now takes spec_opts and out params so it can be used for doc generation +* RCov integration for RSpec Rake task (#4058) +* Group all results instead of printing them several times (#4057) +* Mocks can now yield +* Various improvements to error reporting (including #4191) +* backtrace excludes rspec code - use -b to include it +* split examples into examples (passing) and failing_examples + +=== Version 0.5.3 +The "hurry up, CoR is in two days" release. + +* Don't run rcov by default +* Make separate task for running tests with RCov +* Added Rake task to fail build if coverage drops below a certain threshold +* Even more failure output cleanup (simplification) +* Added duck_type constraint for mocks + +=== Version 0.5.2 +This release has minor improvements to the commandline and fixes some gem warnings + +* Readded README to avoid RDoc warnings +* Added --version switch to commandline +* More changes to the mock API + +=== Version 0.5.1 +This release is the first release of RSpec with a new website. It will look better soon. + +* Added initial documentation for API +* Added website based on webgen +* Modified test task to use rcov +* Deleted unused code (thanks, rcov!) +* Various changes to the mock API, +* Various improvements to failure reporting + +=== Version 0.5.0 +This release introduces a new API and obsolesces previous versions. + +* Moved source code to separate subfolders +* Added new DSL runner based on instance_exec +* Added spike for testdox/rdoc generation +* merge Astels' and Chelimsky's work on ShouldHelper +* this would be 0.5.0 if I updated the documentation +* it breaks all of your existing specifications. We're not sorry. + +=== Version 0.3.2 + +The "srbaker is an idiot" release. + +* also forgot to update the path to the actual Subversion repository +* this should be it + +=== Version 0.3.1 + +This is just 0.3.0, but with the TUTORIAL added to the documentation list. + +* forgot to include TUTORIAL in the documentation + +=== Version 0.3.0 + +It's been a while since last release, lots of new stuff is available. For instance: + +* improvements to the runners +* addition of should_raise expectation (thanks to Brian Takita) +* some documentation improvements +* RSpec usable as a DSL + +=== Version 0.2.0 + +This release provides a tutorial for new users wishing to get started with +RSpec, and many improvements. + +* improved reporting in the spec runner output +* update the examples to the new mock api +* added TUTORIAL, a getting started document for new users of RSpec + +=== Version 0.1.7 + +This release improves installation and documentation, mock integration and error reporting. + +* Comparison errors now print the class name too. +* Mocks now take an optional +options+ parameter to specify behaviour. +* Removed __expects in favour of should_receive +* Added line number reporting in mock error messages for unreceived message expectations. +* Added should_match and should_not_match. +* Added a +mock+ method to Spec::Context which will create mocks that autoverify (no need to call __verify). +* Mocks now require names in the constructor to ensure sensible error messages. +* Made 'spec' executable and updated usage instructions in README accordingly. +* Made more parts of the Spec::Context API private to avoid accidental usage. +* Added more RDoc to Spec::Context. + +=== Version 0.1.6 + +More should methods. + +* Added should_match and should_not_match. + +=== Version 0.1.5 + +Included examples and tests in gem. + +=== Version 0.1.4 + +More tests on block based Mock expectations. + +=== Version 0.1.3 + +Improved mocking: + +* block based Mock expectations. + +=== Version 0.1.2 + +This release adds some improvements to the mock API and minor syntax improvements + +* Added Mock.should_expect for a more consistent DSL. +* Added MockExpectation.and_returns for a better DSL. +* Made Mock behave as a null object after a call to Mock.ignore_missing +* Internal syntax improvements. +* Improved exception trace by adding exception class name to error message. +* Renamed some tests for better consistency. + +=== Version 0.1.1 + +This release adds some shoulds and improves error reporting + +* Added should be_same_as and should_not be_same_as. +* Improved error reporting for comparison expectations. + +=== Version 0.1.0 + +This is the first preview release of RSpec, a Behaviour-Driven Development library for Ruby + +* Added Rake script with tasks for gems, rdoc etc. +* Added an XForge task to make release go easier. diff --git a/vendor/gems/rspec-1.3.1/License.txt b/vendor/gems/rspec-1.3.1/License.txt new file mode 100644 index 000000000..1a9ac4cb0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/License.txt @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2005-2010 The RSpec Development Team + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/gems/rspec-1.3.1/Manifest.txt b/vendor/gems/rspec-1.3.1/Manifest.txt new file mode 100644 index 000000000..3cb225e1a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/Manifest.txt @@ -0,0 +1,384 @@ +.document +History.rdoc +License.txt +Manifest.txt +README.rdoc +Rakefile +Ruby1.9.rdoc +TODO.txt +Upgrade.rdoc +bin/autospec +bin/spec +cucumber.yml +examples/failing/README.txt +examples/failing/diffing_spec.rb +examples/failing/failing_implicit_docstrings_example.rb +examples/failing/failure_in_after.rb +examples/failing/failure_in_before.rb +examples/failing/mocking_example.rb +examples/failing/mocking_with_flexmock.rb +examples/failing/mocking_with_mocha.rb +examples/failing/mocking_with_rr.rb +examples/failing/partial_mock_example.rb +examples/failing/pending_example.rb +examples/failing/predicate_example.rb +examples/failing/raising_example.rb +examples/failing/syntax_error_example.rb +examples/failing/team_spec.rb +examples/failing/timeout_behaviour.rb +examples/passing/custom_formatter.rb +examples/passing/custom_matchers.rb +examples/passing/dynamic_spec.rb +examples/passing/file_accessor.rb +examples/passing/file_accessor_spec.rb +examples/passing/filtered_formatter.rb +examples/passing/filtered_formatter_example.rb +examples/passing/greeter_spec.rb +examples/passing/helper_method_example.rb +examples/passing/implicit_docstrings_example.rb +examples/passing/io_processor.rb +examples/passing/io_processor_spec.rb +examples/passing/mocking_example.rb +examples/passing/multi_threaded_example_group_runner.rb +examples/passing/nested_classes_example.rb +examples/passing/options_example.rb +examples/passing/options_formatter.rb +examples/passing/partial_mock_example.rb +examples/passing/pending_example.rb +examples/passing/predicate_example.rb +examples/passing/shared_example_group_example.rb +examples/passing/shared_stack_examples.rb +examples/passing/simple_matcher_example.rb +examples/passing/stack.rb +examples/passing/stack_spec.rb +examples/passing/stack_spec_with_nested_example_groups.rb +examples/passing/stubbing_example.rb +examples/passing/yielding_example.rb +examples/ruby1.9.compatibility/access_to_constants_spec.rb +features/before_and_after_blocks/before_and_after_blocks.feature +features/command_line/line_number_option.feature +features/command_line/line_number_option_with_example_with_no_name.feature +features/example_groups/define_example_attribute.feature +features/example_groups/example_group_with_should_methods.feature +features/example_groups/implicit_docstrings.feature +features/example_groups/nested_groups.feature +features/expectations/customized_message.feature +features/expectations/expect_change.feature +features/expectations/expect_error.feature +features/extensions/custom_example_group.feature +features/formatters/custom_formatter.feature +features/formatters/nested_formatter.feature +features/interop/cucumber_stubs_dont_leak.feature +features/interop/examples_and_tests_together.feature +features/interop/rspec_output.feature +features/interop/test_but_not_test_unit.feature +features/interop/test_case_with_should_methods.feature +features/load_paths/add_lib_to_load_path.feature +features/load_paths/add_spec_to_load_path.feature +features/matchers/define_diffable_matcher.feature +features/matchers/define_matcher.feature +features/matchers/define_matcher_outside_rspec.feature +features/matchers/define_matcher_with_fluent_interface.feature +features/matchers/define_wrapped_matcher.feature +features/matchers/match_unless_raises.feature +features/matchers/match_unless_raises_unexpected_error.feature +features/mock_framework_integration/use_flexmock.feature +features/mock_framework_integration/use_mocha.feature +features/mock_framework_integration/use_rr.feature +features/mocks/block_local_expectations.feature +features/mocks/mix_stubs_and_mocks.feature +features/mocks/stub_implementation.feature +features/pending/pending_examples.feature +features/runner/specify_line_number.feature +features/spec_helper/spec_helper.feature +features/step_definitions/running_rspec_steps.rb +features/step_definitions/stubbing_steps.rb +features/subject/explicit_subject.feature +features/subject/implicit_subject.feature +features/support/env.rb +features/support/matchers/smart_match.rb +geminstaller.yml +init.rb +lib/autotest/discover.rb +lib/autotest/rspec.rb +lib/spec.rb +lib/spec/adapters/mock_frameworks/flexmock.rb +lib/spec/adapters/mock_frameworks/mocha.rb +lib/spec/adapters/mock_frameworks/rr.rb +lib/spec/adapters/mock_frameworks/rspec.rb +lib/spec/autorun.rb +lib/spec/deprecation.rb +lib/spec/dsl.rb +lib/spec/dsl/main.rb +lib/spec/example.rb +lib/spec/example/args_and_options.rb +lib/spec/example/before_and_after_hooks.rb +lib/spec/example/errors.rb +lib/spec/example/example_group.rb +lib/spec/example/example_group_factory.rb +lib/spec/example/example_group_hierarchy.rb +lib/spec/example/example_group_methods.rb +lib/spec/example/example_group_proxy.rb +lib/spec/example/example_matcher.rb +lib/spec/example/example_methods.rb +lib/spec/example/example_proxy.rb +lib/spec/example/module_reopening_fix.rb +lib/spec/example/pending.rb +lib/spec/example/predicate_matchers.rb +lib/spec/example/shared_example_group.rb +lib/spec/example/subject.rb +lib/spec/expectations.rb +lib/spec/expectations/errors.rb +lib/spec/expectations/extensions.rb +lib/spec/expectations/extensions/kernel.rb +lib/spec/expectations/fail_with.rb +lib/spec/expectations/handler.rb +lib/spec/extensions/instance_exec.rb +lib/spec/interop/test.rb +lib/spec/interop/test/unit/autorunner.rb +lib/spec/interop/test/unit/testcase.rb +lib/spec/interop/test/unit/testresult.rb +lib/spec/interop/test/unit/testsuite_adapter.rb +lib/spec/interop/test/unit/ui/console/testrunner.rb +lib/spec/matchers.rb +lib/spec/matchers/be.rb +lib/spec/matchers/be_close.rb +lib/spec/matchers/be_instance_of.rb +lib/spec/matchers/be_kind_of.rb +lib/spec/matchers/change.rb +lib/spec/matchers/compatibility.rb +lib/spec/matchers/dsl.rb +lib/spec/matchers/eql.rb +lib/spec/matchers/equal.rb +lib/spec/matchers/errors.rb +lib/spec/matchers/exist.rb +lib/spec/matchers/generated_descriptions.rb +lib/spec/matchers/has.rb +lib/spec/matchers/have.rb +lib/spec/matchers/include.rb +lib/spec/matchers/match.rb +lib/spec/matchers/match_array.rb +lib/spec/matchers/matcher.rb +lib/spec/matchers/method_missing.rb +lib/spec/matchers/operator_matcher.rb +lib/spec/matchers/pretty.rb +lib/spec/matchers/raise_exception.rb +lib/spec/matchers/respond_to.rb +lib/spec/matchers/satisfy.rb +lib/spec/matchers/simple_matcher.rb +lib/spec/matchers/throw_symbol.rb +lib/spec/matchers/wrap_expectation.rb +lib/spec/mocks.rb +lib/spec/mocks/argument_expectation.rb +lib/spec/mocks/argument_matchers.rb +lib/spec/mocks/error_generator.rb +lib/spec/mocks/errors.rb +lib/spec/mocks/example_methods.rb +lib/spec/mocks/extensions.rb +lib/spec/mocks/extensions/object.rb +lib/spec/mocks/framework.rb +lib/spec/mocks/message_expectation.rb +lib/spec/mocks/methods.rb +lib/spec/mocks/mock.rb +lib/spec/mocks/order_group.rb +lib/spec/mocks/proxy.rb +lib/spec/mocks/space.rb +lib/spec/rake/spectask.rb +lib/spec/rake/verify_rcov.rb +lib/spec/ruby.rb +lib/spec/runner.rb +lib/spec/runner/backtrace_tweaker.rb +lib/spec/runner/class_and_arguments_parser.rb +lib/spec/runner/command_line.rb +lib/spec/runner/configuration.rb +lib/spec/runner/differs/default.rb +lib/spec/runner/differs/load-diff-lcs.rb +lib/spec/runner/drb_command_line.rb +lib/spec/runner/example_group_runner.rb +lib/spec/runner/extensions/kernel.rb +lib/spec/runner/formatter/base_formatter.rb +lib/spec/runner/formatter/base_text_formatter.rb +lib/spec/runner/formatter/failing_example_groups_formatter.rb +lib/spec/runner/formatter/failing_examples_formatter.rb +lib/spec/runner/formatter/html_formatter.rb +lib/spec/runner/formatter/nested_text_formatter.rb +lib/spec/runner/formatter/no_op_method_missing.rb +lib/spec/runner/formatter/profile_formatter.rb +lib/spec/runner/formatter/progress_bar_formatter.rb +lib/spec/runner/formatter/silent_formatter.rb +lib/spec/runner/formatter/snippet_extractor.rb +lib/spec/runner/formatter/specdoc_formatter.rb +lib/spec/runner/formatter/text_mate_formatter.rb +lib/spec/runner/heckle_runner.rb +lib/spec/runner/heckle_runner_unsupported.rb +lib/spec/runner/line_number_query.rb +lib/spec/runner/option_parser.rb +lib/spec/runner/options.rb +lib/spec/runner/reporter.rb +lib/spec/stubs/cucumber.rb +lib/spec/test/unit.rb +lib/spec/version.rb +resources/helpers/cmdline.rb +resources/rake/examples.rake +resources/rake/examples_with_rcov.rake +resources/rake/failing_examples_with_html.rake +resources/rake/verify_rcov.rake +spec/README.jruby +spec/autotest/autotest_helper.rb +spec/autotest/autotest_matchers.rb +spec/autotest/discover_spec.rb +spec/autotest/failed_results_re_spec.rb +spec/autotest/rspec_spec.rb +spec/ruby_forker.rb +spec/spec.opts +spec/spec/dsl/main_spec.rb +spec/spec/example/example_group_class_definition_spec.rb +spec/spec/example/example_group_factory_spec.rb +spec/spec/example/example_group_methods_spec.rb +spec/spec/example/example_group_proxy_spec.rb +spec/spec/example/example_group_spec.rb +spec/spec/example/example_matcher_spec.rb +spec/spec/example/example_methods_spec.rb +spec/spec/example/example_proxy_spec.rb +spec/spec/example/helper_method_spec.rb +spec/spec/example/nested_example_group_spec.rb +spec/spec/example/pending_module_spec.rb +spec/spec/example/predicate_matcher_spec.rb +spec/spec/example/shared_example_group_spec.rb +spec/spec/example/subclassing_example_group_spec.rb +spec/spec/example/subject_spec.rb +spec/spec/expectations/differs/default_spec.rb +spec/spec/expectations/extensions/kernel_spec.rb +spec/spec/expectations/fail_with_spec.rb +spec/spec/expectations/handler_spec.rb +spec/spec/expectations/wrap_expectation_spec.rb +spec/spec/interop/test/unit/resources/spec_that_fails.rb +spec/spec/interop/test/unit/resources/spec_that_passes.rb +spec/spec/interop/test/unit/resources/spec_with_errors.rb +spec/spec/interop/test/unit/resources/spec_with_options_hash.rb +spec/spec/interop/test/unit/resources/test_case_that_fails.rb +spec/spec/interop/test/unit/resources/test_case_that_passes.rb +spec/spec/interop/test/unit/resources/test_case_with_errors.rb +spec/spec/interop/test/unit/resources/test_case_with_various_names.rb +spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb +spec/spec/interop/test/unit/spec_spec.rb +spec/spec/interop/test/unit/test_unit_spec_helper.rb +spec/spec/interop/test/unit/testcase_spec.rb +spec/spec/interop/test/unit/testsuite_adapter_spec.rb +spec/spec/matchers/be_close_spec.rb +spec/spec/matchers/be_instance_of_spec.rb +spec/spec/matchers/be_kind_of_spec.rb +spec/spec/matchers/be_spec.rb +spec/spec/matchers/change_spec.rb +spec/spec/matchers/compatibility_spec.rb +spec/spec/matchers/description_generation_spec.rb +spec/spec/matchers/dsl_spec.rb +spec/spec/matchers/eql_spec.rb +spec/spec/matchers/equal_spec.rb +spec/spec/matchers/exist_spec.rb +spec/spec/matchers/has_spec.rb +spec/spec/matchers/have_spec.rb +spec/spec/matchers/include_spec.rb +spec/spec/matchers/match_array_spec.rb +spec/spec/matchers/match_spec.rb +spec/spec/matchers/matcher_spec.rb +spec/spec/matchers/matchers_spec.rb +spec/spec/matchers/operator_matcher_spec.rb +spec/spec/matchers/raise_exception_spec.rb +spec/spec/matchers/respond_to_spec.rb +spec/spec/matchers/satisfy_spec.rb +spec/spec/matchers/simple_matcher_spec.rb +spec/spec/matchers/throw_symbol_spec.rb +spec/spec/mocks/and_yield_spec.rb +spec/spec/mocks/any_number_of_times_spec.rb +spec/spec/mocks/argument_expectation_spec.rb +spec/spec/mocks/argument_matchers_spec.rb +spec/spec/mocks/at_least_spec.rb +spec/spec/mocks/at_most_spec.rb +spec/spec/mocks/bug_report_10260_spec.rb +spec/spec/mocks/bug_report_10263_spec.rb +spec/spec/mocks/bug_report_11545_spec.rb +spec/spec/mocks/bug_report_15719_spec.rb +spec/spec/mocks/bug_report_496_spec.rb +spec/spec/mocks/bug_report_600_spec.rb +spec/spec/mocks/bug_report_7611_spec.rb +spec/spec/mocks/bug_report_7805_spec.rb +spec/spec/mocks/bug_report_8165_spec.rb +spec/spec/mocks/bug_report_8302_spec.rb +spec/spec/mocks/bug_report_830_spec.rb +spec/spec/mocks/double_spec.rb +spec/spec/mocks/failing_argument_matchers_spec.rb +spec/spec/mocks/hash_including_matcher_spec.rb +spec/spec/mocks/hash_not_including_matcher_spec.rb +spec/spec/mocks/mock_ordering_spec.rb +spec/spec/mocks/mock_space_spec.rb +spec/spec/mocks/mock_spec.rb +spec/spec/mocks/multiple_return_value_spec.rb +spec/spec/mocks/nil_expectation_warning_spec.rb +spec/spec/mocks/null_object_mock_spec.rb +spec/spec/mocks/once_counts_spec.rb +spec/spec/mocks/options_hash_spec.rb +spec/spec/mocks/partial_mock_spec.rb +spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb +spec/spec/mocks/passing_argument_matchers_spec.rb +spec/spec/mocks/precise_counts_spec.rb +spec/spec/mocks/record_messages_spec.rb +spec/spec/mocks/stub_chain_spec.rb +spec/spec/mocks/stub_implementation_spec.rb +spec/spec/mocks/stub_spec.rb +spec/spec/mocks/stubbed_message_expectations_spec.rb +spec/spec/mocks/twice_counts_spec.rb +spec/spec/mocks/unstub_spec.rb +spec/spec/package/bin_spec_spec.rb +spec/spec/rake/spectask_spec.rb +spec/spec/runner/class_and_argument_parser_spec.rb +spec/spec/runner/command_line_spec.rb +spec/spec/runner/configuration_spec.rb +spec/spec/runner/drb_command_line_spec.rb +spec/spec/runner/empty_file.txt +spec/spec/runner/example_group_runner_spec.rb +spec/spec/runner/examples.txt +spec/spec/runner/failed.txt +spec/spec/runner/formatter/base_formatter_spec.rb +spec/spec/runner/formatter/base_text_formatter_spec.rb +spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb +spec/spec/runner/formatter/failing_examples_formatter_spec.rb +spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html +spec/spec/runner/formatter/html_formatted-1.8.6.html +spec/spec/runner/formatter/html_formatted-1.8.7.html +spec/spec/runner/formatter/html_formatted-1.9.1.html +spec/spec/runner/formatter/html_formatter_spec.rb +spec/spec/runner/formatter/nested_text_formatter_spec.rb +spec/spec/runner/formatter/profile_formatter_spec.rb +spec/spec/runner/formatter/progress_bar_formatter_spec.rb +spec/spec/runner/formatter/snippet_extractor_spec.rb +spec/spec/runner/formatter/specdoc_formatter_spec.rb +spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html +spec/spec/runner/formatter/text_mate_formatted-1.8.6.html +spec/spec/runner/formatter/text_mate_formatted-1.8.7.html +spec/spec/runner/formatter/text_mate_formatted-1.9.1.html +spec/spec/runner/formatter/text_mate_formatter_spec.rb +spec/spec/runner/heckle_runner_spec.rb +spec/spec/runner/heckler_spec.rb +spec/spec/runner/line_number_query/line_number_query_fixture.rb +spec/spec/runner/line_number_query_spec.rb +spec/spec/runner/noisy_backtrace_tweaker_spec.rb +spec/spec/runner/option_parser_spec.rb +spec/spec/runner/options_spec.rb +spec/spec/runner/output_one_time_fixture.rb +spec/spec/runner/output_one_time_fixture_runner.rb +spec/spec/runner/output_one_time_spec.rb +spec/spec/runner/quiet_backtrace_tweaker_spec.rb +spec/spec/runner/reporter_spec.rb +spec/spec/runner/resources/a_bar.rb +spec/spec/runner/resources/a_foo.rb +spec/spec/runner/resources/a_spec.rb +spec/spec/runner/resources/custom_example_group_runner.rb +spec/spec/runner/resources/utf8_encoded.rb +spec/spec/runner/spec.opts +spec/spec/runner/spec_drb.opts +spec/spec/runner/spec_spaced.opts +spec/spec/runner_spec.rb +spec/spec_helper.rb +spec/support/macros.rb +spec/support/spec_classes.rb diff --git a/vendor/gems/rspec-1.3.1/README.rdoc b/vendor/gems/rspec-1.3.1/README.rdoc new file mode 100644 index 000000000..523fa6af1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/README.rdoc @@ -0,0 +1,41 @@ +== RSpec + +http://rspec.info + +Behaviour Driven Development for Ruby + +This is the repository for rspec-1.x. If you're looking +for rspec-2 (and if you're not, what are you waiting for?), +see http://github.com/rspec/rspec + +== Install + + gem install rspec + +== Synopsis + + describe Account do + context "transfering money" do + it "deposits transfer amount to the other account" do + source = Account.new(50, :USD) + target = mock('target account') + target.should_receive(:deposit).with(Money.new(5, :USD)) + source.transfer(5, :USD).to(target) + end + + it "reduces its balance by the transfer amount" do + source = Account.new(50, :USD) + target = stub('target account') + source.transfer(5, :USD).to(target) + source.balance.should == Money.new(45, :USD) + end + end + end + + $ spec ./spec/account_spec.rb --format nested + Account + transfering money + deposits transfer amount to the other account + reduces its balance by the transfer amount + + 2 examples, 0 failures diff --git a/vendor/gems/rspec-1.3.1/Rakefile b/vendor/gems/rspec-1.3.1/Rakefile new file mode 100644 index 000000000..ffdcf210f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/Rakefile @@ -0,0 +1,149 @@ +# -*- ruby -*- +gem 'hoe', '>=2.0.0' +require 'hoe' + +$:.unshift 'lib' + +require 'spec/version' +require 'spec/rake/spectask' +require 'spec/ruby' + +Hoe.spec 'rspec' do + self.version = Spec::VERSION::STRING + self.summary = Spec::VERSION::SUMMARY + self.description = "Behaviour Driven Development for Ruby." + self.rubyforge_name = 'rspec' + self.developer('RSpec Development Team', 'rspec-devel@rubyforge.org') + self.extra_dev_deps << ["cucumber",">=0.3"] << ["fakefs",">=0.2.1"] << ["syntax",">=1.0"] << ["diff-lcs",">=1.1.2"] + self.extra_dev_deps << ["heckle",">=1.4.3"] unless Spec::Ruby.version >= "1.9" + self.remote_rdoc_dir = "rspec/#{Spec::VERSION::STRING}" + self.rspec_options = ['--options', 'spec/spec.opts'] + self.history_file = 'History.rdoc' + self.readme_file = 'README.rdoc' + self.post_install_message = <<-POST_INSTALL_MESSAGE +#{'*'*50} + + Thank you for installing rspec-#{Spec::VERSION::STRING} + + Please be sure to read History.rdoc and Upgrade.rdoc + for useful information about this release. + +#{'*'*50} +POST_INSTALL_MESSAGE +end + +['audit','test','test_deps','default','post_blog'].each do |task| + Rake.application.instance_variable_get('@tasks').delete(task) +end + +task :post_blog do + # no-op +end + +# Some of the tasks are in separate files since they are also part of the website documentation +load 'resources/rake/examples.rake' +load 'resources/rake/examples_with_rcov.rake' +load 'resources/rake/failing_examples_with_html.rake' +load 'resources/rake/verify_rcov.rake' + +task :cleanup_rcov_files do + rm_rf 'coverage.data' +end + + +if RUBY_VERSION =~ /^1.8/ + task :default => [:cleanup_rcov_files, :features, :verify_rcov] +else + task :default => [:spec, :features] +end + +namespace :spec do + + desc "Run all specs with rcov" + Spec::Rake::SpecTask.new(:rcov) do |t| + t.spec_files = FileList['spec/**/*_spec.rb'] + t.spec_opts = ['--options', 'spec/spec.opts'] + t.rcov = true + t.rcov_dir = 'coverage' + t.rcov_opts = ['--exclude', "features,kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"] + t.rcov_opts << '--sort coverage --text-summary --aggregate coverage.data' + end + + desc "Run files listed in spec/spec_files.txt" + Spec::Rake::SpecTask.new(:focus) do |t| + if File.exists?('spec/spec_files.txt') + t.spec_files = File.readlines('spec/spec_files.txt').collect{|f| f.chomp} + end + end +end + +begin + require 'cucumber/rake/task' + desc "Run Cucumber features" + if RUBY_VERSION =~ /^1.8/ + Cucumber::Rake::Task.new :features do |t| + t.rcov = true + t.rcov_opts = ['--exclude', "features,kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"] + t.rcov_opts << '--no-html --aggregate coverage.data' + t.cucumber_opts = %w{--format progress} + end + else + task :features do + sh 'cucumber --profile no_heckle' + end + end +rescue LoadError + puts "You need cucumber installed to run cucumber tasks" +end + +desc "Run failing examples (see failure output)" +Spec::Rake::SpecTask.new('failing_examples') do |t| + t.spec_files = FileList['failing_examples/**/*_spec.rb'] + t.spec_opts = ['--options', 'spec/spec.opts'] +end + +def egrep(pattern) + Dir['**/*.rb'].each do |fn| + count = 0 + open(fn) do |f| + while line = f.gets + count += 1 + if line =~ pattern + puts "#{fn}:#{count}:#{line}" + end + end + end + end +end + +desc "Look for TODO and FIXME tags in the code" +task :todo do + egrep /(FIXME|TODO|TBD)/ +end + +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('git status') do |io| + io.each_line do |line| + raise "\n!!! Do a git commit first !!!\n\n" if line =~ /^#\s*modified:/ + end + end +end + +namespace :update do + desc "update the manifest" + task :manifest do + system %q[touch Manifest.txt; rake check_manifest | grep -v "(in " | patch] + end +end + +task :clobber => :clobber_tmp + +task :clobber_tmp do + cmd = %q[rm -r tmp] + puts cmd + system cmd if test ?d, 'tmp' +end diff --git a/vendor/gems/rspec-1.3.1/Ruby1.9.rdoc b/vendor/gems/rspec-1.3.1/Ruby1.9.rdoc new file mode 100644 index 000000000..e42cc85e4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/Ruby1.9.rdoc @@ -0,0 +1,31 @@ += RSpec and Ruby 1.9 + +RSpec runs on Ruby 1.9.1 with the following caveats. + +== Test::Unit + +RSpec/Test::Unit interop will run with the test-unit-1.2.3 gem, but you must install it. + +== Class Variables + +Due to changes in scoping rules, class variables within example groups are not +supported in Ruby 1.9. + + describe "a class variable" do + @@class_variable = "a class variable" + + it "can access class variables in examples in Ruby 1.8" do + with_ruby 1.8 do + @@class_variable.should == "a class variable" + end + end + + it "can NOT access class variables in examples in Ruby 1.9" do + with_ruby 1.9 do + lambda do + @@class_variable.should == "a class variable" + end.should raise_error(NameError) + end + end + end + diff --git a/vendor/gems/rspec-1.3.1/TODO.txt b/vendor/gems/rspec-1.3.1/TODO.txt new file mode 100644 index 000000000..fc59a25bb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/TODO.txt @@ -0,0 +1,17 @@ +== Refactoring + +** global predictate matchers should be stored in run_options +* eliminate dependency on global options and configuration +** the only place they should exist is in the Runner, which should manage them + +== Future + +* do SOMETHING with the website +* separate the underlying framework from the DSL + * be able to do everything with classes and methods +* tweak raise_error rdoc to show only one arg + +== rspec-2.0 + +* rename top level namespace to Rspec and commands to 'rspec' and 'autorspec' + * continue to support Spec 'spec' and 'autospec' as aliases for a reasonable time diff --git a/vendor/gems/rspec-1.3.1/Upgrade.rdoc b/vendor/gems/rspec-1.3.1/Upgrade.rdoc new file mode 100644 index 000000000..86c792aec --- /dev/null +++ b/vendor/gems/rspec-1.3.1/Upgrade.rdoc @@ -0,0 +1,260 @@ += Upgrade to 1.3.0 + +== What's changed + +=== +be_true+ and +be_false+ + +These methods now align with Ruby's conditional semantics: + +* +be_false+ passes for +false+ and +nil+ +* +be_true+ passes for everything else + +This is a change from the previous behaviour (which wasn't working correctly +anyway), which was supposed to treat +be_true+ as <tt>equal(true)</tt>, and +be_false+ as +<tt>equal(false)</tt>. + +If the actual values +true+ and +false+ are meaningful to your examples, you'll +want to change the to use <tt>equal(true)</tt> and <tt>equal(false)</tt> (or +<tt>==(true)</tt> and <tt>==(false)</tt>). + +=== +raise_exception+ + +We changed the +raise_error+ matcher to +raise_exception+, and aliased it with ++raise_error+. This maintains backward compatibility, and also gives you the +option of being more precise in specs about what is expected. + +=== Matcher DSL + +==== +match+ rescues from +ExpectationNotMetErrror+ by default + +This allows you to wrap other expectations in the +match+ method. Consider +this matcher: + + Spec::Matchers.define :teach do |subject| + match do |teacher| + teacher.subjects.should include(subject) + end + end + +The block passed to +match+ is called internally by Rspec, and is expected to +return a boolean value. In this case, if <tt>should include(subject)</tt> +fails, it raises an +ExpectationNotMetError+. + +Beginning with rspec-1.3.0, when the match block raises an ++ExpectationNotMetError+, it is captured and the block returns +false+. +Otherwise it returns +true+, so it works like any other matcher. + +==== match_unless_raises + +The new +match_unless_raises+ method allows you to wrap <tt>Test::Unit</tt> +assertions by capturing +AssertionFailedError+ and returning false, just as the ++match+ method now does with +ExpectationNotMetError+. + + Spec::Matchers.define :teach do |subject| + match_unless_raises Test::Unit::AssertionFailedError do |teacher| + assert teacher.subjects.include?(subject) + end + end + += Upgrade to rspec-1.2.9 + +== What's new + +=== spec/spec.opts + +If you have a spec/spec.opts file, the spec command will now use that +automatically as long as you don't include any options on the command line. + +=== let() + +Writing specs tends to follow a regular pattern of using local variables, +discovering duplication, and then having to convert to local variables to +instance variables by adding an "@" symbol. The let() method assigns the result +of a lazy eval'd block as the return value of an instance method using the same +name. This way you can go from this: + + describe Subscription do + it "does something" do + subscription = Subscription.create :limit => 1 + subscription... + end + + it "does something else" do + subscription = Subscription.create :limit => 1 + subscription... + end + end + +to this: + + describe Subscription do + let(:subscription) { Subscription.create :limit => 1 } + + it "does something" do + subscription... + end + + it "does something else" do + subscription... + end + end + +=== its() + +If you're in the habit of writing one-liners using implicit subject, this new +its() feature is for you. Here's the basic idea: + + describe Array do + its(:length) { should == 0 } + end + += Upgrade to rspec-1.2.3-1.2.7 + +== What's Changed + +=== Matcher DSL + +Use Spec::Matchers.define instead of Spec::Matchers.create (which is now +deprecated). + +=== Explicit Predicate Matchers are deprecated + +With the addition of the new Matcher DSL the old, confusing, and +almost-nobody-uses-it explicit predicate matcher functionality's days are now +numbered. + +If you're not familiar with this feature, don't worry about it. If you have anything +that looks like this: + + predicate_matchers[:swim] = :can_swim? + +Or this + + config.predicate_matchers[:swim] = :can_swim? + +Change it to this: + + Spec::Matchers.define :swim do + match do |potential_swimmer| + potential_swimmer.can_swim? + end + end + +== Custom Formatters + +If you have an custom formatter, the <tt>add_example_group</tt> method has +been changed to <tt>example_group_started</tt>, and kept as an alias so your +formatters will still work. Though not yet, <tt>add_example_group</tt> will be +deprecated in a future minor release, and removed in a future major release, +so we recommend you make this change now. + += Upgrade to rspec-1.2.2 + +== What's Changed + +=== <tt>require 'rubygems' unless ENV['NO_RUBYGEMS']</tt> + +After minor public outcry and confusion, we restored necessary references to +rubygems in rspec. If you use a different mechanism for managing gems, just +set a <tt>NO_RUBYGEMS</tt> environment variable (to any non-nil value). + +=== Proxies and locations + +This is probably only interesting to you if you use custom formatters. + +Formatters now receive Spec::Example::ExampleGroupProxy and +Spec::Example::ExampleGroup objects with cohesive APIs for reporting. See the +RDoc for those classes and Spec::Runner::Formatter::BaseFormatter for more +information. + +== What's new + +=== The new matcher DSL works with test/unit (without the rest of rspec) + +We'll be separating this out to its own gem for rspec 2.0, but for now, just install +rspec >= 1.2.1 and add the following to your <tt>test_helper</tt> file: + + require 'spec/expectations' + class Test::Unit::TestCase + include Spec::Matchers + end + +This will add <tt>should()</tt> and <tt>should_not()</tt> to your objects, make all of +rspec's built-in matchers available to your tests, INCLUDING rspec's DSL for +creating matchers (see below, under Upgrade to rspec-1.2.0) + +=== debugger + +If you have ruby-debug installed, you can set a breakpoint by adding <tt>debugger()</tt> +in your code: + + # some code ..... + debugger + # some more code .... + +... and using the <tt>--debugger</tt> or <tt>-u</tt> command line option. + + spec path/to/file.rb --debugger + += Upgrade to rspec-1.2.0 + +== What's Changed + +=== WARNINGS + +* If you use the ruby command to run specs instead of the spec command, you'll + need to require 'spec/autorun' or they won't run. This won't affect you if + you use the spec command or the Spec::Rake::SpecTask that ships with RSpec. + +* require 'spec/test/unit' to invoke test/unit interop if you're using + RSpec's core (this is handled implicitly with spec-rails) + +* setup and teardown are gone - use before and after instead + + * you can still use setup and teardown if you're using + Test::Unit::TestCase as the base ExampleGroup class (which is implicit + in rspec-rails) + +* The matcher protocol has been improved. The old protocol is still supported, + but we added support for two new methods that speak a bit more clearly: + + failure_message => failure_message_for_should + negative_failure_message => failure_message_for_should_not + +* All references to rubygems have been removed from within rspec's code. + + * See http://gist.github.com/54177 for rationale and suggestions on + alternative approaches to loading rubygems + +== What's New + +=== Ruby 1.9 + +RSpec now works with Ruby 1.9.1. See http://wiki.github.com/dchelimsky/rspec/ruby-191 +for useful information. + +=== Improved heckle integration + +RSpec works with heckle again! Gotta use heckle >= 1.4.2 for this to work +though, and it only works with ruby-1.8.6 and 1.8.7 (heckle doesn't support +1.9.1 yet). + + [sudo] gem install heckle --version ">=1.4.2" + spec spec/game/mastermind.rb --heckle Game::Mastermind + +=== New Matcher DSL + +We've added a new DSL for generating custom matchers very simply and cleanly. +We'll still support the simple_matcher method, so never fear if you're using +that, but we recommend that you start developing your new matchers with this +new syntax. + + Spec::Matchers.create :be_a_multiple_of do |smaller| + match do |bigger| + bigger % smaller == 0 + end + end + + 9.should be_a_multiple_of(3) + +See <tt>features/matchers/define_matcher.feature</tt> for more examples diff --git a/vendor/gems/rspec-1.3.1/bin/autospec b/vendor/gems/rspec-1.3.1/bin/autospec new file mode 100755 index 000000000..82a314f15 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/bin/autospec @@ -0,0 +1,4 @@ +#!/usr/bin/env ruby +ENV['RSPEC'] = 'true' # allows autotest to discover rspec +ENV['AUTOTEST'] = 'true' # allows autotest to run w/ color on linux +system (RUBY_PLATFORM =~ /mswin|mingw/ ? 'autotest.bat' : 'autotest'), *ARGV
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/bin/spec b/vendor/gems/rspec-1.3.1/bin/spec new file mode 100755 index 000000000..d3dd2430f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/bin/spec @@ -0,0 +1,5 @@ +#!/usr/bin/env ruby +rspec_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')) +$LOAD_PATH.unshift(rspec_dir) unless $LOAD_PATH.include?(rspec_dir) +require 'spec/autorun' +exit ::Spec::Runner::CommandLine.run diff --git a/vendor/gems/rspec-1.3.1/cucumber.yml b/vendor/gems/rspec-1.3.1/cucumber.yml new file mode 100644 index 000000000..31733b5d8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/cucumber.yml @@ -0,0 +1,5 @@ +default: --require features features -t ~@wip +pending: --require features features-pending +no_heckle: --require features features --exclude heckle +focus: --require features features -t focus +wip: --require features features -t @wip diff --git a/vendor/gems/rspec-1.3.1/examples/failing/README.txt b/vendor/gems/rspec-1.3.1/examples/failing/README.txt new file mode 100644 index 000000000..7e9f49236 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/README.txt @@ -0,0 +1,11 @@ +"Why have failing examples?", you might ask. + +They allow us to see failure messages. RSpec wants to provide meaningful and +helpful failure messages. The failures in this directory not only provide you +a way of seeing the failure messages, but they provide RSpec's own specs a way +of describing what they should look like and ensuring they stay correct. + +To see the types of messages you can expect, stand in the root directory and +run: + +bin/spec examples/failing/*.rb
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/failing/diffing_spec.rb b/vendor/gems/rspec-1.3.1/examples/failing/diffing_spec.rb new file mode 100644 index 000000000..85e13e8c0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/diffing_spec.rb @@ -0,0 +1,36 @@ +describe "Running specs with --diff" do + it "should print diff of different strings" do + uk = <<-EOF +RSpec is a +behaviour driven development +framework for Ruby +EOF + usa = <<-EOF +RSpec is a +behavior driven development +framework for Ruby +EOF + usa.should == uk + end + + class Animal + def initialize(name,species) + @name,@species = name,species + end + + def inspect + <<-EOA +<Animal +name=#{@name}, +species=#{@species} +> + EOA + end + end + + it "should print diff of different objects' pretty representation" do + expected = Animal.new "bob", "giraffe" + actual = Animal.new "bob", "tortoise" + expected.should eql(actual) + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/failing_implicit_docstrings_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/failing_implicit_docstrings_example.rb new file mode 100644 index 000000000..7b0b86614 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/failing_implicit_docstrings_example.rb @@ -0,0 +1,17 @@ +# Run spec w/ -fs to see the output of this file + +describe "Failing examples with no descriptions" do + + # description is auto-generated as "should equal(5)" based on the last #should + it do + 3.should equal(2) + 5.should equal(5) + end + + it { 3.should be > 5 } + + it { ["a"].should include("b") } + + it { [1,2,3].should_not respond_to(:size) } + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/failure_in_after.rb b/vendor/gems/rspec-1.3.1/examples/failing/failure_in_after.rb new file mode 100644 index 000000000..a47338aee --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/failure_in_after.rb @@ -0,0 +1,10 @@ +describe "This example" do + + it "should be listed as failing in after" do + end + + after(:each) do + NonExistentClass.new + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/failure_in_before.rb b/vendor/gems/rspec-1.3.1/examples/failing/failure_in_before.rb new file mode 100644 index 000000000..b0826604e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/failure_in_before.rb @@ -0,0 +1,10 @@ +describe "This example" do + + before(:each) do + NonExistentClass.new + end + + it "should be listed as failing in each" do + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/mocking_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/mocking_example.rb new file mode 100644 index 000000000..9c735e00b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/mocking_example.rb @@ -0,0 +1,38 @@ +describe "Mocker" do + + it "should be able to call mock()" do + mock = mock("poke me") + mock.should_receive(:poke) + mock.poke + end + + it "should fail when expected message not received" do + mock = mock("poke me") + mock.should_receive(:poke) + end + + it "should fail when messages are received out of order" do + mock = mock("one two three") + mock.should_receive(:one).ordered + mock.should_receive(:two).ordered + mock.should_receive(:three).ordered + mock.one + mock.three + mock.two + end + + it "should get yelled at when sending unexpected messages" do + mock = mock("don't talk to me") + mock.should_not_receive(:any_message_at_all) + mock.any_message_at_all + end + + it "has a bug we need to fix" do + pending "here is the bug" do + # Actually, no. It's fixed. This will fail because it passes :-) + mock = mock("Bug") + mock.should_receive(:hello) + mock.hello + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_flexmock.rb b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_flexmock.rb new file mode 100644 index 000000000..6e79ece0e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_flexmock.rb @@ -0,0 +1,26 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_FLEXMOCK_EXAMPLE=true ruby ../bin/spec mocking_with_flexmock.rb + +if ENV['RUN_FLEXMOCK_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + + describe "Flexmocks" do + it "should fail when the expected message is received with wrong arguments" do + m = flexmock("now flex!") + m.should_receive(:msg).with("arg").once + m.msg("other arg") + end + + it "should fail when the expected message is not received at all" do + m = flexmock("now flex!") + m.should_receive(:msg).with("arg").once + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_mocha.rb b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_mocha.rb new file mode 100644 index 000000000..f14a1a3e5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_mocha.rb @@ -0,0 +1,25 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_MOCHA_EXAMPLE=true ruby ../bin/spec mocking_with_mocha.rb + +if ENV['RUN_MOCHA_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :mocha + end + describe "Mocha framework" do + it "should should be made available by saying config.mock_with :mocha" do + m = mock() + m.expects(:msg).with("arg") + m.msg + end + it "should should be made available by saying config.mock_with :mocha" do + o = Object.new + o.expects(:msg).with("arg") + o.msg + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_rr.rb b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_rr.rb new file mode 100644 index 000000000..0d2b4fe04 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/mocking_with_rr.rb @@ -0,0 +1,27 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_RR_EXAMPLE=true ruby ../bin/spec mocking_with_rr.rb + +if ENV['RUN_RR_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :rr + end + describe "RR framework" do + it "should should be made available by saying config.mock_with :rr" do + o = Object.new + mock(o).msg("arg") + o.msg + end + it "should should be made available by saying config.mock_with :rr" do + o = Object.new + mock(o) do |m| + m.msg("arg") + end + o.msg + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/partial_mock_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/partial_mock_example.rb new file mode 100644 index 000000000..7f8d081b1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/partial_mock_example.rb @@ -0,0 +1,18 @@ +class MockableClass + def self.find id + return :original_return + end +end + +describe "A partial mock" do + + it "should work at the class level (but fail here due to the type mismatch)" do + MockableClass.should_receive(:find).with(1).and_return {:stub_return} + MockableClass.find("1").should equal(:stub_return) + end + + it "should revert to the original after each spec" do + MockableClass.find(1).should equal(:original_return) + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/pending_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/pending_example.rb new file mode 100644 index 000000000..825af2ed1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/pending_example.rb @@ -0,0 +1,7 @@ +describe "pending example (which is fixed)" do + it %Q|reports "FIXED ... Expected ... to fail. No Error was raised."| do + pending("for some reason") do + # success + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/predicate_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/predicate_example.rb new file mode 100644 index 000000000..aed8b14bd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/predicate_example.rb @@ -0,0 +1,32 @@ +class BddFramework + def intuitive? + true + end + + def adopted_quickly? + #this will cause failures because it reallly SHOULD be adopted quickly + false + end +end + +describe "BDD framework" do + + before(:each) do + @bdd_framework = BddFramework.new + end + + it "should be adopted quickly" do + #this will fail because it reallly SHOULD be adopted quickly + @bdd_framework.should be_adopted_quickly + end + + it "should be intuitive" do + @bdd_framework.should be_intuitive + end + + it "should not respond to test" do + #this will fail + @bdd_framework.test + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/raising_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/raising_example.rb new file mode 100644 index 000000000..e40b51ec8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/raising_example.rb @@ -0,0 +1,47 @@ +describe "This example" do + + it "should show that a NoMethodError is raised but an Exception was expected" do + proc { ''.nonexistent_method }.should raise_error + end + + it "should pass" do + proc { ''.nonexistent_method }.should raise_error(NoMethodError) + end + + it "should show that a NoMethodError is raised but a SyntaxError was expected" do + proc { ''.nonexistent_method }.should raise_error(SyntaxError) + end + + it "should show that nothing is raised when SyntaxError was expected" do + proc { }.should raise_error(SyntaxError) + end + + it "should show that a NoMethodError is raised but a Exception was expected" do + proc { ''.nonexistent_method }.should_not raise_error + end + + it "should show that a NoMethodError is raised" do + proc { ''.nonexistent_method }.should_not raise_error(NoMethodError) + end + + it "should also pass" do + proc { ''.nonexistent_method }.should_not raise_error(SyntaxError) + end + + it "should show that a NoMethodError is raised when nothing expected" do + proc { ''.nonexistent_method }.should_not raise_error(Exception) + end + + it "should show that the wrong message was received" do + proc { raise StandardError.new("what is an enterprise?") }.should raise_error(StandardError, "not this") + end + + it "should show that the unexpected error/message was thrown" do + proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "abc") + end + + it "should pass too" do + proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "xyz") + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/syntax_error_example.rb b/vendor/gems/rspec-1.3.1/examples/failing/syntax_error_example.rb new file mode 100644 index 000000000..c9bb90774 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/syntax_error_example.rb @@ -0,0 +1,7 @@ +describe "when passing a block to a matcher" do + it "you should use {} instead of do/end" do + Object.new.should satisfy do + "this block is being passed to #should instead of #satisfy - use {} instead" + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/team_spec.rb b/vendor/gems/rspec-1.3.1/examples/failing/team_spec.rb new file mode 100644 index 000000000..ab35b5274 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/team_spec.rb @@ -0,0 +1,41 @@ +class Team + attr_reader :players + def initialize + @players = Players.new + end +end + +class Players + def initialize + @players = [] + end + def size + @players.size + end + def include? player + raise "player must be a string" unless player.is_a?(String) + @players.include? player + end +end + +describe "A new team" do + + before(:each) do + @team = Team.new + end + + it "should have 3 players (failing example)" do + @team.should have(3).players + end + + it "should include some player (failing example)" do + @team.players.should include("Some Player") + end + + it "should include 5 (failing example)" do + @team.players.should include(5) + end + + it "should have no players" + +end diff --git a/vendor/gems/rspec-1.3.1/examples/failing/timeout_behaviour.rb b/vendor/gems/rspec-1.3.1/examples/failing/timeout_behaviour.rb new file mode 100644 index 000000000..1a3615ff0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/failing/timeout_behaviour.rb @@ -0,0 +1,5 @@ +describe "Something really slow" do + it "should be failed by RSpec when it takes longer than --timeout" do + sleep(2) + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/custom_formatter.rb b/vendor/gems/rspec-1.3.1/examples/passing/custom_formatter.rb new file mode 100644 index 000000000..4c7482190 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/custom_formatter.rb @@ -0,0 +1,11 @@ +require 'spec/runner/formatter/progress_bar_formatter' + +# Example of a formatter with custom bactrace printing. Run me with: +# ruby bin/spec examples/failing -r examples/passing/custom_formatter.rb -f CustomFormatter +class CustomFormatter < Spec::Runner::Formatter::ProgressBarFormatter + def backtrace_line(line) + line.gsub(/([^:]*\.rb):(\d*)/) do + "<a href=\"file://#{File.expand_path($1)}\">#{$1}:#{$2}</a> " + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/custom_matchers.rb b/vendor/gems/rspec-1.3.1/examples/passing/custom_matchers.rb new file mode 100644 index 000000000..075bb542d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/custom_matchers.rb @@ -0,0 +1,54 @@ +module AnimalSpecHelper + class Eat + def initialize(food) + @food = food + end + + def matches?(animal) + @animal = animal + @animal.eats?(@food) + end + + def failure_message + "expected #{@animal} to eat #{@food}, but it does not" + end + + def negative_failure_message + "expected #{@animal} not to eat #{@food}, but it does" + end + end + + def eat(food) + Eat.new(food) + end +end + +module Animals + class Animal + def eats?(food) + return foods_i_eat.include?(food) + end + end + + class Mouse < Animal + def foods_i_eat + [:cheese] + end + end + + describe Mouse do + include AnimalSpecHelper + before(:each) do + @mouse = Animals::Mouse.new + end + + it "should eat cheese" do + @mouse.should eat(:cheese) + end + + it "should not eat cat" do + @mouse.should_not eat(:cat) + end + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/dynamic_spec.rb b/vendor/gems/rspec-1.3.1/examples/passing/dynamic_spec.rb new file mode 100644 index 000000000..7c0372631 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/dynamic_spec.rb @@ -0,0 +1,7 @@ +describe "The square root" do + (1..10).each do |n| + it "of #{n*n} should be #{n}" do + Math.sqrt(n*n).should == n + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/file_accessor.rb b/vendor/gems/rspec-1.3.1/examples/passing/file_accessor.rb new file mode 100644 index 000000000..e67f44735 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/file_accessor.rb @@ -0,0 +1,18 @@ +class FileAccessor + def open_and_handle_with(pathname, processor) + pathname.open do |io| + processor.process(io) + end + end +end + +if __FILE__ == $0 + require 'examples/passing/io_processor' + require 'pathname' + + accessor = FileAccessor.new + io_processor = IoProcessor.new + file = Pathname.new ARGV[0] + + accessor.open_and_handle_with(file, io_processor) +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/file_accessor_spec.rb b/vendor/gems/rspec-1.3.1/examples/passing/file_accessor_spec.rb new file mode 100644 index 000000000..84428b6fc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/file_accessor_spec.rb @@ -0,0 +1,37 @@ +require 'examples/passing/file_accessor' +require 'stringio' + +describe "A FileAccessor" do + # This sequence diagram illustrates what this spec specifies. + # + # +--------------+ +----------+ +-------------+ + # | FileAccessor | | Pathname | | IoProcessor | + # +--------------+ +----------+ +-------------+ + # | | | + # open_and_handle_with | | | + # -------------------->| | open | | + # | |--------------->| | | + # | | io | | | + # | |<...............| | | + # | | | process(io) | + # | |---------------------------------->| | + # | | | | | + # | |<..................................| | + # | | | + # + it "should open a file and pass it to the processor's process method" do + # This is the primary actor + accessor = FileAccessor.new + + # These are the primary actor's neighbours, which we mock. + file = mock "Pathname" + io_processor = mock "IoProcessor" + + io = StringIO.new "whatever" + file.should_receive(:open).and_yield io + io_processor.should_receive(:process).with(io) + + accessor.open_and_handle_with(file, io_processor) + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter.rb b/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter.rb new file mode 100644 index 000000000..eaeabbcfa --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter.rb @@ -0,0 +1,17 @@ +require 'spec/runner/formatter/nested_text_formatter' + +class FilteredFormatter < Spec::Runner::Formatter::NestedTextFormatter + def add_example_group(example_group) + if example_group.options[:show] == false + @showing = false + else + @showing = true + puts example_group.description + end + end + + def example_passed(example) + puts " " << example.description if @showing unless example.options[:show] == false + end +end + diff --git a/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter_example.rb new file mode 100644 index 000000000..3c9d067f1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/filtered_formatter_example.rb @@ -0,0 +1,31 @@ +# This demonstrates how you can write custom formatters to handle arbitrary +# options passed to the +describe+ and +it+ methods. To see it in action, stand +# in the project root and say: +# +# bin/spec -r examples/passing/filtered_formatter.rb examples/passing/filtered_formatter_example.rb -f FilteredFormatter +# +# You should only see the examples and groups below that are not explicitly +# marked :show => false +# +# group 1 +# example 1 a +# group 3 +# example 3 + + +describe "group 1", :show => true do + it "example 1 a", :show => true do + end + it "example 1 b", :show => false do + end +end + +describe "group 2", :show => false do + it "example 2" do + end +end + +describe "group 3" do + it "example 3" do + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/passing/greeter_spec.rb b/vendor/gems/rspec-1.3.1/examples/passing/greeter_spec.rb new file mode 100644 index 000000000..7d67e3187 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/greeter_spec.rb @@ -0,0 +1,30 @@ +# greeter.rb +# +# Based on http://glu.ttono.us/articles/2006/12/19/tormenting-your-tests-with-heckle +# +# Run with: +# +# spec greeter_spec.rb --heckle Greeter +# +class Greeter + def initialize(person = nil) + @person = person + end + + def greet + @person.nil? ? "Hi there!" : "Hi #{@person}!" + end +end + +describe "Greeter" do + it "should say Hi to person" do + greeter = Greeter.new("Kevin") + greeter.greet.should == "Hi Kevin!" + end + + it "should say Hi to nobody" do + greeter = Greeter.new + # Uncomment the next line to make Heckle happy + #greeter.greet.should == "Hi there!" + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/helper_method_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/helper_method_example.rb new file mode 100644 index 000000000..eb3dca92f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/helper_method_example.rb @@ -0,0 +1,12 @@ +module HelperMethodExample + describe "an example group with helper a method" do + def helper_method + "received call" + end + + it "should make that method available to specs" do + helper_method.should == "received call" + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/examples/passing/implicit_docstrings_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/implicit_docstrings_example.rb new file mode 100644 index 000000000..889cef425 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/implicit_docstrings_example.rb @@ -0,0 +1,16 @@ +# Run "spec implicit_docstrings_example.rb --format specdoc" to see the output of this file + +describe "Examples with no docstrings generate their own:" do + + specify { 3.should be < 5 } + + specify { ["a"].should include("a") } + + specify { [1,2,3].should respond_to(:size) } + +end + +describe 1 do + it { should == 1 } + it { should be < 2} +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/io_processor.rb b/vendor/gems/rspec-1.3.1/examples/passing/io_processor.rb new file mode 100644 index 000000000..6b15147b6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/io_processor.rb @@ -0,0 +1,8 @@ +class DataTooShort < StandardError; end + +class IoProcessor + # Does some fancy stuff unless the length of +io+ is shorter than 32 + def process(io) + raise DataTooShort if io.read.length < 32 + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/io_processor_spec.rb b/vendor/gems/rspec-1.3.1/examples/passing/io_processor_spec.rb new file mode 100644 index 000000000..1f5020e76 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/io_processor_spec.rb @@ -0,0 +1,20 @@ +require 'examples/passing/io_processor' +require 'stringio' + +describe "An IoProcessor" do + before(:each) do + @processor = IoProcessor.new + end + + it "should raise nothing when the file is exactly 32 bytes" do + lambda { + @processor.process(StringIO.new("z"*32)) + }.should_not raise_error + end + + it "should raise an exception when the file length is less than 32 bytes" do + lambda { + @processor.process(StringIO.new("z"*31)) + }.should raise_error(DataTooShort) + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/mocking_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/mocking_example.rb new file mode 100644 index 000000000..1d342c735 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/mocking_example.rb @@ -0,0 +1,25 @@ +describe "A consumer of a mock" do + it "should be able to send messages to the mock" do + mock = mock("poke me") + mock.should_receive(:poke) + mock.poke + end +end + +describe "a mock" do + it "should be able to mock the same message twice w/ different args" do + mock = mock("mock") + mock.should_receive(:msg).with(:arg1).and_return(:val1) + mock.should_receive(:msg).with(:arg2).and_return(:val2) + mock.msg(:arg1).should eql(:val1) + mock.msg(:arg2).should eql(:val2) + end + + it "should be able to mock the same message twice w/ different args in reverse order" do + mock = mock("mock") + mock.should_receive(:msg).with(:arg1).and_return(:val1) + mock.should_receive(:msg).with(:arg2).and_return(:val2) + mock.msg(:arg2).should eql(:val2) + mock.msg(:arg1).should eql(:val1) + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/multi_threaded_example_group_runner.rb b/vendor/gems/rspec-1.3.1/examples/passing/multi_threaded_example_group_runner.rb new file mode 100644 index 000000000..d5458ddf8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/multi_threaded_example_group_runner.rb @@ -0,0 +1,26 @@ +class MultiThreadedExampleGroupRunner < Spec::Runner::ExampleGroupRunner + def initialize(options, arg) + super(options) + # configure these + @thread_count = 4 + @thread_wait = 0 + end + + def run + @threads = [] + q = Queue.new + example_groups.each { |b| q << b} + success = true + @thread_count.times do + @threads << Thread.new(q) do |queue| + while not queue.empty? + example_group = queue.pop + success &= example_group.suite.run(nil) + end + end + sleep @thread_wait + end + @threads.each {|t| t.join} + success + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/passing/nested_classes_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/nested_classes_example.rb new file mode 100644 index 000000000..ce5499591 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/nested_classes_example.rb @@ -0,0 +1,35 @@ +require 'examples/passing/stack' + +class StackExamples < Spec::ExampleGroup + describe(Stack) + before(:each) do + @stack = Stack.new + end +end + +class EmptyStackExamples < StackExamples + describe("when empty") + it "should be empty" do + @stack.should be_empty + end +end + +class AlmostFullStackExamples < StackExamples + describe("when almost full") + before(:each) do + (1..9).each {|n| @stack.push n} + end + it "should be full" do + @stack.should_not be_full + end +end + +class FullStackExamples < StackExamples + describe("when full") + before(:each) do + (1..10).each {|n| @stack.push n} + end + it "should be full" do + @stack.should be_full + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/passing/options_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/options_example.rb new file mode 100644 index 000000000..bed3077eb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/options_example.rb @@ -0,0 +1,29 @@ +# This demonstrates the use of the options hash to support custom reporting. +# To see the result, run this command from the project root: +# +# bin/spec --require examples/passing/options_formatter.rb examples/passing/options_example.rb \ +# --format OptionsFormatter + +describe "this group will be reported", :report => true do + it "this example will be reported", :report => true do + # no-op + end + + it "this example will not be reported", :report => false do + # no-op + end + + it "this example will also not be reported", :foo => 'bar' do + # no-op + end + + it "this example will also also not be reported" do + # no-op + end +end + +describe "this group will not be reported", :report => false do + it "though this example will", :report => true do + # no-op + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/passing/options_formatter.rb b/vendor/gems/rspec-1.3.1/examples/passing/options_formatter.rb new file mode 100644 index 000000000..b88bebbc5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/options_formatter.rb @@ -0,0 +1,20 @@ +# This is an example of how you can use a custom formatter to do custom +# reporting. This formatter will only report example groups and examples that +# have :report => true (or anything truthy) in the declaration. See +# options_example.rb in this directory. + +require 'spec/runner/formatter/base_text_formatter' + +class OptionsFormatter < Spec::Runner::Formatter::BaseTextFormatter + def example_started(proxy) + if proxy.options[:report] + puts proxy.description + end + end + + def example_group_started(proxy) + if proxy.options[:report] + puts proxy.description + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/partial_mock_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/partial_mock_example.rb new file mode 100644 index 000000000..38aafa149 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/partial_mock_example.rb @@ -0,0 +1,27 @@ +class MockableClass + def self.find id + return :original_return + end +end + +describe "A partial mock" do + + it "should work at the class level" do + MockableClass.should_receive(:find).with(1).and_return {:stub_return} + MockableClass.find(1).should equal(:stub_return) + end + + it "should revert to the original after each spec" do + MockableClass.find(1).should equal(:original_return) + end + + it "can be mocked w/ ordering" do + MockableClass.should_receive(:msg_1).ordered + MockableClass.should_receive(:msg_2).ordered + MockableClass.should_receive(:msg_3).ordered + MockableClass.msg_1 + MockableClass.msg_2 + MockableClass.msg_3 + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/pending_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/pending_example.rb new file mode 100644 index 000000000..7ce382742 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/pending_example.rb @@ -0,0 +1,18 @@ +describe "pending example (using pending method)" do + it %Q|should be reported as "PENDING: for some reason"| do + pending("for some reason") + end +end + +describe "pending example (with no block)" do + it %Q|should be reported as "PENDING: Not Yet Implemented"| +end + +describe "pending example (with block for pending)" do + it %Q|should have a failing block, passed to pending, reported as "PENDING: for some reason"| do + pending("for some reason") do + raise "some reason" + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/examples/passing/predicate_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/predicate_example.rb new file mode 100644 index 000000000..f10c386f3 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/predicate_example.rb @@ -0,0 +1,25 @@ +class BddFramework + def intuitive? + true + end + + def adopted_quickly? + true + end +end + +describe "BDD framework" do + + before(:each) do + @bdd_framework = BddFramework.new + end + + it "should be adopted quickly" do + @bdd_framework.should be_adopted_quickly + end + + it "should be intuitive" do + @bdd_framework.should be_intuitive + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/shared_example_group_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/shared_example_group_example.rb new file mode 100644 index 000000000..39fecf612 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/shared_example_group_example.rb @@ -0,0 +1,43 @@ +module SharedExampleGroupExample + class OneThing + def what_things_do + "stuff" + end + end + + class AnotherThing + def what_things_do + "stuff" + end + end + + class YetAnotherThing + def what_things_do + "stuff" + end + end + + # A SharedExampleGroup is an example group that doesn't get run. + # You can create one like this: + share_examples_for "most things" do + def helper_method + "helper method" + end + + it "should do what things do" do + @thing.what_things_do.should == "stuff" + end + end + + describe OneThing do + # Now you can include the shared example group like this, which + # feels more like what you might say ... + it_should_behave_like "most things" + + before(:each) { @thing = OneThing.new } + + it "should have access to helper methods defined in the shared example group" do + helper_method.should == "helper method" + end + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/shared_stack_examples.rb b/vendor/gems/rspec-1.3.1/examples/passing/shared_stack_examples.rb new file mode 100644 index 000000000..e14fd146d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/shared_stack_examples.rb @@ -0,0 +1,36 @@ +shared_examples_for "non-empty Stack" do + + it { @stack.should_not be_empty } + + it "should return the top item when sent #peek" do + @stack.peek.should == @last_item_added + end + + it "should NOT remove the top item when sent #peek" do + @stack.peek.should == @last_item_added + @stack.peek.should == @last_item_added + end + + it "should return the top item when sent #pop" do + @stack.pop.should == @last_item_added + end + + it "should remove the top item when sent #pop" do + @stack.pop.should == @last_item_added + unless @stack.empty? + @stack.pop.should_not == @last_item_added + end + end + +end + +shared_examples_for "non-full Stack" do + + it { @stack.should_not be_full } + + it "should add to the top when sent #push" do + @stack.push "newly added top item" + @stack.peek.should == "newly added top item" + end + +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/passing/simple_matcher_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/simple_matcher_example.rb new file mode 100644 index 000000000..9bf7ce0a7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/simple_matcher_example.rb @@ -0,0 +1,29 @@ +describe "arrays" do + Spec::Matchers.define :contain_same_elements_as do |expected| + match do |actual| + if actual.size == expected.size + a, e = actual.dup, expected.dup + until e.empty? do + if i = a.index(e.pop) then a.delete_at(i) end + end + a.empty? + else + false + end + end + end + + describe "can be matched by their contents disregarding order" do + subject { [1,2,2,3] } + it { should contain_same_elements_as([1,2,2,3]) } + it { should contain_same_elements_as([2,3,2,1]) } + it { should_not contain_same_elements_as([3,3,2,1]) } + end + + describe "fail the match with different contents" do + subject { [1,2,3] } + it { should_not contain_same_elements_as([2,3,4])} + it { should_not contain_same_elements_as([1,2,2,3])} + it { should_not contain_same_elements_as([1,2])} + end +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/stack.rb b/vendor/gems/rspec-1.3.1/examples/passing/stack.rb new file mode 100644 index 000000000..407173f7b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/stack.rb @@ -0,0 +1,36 @@ +class StackUnderflowError < RuntimeError +end + +class StackOverflowError < RuntimeError +end + +class Stack + + def initialize + @items = [] + end + + def push object + raise StackOverflowError if @items.length == 10 + @items.push object + end + + def pop + raise StackUnderflowError if @items.empty? + @items.delete @items.last + end + + def peek + raise StackUnderflowError if @items.empty? + @items.last + end + + def empty? + @items.empty? + end + + def full? + @items.length == 10 + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/stack_spec.rb b/vendor/gems/rspec-1.3.1/examples/passing/stack_spec.rb new file mode 100644 index 000000000..6d0d06366 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/stack_spec.rb @@ -0,0 +1,63 @@ +require 'examples/passing/stack' +require 'examples/passing/shared_stack_examples' + +describe Stack, " (empty)" do + before(:each) do + @stack = Stack.new + end + + # This uses @stack (because the described class is Stack) auto-generates the + # description "should be empty" + it { should be_empty } + + it_should_behave_like "non-full Stack" + + it "should complain when sent #peek" do + lambda { @stack.peek }.should raise_error(StackUnderflowError) + end + + it "should complain when sent #pop" do + lambda { @stack.pop }.should raise_error(StackUnderflowError) + end +end + +describe Stack, " (with one item)" do + before(:each) do + @stack = Stack.new + @stack.push 3 + @last_item_added = 3 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + +end + +describe Stack, " (with one item less than capacity)" do + before(:each) do + @stack = Stack.new + (1..9).each { |i| @stack.push i } + @last_item_added = 9 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" +end + +describe Stack, " (full)" do + before(:each) do + @stack = Stack.new + (1..10).each { |i| @stack.push i } + @last_item_added = 10 + end + + # NOTE that this one auto-generates the description "should be full" + it { @stack.should be_full } + + it_should_behave_like "non-empty Stack" + + it "should complain on #push" do + lambda { @stack.push Object.new }.should raise_error(StackOverflowError) + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/stack_spec_with_nested_example_groups.rb b/vendor/gems/rspec-1.3.1/examples/passing/stack_spec_with_nested_example_groups.rb new file mode 100644 index 000000000..6e36df789 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/stack_spec_with_nested_example_groups.rb @@ -0,0 +1,66 @@ +require 'examples/passing/stack' +require 'examples/passing/shared_stack_examples' + +describe Stack do + + before(:each) do + @stack = Stack.new + end + + describe "(empty)" do + + it { @stack.should be_empty } + + it_should_behave_like "non-full Stack" + + it "should complain when sent #peek" do + lambda { @stack.peek }.should raise_error(StackUnderflowError) + end + + it "should complain when sent #pop" do + lambda { @stack.pop }.should raise_error(StackUnderflowError) + end + + end + + describe "(with one item)" do + + before(:each) do + @stack.push 3 + @last_item_added = 3 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + + end + + describe "(with one item less than capacity)" do + + before(:each) do + (1..9).each { |i| @stack.push i } + @last_item_added = 9 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + end + + describe "(full)" do + + before(:each) do + (1..10).each { |i| @stack.push i } + @last_item_added = 10 + end + + it { @stack.should be_full } + + it_should_behave_like "non-empty Stack" + + it "should complain on #push" do + lambda { @stack.push Object.new }.should raise_error(StackOverflowError) + end + + end + +end diff --git a/vendor/gems/rspec-1.3.1/examples/passing/stubbing_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/stubbing_example.rb new file mode 100644 index 000000000..dab8982ee --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/stubbing_example.rb @@ -0,0 +1,67 @@ +describe "A consumer of a stub" do + it "should be able to stub methods on any Object" do + obj = Object.new + obj.stub!(:foobar).and_return {:return_value} + obj.foobar.should equal(:return_value) + end +end + +class StubbableClass + def self.find id + return :original_return + end +end + +describe "A stubbed method on a class" do + it "should return the stubbed value" do + StubbableClass.stub!(:find).and_return(:stub_return) + StubbableClass.find(1).should equal(:stub_return) + end + + it "should revert to the original method after each spec" do + StubbableClass.find(1).should equal(:original_return) + end + + it "can stub! and mock the same message" do + StubbableClass.stub!(:msg).and_return(:stub_value) + StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value) + + StubbableClass.msg.should equal(:stub_value) + StubbableClass.msg(:other_arg).should equal(:stub_value) + StubbableClass.msg(:arg).should equal(:mock_value) + StubbableClass.msg(:another_arg).should equal(:stub_value) + StubbableClass.msg(:yet_another_arg).should equal(:stub_value) + StubbableClass.msg.should equal(:stub_value) + end +end + +describe "A mock" do + it "can stub!" do + mock = mock("stubbing mock") + mock.stub!(:msg).and_return(:value) + (1..10).each {mock.msg.should equal(:value)} + end + + it "can stub! and mock" do + mock = mock("stubbing mock") + mock.stub!(:stub_message).and_return(:stub_value) + mock.should_receive(:mock_message).once.and_return(:mock_value) + (1..10).each {mock.stub_message.should equal(:stub_value)} + mock.mock_message.should equal(:mock_value) + (1..10).each {mock.stub_message.should equal(:stub_value)} + end + + it "can stub! and mock the same message" do + mock = mock("stubbing mock") + mock.stub!(:msg).and_return(:stub_value) + mock.should_receive(:msg).with(:arg).and_return(:mock_value) + mock.msg.should equal(:stub_value) + mock.msg(:other_arg).should equal(:stub_value) + mock.msg(:arg).should equal(:mock_value) + mock.msg(:another_arg).should equal(:stub_value) + mock.msg(:yet_another_arg).should equal(:stub_value) + mock.msg.should equal(:stub_value) + end +end + + diff --git a/vendor/gems/rspec-1.3.1/examples/passing/yielding_example.rb b/vendor/gems/rspec-1.3.1/examples/passing/yielding_example.rb new file mode 100644 index 000000000..e7b43fffa --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/passing/yielding_example.rb @@ -0,0 +1,31 @@ +class MessageAppender + + def initialize(appendage) + @appendage = appendage + end + + def append_to(message) + if_told_to_yield do + message << @appendage + end + end + +end + +describe "a message expectation yielding to a block" do + it "should yield if told to" do + appender = MessageAppender.new("appended to") + appender.should_receive(:if_told_to_yield).and_yield + message = "" + appender.append_to(message) + message.should == "appended to" + end + + it "should not yield if not told to" do + appender = MessageAppender.new("appended to") + appender.should_receive(:if_told_to_yield) + message = "" + appender.append_to(message) + message.should == "" + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/examples/ruby1.9.compatibility/access_to_constants_spec.rb b/vendor/gems/rspec-1.3.1/examples/ruby1.9.compatibility/access_to_constants_spec.rb new file mode 100644 index 000000000..b34b8ba6d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/examples/ruby1.9.compatibility/access_to_constants_spec.rb @@ -0,0 +1,85 @@ +# courtesy of Matthias Hennemeyer +# +# The following should pass against ruby 1.8 and 1.9. It currently only passes +# 1.8 (as of 1/2/2009) +# +# Once cucumber supports ruby 1.9, this should be moved to cucumber scenarios instead. +module Foo + module Bar + + module ModuleInEnclosingModule;end + class ClassInEnclosingModule;end + def method_in_enclosing_module;end + CONSTANT_IN_ENCLOSING_MODULE = 0 + + describe "Examples trying to access constants defined in an enclosing module" do + + it "can access Modules" do + ModuleInEnclosingModule + end + it "can access Classes" do + ClassInEnclosingModule.new + end + it "can access CONSTANTS" do + CONSTANT_IN_ENCLOSING_MODULE + end + it "can NOT access methods" do + lambda {method_in_enclosing_module}.should raise_error(/undefined/) + end + + describe "from a nested example group" do + + it "can access Modules" do + ModuleInEnclosingModule + end + it "can access Classes" do + ClassInEnclosingModule.new + end + it "can access CONSTANTS" do + CONSTANT_IN_ENCLOSING_MODULE + end + it "can NOT access methods" do + lambda {method_in_enclosing_module}.should raise_error(/undefined/) + end + + end + + end + + describe "Examples trying to access constants defined in the example group" do + + module ModuleDefinedInGroup;end + class ClassDefinedInGroup; end + def method_defined_in_group; end + CONSTANT_DEFINED_IN_GROUP = 0 + + it "can access Modules" do + ModuleDefinedInGroup + end + it "can access Classes" do + ClassDefinedInGroup.new + end + it "can access CONSTANTS" do + CONSTANT_DEFINED_IN_GROUP + end + it "can access methods" do + method_defined_in_group + end + + describe "that live inside a nested group" do + it "can access Modules" do + ModuleDefinedInGroup + end + it "can access Classes" do + ClassDefinedInGroup.new + end + it "can access CONSTANTS" do + CONSTANT_DEFINED_IN_GROUP + end + it "can access methods" do + method_defined_in_group + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/features/before_and_after_blocks/before_and_after_blocks.feature b/vendor/gems/rspec-1.3.1/features/before_and_after_blocks/before_and_after_blocks.feature new file mode 100644 index 000000000..c1446bbb5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/before_and_after_blocks/before_and_after_blocks.feature @@ -0,0 +1,167 @@ +Feature: before and after blocks + + As a developer using RSpec + I want to execute arbitrary code before and after each example + So that I can control the environment in which it is run + + This is supported by the before and after methods which each take a symbol + indicating the scope, and a block of code to execute. + + before(:each) blocks are run before each example + before(:all) blocks are run once before all of the examples in a group + before(:suite) blocks are run once before the entire suite + + after(:each) blocks are run after each example + after(:all) blocks are run once after all of the examples in a group + after(:suite) blocks are run once after the entire suite + + Before and after blocks are called in the following order: + before suite + before all + before each + after each + after all + after suite + + Before and after blocks can be defined in the example groups to which they + apply or in a configuration. When defined in a configuration, they can be + applied to all groups or subsets of all groups defined by example group + types. + + Scenario: define before(:each) block in example group + Given a file named "before_each_in_example_group_spec.rb" with: + """ + class Thing + def widgets + @widgets ||= [] + end + end + + describe Thing do + before(:each) do + @thing = Thing.new + end + + context "initialized in before(:each)" do + it "has 0 widgets" do + @thing.should have(0).widgets + end + + it "can get accept new widgets" do + @thing.widgets << Object.new + end + + it "does not share state across examples" do + @thing.should have(0).widgets + end + end + end + """ + When I run "spec before_each_in_example_group_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: define before(:all) block in example group + Given a file named "before_all_in_example_group_spec.rb" with: + """ + class Thing + def widgets + @widgets ||= [] + end + end + + describe Thing do + before(:all) do + @thing = Thing.new + end + + context "initialized in before(:all)" do + it "has 0 widgets" do + @thing.should have(0).widgets + end + + it "can get accept new widgets" do + @thing.widgets << Object.new + end + + it "shares state across examples" do + @thing.should have(1).widgets + end + end + end + """ + When I run "spec before_all_in_example_group_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: define before and after blocks in configuration + Given a file named "befores_in_configuration_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.before(:suite) do + $before_suite = "before suite" + end + config.before(:each) do + @before_each = "before each" + end + config.before(:all) do + @before_all = "before all" + end + end + + describe "stuff in before blocks" do + describe "with :suite" do + it "should be available in the example" do + $before_suite.should == "before suite" + end + end + describe "with :all" do + it "should be available in the example" do + @before_all.should == "before all" + end + end + describe "with :each" do + it "should be available in the example" do + @before_each.should == "before each" + end + end + end + """ + When I run "spec befores_in_configuration_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: before/after blocks are run in order + Given a file named "ensure_block_order_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.before(:suite) do + puts "before suite" + end + config.after(:suite) do + puts "after suite" + end + end + + describe "before and after callbacks" do + before(:all) do + puts "before all" + end + + before(:each) do + puts "before each" + end + + after(:each) do + puts "after each" + end + + after(:all) do + puts "after all" + end + + it "gets run in order" do + + end + end + """ + When I run "spec ensure_block_order_spec.rb" + Then the stdout should include /before suite\nbefore all\nbefore each\nafter each\n\.after all\n.*after suite/m + diff --git a/vendor/gems/rspec-1.3.1/features/command_line/line_number_option.feature b/vendor/gems/rspec-1.3.1/features/command_line/line_number_option.feature new file mode 100644 index 000000000..7fc6fc50d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/command_line/line_number_option.feature @@ -0,0 +1,56 @@ +Feature: Spec and test together + + As an RSpec user + I want to run one example identified by the line number + + Background: + Given a file named "example.rb" with: + """ + describe "a group" do + + it "has a first example" do + + end + + it "has a second example" do + + end + + end + """ + + Scenario: two examples - first example on declaration line + When I run "spec example.rb:3 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - first example from line inside declaration + When I run "spec example.rb:4 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - first example from line below declaration + When I run "spec example.rb:6 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - second example from line below declaration + When I run "spec example.rb:7 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a second example" + But the stdout should not match "has a first example" + + Scenario: two examples - both examples from the group declaration + When I run "spec example.rb:1 --format nested" + Then the stdout should include "2 examples, 0 failures" + And the stdout should include "has a second example" + And the stdout should include "has a first example" + + Scenario: two examples - both examples from above the first example declaration + When I run "spec example.rb:2 --format nested" + Then the stdout should include "2 examples, 0 failures" + And the stdout should include "has a second example" + And the stdout should include "has a first example" diff --git a/vendor/gems/rspec-1.3.1/features/command_line/line_number_option_with_example_with_no_name.feature b/vendor/gems/rspec-1.3.1/features/command_line/line_number_option_with_example_with_no_name.feature new file mode 100644 index 000000000..244db51fb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/command_line/line_number_option_with_example_with_no_name.feature @@ -0,0 +1,22 @@ +Feature: Spec and test together + + As an RSpec user + I want to run one example identified by the line number + + Background: + Given a file named "example.rb" with: + """ + describe 9 do + + it { should be > 8 } + + it { should be < 10 } + + end + """ + + Scenario: two examples - first example on declaration line + When I run "spec example.rb:3 --format nested" + Then the stdout should include "1 example, 0 failures" + Then the stdout should include "should be > 8" + But the stdout should not match "should be < 10" diff --git a/vendor/gems/rspec-1.3.1/features/example_groups/define_example_attribute.feature b/vendor/gems/rspec-1.3.1/features/example_groups/define_example_attribute.feature new file mode 100644 index 000000000..9fc72ac64 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/example_groups/define_example_attribute.feature @@ -0,0 +1,41 @@ +Feature: Define example attribute + + In order to streamline process + As an RSpec user + I want to easily define helper methods that act as a variable assignment + + It is fairly common to start with a local variable in one example, use the same + local variable in the next, and then extract the declaration of that variable + to before(:each). This requires converting the locals to instance variables. + + This feature streamlines the process by defining a helper method so you can extract + the duplication without having to change other references to the same variables + to @instance_variables. + + Scenario: + Given a file named "counter_spec.rb" with: + """ + require 'spec/autorun' + + class Counter + def initialize + @count = 0 + end + def count + @count += 1 + end + end + + describe Counter do + let(:counter) { Counter.new } + it "returns 1 the first time" do + counter.count.should == 1 + end + it "returns 2 the second time because the counter itself is cached by the 'assign' method" do + counter.count + counter.count.should == 2 + end + end + """ + When I run "spec counter_spec.rb" + Then the stdout should include "2 examples, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/example_groups/example_group_with_should_methods.feature b/vendor/gems/rspec-1.3.1/features/example_groups/example_group_with_should_methods.feature new file mode 100644 index 000000000..b5f76bf8a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/example_groups/example_group_with_should_methods.feature @@ -0,0 +1,29 @@ +Feature: Spec::ExampleGroup with should methods + + As an RSpec adopter accustomed to classes and methods + I want to use should_* methods in an ExampleGroup + So that I use RSpec with classes and methods that look more like RSpec examples + + Scenario Outline: Example Group class with should methods + Given a file named "example_group_with_should_methods.rb" with: + """ + require 'spec/autorun' + + class MySpec < Spec::ExampleGroup + def should_pass_with_should + 1.should == 1 + end + + def should_fail_with_should + 1.should == 2 + end + end + """ + When I run "<Command> example_group_with_should_methods.rb" + Then the exit code should be 256 + And the stdout should include "2 examples, 1 failure" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/gems/rspec-1.3.1/features/example_groups/implicit_docstrings.feature b/vendor/gems/rspec-1.3.1/features/example_groups/implicit_docstrings.feature new file mode 100644 index 000000000..b83a3470c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/example_groups/implicit_docstrings.feature @@ -0,0 +1,59 @@ +Feature: implicit docstrings + + As an RSpec user + I want examples to generate their own names + So that I can reduce duplication between example names and example code + + Scenario Outline: run passing examples + Given a file named "implicit_docstrings_example.rb" with: + """ + require 'spec/autorun' + describe "Examples with no docstrings generate their own:" do + + specify { 3.should be < 5 } + + specify { ["a"].should include("a") } + + specify { [1,2,3].should respond_to(:size) } + + end + """ + + When I run "<Command> implicit_docstrings_example.rb -fs" + + Then the stdout should include /should be < 5/ + And the stdout should include /should include "a"/ + And the stdout should include /should respond to #size/ + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | + + Scenario Outline: run failing examples + Given a file named "failing_implicit_docstrings_example.rb" with: + """ + require 'spec/autorun' + describe "Failing examples with no descriptions" do + + # description is auto-generated as "should equal(5)" based on the last #should + it do + 3.should equal(2) + 5.should equal(5) + end + + it { 3.should be > 5 } + + it { ["a"].should include("b") } + + it { [1,2,3].should_not respond_to(:size) } + + end + """ + + When I run "<Command> failing_implicit_docstrings_example.rb -fs" + + Then the stdout should include /should equal 2/ + And the stdout should include /should be > 5/ + And the stdout should include /should include "b"/ + And the stdout should include /should not respond to #size/ diff --git a/vendor/gems/rspec-1.3.1/features/example_groups/nested_groups.feature b/vendor/gems/rspec-1.3.1/features/example_groups/nested_groups.feature new file mode 100644 index 000000000..6d8c7aadf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/example_groups/nested_groups.feature @@ -0,0 +1,32 @@ +Feature: Nested example groups + + As an RSpec user + I want to nest examples groups + So that I can better organize my examples + + Scenario Outline: Nested example groups + Given a file named "nested_example_groups.rb" with: + """ + require 'spec/autorun' + + describe "Some Object" do + describe "with some more context" do + it "should do this" do + true.should be_true + end + end + describe "with some other context" do + it "should do that" do + false.should be_false + end + end + end + """ + When I run "<Command> nested_example_groups.rb -fs" + Then the stdout should include /Some Object with some more context/ + And the stdout should include /Some Object with some other context/ + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/gems/rspec-1.3.1/features/expectations/customized_message.feature b/vendor/gems/rspec-1.3.1/features/expectations/customized_message.feature new file mode 100644 index 000000000..c19490c7a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/expectations/customized_message.feature @@ -0,0 +1,54 @@ +Feature: customized message + + In order to get the feedback I want + As an RSpec user + I want to customize the failure message per example + + Scenario: one additional method + Given a file named "node_spec.rb.rb" with: + """ + class Node + def initialize(state=:waiting) + @state = state + end + def state + @state + end + def waiting? + @state == :waiting + end + def started? + @state == :started + end + def start + @state = :started + end + end + + describe "a new Node" do + it "should be waiting" do + node = Node.new(:started) #start w/ started to trigger failure + node.should be_waiting, "node.state: #{node.state} (first example)" + end + + it "should not be started" do + node = Node.new(:started) #start w/ started to trigger failure + node.should_not be_started, "node.state: #{node.state} (second example)" + end + end + + describe "node.start" do + it "should change the state" do + node = Node.new(:started) #start w/ started to trigger failure + lambda {node.start}.should change{node.state}, "expected a change" + end + end + + """ + When I run "spec node_spec.rb.rb --format specdoc" + Then the stdout should include "3 examples, 3 failures" + And the stdout should not match "to return true, got false" + And the stdout should not match "to return false, got true" + And the stdout should include "node.state: started (first example)" + And the stdout should include "node.state: started (second example)" + And the stdout should include "expected a change" diff --git a/vendor/gems/rspec-1.3.1/features/expectations/expect_change.feature b/vendor/gems/rspec-1.3.1/features/expectations/expect_change.feature new file mode 100644 index 000000000..f644b52e7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/expectations/expect_change.feature @@ -0,0 +1,65 @@ +Feature: expect change + + Expect some code (wrapped in a proc) to change the state of some object. + + Scenario: expecting change + Given a file named "expect_change.rb" with: + """ + class Counter + class << self + def increment + @count ||= 0 + @count += 1 + end + + def count + @count ||= 0 + end + end + end + + describe Counter, "#increment" do + it "should increment the count" do + expect{Counter.increment}.to change{Counter.count}.from(0).to(1) + end + + # deliberate failure + it "should increment the count by 2" do + expect{Counter.increment}.to change{Counter.count}.by(2) + end + end + """ + When I run "spec expect_change.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "should have been changed by 2, but was changed by 1" + + Scenario: expecting no change + Given a file named "expect_no_change.rb" with: + """ + class Counter + class << self + def increment + @count ||= 0 + @count += 1 + end + + def count + @count ||= 0 + end + end + end + + describe Counter, "#increment" do + it "should not increment the count by 2" do + expect{Counter.increment}.to_not change{Counter.count}.from(0).to(2) + end + + # deliberate failure + it "should not increment the count by 1" do + expect{Counter.increment}.to_not change{Counter.count}.by(1) + end + end + """ + When I run "spec expect_no_change.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "should not have changed, but did change from 1 to 2" diff --git a/vendor/gems/rspec-1.3.1/features/expectations/expect_error.feature b/vendor/gems/rspec-1.3.1/features/expectations/expect_error.feature new file mode 100644 index 000000000..7c48e7cef --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/expectations/expect_error.feature @@ -0,0 +1,44 @@ +Feature: expect error + + Expect a proc to change the state of some object. + + Scenario: expect error + Given a file named "expect_error.rb" with: + """ + describe Object, "#non_existent_message" do + it "should raise" do + expect{Object.non_existent_message}.to raise_error(NameError) + end + end + + #deliberate failure + describe Object, "#public_instance_methods" do + it "should raise" do + expect{Object.public_instance_methods}.to raise_error(NameError) + end + end + """ + When I run "spec expect_error.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "expected NameError but nothing was raised" + + Scenario: expect no error + Given a file named "expect_no_error.rb" with: + """ + describe Object, "#public_instance_methods" do + it "should not raise" do + expect{Object.public_instance_methods}.to_not raise_error(NameError) + end + end + + #deliberate failure + describe Object, "#non_existent_message" do + it "should not raise" do + expect{Object.non_existent_message}.to_not raise_error(NameError) + end + end + """ + When I run "spec expect_no_error.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "undefined method `non_existent_message'" + diff --git a/vendor/gems/rspec-1.3.1/features/extensions/custom_example_group.feature b/vendor/gems/rspec-1.3.1/features/extensions/custom_example_group.feature new file mode 100644 index 000000000..70974dba7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/extensions/custom_example_group.feature @@ -0,0 +1,19 @@ +Feature: custom example group + + Scenario: simple custom example group + Given a file named "custom_example_group_spec.rb" with: + """ + class CustomGroup < Spec::ExampleGroup + end + + Spec::Example::ExampleGroupFactory.default(CustomGroup) + + describe "a custom group set as the default" do + it "becomes the default base class for example groups" do + CustomGroup.should === self + end + end + """ + When I run "spec custom_example_group_spec.rb" + Then the stdout should include "1 example, 0 failures" + diff --git a/vendor/gems/rspec-1.3.1/features/formatters/custom_formatter.feature b/vendor/gems/rspec-1.3.1/features/formatters/custom_formatter.feature new file mode 100644 index 000000000..191ac369b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/formatters/custom_formatter.feature @@ -0,0 +1,30 @@ +Feature: custom formatters + + In order to format output/reporting to my particular needs + As an RSpec user + I want to create my own custom output formatters + + Scenario: specdoc format + Given a file named "custom_formatter.rb" with: + """ + require 'spec/runner/formatter/base_formatter' + class CustomFormatter < Spec::Runner::Formatter::BaseFormatter + def initialize(options, output) + @output = output + end + def example_started(proxy) + @output << "example: " << proxy.description + end + end + """ + And a file named "simple_example_spec.rb" with: + """ + describe "my group" do + specify "my example" do + end + end + """ + + When I run "spec simple_example_spec.rb --require custom_formatter.rb --format CustomFormatter" + Then the exit code should be 0 + And the stdout should include "example: my example" diff --git a/vendor/gems/rspec-1.3.1/features/formatters/nested_formatter.feature b/vendor/gems/rspec-1.3.1/features/formatters/nested_formatter.feature new file mode 100644 index 000000000..abfe14ab8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/formatters/nested_formatter.feature @@ -0,0 +1,32 @@ +Feature: nested formatter + + The nested formatter follows the nesting in each spec. + + Scenario: parallel contexts + Given a file named "simple_example_spec.rb" with: + """ + describe "first group" do + context "with context" do + specify "does something" do + end + end + end + describe "second group" do + context "with context" do + specify "does something" do + end + end + end + """ + + When I run "spec simple_example_spec.rb --format nested" + Then the exit code should be 0 + And the stdout should include + """ + first group + with context + does something + second group + with context + does something + """ diff --git a/vendor/gems/rspec-1.3.1/features/interop/cucumber_stubs_dont_leak.feature b/vendor/gems/rspec-1.3.1/features/interop/cucumber_stubs_dont_leak.feature new file mode 100644 index 000000000..123ace2a7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/interop/cucumber_stubs_dont_leak.feature @@ -0,0 +1,11 @@ +Feature: Cucumber Stubs Don't Leak + In order to not explode from frustration + a developer + does not want rspec stubs to leak between cucumber scenarios + + Scenario: Create a stub + When I stub "nap" on "Time" to "When I Get Cranky" + Then calling "nap" on "Time" should return "When I Get Cranky" + + Scenario: Check to see if the stub leaked + Then "nap" should not be defined on "Time" diff --git a/vendor/gems/rspec-1.3.1/features/interop/examples_and_tests_together.feature b/vendor/gems/rspec-1.3.1/features/interop/examples_and_tests_together.feature new file mode 100644 index 000000000..dda11af2f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/interop/examples_and_tests_together.feature @@ -0,0 +1,84 @@ +Feature: Spec and test together + + As an RSpec adopter with existing Test::Unit tests + I want to run a few specs alongside my existing Test::Unit tests + So that I can experience a smooth, gradual migration path + + Scenario Outline: Run specs and tests together + Given a file named "spec_and_test_together.rb" with: + """ + require 'spec/autorun' + require 'spec/test/unit' + + describe "An Example" do + it "should pass with assert" do + assert true + end + + it "should fail with assert" do + assert false + end + + it "should pass with should" do + 1.should == 1 + end + + it "should fail with should" do + 1.should == 2 + end + end + + class ATest < Test::Unit::TestCase + def test_should_pass_with_assert + assert true + end + + def test_should_fail_with_assert + assert false + end + + def test_should_pass_with_should + 1.should == 1 + end + + def test_should_fail_with_should + 1.should == 2 + end + + def setup + @from_setup ||= 3 + @from_setup += 1 + end + + def test_should_fail_with_setup_method_variable + @from_setup.should == 40 + end + + before do + @from_before = @from_setup + 1 + end + + def test_should_fail_with_before_block_variable + @from_before.should == 50 + end + + define_method :"test: should run with strange name" do + assert true + end + end + """ + + When I run "<Command> spec_and_test_together.rb -fs" + + Then the exit code should be 256 + And the stdout should include "ATest" + And the stdout should include "Test::Unit::AssertionFailedError in 'An Example should fail with assert'" + And the stdout should include "'An Example should fail with should' FAILED" + And the stdout should include "11 examples, 6 failures" + And the stdout should include /expected: 40,\s*got: 4/m + And the stdout should include /expected: 50,\s*got: 5/m + + Scenarios: run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/gems/rspec-1.3.1/features/interop/rspec_output.feature b/vendor/gems/rspec-1.3.1/features/interop/rspec_output.feature new file mode 100644 index 000000000..3a34d21f7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/interop/rspec_output.feature @@ -0,0 +1,25 @@ +Feature: spec output + + When running in interop mode with test/unit, RSpec will output + the RSpec summary, but not the test/unit summary. + + Scenario Outline: Interop mode with test/unit + Given a file named "simple_spec.rb" with: + """ + require 'spec/autorun' + + describe "Running an Example" do + it "should not output twice" do + true.should be_true + end + end + """ + When I run "<Command> simple_spec.rb" + Then the exit code should be 0 + And the stdout should not match /\d+ tests, \d+ assertions, \d+ failures, \d+ errors/m + And the stdout should include "1 example, 0 failures" + + Scenarios: Run with ruby and CommandLine object + | Command | + | ruby | + | cmdline.rb | diff --git a/vendor/gems/rspec-1.3.1/features/interop/test_but_not_test_unit.feature b/vendor/gems/rspec-1.3.1/features/interop/test_but_not_test_unit.feature new file mode 100644 index 000000000..fc87bed2f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/interop/test_but_not_test_unit.feature @@ -0,0 +1,26 @@ +Feature: Test is defined, but not Test::Unit + + As an RSpec user who has my own library named Test (but not Test::Unit) + I want to run examples without getting Test::Unit NameErrors + + Scenario Outline: Spec including Test const but not Test::Unit + Given a file named "spec_including_test_but_not_unit.rb" with: + """ + require 'spec/autorun' + + module Test + end + + describe "description" do + it "should description" do + 1.should == 1 + end + end + """ + When I run "<Command> spec_including_test_but_not_unit.rb" + Then the stderr should not match "Test::Unit" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/gems/rspec-1.3.1/features/interop/test_case_with_should_methods.feature b/vendor/gems/rspec-1.3.1/features/interop/test_case_with_should_methods.feature new file mode 100644 index 000000000..db6a4abf1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/interop/test_case_with_should_methods.feature @@ -0,0 +1,46 @@ +Feature: Test::Unit::TestCase extended by rspec with should methods + + As an RSpec adopter with existing Test::Unit tests + I want to use should_* methods in a Test::Unit::TestCase + So that I use RSpec with classes and methods that look more like RSpec examples + + Scenario Outline: TestCase with should methods + Given a file named "test_case_with_should_methods.rb" with: + """ + require 'spec/autorun' + require 'spec/test/unit' + + class MyTest < Test::Unit::TestCase + def should_pass_with_should + 1.should == 1 + end + + def should_fail_with_should + 1.should == 2 + end + + def should_pass_with_assert + assert true + end + + def should_fail_with_assert + assert false + end + + def test + raise "This is not a real test" + end + + def test_ify + raise "This is a real test" + end + end + """ + When I run "<Command> test_case_with_should_methods.rb" + Then the exit code should be 256 + And the stdout should include "5 examples, 3 failures" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/gems/rspec-1.3.1/features/load_paths/add_lib_to_load_path.feature b/vendor/gems/rspec-1.3.1/features/load_paths/add_lib_to_load_path.feature new file mode 100644 index 000000000..81513ec75 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/load_paths/add_lib_to_load_path.feature @@ -0,0 +1,20 @@ +Feature: add ./lib to load path + In order to ... + As a spec author + I want rspec to add ./lib to the load path + + Scenario: spec helper + Given a directory named "spec" + And a file named "example.rb" with: + """ + describe $LOAD_PATH do + it "begins with 'lib' in the current directory in the load path" do + libdir = File.expand_path(File.join(File.dirname(__FILE__), 'lib')) + $LOAD_PATH.should include(libdir) + end + end + """ + When I run "spec example.rb" + Then the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/gems/rspec-1.3.1/features/load_paths/add_spec_to_load_path.feature b/vendor/gems/rspec-1.3.1/features/load_paths/add_spec_to_load_path.feature new file mode 100644 index 000000000..b216ebedd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/load_paths/add_spec_to_load_path.feature @@ -0,0 +1,20 @@ +Feature: add 'spec' to load path + In order to ... + As a spec author + I want rspec to add 'spec to the load path + + Scenario: add 'spec' to load path + Given a directory named "spec" + And a file named "example.rb" with: + """ + describe $LOAD_PATH do + it "includes with 'spec' in the current directory in the load path" do + specdir = File.expand_path(File.join(File.dirname(__FILE__), 'spec')) + $LOAD_PATH.should include(specdir) + end + end + """ + When I run "spec example.rb" + Then the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/gems/rspec-1.3.1/features/matchers/define_diffable_matcher.feature b/vendor/gems/rspec-1.3.1/features/matchers/define_diffable_matcher.feature new file mode 100644 index 000000000..8715641ec --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/define_diffable_matcher.feature @@ -0,0 +1,26 @@ +Feature: define diffable matcher + + When a matcher is defined as diffable, and the --diff + flag is set, the output will include a diff of the submitted + objects. + + Scenario: define a diffable matcher + Given a file named "diffable_matcher_spec.rb" with: + """ + Spec::Matchers.define :be_just_like do |expected| + match do |actual| + actual == expected + end + + diffable + end + + describe "this" do + it {should be_just_like("that")} + end + """ + When I run "spec diffable_matcher_spec.rb --diff" + Then the exit code should be 256 + + And the stdout should include "should be just like \"that\"" + And the stdout should include "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this" diff --git a/vendor/gems/rspec-1.3.1/features/matchers/define_matcher.feature b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher.feature new file mode 100644 index 000000000..79edae73f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher.feature @@ -0,0 +1,179 @@ +Feature: define matcher + + In order to express my domain clearly in my code examples + As an RSpec user + I want a shortcut to define custom matchers + + Scenario: define a matcher with default messages + Given a file named "matcher_with_default_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + end + + describe 9 do + it {should be_a_multiple_of(3)} + end + + describe 9 do + it {should_not be_a_multiple_of(4)} + end + + # fail intentionally to generate expected output + describe 9 do + it {should be_a_multiple_of(4)} + end + + # fail intentionally to generate expected output + describe 9 do + it {should_not be_a_multiple_of(3)} + end + + """ + When I run "spec matcher_with_default_message_spec.rb --format specdoc" + Then the exit code should be 256 + + And the stdout should include "should be a multiple of 3" + And the stdout should include "should not be a multiple of 4" + And the stdout should include "should be a multiple of 4 (FAILED - 1)" + And the stdout should include "should not be a multiple of 3 (FAILED - 2)" + + And the stdout should include "4 examples, 2 failures" + And the stdout should include "expected 9 to be a multiple of 4" + And the stdout should include "expected 9 not to be a multiple of 3" + + Scenario: overriding the failure_message_for_should + Given a file named "matcher_with_failure_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + failure_message_for_should do |actual| + "expected that #{actual} would be a multiple of #{expected}" + end + end + + # fail intentionally to generate expected output + describe 9 do + it {should be_a_multiple_of(4)} + end + """ + When I run "spec matcher_with_failure_message_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "expected that 9 would be a multiple of 4" + + Scenario: overriding the failure_message_for_should_not + Given a file named "matcher_with_failure_for_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + failure_message_for_should_not do |actual| + "expected that #{actual} would not be a multiple of #{expected}" + end + end + + # fail intentionally to generate expected output + describe 9 do + it {should_not be_a_multiple_of(3)} + end + """ + When I run "spec matcher_with_failure_for_message_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "expected that 9 would not be a multiple of 3" + + Scenario: overriding the description + Given a file named "matcher_overriding_description_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + description do + "be multiple of #{expected}" + end + end + + describe 9 do + it {should be_a_multiple_of(3)} + end + + describe 9 do + it {should_not be_a_multiple_of(4)} + end + """ + When I run "spec matcher_overriding_description_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" + And the stdout should include "should be multiple of 3" + And the stdout should include "should not be multiple of 4" + + Scenario: with no args + Given a file named "matcher_with_no_args_spec.rb" with: + """ + Spec::Matchers.define :have_7_fingers do + match do |thing| + thing.fingers.length == 7 + end + end + + class Thing + def fingers; (1..7).collect {"finger"}; end + end + + describe Thing do + it {should have_7_fingers} + end + """ + When I run "spec matcher_with_no_args_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + And the stdout should include "should have 7 fingers" + + Scenario: with multiple args + Given a file named "matcher_with_multiple_args_spec.rb" with: + """ + Spec::Matchers.define :be_the_sum_of do |a,b,c,d| + match do |sum| + a + b + c + d == sum + end + end + + describe 10 do + it {should be_the_sum_of(1,2,3,4)} + end + """ + When I run "spec matcher_with_multiple_args_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + And the stdout should include "should be the sum of 1, 2, 3, and 4" + + Scenario: with helper methods + Given a file named "matcher_with_internal_helper_spec.rb" with: + """ + Spec::Matchers.define :have_same_elements_as do |sample| + match do |actual| + similar?(sample, actual) + end + + def similar?(a, b) + a.sort == b.sort + end + end + + describe "these two arrays" do + specify "should be similar" do + [1,2,3].should have_same_elements_as([2,3,1]) + end + end + """ + When I run "spec matcher_with_internal_helper_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + diff --git a/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_outside_rspec.feature b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_outside_rspec.feature new file mode 100644 index 000000000..5e7d705c2 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_outside_rspec.feature @@ -0,0 +1,38 @@ +Feature: define matcher outside rspec + + In order to express my domain clearly in my code examples + As a non-rspec user + I want a shortcut to define custom matchers + + Scenario: define a matcher with default messages + Given a file named "test_multiples.rb" with: + """ + require 'test/unit' + require 'spec/expectations' + + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + end + + class Test::Unit::TestCase + include Spec::Matchers + end + + class TestMultiples < Test::Unit::TestCase + + def test_9_should_be_a_multiple_of_3 + 9.should be_a_multiple_of(3) + end + + def test_9_should_be_a_multiple_of_4 + 9.should be_a_multiple_of(4) + end + + end + """ + When I run "ruby test_multiples.rb" + Then the exit code should be 256 + And the stdout should include "expected 9 to be a multiple of 4" + And the stdout should include "2 tests, 0 assertions, 1 failures, 0 errors" diff --git a/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_with_fluent_interface.feature b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_with_fluent_interface.feature new file mode 100644 index 000000000..9042484e5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/define_matcher_with_fluent_interface.feature @@ -0,0 +1,48 @@ +Feature: define matcher + + In order to express my domain clearly in my code examples + As an RSpec user + I want to define matchers with fluent interfaces + + Scenario: one additional method + Given a file named "between_spec.rb" with: + """ + Spec::Matchers.define :be_bigger_than do |first| + def but_smaller_than(second) + @second = second + self + end + + match do |actual| + (actual > first) && (actual < @second) + end + end + + describe 5 do + it { should be_bigger_than(4).but_smaller_than(6) } + end + """ + When I run "spec between_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "should be bigger than 4" + + Scenario: generate method using dsl + Given a file named "between_spec.rb" with: + """ + Spec::Matchers.define :be_bigger_than do |first| + chain :but_smaller_than do |limit| + @limit = limit + end + + match do |actual| + (actual > first) && (actual < @limit) + end + end + + describe 5 do + it { should be_bigger_than(4).but_smaller_than(6) } + end + """ + When I run "spec between_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "should be bigger than 4" diff --git a/vendor/gems/rspec-1.3.1/features/matchers/define_wrapped_matcher.feature b/vendor/gems/rspec-1.3.1/features/matchers/define_wrapped_matcher.feature new file mode 100644 index 000000000..ab2fef09f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/define_wrapped_matcher.feature @@ -0,0 +1,56 @@ +Feature: define wrapped matcher + + In order to reuse existing matchers + As an RSpec user + I want to define matchers that wrap other matchers + + When the wrapped matcher passes, the wrapping matcher returns true. + When the wrapped matcher fails, the wrapping matcher returns false. + + Scenario: wrap a matcher using should + Given a file named "new_model_spec.rb" with: + """ + Spec::Matchers.define :have_tag do |tag| + match do |markup| + markup =~ /<#{tag}>.*<\/#{tag}>/ + end + end + + Spec::Matchers.define :have_button do + match do |markup| + markup.should have_tag('button') + end + end + + describe "some markup" do + it "has a button" do + "<button>Label</button>".should have_button + end + end + """ + When I run "spec new_model_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" + + Scenario: wrap a matcher using should_not + Given a file named "new_model_spec.rb" with: + """ + Spec::Matchers.define :have_tag do |tag| + match do |markup| + markup =~ /<#{tag}>.*<\/#{tag}>/ + end + end + + Spec::Matchers.define :have_button do + match do |markup| + markup.should have_tag('button') + end + end + + describe "some markup" do + it "has no buttons" do + "<p>Label</p>".should_not have_button + end + end + """ + When I run "spec new_model_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises.feature b/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises.feature new file mode 100644 index 000000000..451f5f840 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises.feature @@ -0,0 +1,60 @@ +Feature: match unless raises + + In order, primarily, to reuse existing test/unit assertions + As an RSpec user + I want to define matchers that wrap a statement that raises an error on failure + + Background: + Given a file named "example.rb" with: + """ + require 'test/unit/assertions' + + Spec::Matchers.define :be_the_same_as do |expected| + extend Test::Unit::Assertions + match_unless_raises Test::Unit::AssertionFailedError do |actual| + assert_equal expected, actual + end + end + """ + + Scenario: passing examples + Given a file named "match_unless_raises_spec.rb" with: + """ + require 'example.rb' + + describe 4 do + it "is 4" do + 4.should be_the_same_as(4) + end + end + + describe 5 do + it "is not 4" do + 5.should_not be_the_same_as(4) + end + end + """ + When I run "spec match_unless_raises_spec.rb" + Then the stdout should include "2 examples, 0 failures" + + Scenario: failing examples + Given a file named "match_unless_raises_spec.rb" with: + """ + require 'example.rb' + + describe 4 do + it "is 4" do + # intentionally fail + 4.should_not be_the_same_as(4) + end + end + + describe 5 do + it "is not 4" do + # intentionally fail + 5.should be_the_same_as(4) + end + end + """ + When I run "spec match_unless_raises_spec.rb" + Then the stdout should include "2 examples, 2 failures" diff --git a/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises_unexpected_error.feature b/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises_unexpected_error.feature new file mode 100644 index 000000000..64524bd1f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/matchers/match_unless_raises_unexpected_error.feature @@ -0,0 +1,39 @@ +Feature: match unless raises with an unexpected error + + In order to know when a match_unless_raises block raises an unexpected error + As an RSpec user + I want the error to bubble up + + Background: + Given a file named "example.rb" with: + """ + Spec::Matchers.define :be_the_same_as do |expected| + match_unless_raises SyntaxError do |actual| + raise "unexpected error" + end + end + """ + + Scenario: failing examples + Given a file named "match_unless_raises_spec.rb" with: + """ + require 'example.rb' + + describe 4 do + it "is 4" do + # intentionally fail + 4.should_not be_the_same_as(4) + end + end + + describe 5 do + it "is not 4" do + # intentionally fail + 5.should be_the_same_as(4) + end + end + """ + When I run "spec match_unless_raises_spec.rb" + Then the stdout should include "2 examples, 2 failures" + Then the stdout should include "unexpected error" +
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_flexmock.feature b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_flexmock.feature new file mode 100644 index 000000000..0a204dfc6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_flexmock.feature @@ -0,0 +1,27 @@ +Feature: mock with flexmock + + As an RSpec user who prefers flexmock + I want to be able to use flexmock without rspec mocks interfering + + Scenario: Mock with flexmock + Given a file named "flexmock_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + + describe "plugging in flexmock" do + it "allows flexmock to be used" do + target = Object.new + flexmock(target).should_receive(:foo).once + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec flexmock_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_mocha.feature b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_mocha.feature new file mode 100644 index 000000000..d53b967cd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_mocha.feature @@ -0,0 +1,27 @@ +Feature: mock with mocha + + As an RSpec user who prefers mocha + I want to be able to use mocha without rspec mocks interfering + + Scenario: Mock with mocha + Given a file named "mocha_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :mocha + end + + describe "plugging in mocha" do + it "allows mocha to be used" do + target = Object.new + target.expects(:foo).once + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec mocha_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_rr.feature b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_rr.feature new file mode 100644 index 000000000..aa30882aa --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mock_framework_integration/use_rr.feature @@ -0,0 +1,27 @@ +Feature: mock with rr + + As an RSpec user who prefers rr + I want to be able to use rr without rspec mocks interfering + + Scenario: Mock with rr + Given a file named "rr_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :rr + end + + describe "plugging in rr" do + it "allows rr to be used" do + target = Object.new + mock(target).foo + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec rr_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/mocks/block_local_expectations.feature b/vendor/gems/rspec-1.3.1/features/mocks/block_local_expectations.feature new file mode 100644 index 000000000..f0155d429 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mocks/block_local_expectations.feature @@ -0,0 +1,62 @@ +Feature: block local expectations + + In order to set message expectations on ... + As an RSpec user + I want to configure the evaluation context + + Background: + Given a file named "account.rb" with: + """ + class Account + def self.create + yield new + end + + def opening_balance(amount, currency) + end + end + """ + + Scenario: passing example + Given a file named "account_dsl.rb" with: + """ + require 'spec_helper' + require 'account' + + describe "account DSL" do + it " .... " do + account = Account.new + Account.should_receive(:create).and_yield do |account| + account.should_receive(:opening_balance).with(100, :USD) + end + Account.create do + opening_balance 100, :USD + end + end + end + """ + When I run "spec account_dsl.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: failing example + + Given a file named "account_dsl.rb" with: + """ + require 'spec_helper' + require 'account' + + describe "account DSL" do + it " .... " do + account = Account.new + Account.should_receive(:create).and_yield do |account| + account.should_receive(:opening_balance).with(100, :USD) + end + Account.create do + # opening_balance is not called here + end + end + end + """ + + When I run "spec account_dsl.rb" + Then the stdout should include "1 example, 1 failure" diff --git a/vendor/gems/rspec-1.3.1/features/mocks/mix_stubs_and_mocks.feature b/vendor/gems/rspec-1.3.1/features/mocks/mix_stubs_and_mocks.feature new file mode 100644 index 000000000..deaf84ecf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mocks/mix_stubs_and_mocks.feature @@ -0,0 +1,22 @@ +Feature: stub and mock together + + As an RSpec user + I want to use stubs and mocks together + + Scenario: stub in before + Given a file named "stub_and_mocks_spec.rb" with: + """ + describe "a stub in before" do + before(:each) do + @messenger = mock('messenger').as_null_object + end + + it "a" do + @messenger.should_receive(:foo).with('first') + @messenger.foo('second') + @messenger.foo('third') + end + end + """ + When I run "spec stub_and_mocks_spec.rb --format nested" + Then the stdout should include "received :foo with unexpected arguments\n expected: (\"first\")\n got: ([\"second\"], [\"third\"])" diff --git a/vendor/gems/rspec-1.3.1/features/mocks/stub_implementation.feature b/vendor/gems/rspec-1.3.1/features/mocks/stub_implementation.feature new file mode 100644 index 000000000..269de4742 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/mocks/stub_implementation.feature @@ -0,0 +1,26 @@ +Feature: stub implementation + + As an rspec user, I want to stub a complete implementation, not just a + return value. + + Scenario: stub implementation + Given a file named "stub_implementation.rb" with: + """ + describe "a stubbed implementation" do + it "works" do + object = Object.new + object.stub(:foo) do |arg| + if arg == :this + "got this" + elsif arg == :that + "got that" + end + end + + object.foo(:this).should == "got this" + object.foo(:that).should == "got that" + end + end + """ + When I run "spec stub_implementation.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/pending/pending_examples.feature b/vendor/gems/rspec-1.3.1/features/pending/pending_examples.feature new file mode 100644 index 000000000..582739563 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/pending/pending_examples.feature @@ -0,0 +1,81 @@ +Feature: pending examples + + RSpec offers three ways to indicate that an example is disabled pending + some action. + + Scenario: pending implementation + Given a file named "example_without_block_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + end + """ + When I run "spec example_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "Not Yet Implemented" + And the stdout should include "example_without_block_spec.rb:2" + + Scenario: pending implementation with spec/test/unit + Given a file named "example_without_block_spec.rb" with: + """ + require 'spec/test/unit' + describe "an example" do + it "has not yet been implemented" + end + """ + When I run "spec example_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "Not Yet Implemented" + And the stdout should include "example_without_block_spec.rb:3" + + Scenario: pending any arbitary reason, with no block + Given a file named "pending_without_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") + end + end + """ + When I run "spec pending_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "(something else getting finished)" + And the stdout should include "pending_without_block_spec.rb:2" + + Scenario: pending any arbitary reason, with a block that fails + Given a file named "pending_with_failing_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") do + raise "this is the failure" + end + end + end + """ + When I run "spec pending_with_failing_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "(something else getting finished)" + And the stdout should include "pending_with_failing_block_spec.rb:2" + + Scenario: pending any arbitary reason, with a block that passes + Given a file named "pending_with_passing_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") do + true.should be(true) + end + end + end + """ + When I run "spec pending_with_passing_block_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "FIXED" + And the stdout should include "Expected pending 'something else getting finished' to fail. No Error was raised." + And the stdout should include "pending_with_passing_block_spec.rb:3" diff --git a/vendor/gems/rspec-1.3.1/features/runner/specify_line_number.feature b/vendor/gems/rspec-1.3.1/features/runner/specify_line_number.feature new file mode 100644 index 000000000..bf44f2c09 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/runner/specify_line_number.feature @@ -0,0 +1,32 @@ +Feature: run specific examples by line number + + In order to run a single example from command line + RSpec allows you to specify the line number of the example(s) to run + + Scenario: --line syntax on single example + Given a file named "example_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + it "has been implemented" do + true + end + end + """ + When I run "spec example_spec.rb --line 2" + Then the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "example_spec.rb:2" + + Scenario: colon line syntax on single example + Given a file named "example_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + it "has been implemented" do + true + end + end + """ + When I run "spec example_spec.rb:2" + Then the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "example_spec.rb:2" diff --git a/vendor/gems/rspec-1.3.1/features/spec_helper/spec_helper.feature b/vendor/gems/rspec-1.3.1/features/spec_helper/spec_helper.feature new file mode 100644 index 000000000..2711e1a58 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/spec_helper/spec_helper.feature @@ -0,0 +1,25 @@ +Feature: spec helper + In order to centralize code needed across most specs + As a spec author + I want to require 'spec_helper' + + Because rspec adds the PROJECT_ROOT/spec directory to the load path, we can + just require 'spec_helper' and it will be found. + + Scenario: spec helper + Given a directory named "spec" + And a file named "spec/spec_helper.rb" with: + """ + SOME_CONSTANT = 'some value' + """ + And a file named "example.rb" with: + """ + require 'spec_helper' + describe SOME_CONSTANT do + it { should == 'some value' } + end + """ + When I run "spec example.rb" + And the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/gems/rspec-1.3.1/features/step_definitions/running_rspec_steps.rb b/vendor/gems/rspec-1.3.1/features/step_definitions/running_rspec_steps.rb new file mode 100644 index 000000000..746e8793b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/step_definitions/running_rspec_steps.rb @@ -0,0 +1,52 @@ +Given %r{^a file named "([^"]+)" with:$} do |file_name, code| + create_file(file_name, code) +end + +Given /^a directory named "([^\"]*)"$/ do |dirname| + create_directory(dirname) +end + +When %r{^I run "spec ([^"]+)"$} do |file_and_args| + spec(file_and_args) +end + +When %r{^I run "ruby ([^"]+)"$} do |file_and_args| + ruby(file_and_args) +end + +When %r{^I run "cmdline.rb ([^"]+)"$} do |file_and_args| + cmdline(file_and_args) +end + +Then /^the (.*) should include (.*)$/ do |stream, string_or_regex| + written = case(stream) + when 'stdout' then last_stdout + when 'stderr' then last_stderr + else raise "Unknown stream: #{stream}" + end + written.should smart_match(string_or_regex) +end + +Then /^the (.*) should include$/ do |stream, string_or_regex| + written = case(stream) + when 'stdout' then last_stdout + when 'stderr' then last_stderr + else raise "Unknown stream: #{stream}" + end + written.should smart_match(string_or_regex) +end + +Then /^the (.*) should not match (.*)$/ do |stream, string_or_regex| + written = case(stream) + when 'stdout' then last_stdout + when 'stderr' then last_stderr + else raise "Unknown stream: #{stream}" + end + written.should_not smart_match(string_or_regex) +end + +Then /^the exit code should be (\d+)$/ do |exit_code| + if last_exit_code != exit_code.to_i + raise "Did not exit with #{exit_code}, but with #{last_exit_code}. Standard error:\n#{last_stderr}" + end +end diff --git a/vendor/gems/rspec-1.3.1/features/step_definitions/stubbing_steps.rb b/vendor/gems/rspec-1.3.1/features/step_definitions/stubbing_steps.rb new file mode 100644 index 000000000..cc194f31c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/step_definitions/stubbing_steps.rb @@ -0,0 +1,16 @@ +When /^I stub "([^\"]*)" on "([^\"]*)" to "([^\"]*)"$/ do |method_name, const_name, value| + const = Object.const_get(const_name) + const.stub!(method_name.to_sym).and_return(value) +end + +Then /^calling "([^\"]*)" on "([^\"]*)" should return "([^\"]*)"$/ do |method_name, const_name, value| + const = Object.const_get(const_name) + const.send(method_name.to_sym).should == value +end + +Then /^"([^\"]*)" should not be defined on "([^\"]*)"$/ do |method_name, const_name| + const = Object.const_get(const_name) + lambda { + const.send(method_name.to_sym) + }.should raise_error(NameError, /#{method_name}/) +end diff --git a/vendor/gems/rspec-1.3.1/features/subject/explicit_subject.feature b/vendor/gems/rspec-1.3.1/features/subject/explicit_subject.feature new file mode 100644 index 000000000..9fb68ad43 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/subject/explicit_subject.feature @@ -0,0 +1,31 @@ +Feature: explicit subject + + You can override the implicit subject using the subject() method. + + Scenario: subject in top level group + Given a file named "top_level_subject_spec.rb" with: + """ + describe Array, "with some elements" do + subject { [1,2,3] } + it "should have the prescribed elements" do + subject.should == [1,2,3] + end + end + """ + When I run "spec top_level_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject in a nested group + Given a file named "nested_subject_spec.rb" with: + """ + describe Array do + subject { [1,2,3] } + describe "with some elements" do + it "should have the prescribed elements" do + subject.should == [1,2,3] + end + end + end + """ + When I run "spec nested_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/subject/implicit_subject.feature b/vendor/gems/rspec-1.3.1/features/subject/implicit_subject.feature new file mode 100644 index 000000000..bc57d2ba4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/subject/implicit_subject.feature @@ -0,0 +1,43 @@ +Feature: implicit subject + + The first argument to the outermost example group block is + made available to each example as an implicit subject of + that example. + + Scenario: subject in top level group + Given a file named "top_level_subject_spec.rb" with: + """ + describe Array, "when first created" do + it "should be empty" do + subject.should == [] + end + end + """ + When I run "spec top_level_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject in a nested group + Given a file named "nested_subject_spec.rb" with: + """ + describe Array do + describe "when first created" do + it "should be empty" do + subject.should == [] + end + end + end + """ + When I run "spec nested_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject with getters + Given a file named "subject_with_getter_spec.rb" with: + """ + describe Array do + describe "when first created" do + its(:length) { should == 0 } + end + end + """ + When I run "spec subject_with_getter_spec.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/gems/rspec-1.3.1/features/support/env.rb b/vendor/gems/rspec-1.3.1/features/support/env.rb new file mode 100644 index 000000000..e649d82c5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/support/env.rb @@ -0,0 +1,83 @@ +$:.unshift File.join(File.dirname(__FILE__), "/../../lib") + +require 'spec/expectations' +require 'forwardable' +require 'tempfile' +require 'spec/ruby_forker' +require 'features/support/matchers/smart_match' +require 'spec/stubs/cucumber' + +class RspecWorld + include Spec::Expectations + include Spec::Matchers + include RubyForker + + extend Forwardable + def_delegators RspecWorld, :working_dir, :spec_command, :cmdline_file, :rspec_lib + + def self.working_dir + @working_dir ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../tmp/cucumber-generated-files")) + end + + def self.spec_command + @spec_command ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../bin/spec")) + end + + def self.cmdline_file + @cmdline_file ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../resources/helpers/cmdline.rb")) + end + + def self.rspec_lib + @rspec_lib ||= File.join(working_dir, "/../../lib") + end + + def spec(args) + ruby("#{spec_command} #{args}") + end + + def cmdline(args) + ruby("#{cmdline_file} #{args}") + end + + def create_file(file_name, contents) + file_path = File.join(working_dir, file_name) + File.open(file_path, "w") { |f| f << contents } + end + + def create_directory(dirname) + FileUtils.mkdir_p File.join(working_dir, dirname) + end + + def last_stdout + @stdout + end + + def last_stderr + @stderr + end + + def last_exit_code + @exit_code + end + + # it seems like this, and the last_* methods, could be moved into RubyForker-- is that being used anywhere but the features? + def ruby(args) + stderr_file = Tempfile.new('rspec') + stderr_file.close + Dir.chdir(working_dir) do + @stdout = super("-I #{rspec_lib} #{args}", stderr_file.path) + end + @stderr = IO.read(stderr_file.path) + @exit_code = $?.to_i + end + +end + +Before do + FileUtils.rm_rf RspecWorld.working_dir if test ?d, RspecWorld.working_dir + FileUtils.mkdir_p RspecWorld.working_dir +end + +World do + RspecWorld.new +end diff --git a/vendor/gems/rspec-1.3.1/features/support/matchers/smart_match.rb b/vendor/gems/rspec-1.3.1/features/support/matchers/smart_match.rb new file mode 100644 index 000000000..7a6aa58a7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/features/support/matchers/smart_match.rb @@ -0,0 +1,31 @@ +Spec::Matchers.define :smart_match do |expected| + def regexp? + /^\/.*\/?$/ + end + + def quoted? + /^".*"$/ + end + + match do |actual| + case expected + when regexp? + actual =~ eval(expected) + when quoted? + actual.index(eval(expected)) + else # multi-line string + actual.index(expected) + end + end + + failure_message_for_should do |actual| + <<-MESSAGE +#{'*'*50} +got: +#{'*'*30} +#{actual} +#{'*'*50} +MESSAGE + end +end + diff --git a/vendor/gems/rspec-1.3.1/geminstaller.yml b/vendor/gems/rspec-1.3.1/geminstaller.yml new file mode 100644 index 000000000..0392cf0fe --- /dev/null +++ b/vendor/gems/rspec-1.3.1/geminstaller.yml @@ -0,0 +1,29 @@ +# Basics needed to run 'rake' from this directory +gems: +- name: cucumber + version: '>= 0.3.101' +- name: diff-lcs + version: '>= 1.1.2' +- name: fakefs + version: '>= 0.2' +- name: flexmock + version: '>= 0.8.6' +- name: heckle + version: '>= 1.4.2' +- name: hoe + version: '>= 2.0' +- name: nokogiri + version: '>= 1.2.3' +- name: mocha + version: '>= 0.9.5' +- name: rake + version: '>= 0.8.4' +- name: rcov + version: '>= 0.9.7.1' +- name: syntax + version: '>= 1.0.0' +- name: rr + version: '>= 0.10.0' +- name: ruby-debug + version: '>= 0.10.3' +- name: autotest-growl diff --git a/vendor/gems/rspec-1.3.1/init.rb b/vendor/gems/rspec-1.3.1/init.rb new file mode 100644 index 000000000..6262f0368 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/init.rb @@ -0,0 +1,9 @@ +# Placeholder to satisfy Rails. +# +# Do NOT add any require statements to this file. Doing +# so will cause Rails to load this plugin all of the time. +# +# Running 'ruby script/generate rspec' will +# generate spec/spec_helper.rb, which includes the necessary +# require statements and configuration. This file should +# be required by all of your spec files.
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/autotest/discover.rb b/vendor/gems/rspec-1.3.1/lib/autotest/discover.rb new file mode 100644 index 000000000..3ac51c135 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/autotest/discover.rb @@ -0,0 +1,3 @@ +Autotest.add_discovery do + "rspec" if File.directory?('spec') && ENV['RSPEC'] +end diff --git a/vendor/gems/rspec-1.3.1/lib/autotest/rspec.rb b/vendor/gems/rspec-1.3.1/lib/autotest/rspec.rb new file mode 100644 index 000000000..73ffcb374 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/autotest/rspec.rb @@ -0,0 +1,54 @@ +require 'autotest' + +Autotest.add_hook :initialize do |at| + at.clear_mappings + # watch out for 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 + + SPEC_PROGRAM = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')) + + def initialize + super + self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n\n?(.*?(\n\n\(.*?)?)\n\n/m + self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m + end + + def consolidate_failures(failed) + filters = new_hash_of_arrays + failed.each do |spec, trace| + if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:/ + filters[$2] << spec + end + end + return filters + end + + def make_test_cmd(files_to_test) + files_to_test.empty? ? '' : + "#{ruby} #{SPEC_PROGRAM} --autospec #{normalize(files_to_test).keys.flatten.join(' ')} #{add_options_if_present}" + end + + def normalize(files_to_test) + files_to_test.keys.inject({}) do |result, filename| + result[File.expand_path(filename)] = [] + result + end + end + + def add_options_if_present # :nodoc: + File.exist?("spec/spec.opts") ? "-O #{File.join('spec','spec.opts')} " : "" + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec.rb b/vendor/gems/rspec-1.3.1/lib/spec.rb new file mode 100644 index 000000000..879c373e8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec.rb @@ -0,0 +1,8 @@ +require 'spec/deprecation' +require 'spec/ruby' +require 'spec/matchers' +require 'spec/expectations' +require 'spec/example' +require 'spec/runner' +require 'spec/version' +require 'spec/dsl' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/flexmock.rb b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/flexmock.rb new file mode 100644 index 000000000..18dd453dd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/flexmock.rb @@ -0,0 +1,24 @@ +#!/usr/bin/env ruby +# +# Created by Jim Weirich on 2007-04-10. +# Copyright (c) 2007. All rights reserved. + +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'flexmock/rspec' + +module Spec + module Adapters + module MockFramework + include FlexMock::MockContainer + def setup_mocks_for_rspec + # No setup required + end + def verify_mocks_for_rspec + flexmock_verify + end + def teardown_mocks_for_rspec + flexmock_close + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/mocha.rb b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/mocha.rb new file mode 100644 index 000000000..4c97c139a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/mocha.rb @@ -0,0 +1,25 @@ +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'mocha/standalone' +require 'mocha/object' + +module Spec + module Adapters + module MockFramework + # Mocha::Standalone was deprecated as of Mocha 0.9.7. + begin + include Mocha::API + rescue NameError + include Mocha::Standalone + end + def setup_mocks_for_rspec + mocha_setup + end + def verify_mocks_for_rspec + mocha_verify + end + def teardown_mocks_for_rspec + mocha_teardown + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rr.rb b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rr.rb new file mode 100644 index 000000000..758ddf611 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rr.rb @@ -0,0 +1,22 @@ +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'rr' + +patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS +patterns.push(RR::Errors::BACKTRACE_IDENTIFIER) + +module Spec + module Adapters + module MockFramework + include RR::Extensions::InstanceMethods + def setup_mocks_for_rspec + RR::Space.instance.reset + end + def verify_mocks_for_rspec + RR::Space.instance.verify_doubles + end + def teardown_mocks_for_rspec + RR::Space.instance.reset + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rspec.rb b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rspec.rb new file mode 100644 index 000000000..b159f8bfe --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/adapters/mock_frameworks/rspec.rb @@ -0,0 +1,21 @@ +require 'spec/mocks/framework' +require 'spec/mocks/extensions' + +module Spec + module Adapters + unless defined?(MockFramework) + module MockFramework + include Spec::Mocks::ExampleMethods + def setup_mocks_for_rspec + $rspec_mocks ||= Spec::Mocks::Space.new + end + def verify_mocks_for_rspec + $rspec_mocks.verify_all + end + def teardown_mocks_for_rspec + $rspec_mocks.reset_all + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/autorun.rb b/vendor/gems/rspec-1.3.1/lib/spec/autorun.rb new file mode 100644 index 000000000..f29b81966 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/autorun.rb @@ -0,0 +1,3 @@ +require 'spec' + +Spec::Runner.autorun diff --git a/vendor/gems/rspec-1.3.1/lib/spec/deprecation.rb b/vendor/gems/rspec-1.3.1/lib/spec/deprecation.rb new file mode 100644 index 000000000..3e3140d47 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/deprecation.rb @@ -0,0 +1,41 @@ +module Spec + class << self + def deprecate(method, alternate_method=nil) + return if Spec::Runner.configuration.suppress_deprecation_warnings? + message = <<-NOTICE + +***************************************************************** +DEPRECATION WARNING: you are using deprecated behaviour that will +be removed from a future version of RSpec. + +#{caller(0)[2]} + +* #{method} is deprecated. +NOTICE + if alternate_method + message << <<-ADDITIONAL +* please use #{alternate_method} instead. +ADDITIONAL + end + + message << "*****************************************************************" + warn(message) + end + + def warn(message) + Kernel.warn(message) + end + + end + + class HashWithDeprecationNotice < Hash + def initialize(method, alternate_method=nil, &block) + @method, @alternate_method = method, alternate_method + end + def []=(k,v) + Spec.deprecate(@method, @alternate_method) + super + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/lib/spec/dsl.rb b/vendor/gems/rspec-1.3.1/lib/spec/dsl.rb new file mode 100644 index 000000000..d93e90d84 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/dsl.rb @@ -0,0 +1 @@ +require 'spec/dsl/main' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/dsl/main.rb b/vendor/gems/rspec-1.3.1/lib/spec/dsl/main.rb new file mode 100644 index 000000000..d0c51f70f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/dsl/main.rb @@ -0,0 +1,93 @@ +module Spec + module DSL + module Main + include Spec::Example::ArgsAndOptions + + # Creates and returns a class that includes the ExampleGroupMethods + # module. Which ExampleGroup type is created depends on the directory of the file + # calling this method. For example, Spec::Rails will use different + # classes for specs living in <tt>spec/models</tt>, + # <tt>spec/helpers</tt>, <tt>spec/views</tt> and + # <tt>spec/controllers</tt>. + # + # It is also possible to override autodiscovery of the example group + # type with an options Hash as the last argument: + # + # describe "name", :type => :something_special do ... + # + # The reason for using different example group classes is to have different + # matcher methods available from within the <tt>describe</tt> block. + # + # See Spec::Example::ExampleGroupFactory#register for details about how to + # register special implementations. + # + def describe(*args, &block) + raise Spec::Example::NoDescriptionError.new("example group", caller(0)[1]) if args.empty? + add_options(args, :scope => self) + set_location(args.options, caller(0)[1]) + Spec::Example::ExampleGroupFactory.create_example_group(*args, &block) + end + alias :context :describe unless defined?(IRB::Context) + + # Creates an example group that can be shared by other example groups + # + # == Examples + # + # share_examples_for "All Editions" do + # it "all editions behaviour" ... + # end + # + # describe SmallEdition do + # it_should_behave_like "All Editions" + # + # it "should do small edition stuff" do + # ... + # end + # end + def share_examples_for(*args, &block) + add_options(args) + set_location(args.options, caller(0)[1]) + Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block) + end + alias :shared_examples_for :share_examples_for + + # Creates a Shared Example Group and assigns it to a constant + # + # share_as :AllEditions do + # it "should do all editions stuff" ... + # end + # + # describe SmallEdition do + # it_should_behave_like AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + # + # And, for those of you who prefer to use something more like Ruby, you + # can just include the module directly + # + # describe SmallEdition do + # include AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + def share_as(name, &block) + Spec.deprecate("share_as","shared_examples_for") + begin + args = [name] + add_options(args) + set_location(args.options, caller(0)[1]) + Object.const_set(name, Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block)) + rescue NameError => e + raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n") + end + end + end + end +end + +include Spec::DSL::Main diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example.rb b/vendor/gems/rspec-1.3.1/lib/spec/example.rb new file mode 100644 index 000000000..afbf41286 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example.rb @@ -0,0 +1,164 @@ +module Spec + # == Example Groups and Code Examples + # + # A Code Example is an executable example of how a bit of code is expected + # to behave. + # + # An Example Group is a group of code examples. + # + # RSpec exposes a DSL to describe groups of examples. + # + # describe Account do + # it "should have a balance of $0" do + # account = Account.new + # account.balance.should == Money.new(0, :dollars) + # end + # end + # + # == Before and After + # + # You can use the <tt>before()</tt> and <tt>after()</tt> methods to extract + # common code within an Example Group. Both methods take an optional scope + # argument so you can run the block before :each example or before :all + # examples + # + # describe "..." do + # before :all do + # ... + # end + # + # before :each do + # ... + # end + # + # it "should do something" do + # ... + # end + # + # it "should do something else" do + # ... + # end + # + # after :each do + # ... + # end + # + # after :all do + # ... + # end + # + # end + # + # The <tt>before :each</tt> block will run before each of the examples, once + # for each example. Likewise, the <tt>after :each</tt> block will run after + # each of the examples. + # + # It is also possible to specify a <tt>before :all</tt> and <tt>after + # :all</tt> block that will run only once for each example group, before the + # first <code>before :each</code> and after the last <code>after + # :each</code> respectively. The use of these is generally discouraged, + # because it introduces dependencies between the examples. Still, it might + # prove useful for very expensive operations if you know what you are doing. + # + # == Local helper methods + # + # You can include local helper methods by simply expressing them within an + # example group: + # + # describe "..." do + # + # it "..." do + # helper_method + # end + # + # def helper_method + # ... + # end + # + # end + # + # == Included helper methods + # + # You can include helper methods in multiple example groups by expressing + # them within a module, and then including that module in your example + # groups: + # + # module AccountExampleHelperMethods + # def helper_method + # ... + # end + # end + # + # describe "A new account" do + # include AccountExampleHelperMethods + # before do + # @account = Account.new + # end + # + # it "should have a balance of $0" do + # helper_method + # @account.balance.should eql(Money.new(0, :dollars)) + # end + # end + # + # == Shared Example Groups + # + # You can define a shared example group, that may be used on other groups + # + # share_examples_for "All Editions" do + # it "all editions behaviour" ... + # end + # + # describe SmallEdition do + # it_should_behave_like "All Editions" + # + # it "should do small edition stuff" do + # ... + # end + # end + # + # You can also assign the shared group to a module and include that + # + # share_as :AllEditions do + # it "should do all editions stuff" ... + # end + # + # describe SmallEdition do + # it_should_behave_like AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + # + # And, for those of you who prefer to use something more like Ruby, you can + # just include the module directly + # + # describe SmallEdition do + # include AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + module Example + end +end + +require 'timeout' +require 'spec/example/args_and_options' +require 'spec/example/predicate_matchers' +require 'spec/example/example_group_proxy' +require 'spec/example/example_proxy' +require 'spec/example/subject' +require 'spec/example/before_and_after_hooks' +require 'spec/example/pending' +require 'spec/example/module_reopening_fix' +require 'spec/example/example_group_hierarchy' +require 'spec/example/example_group_methods' +require 'spec/example/example_methods' +require 'spec/example/example_group' +require 'spec/example/shared_example_group' +require 'spec/example/example_group_factory' +require 'spec/example/errors' +require 'spec/example/example_matcher' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/args_and_options.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/args_and_options.rb new file mode 100644 index 000000000..b74fddd8e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/args_and_options.rb @@ -0,0 +1,27 @@ +module Spec + module Example + module ArgsAndOptions + def args_and_options(*args) # :nodoc: + options = Hash === args.last ? args.pop : {} + return args, options + end + + def add_options(args, options={}) # :nodoc: + args << {} unless Hash === args.last + args.extend WithOptions + args.options.merge!(options) + args.options + end + + def set_location(options, location) # :nodoc: + options[:location] ||= location + end + + module WithOptions # :nodoc: + def options + last + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/before_and_after_hooks.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/before_and_after_hooks.rb new file mode 100644 index 000000000..9f5039d1e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/before_and_after_hooks.rb @@ -0,0 +1,93 @@ +module Spec + module Example + module BeforeAndAfterHooks + class << self + def before_suite_parts # :nodoc: + @before_suite_parts ||= [] + end + + def after_suite_parts # :nodoc: + @after_suite_parts ||= [] + end + end + + # Registers a block to be executed before examples. <tt>scope</tt> can be + # <tt>:each</tt> (default), <tt>:all</tt>, or <tt>:suite</tt>. When + # <tt>:each</tt>, the block is executed before each example. When + # <tt>:all</tt>, the block is executed only once before any examples are + # run. + def append_before(scope = :each, &block) + before_parts(scope) << block + end + alias_method :before, :append_before + + # Registers a block to be executed before each example. + # This method prepends +block+ to existing before blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_before(scope = :each, &block) + before_parts(scope).unshift(block) + end + + # Registers a block to be executed after each example. + # This method prepends +block+ to existing after blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_after(scope = :each, &block) + after_parts(scope).unshift(block) + end + alias_method :after, :prepend_after + + # Registers a block to be executed after each example. + # This method appends +block+ to existing after blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def append_after(scope = :each, &block) + after_parts(scope) << block + end + + def before_each_parts # :nodoc: + @before_each_parts ||= [] + end + + def after_each_parts # :nodoc: + @after_each_parts ||= [] + end + + def before_all_parts # :nodoc: + @before_all_parts ||= [] + end + + def after_all_parts # :nodoc: + @after_all_parts ||= [] + end + + def before_suite_parts # :nodoc: + BeforeAndAfterHooks.before_suite_parts + end + + def after_suite_parts # :nodoc: + BeforeAndAfterHooks.after_suite_parts + end + + private + + def before_parts(scope) + case scope + when :each; before_each_parts + when :all; before_all_parts + when :suite; before_suite_parts + end + end + + def after_parts(scope) + case scope + when :each; after_each_parts + when :all; after_all_parts + when :suite; after_suite_parts + end + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/errors.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/errors.rb new file mode 100644 index 000000000..157b669b0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/errors.rb @@ -0,0 +1,25 @@ +module Spec + module Example + class ExamplePendingError < StandardError; end + + class NotYetImplementedError < ExamplePendingError + MESSAGE = "Not Yet Implemented" + def initialize + super(MESSAGE) + end + end + + class PendingExampleFixedError < StandardError; end + + class NoDescriptionError < ArgumentError + class << self + def message(kind, location) + "No description supplied for #{kind} declared on #{location}" + end + end + def initialize(kind, location) + super(self.class.message(kind, location)) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_group.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group.rb new file mode 100644 index 000000000..983be9a24 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group.rb @@ -0,0 +1,10 @@ +module Spec + module Example + # 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 + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_factory.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_factory.rb new file mode 100644 index 000000000..1d662782a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_factory.rb @@ -0,0 +1,82 @@ +module Spec + module Example + + class ExampleGroupFactory + module ClassMethods + include Spec::Example::ArgsAndOptions + + def reset + @example_group_types = nil + default(ExampleGroup) + end + + def example_group_creation_listeners + @example_group_creation_listeners ||= [] + end + + def register_example_group(klass) + example_group_creation_listeners.each do |listener| + listener.register_example_group(klass) + end + end + + def create_shared_example_group(*args, &example_group_block) # :nodoc: + ::Spec::Example::SharedExampleGroup.register(*args, &example_group_block) + end + + def create_example_group(*args, &block) + raise ArgumentError if args.empty? || block.nil? + add_options(args) + superclass = determine_superclass(args.last) + superclass.describe(*args, &block) + end + + # Registers an example group class +klass+ with the symbol +type+. For + # example: + # + # Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup) + # + # 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.to_sym] = example_group_class + end + + # Sets the default ExampleGroup class + def default(example_group_class) + Spec.__send__ :remove_const, :ExampleGroup if Spec.const_defined?(:ExampleGroup) + Spec.const_set(:ExampleGroup, example_group_class) + old = @example_group_types + @example_group_types = Hash.new(example_group_class) + @example_group_types.merge!(old) if old + end + + def [](key) + @example_group_types[key] + end + + protected + + def determine_superclass(opts) + if type = opts[:type] + self[type] + elsif opts[:location] =~ /spec(\\|\/)(#{@example_group_types.keys.sort_by{|k| k.to_s.length}.reverse.join('|')})/ + self[$2 == '' ? nil : $2.to_sym] + else + self[nil] + end + end + + end + extend ClassMethods + self.reset + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_hierarchy.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_hierarchy.rb new file mode 100644 index 000000000..f2c9fb5cd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_hierarchy.rb @@ -0,0 +1,53 @@ +module Spec + module Example + class ExampleGroupHierarchy < Array + def initialize(example_group_class) + push example_group_class + if example_group_class.respond_to?(:superclass) && example_group_class.superclass.respond_to?(:example_group_hierarchy) + unshift example_group_class.superclass.example_group_hierarchy + flatten! + end + end + + def run_before_all(example) + example.eval_each_fail_fast(before_all_parts) + end + + def run_before_each(example) + example.eval_each_fail_fast(before_each_parts) + end + + def run_after_each(example) + example.eval_each_fail_slow(after_each_parts) + end + + def run_after_all(example) + example.eval_each_fail_slow(after_all_parts) + end + + def before_all_parts + @before_all_parts ||= collect {|klass| klass.before_all_parts}.flatten + end + + def before_each_parts + @before_each_parts ||= collect {|klass| klass.before_each_parts}.flatten + end + + def after_each_parts + @after_each_parts ||= reverse.collect {|klass| klass.after_each_parts}.flatten + end + + def after_all_parts + @after_all_parts ||= reverse.collect {|klass| klass.after_all_parts}.flatten + end + + def nested_descriptions + @nested_descriptions ||= collect {|eg| nested_description_from(eg) == "" ? nil : nested_description_from(eg) }.compact + end + + def nested_description_from(example_group) + example_group.description_args.join + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_methods.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_methods.rb new file mode 100644 index 000000000..93f459587 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_methods.rb @@ -0,0 +1,287 @@ +module Spec + module Example + + module ExampleGroupMethods + class << self + attr_accessor :matcher_class + + def build_description_from(*args) + text = args.inject("") do |description, arg| + description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/) + description << arg.to_s + end + text == "" ? nil : text + end + end + + include Spec::Example::BeforeAndAfterHooks + include Spec::Example::Subject::ExampleGroupMethods + include Spec::Example::PredicateMatchers + include Spec::Example::ArgsAndOptions + + attr_reader :location + + def options # :nodoc: + @options ||= {} + end + + def inherited(klass) # :nodoc: + super + ExampleGroupFactory.register_example_group(klass) + end + + # Makes the describe/it syntax available from a class. For example: + # + # class StackSpec < Spec::ExampleGroup + # describe Stack, "with no elements" + # + # before + # @stack = Stack.new + # end + # + # it "should raise on pop" do + # lambda{ @stack.pop }.should raise_error + # end + # end + # + def describe(*args, &example_group_block) + raise Spec::Example::NoDescriptionError.new("example group", caller(0)[1]) if args.empty? + if example_group_block + options = add_options(args) + set_location(options, caller(0)[1]) + if options[:shared] + ExampleGroupFactory.create_shared_example_group(*args, &example_group_block) + else + subclass(*args, &example_group_block) + end + else + set_description(*args) + end + end + alias :context :describe + + # Use this to pull in examples from shared example groups. + def it_should_behave_like(*shared_example_groups) + shared_example_groups.each do |group| + include_shared_example_group(group) + end + end + + # 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={}, backtrace=nil, &implementation) + example_proxy = ExampleProxy.new(description, options, backtrace || caller(0)[1]) + example_proxies << example_proxy + example_implementations[example_proxy] = implementation || pending_implementation + example_proxy + end + + def pending_implementation + lambda {|*args| raise(Spec::Example::NotYetImplementedError) } + end + + alias_method :it, :example + alias_method :specify, :example + + # Use this to temporarily disable an example. + def xexample(description=nil, opts={}, &block) + Kernel.warn("Example disabled: #{description}") + end + + alias_method :xit, :xexample + alias_method :xspecify, :xexample + + def run(run_options) + examples = examples_to_run(run_options) + notify(run_options.reporter) unless examples.empty? + return true if examples.empty? + return dry_run(examples, run_options) if run_options.dry_run? + + define_methods_from_predicate_matchers + + success, before_all_instance_variables = run_before_all(run_options) + success, after_all_instance_variables = run_examples(success, before_all_instance_variables, examples, run_options) + success = run_after_all(success, after_all_instance_variables, run_options) + end + + def set_description(*args) + @description_args, @options = args_and_options(*args) + @backtrace = caller(1) + @location = File.expand_path(options[:location]) if options[:location] + self + end + + def notify(reporter) # :nodoc: + reporter.example_group_started(ExampleGroupProxy.new(self)) + end + + def description + @description ||= ExampleGroupMethods.build_description_from(*description_parts) || to_s + end + + def described_type + @described_type ||= description_parts.reverse.find {|part| part.is_a?(Module)} + end + + def described_class + @described_class ||= Class === described_type ? described_type : nil + end + + def description_args + @description_args ||= [] + end + + def description_parts #:nodoc: + @description_parts ||= example_group_hierarchy.inject([]) do |parts, example_group_class| + [parts << example_group_class.description_args].flatten + end + end + + def example_proxies # :nodoc: + @example_proxies ||= [] + end + + def example_implementations # :nodoc: + @example_implementations ||= {} + end + + def examples(run_options=nil) #:nodoc: + (run_options && run_options.reverse) ? example_proxies.reverse : example_proxies + end + + def number_of_examples #:nodoc: + example_proxies.length + end + + def example_group_hierarchy + @example_group_hierarchy ||= ExampleGroupHierarchy.new(self) + end + + def nested_descriptions + example_group_hierarchy.nested_descriptions + end + + def include_constants_in(mod) + include mod if (Spec::Ruby.version.to_f >= 1.9) & (Module === mod) & !(Class === mod) + end + + def let(name, &block) + define_method name do + @assignments ||= {} + @assignments[name] ||= instance_eval(&block) + end + end + + def let!(name, &block) + let(name, &block) + before { __send__(name) } + end + + private + + def subclass(*args, &example_group_block) + @class_count ||= 0 + @class_count += 1 + klass = const_set("Subclass_#{@class_count}", Class.new(self)) + klass.set_description(*args) + klass.include_constants_in(args.last[:scope]) + klass.module_eval(&example_group_block) + klass + end + + def dry_run(examples, run_options) + examples.each do |example| + run_options.reporter.example_started(example) + run_options.reporter.example_finished(example) + end + end + + def run_before_all(run_options) + return [true,{}] if example_group_hierarchy.before_all_parts.empty? + example_proxy = ExampleProxy.new("before(:all)") + before_all = new(example_proxy) + begin + example_group_hierarchy.run_before_all(before_all) + return [true, before_all.instance_variable_hash] + rescue Exception => e + run_options.reporter.example_failed(example_proxy, e) + return [false, before_all.instance_variable_hash] + end + end + + def run_examples(success, instance_variables, examples, run_options) + return [success, instance_variables] unless success + + after_all_instance_variables = instance_variables + + examples.each do |example| + example_group_instance = new(example, &example_implementations[example]) + success &= example_group_instance.execute(run_options, instance_variables) + after_all_instance_variables = example_group_instance.instance_variable_hash + end + + return [success, after_all_instance_variables] + end + + def run_after_all(success, instance_variables, run_options) + return success if example_group_hierarchy.after_all_parts.empty? + example_proxy = ExampleProxy.new("after(:all)") + after_all = new(example_proxy) + after_all.set_instance_variables_from_hash(instance_variables) + example_group_hierarchy.run_after_all(after_all) + success + rescue Exception => e + run_options.reporter.example_failed(example_proxy, e) + false + end + + def examples_to_run(run_options) + return example_proxies unless examples_were_specified?(run_options) + if run_options.line_number_requested? + if location =~ /:#{run_options.example_line}:?/ + example_proxies + else + example_proxies.select {|proxy| proxy.location =~ /:#{run_options.example_line}:?/} + end + else + example_proxies.reject do |proxy| + matcher = ExampleGroupMethods.matcher_class. + new(description.to_s, proxy.description) + !matcher.matches?(run_options.examples) + end + end + end + + def examples_were_specified?(run_options) + !run_options.examples.empty? + end + + def method_added(name) # :nodoc: + example(name.to_s, {}, caller(0)[1]) {__send__ name.to_s} if example_method?(name.to_s) + end + + def example_method?(method_name) + should_method?(method_name) + end + + def should_method?(method_name) + !(method_name =~ /^should(_not)?$/) && + method_name =~ /^should/ && + instance_method(method_name).arity < 1 + end + + def include_shared_example_group(shared_example_group) + case shared_example_group + when SharedExampleGroup + include shared_example_group + else + unless example_group = SharedExampleGroup.find(shared_example_group) + raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found") + end + include(example_group) + end + end + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_proxy.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_proxy.rb new file mode 100644 index 000000000..3c258d61f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_group_proxy.rb @@ -0,0 +1,61 @@ +module Spec + module Example + # Lightweight proxy for an example group. This is the object that is passed + # to Spec::Runner::Formatter::BaseFormatter#example_group_started + class ExampleGroupProxy + + def initialize(example_group) # :nodoc: + @description = example_group.description + @nested_descriptions = example_group.nested_descriptions + @examples = example_group.example_proxies + @location = example_group.location + @backtrace = example_group.location # deprecated - see the backtrace method below + @options = example_group.options.dup + @options.delete(:location) + @options.delete(:scope) + end + + # Optional hash passed to the example group declaration. Note that RSpec uses + # this hash internally and reserves the keys :location and :scope for its own + # use (and removes them from this hash) + attr_reader :options + + # This is the description passed to the <tt>describe()</tt> method or any + # of its aliases + attr_reader :description + + # Used by Spec::Runner::Formatter::NestedTextFormatter to access the + # description of each example group in a nested group separately. + attr_reader :nested_descriptions + + # A collection of ExampleGroupProxy objects, one for each example + # declared in this group. + attr_reader :examples + + # The file and line number at which the proxied example group + # was declared. This is extracted from <tt>caller</tt>, and is therefore + # formatted as an individual line in a backtrace. + attr_reader :location + + # Deprecated - use location() instead + def backtrace + Spec::deprecate("ExampleGroupProxy#backtrace","ExampleGroupProxy#location") + @backtrace + end + + # Deprecated - just use gsub on the description instead. + def filtered_description(regexp) + Spec::deprecate("ExampleGroupProxy#filtered_description","gsub (or similar) to modify ExampleGroupProxy#description") + ExampleGroupMethods.build_description_from( + *nested_descriptions.collect do |description| + description =~ regexp ? description.gsub($1, "") : description + end + ) + end + + def ==(other) # :nodoc: + other.description == description + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_matcher.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_matcher.rb new file mode 100644 index 000000000..3acd7e14a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_matcher.rb @@ -0,0 +1,43 @@ +module Spec + module Example + class ExampleMatcher + def initialize(example_group_description, example_name) + @example_group_description = example_group_description + @example_name = example_name + end + + def matches?(specified_examples) + specified_examples.any? do |specified_example| + matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example) + end + end + + protected + def matches_literal_example?(specified_example) + specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/ + end + + def matches_example_not_considering_modules?(specified_example) + specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/ + end + + def example_group_regex + Regexp.escape(@example_group_description) + end + + def example_group_with_before_all_regexp + Regexp.escape("#{@example_group_description} before(:all)") + end + + def example_group_regex_not_considering_modules + Regexp.escape(@example_group_description.split('::').last) + end + + def example_regexp + Regexp.escape(@example_name) if @example_name + end + end + + ExampleGroupMethods.matcher_class = ExampleMatcher + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_methods.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_methods.rb new file mode 100644 index 000000000..10f45a722 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_methods.rb @@ -0,0 +1,152 @@ +module Spec + module Example + module ExampleMethods + + extend Spec::Example::ModuleReopeningFix + include Spec::Example::Subject::ExampleMethods + + def violated(message="") + raise Spec::Expectations::ExpectationNotMetError.new(message) + end + + # Declared description for this example: + # + # describe Account do + # it "should start with a balance of 0" do + # ... + # + # description + # => "should start with a balance of 0" + def description + if description = @_proxy.description || ::Spec::Matchers.generated_description + description + else + Spec.warn Spec::Example::NoDescriptionError.message("example", @_proxy.location) + end + end + + def options # :nodoc: + @_proxy.options + end + + def execute(run_options, instance_variables) # :nodoc: + run_options.reporter.example_started(@_proxy) + set_instance_variables_from_hash(instance_variables) + + execution_error = nil + Timeout.timeout(run_options.timeout) do + begin + before_each_example + instance_eval(&@_implementation) + rescue Interrupt + exit 1 + rescue Exception => e + execution_error ||= e + end + begin + after_each_example + rescue Interrupt + exit 1 + rescue Exception => e + execution_error ||= e + end + end + + run_options.reporter.example_finished(@_proxy.update(description), execution_error) + success = execution_error.nil? || ExamplePendingError === execution_error + end + + module BlockAliases + alias_method :to, :should + alias_method :to_not, :should_not + end + + # Extends the submitted block with aliases to and to_not + # for should and should_not. Allows expectations like this: + # + # expect { this_block }.to change{this.expression}.from(old_value).to(new_value) + # expect { this_block }.to raise_error + def expect(&block) + block.extend BlockAliases + end + + def eval_each_fail_fast(blocks) # :nodoc: + blocks.each {|block| instance_eval(&block)} + end + + def eval_each_fail_slow(blocks) # :nodoc: + first_exception = nil + blocks.each do |block| + begin + instance_eval(&block) + rescue Exception => e + first_exception ||= e + end + end + raise first_exception if first_exception + end + + 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 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 ['@_proxy', '@_implementation', '@method_name'].include?(variable_name.to_s) + instance_variable_set variable_name, value + end + end + end + + # Run all the before(:each) blocks for this example + def run_before_each + example_group_hierarchy.run_before_each(self) + end + + # Run all the after(:each) blocks for this example + def run_after_each + example_group_hierarchy.run_after_each(self) + end + + def initialize(example_proxy, &implementation) + @_proxy = example_proxy + @_implementation = implementation + @_backtrace = caller + end + + private + + include Matchers + include Pending + + def before_each_example + setup_mocks_for_rspec + run_before_each + end + + def after_each_example + run_after_each + verify_mocks_for_rspec + ensure + teardown_mocks_for_rspec + end + + def described_class + self.class.described_class + end + + def description_args + self.class.description_args + end + + def example_group_hierarchy + self.class.example_group_hierarchy + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/example_proxy.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/example_proxy.rb new file mode 100644 index 000000000..f726d0e70 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/example_proxy.rb @@ -0,0 +1,41 @@ +module Spec + module Example + # Lightweight proxy for an example. This is the object that is passed to + # example-related methods in Spec::Runner::Formatter::BaseFormatter + class ExampleProxy + + def initialize(description=nil, options={}, location=nil) # :nodoc: + @description, @options, @location = description, options, location + end + + # Optional hash passed to the example declaration + attr_reader :options + + # This is the docstring passed to the <tt>it()</tt> method or any + # of its aliases + attr_reader :description + + # The file and line number at which the represented example + # was declared. This is extracted from <tt>caller</tt>, and is therefore + # formatted as an individual line in a backtrace. + attr_reader :location + + # Deprecated - use location() + def backtrace + Spec.deprecate("ExampleProxy#backtrace","ExampleProxy#location") + location + end + + # Convenience method for example group - updates the value of + # <tt>description</tt> and returns self. + def update(description) # :nodoc: + @description = description + self + end + + def ==(other) # :nodoc: + (other.description == description) & (other.location == location) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/module_reopening_fix.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/module_reopening_fix.rb new file mode 100644 index 000000000..9ea088a2e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/module_reopening_fix.rb @@ -0,0 +1,43 @@ +module Spec + module Example + # When you reopen a module that is included in another module that is included in a class, + # the new material you define does not make it to the class. This fixes that. + # + # == Example + # + # module M1; end + # + # module M2 + # def foo; "FOO"; end + # end + # + # class C + # include M1 + # end + # + # module M1 + # include M2 + # end + # + # c = C.new + # c.foo + # NoMethodError: undefined method `foo' for #<C:0x5e89a4> + # from (irb):12 + module ModuleReopeningFix + def child_modules + @child_modules ||= [] + end + + def included(mod) + child_modules << mod + end + + def include(mod) + super + child_modules.each do |child_module| + child_module.__send__(:include, mod) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/pending.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/pending.rb new file mode 100644 index 000000000..9aad1aab0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/pending.rb @@ -0,0 +1,18 @@ +module Spec + module Example + module Pending + def pending(message = "TODO") + if block_given? + begin + yield + rescue Exception + raise Spec::Example::ExamplePendingError.new(message) + end + raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.") + else + raise Spec::Example::ExamplePendingError.new(message) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/predicate_matchers.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/predicate_matchers.rb new file mode 100644 index 000000000..c3c319519 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/predicate_matchers.rb @@ -0,0 +1,46 @@ +module Spec + module Example + module PredicateMatchers + # :call-seq: + # predicate_matchers[matcher_name] = method_on_object + # predicate_matchers[matcher_name] = [method1_on_object, method2_on_object] + # + # Dynamically generates a custom matcher that will match + # a predicate on your class. RSpec provides a couple of these + # out of the box: + # + # exist (for state expectations) + # File.should exist("path/to/file") + # + # an_instance_of (for mock argument matchers) + # mock.should_receive(:message).with(an_instance_of(String)) + # + # == Examples + # + # class Fish + # def can_swim? + # true + # end + # end + # + # describe Fish do + # predicate_matchers[:swim] = :can_swim? + # it "should swim" do + # Fish.new.should swim + # end + # end + def predicate_matchers + @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL") + end + + def define_methods_from_predicate_matchers # :nodoc: + 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 + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/shared_example_group.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/shared_example_group.rb new file mode 100644 index 000000000..336944914 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/shared_example_group.rb @@ -0,0 +1,59 @@ +module Spec + module Example + class SharedExampleGroup < Module + 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 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 + @shared_example_groups ||= [] + end + + 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 expanded_path(new_example_group) == expanded_path(existing_example_group) + raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists") + end + + def expanded_path(example_group) + File.expand_path(example_group.location) + end + end + + extend ClassMethods + include ExampleGroupMethods + + def initialize(*args, &example_group_block) + set_description(*args) + @example_group_block = example_group_block + end + + def included(mod) # :nodoc: + mod.module_eval(&@example_group_block) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/example/subject.rb b/vendor/gems/rspec-1.3.1/lib/spec/example/subject.rb new file mode 100644 index 000000000..4f53f543a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/example/subject.rb @@ -0,0 +1,114 @@ +module Spec + module Example + module Subject + module ExampleGroupMethods + # 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 } + # its(:currency) { should == :USD } + # end + # + # See +ExampleMethods#should+ for more information about this approach. + def subject(&block) + block.nil? ? + explicit_subject || implicit_subject : @explicit_subject_block = block + end + + def its(attribute, &block) + describe(attribute) do + example do + self.class.class_eval do + define_method(:subject) do + super().send(attribute) + end + end + instance_eval(&block) + end + end + end + + attr_reader :explicit_subject_block # :nodoc: + + private + + def explicit_subject + group = self + while group.respond_to?(:explicit_subject_block) + return group.explicit_subject_block if group.explicit_subject_block + group = group.superclass + end + end + + def implicit_subject + (described_class ? proc {described_class.new} : proc {description_args.first}) + end + end + + module ExampleMethods + + alias_method :__should_for_example_group__, :should + alias_method :__should_not_for_example_group__, :should_not + + # Returns the subject defined in ExampleGroupMethods#subject. The + # subject block is only executed once per example, the result of which + # is cached and returned by any subsequent calls to +subject+. + # + # If a class is passed to +describe+ and no subject is explicitly + # declared in the example group, then +subject+ will return a new + # instance of that class. + # + # == Examples + # + # # explicit subject defined by the subject method + # describe Person do + # subject { Person.new(:birthdate => 19.years.ago) } + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # end + # end + # + # # implicit subject => { Person.new } + # describe Person do + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # end + # end + def subject + @subject ||= instance_eval(&self.class.subject) + end + + # When +should+ is called with no explicit receiver, the call is + # delegated to the object returned by +subject+. Combined with + # an implicit subject (see +subject+), this supports very concise + # expressions. + # + # == Examples + # + # describe Person do + # it { should be_eligible_to_vote } + # end + def should(matcher=nil, message=nil) + self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message) + end + + # Just like +should+, +should_not+ delegates to the subject (implicit or + # explicit) of the example group. + # + # == Examples + # + # describe Person do + # it { should_not be_eligible_to_vote } + # end + def should_not(matcher=nil, message=nil) + self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations.rb new file mode 100644 index 000000000..13cf59b26 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations.rb @@ -0,0 +1,35 @@ +require 'spec/matchers' +require 'spec/expectations/fail_with' +require 'spec/expectations/errors' +require 'spec/expectations/extensions' +require 'spec/expectations/handler' + +module Spec + + # Spec::Expectations lets you set expectations on your objects. + # + # result.should == 37 + # team.should have(11).players_on_the_field + # + # == How Expectations work. + # + # Spec::Expectations adds two methods to Object: + # + # should(matcher=nil) + # should_not(matcher=nil) + # + # Both methods take an optional Expression Matcher (See Spec::Matchers). + # + # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If + # it returns +true+, the spec passes and execution continues. If it returns + # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>. + # + # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If + # it returns +false+, the spec passes and execution continues. If it returns + # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>. + # + # RSpec ships with a standard set of useful matchers, and writing your own + # matchers is quite simple. See Spec::Matchers for details. + module Expectations + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations/errors.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations/errors.rb new file mode 100644 index 000000000..1fabd105d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations/errors.rb @@ -0,0 +1,12 @@ +module Spec + module Expectations + # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit + # will report unmet RSpec expectations as failures rather than errors. + superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c| + eval(c) rescue nil + end.compact.first + + class ExpectationNotMetError < superclass + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions.rb new file mode 100644 index 000000000..d68212e42 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions.rb @@ -0,0 +1 @@ +require 'spec/expectations/extensions/kernel' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions/kernel.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions/kernel.rb new file mode 100644 index 000000000..7d8849226 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations/extensions/kernel.rb @@ -0,0 +1,52 @@ +module Kernel + # :call-seq: + # should(matcher) + # should == expected + # should === expected + # should =~ expected + # + # receiver.should(matcher) + # => Passes if matcher.matches?(receiver) + # + # receiver.should == expected #any value + # => Passes if (receiver == expected) + # + # receiver.should === expected #any value + # => Passes if (receiver === expected) + # + # receiver.should =~ regexp + # => Passes if (receiver =~ regexp) + # + # See Spec::Matchers for more information about matchers + # + # == Warning + # + # NOTE that this does NOT support receiver.should != expected. + # Instead, use receiver.should_not == expected + def should(matcher=nil, message=nil, &block) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block) + end + + # :call-seq: + # should_not(matcher) + # should_not == expected + # should_not === expected + # should_not =~ expected + # + # receiver.should_not(matcher) + # => Passes unless matcher.matches?(receiver) + # + # receiver.should_not == expected + # => Passes unless (receiver == expected) + # + # receiver.should_not === expected + # => Passes unless (receiver === expected) + # + # receiver.should_not =~ regexp + # => Passes unless (receiver =~ regexp) + # + # See Spec::Matchers for more information about matchers + def should_not(matcher=nil, message=nil, &block) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block) + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations/fail_with.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations/fail_with.rb new file mode 100644 index 000000000..5e01f99df --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations/fail_with.rb @@ -0,0 +1,45 @@ +module Spec + module Expectations + class << self + attr_accessor :differ + + # raises a Spec::Expectations::ExpectationNotMetError with message + # + # When a differ has been assigned and fail_with is passed + # <code>expected</code> and <code>target</code>, passes them + # to the differ to append a diff message to the failure message. + def fail_with(message, expected=nil, target=nil) # :nodoc: + if message.nil? + raise ArgumentError, "Failure message is nil. Does your matcher define the " + + "appropriate failure_message_for_* method to return a string?" + end + if (Array === message) & (message.length == 3) + ::Spec.warn(<<-NOTICE + +***************************************************************** +DEPRECATION WARNING: you are using deprecated behaviour that will +be removed from a future version of RSpec. + +* Support for matchers that return arrays from failure message +methods is deprecated. +* Instead, the matcher should return a string, and expose methods +for the expected() and actual() values. +***************************************************************** +NOTICE + ) + message, expected, target = message[0], message[1], message[2] + end + unless (differ.nil? || expected.nil? || target.nil?) + if expected.is_a?(String) + message << "\n\n Diff:" << self.differ.diff_as_string(target.to_s, expected) + elsif expected.is_a?(Hash) && target.is_a?(Hash) + message << "\n\n Diff:" << self.differ.diff_as_hash(target, expected) + elsif !target.is_a?(Proc) + message << "\n\n Diff:" << self.differ.diff_as_object(target, expected) + end + end + Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message)) + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/expectations/handler.rb b/vendor/gems/rspec-1.3.1/lib/spec/expectations/handler.rb new file mode 100644 index 000000000..c059637c7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/expectations/handler.rb @@ -0,0 +1,50 @@ +module Spec + module Expectations + class InvalidMatcherError < ArgumentError; end + + class PositiveExpectationHandler + def self.handle_matcher(actual, matcher, message=nil, &block) + ::Spec::Matchers.last_should = :should + ::Spec::Matchers.last_matcher = matcher + return ::Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil? + + match = matcher.matches?(actual, &block) + return match if match + + message ||= matcher.respond_to?(:failure_message_for_should) ? + matcher.failure_message_for_should : + matcher.failure_message + + if matcher.respond_to?(:diffable?) && matcher.diffable? + ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual + else + ::Spec::Expectations.fail_with message + end + end + end + + class NegativeExpectationHandler + def self.handle_matcher(actual, matcher, message=nil, &block) + ::Spec::Matchers.last_should = :should_not + ::Spec::Matchers.last_matcher = matcher + return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil? + + match = matcher.respond_to?(:does_not_match?) ? + !matcher.does_not_match?(actual, &block) : + matcher.matches?(actual, &block) + return match unless match + + message ||= matcher.respond_to?(:failure_message_for_should_not) ? + matcher.failure_message_for_should_not : + matcher.negative_failure_message + + if matcher.respond_to?(:diffable?) && matcher.diffable? + ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual + else + ::Spec::Expectations.fail_with message + end + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/lib/spec/extensions/instance_exec.rb b/vendor/gems/rspec-1.3.1/lib/spec/extensions/instance_exec.rb new file mode 100644 index 000000000..ca7e14ead --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/extensions/instance_exec.rb @@ -0,0 +1,31 @@ +module Spec + module Matchers + module InstanceExec + unless respond_to?(:instance_exec) + # based on Bounded Spec InstanceExec (Mauricio Fernandez) + # http://eigenclass.org/hiki/bounded+space+instance_exec + # - uses singleton_class of matcher instead of global + # InstanceExecHelper module + # - this keeps it scoped to this class only, which is the + # only place we need it + # - only necessary for ruby 1.8.6 + def instance_exec(*args, &block) + singleton_class = (class << self; self; end) + begin + orig_critical, Thread.critical = Thread.critical, true + n = 0 + n += 1 while respond_to?(method_name="__instance_exec#{n}") + singleton_class.module_eval{ define_method(:__instance_exec, &block) } + ensure + Thread.critical = orig_critical + end + begin + return send(:__instance_exec, *args) + ensure + singleton_class.module_eval{ remove_method(:__instance_exec) } rescue nil + end + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test.rb new file mode 100644 index 000000000..156ab8f87 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test.rb @@ -0,0 +1,44 @@ +require 'spec' + +if Spec::Ruby.version.to_f >= 1.9 + gem 'test-unit','= 1.2.3' +end + +require 'test/unit' + +if Spec::Ruby.version.to_f >= 1.9 + require 'test/unit/version' + if Test::Unit::VERSION > '1.2.3' + raise <<-MESSAGE +#{'*' * 50} +Required: test-unit-1.2.3 +Loaded: test-unit-#{Test::Unit::VERSION} + +With ruby-1.9, rspec-#{Spec::VERSION::STRING} requires test-unit-1.2.3, and +tries to force it with "gem 'test-unit', '= 1.2.3'" in: + + #{__FILE__} + +Unfortunately, test-unit-#{Test::Unit::VERSION} was loaded anyway. While we are +aware of this bug we have not been able to track down its source. +Until we do, you have two alternatives: + +* uninstall test-unit-#{Test::Unit::VERSION} +* use 'script/spec' instead of 'rake spec' +#{'*' * 50} +MESSAGE + end +end + + +require 'test/unit/testresult' + +require 'spec/interop/test/unit/testcase' +require 'spec/interop/test/unit/testsuite_adapter' +require 'spec/interop/test/unit/autorunner' +require 'spec/interop/test/unit/testresult' +require 'spec/interop/test/unit/ui/console/testrunner' + +Spec::Example::ExampleGroupFactory.default(Test::Unit::TestCase) + +Test::Unit.run = true diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/autorunner.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/autorunner.rb new file mode 100644 index 000000000..3944e6995 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/autorunner.rb @@ -0,0 +1,6 @@ +class Test::Unit::AutoRunner + remove_method :process_args + def process_args(argv) + true + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testcase.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testcase.rb new file mode 100644 index 000000000..dc10a2a64 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testcase.rb @@ -0,0 +1,56 @@ +require 'test/unit/testcase' + +module Test + module Unit + # This extension of the standard Test::Unit::TestCase makes RSpec + # available from within, so that you can do things like: + # + # require 'spec/test/unit' + # + # class MyTest < Test::Unit::TestCase + # it "should work with Test::Unit assertions" do + # assert_equal 4, 2+1 + # end + # + # def test_should_work_with_rspec_expectations + # (3+1).should == 5 + # end + # end + # + # See also Spec::Example::ExampleGroup + class TestCase + extend Spec::Example::ExampleGroupMethods + include Spec::Example::ExampleMethods + + def self.suite + Test::Unit::TestSuiteAdapter.new(self) + end + + def self.example_method?(method_name) + should_method?(method_name) || test_method?(method_name) + end + + def self.test_method?(method_name) + method_name =~ /^test./ && ( + instance_method(method_name).arity == 0 || + instance_method(method_name).arity == -1 + ) + end + + before(:each) {setup} + after(:each) {teardown} + + def initialize(description, &implementation) + super + # Some Test::Unit extensions depend on @method_name being present. + @method_name = description.description + @_result = ::Test::Unit::TestResult.new + end + + def run(ignore_this_argument=nil) + super() + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testresult.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testresult.rb new file mode 100644 index 000000000..dddcfe868 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testresult.rb @@ -0,0 +1,6 @@ +class Test::Unit::TestResult + alias_method :tu_passed?, :passed? + def passed? + return tu_passed? & ::Spec::Runner.run + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testsuite_adapter.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testsuite_adapter.rb new file mode 100644 index 000000000..76dcd14dc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/testsuite_adapter.rb @@ -0,0 +1,36 @@ +require 'test/unit/testsuite' + +module Test + module Unit + class TestSuiteAdapter < TestSuite + attr_reader :example_group, :examples + alias_method :tests, :examples + def initialize(example_group) + @example_group = example_group + @examples = example_group.examples + end + + def name + example_group.description + end + + def run(*args) + return true unless args.empty? + example_group.run(Spec::Runner.options) + end + + def size + example_group.number_of_examples + end + + def delete(example) + examples.delete example + end + + def empty? + examples.empty? + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/ui/console/testrunner.rb b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/ui/console/testrunner.rb new file mode 100644 index 000000000..8e9995e02 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/interop/test/unit/ui/console/testrunner.rb @@ -0,0 +1,61 @@ +require 'test/unit/ui/console/testrunner' + +module Test + module Unit + module UI + module Console + class TestRunner + + alias_method :started_without_rspec, :started + def started_with_rspec(result) + @result = result + @need_to_output_started = true + end + alias_method :started, :started_with_rspec + + alias_method :test_started_without_rspec, :test_started + def test_started_with_rspec(name) + if @need_to_output_started + if @rspec_io + @rspec_io.rewind + output(@rspec_io.read) + end + output("Started") + @need_to_output_started = false + end + test_started_without_rspec(name) + end + alias_method :test_started, :test_started_with_rspec + + alias_method :test_finished_without_rspec, :test_finished + def test_finished_with_rspec(name) + test_finished_without_rspec(name) + @ran_test = true + end + alias_method :test_finished, :test_finished_with_rspec + + alias_method :finished_without_rspec, :finished + def finished_with_rspec(elapsed_time) + @ran_test ||= false + if @ran_test + finished_without_rspec(elapsed_time) + end + end + alias_method :finished, :finished_with_rspec + + alias_method :setup_mediator_without_rspec, :setup_mediator + def setup_mediator_with_rspec + orig_io = @io + @io = StringIO.new + setup_mediator_without_rspec + ensure + @rspec_io = @io + @io = orig_io + end + alias_method :setup_mediator, :setup_mediator_with_rspec + + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers.rb new file mode 100644 index 000000000..a235df3ad --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers.rb @@ -0,0 +1,214 @@ +require 'spec/extensions/instance_exec' +require 'spec/matchers/pretty' +require 'spec/matchers/matcher' +require 'spec/matchers/operator_matcher' +require 'spec/matchers/be' +require 'spec/matchers/be_close' +require 'spec/matchers/be_instance_of' +require 'spec/matchers/be_kind_of' +require 'spec/matchers/change' +require 'spec/matchers/eql' +require 'spec/matchers/equal' +require 'spec/matchers/errors' +require 'spec/matchers/exist' +require 'spec/matchers/generated_descriptions' +require 'spec/matchers/has' +require 'spec/matchers/have' +require 'spec/matchers/include' +require 'spec/matchers/match' +require 'spec/matchers/match_array' +require 'spec/matchers/method_missing' +require 'spec/matchers/raise_exception' +require 'spec/matchers/respond_to' +require 'spec/matchers/satisfy' +require 'spec/matchers/simple_matcher' +require 'spec/matchers/throw_symbol' +require 'spec/matchers/wrap_expectation' +require 'spec/matchers/compatibility' +require 'spec/matchers/dsl' + +module Spec + + # RSpec ships with a number of useful Expression Matchers. An Expression Matcher + # is any object that responds to the following methods: + # + # matches?(actual) + # failure_message_for_should + # + # These methods are also part of the matcher protocol, but are optional: + # + # does_not_match?(actual) + # failure_message_for_should_not + # description #optional + # + # These methods are from older versions of the protocol. They are still supported, + # but are not recommended: + # + # failure_message (use failure_message_for_should instead) + # negative_failure_message (use failure_message_for_should_not instead) + # + # See Spec::Expectations to learn how to use these as Expectation Matchers. + # + # == Predicates + # + # In addition to those Expression Matchers that are defined explicitly, RSpec will + # create custom Matchers on the fly for any arbitrary predicate, giving your specs + # a much more natural language feel. + # + # A Ruby predicate is a method that ends with a "?" and returns true or false. + # Common examples are +empty?+, +nil?+, and +instance_of?+. + # + # All you need to do is write +should be_+ followed by the predicate without + # the question mark, and RSpec will figure it out from there. For example: + # + # [].should be_empty => [].empty? #passes + # [].should_not be_empty => [].empty? #fails + # + # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_" + # and "be_an_", making your specs read much more naturally: + # + # "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes + # + # 3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes + # 3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes + # 3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes + # 3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails + # + # RSpec will also create custom matchers for predicates like +has_key?+. To + # use this feature, just state that the object should have_key(:key) and RSpec will + # call has_key?(:key) on the target. For example: + # + # {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes + # {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails + # + # You can use this feature to invoke any predicate that begins with "has_", whether it is + # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class. + # + # == Custom Matchers + # + # When you find that none of the stock Expectation Matchers provide a natural + # feeling expectation, you can very easily write your own using RSpec's matcher + # DSL or writing one from scratch. + # + # === Matcher DSL + # + # Imagine that you are writing a game in which players can be in various + # zones on a virtual board. To specify that bob should be in zone 4, you + # could say: + # + # bob.current_zone.should eql(Zone.new("4")) + # + # But you might find it more expressive to say: + # + # bob.should be_in_zone("4") + # + # and/or + # + # bob.should_not be_in_zone("3") + # + # You can create such a matcher like so: + # + # Spec::Matchers.define :be_in_zone do |zone| + # match do |player| + # player.in_zone?(zone) + # end + # end + # + # This will generate a <tt>be_in_zone</tt> method that returns a matcher + # with logical default messages for failures. You can override the failure + # messages and the generated description as follows: + # + # Spec::Matchers.define :be_in_zone do |zone| + # match do |player| + # player.in_zone?(zone) + # end + # failure_message_for_should do |player| + # # generate and return the appropriate string. + # end + # failure_message_for_should_not do |player| + # # generate and return the appropriate string. + # end + # description do + # # generate and return the appropriate string. + # end + # end + # + # Each of the message-generation methods has access to the block arguments + # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The + # failure message methods (<tt>failure_message_for_should</tt> and + # <tt>failure_message_for_should_not</tt>) are passed the actual value (the + # receiver of <tt>should</tt> or <tt>should_not</tt>). + # + # You can also create matchers that obey a fluent interface using the + # <tt>chain</tt> method: + # + # Spec::Matchers.define :tip do |expected_tip| + # chain :on do |bill| + # @bill = bill + # end + # + # match do |person| + # person.tip_for(bill) == expected_tip + # end + # end + # + # This matcher can be used as follows: + # + # describe Customer do + # it { should tip(10).on(50) } + # end + # + # === Custom Matcher from scratch + # + # You could also write a custom matcher from scratch, as follows: + # + # class BeInZone + # def initialize(expected) + # @expected = expected + # end + # def matches?(target) + # @target = target + # @target.current_zone.eql?(Zone.new(@expected)) + # end + # def failure_message_for_should + # "expected #{@target.inspect} to be in Zone #{@expected}" + # end + # def failure_message_for_should_not + # "expected #{@target.inspect} not to be in Zone #{@expected}" + # end + # end + # + # ... and a method like this: + # + # def be_in_zone(expected) + # BeInZone.new(expected) + # end + # + # And then expose the method to your specs. This is normally done + # by including the method and the class in a module, which is then + # included in your spec: + # + # module CustomGameMatchers + # class BeInZone + # ... + # end + # + # def be_in_zone(expected) + # ... + # end + # end + # + # describe "Player behaviour" do + # include CustomGameMatchers + # ... + # end + # + # or you can include in globally in a spec_helper.rb file <tt>require</tt>d + # from your spec file(s): + # + # Spec::Runner.configure do |config| + # config.include(CustomGameMatchers) + # end + # + module Matchers; end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/be.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be.rb new file mode 100644 index 000000000..1cbf90308 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be.rb @@ -0,0 +1,249 @@ +require 'spec/matchers/dsl' + +Spec::Matchers.define :be_true do + match do |actual| + !!actual + end +end + +Spec::Matchers.define :be_false do + match do |actual| + !actual + end +end + +Spec::Matchers.define :be_nil do + match do |actual| + actual.nil? + end + + failure_message_for_should do |actual| + "expected nil, got #{actual.inspect}" + end + + failure_message_for_should_not do + "expected not nil, got nil" + end +end + +module Spec + module Matchers + + class Be #:nodoc: + include Spec::Matchers::Pretty + + def initialize(*args, &block) + @args = args + end + + def matches?(actual) + @actual = actual + !!@actual + end + + def failure_message_for_should + "expected #{@actual.inspect} to evaluate to true" + end + + def failure_message_for_should_not + "expected #{@actual.inspect} to evaluate to false" + end + + def description + "be" + end + + [:==, :<, :<=, :>=, :>, :===].each do |operator| + define_method operator do |operand| + BeComparedTo.new(operand, operator) + end + end + + private + + def args_to_s + @args.empty? ? "" : parenthesize(inspected_args.join(', ')) + end + + def parenthesize(string) + return "(#{string})" + end + + def inspected_args + @args.collect{|a| a.inspect} + end + + def expected_to_sentence + split_words(@expected) + end + + def args_to_sentence + to_sentence(@args) + end + + end + + class BeComparedTo < Be + + def initialize(operand, operator) + @expected, @operator = operand, operator + @args = [] + end + + def matches?(actual) + @actual = actual + @actual.__send__(@operator, @expected) + end + + def failure_message_for_should + "expected #{@operator} #{@expected}, got #{@actual.inspect}" + end + + def failure_message_for_should_not + message = <<-MESSAGE +'should_not be #{@operator} #{@expected}' not only FAILED, +it is a bit confusing. + MESSAGE + + raise message << ([:===,:==].include?(@operator) ? + "It might be more clearly expressed without the \"be\"?" : + "It might be more clearly expressed in the positive?") + end + + def description + "be #{@operator} #{expected_to_sentence}#{args_to_sentence}" + end + + end + + class BePredicate < Be + + def initialize(*args, &block) + @expected = parse_expected(args.shift) + @args = args + @block = block + end + + def matches?(actual) + @actual = actual + begin + return @result = actual.__send__(predicate, *@args, &@block) + 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 + + begin + return @result = actual.__send__(present_tense_predicate, *@args, &@block) + rescue NameError + raise predicate_missing_error + end + end + + def failure_message_for_should + "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" + end + + def failure_message_for_should_not + "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}" + end + + def description + "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}" + end + + private + + def predicate + "#{@expected}?".to_sym + end + + def present_tense_predicate + "#{@expected}s?".to_sym + end + + def parse_expected(expected) + @prefix, expected = prefix_and_expected(expected) + expected + end + + def prefix_and_expected(symbol) + symbol.to_s =~ /^(be_(an?_)?)(.*)/ + return $1, $3 + end + + def prefix_to_sentence + split_words(@prefix) + end + + end + + class BeSameAs < Be + + def initialize(*args, &block) + @expected = args.shift + @args = args + end + + def matches?(actual) + @actual = actual + @actual.equal?(@expected) + end + + def failure_message_for_should + "expected #{@expected}, got #{@actual.inspect}" + end + + def failure_message_for_should_not + "expected not #{@expected}, got #{@actual.inspect}" + end + + def description + "be #{expected_to_sentence}#{args_to_sentence}" + end + + end + + # :call-seq: + # should be_true + # should be_false + # should be_nil + # should be_[arbitrary_predicate](*args) + # should_not be_nil + # should_not be_[arbitrary_predicate](*args) + # + # Given true, false, or nil, will pass if actual 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 + # convert that into a query against the target object. + # + # The arbitrary_predicate feature will handle any predicate + # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) + # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate. + # + # == Examples + # + # target.should be_true + # target.should be_false + # target.should be_nil + # target.should_not be_nil + # + # collection.should be_empty #passes if target.empty? + # target.should_not be_empty #passes unless target.empty? + # target.should_not be_old_enough(16) #passes unless target.old_enough?(16) + def be(*args) + args.empty? ? + Matchers::Be.new : + Matchers::BeSameAs.new(*args) + end + + # passes if target.kind_of?(klass) + def be_a(klass) + be_a_kind_of(klass) + end + + alias_method :be_an, :be_a + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_close.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_close.rb new file mode 100644 index 000000000..28015f5fb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_close.rb @@ -0,0 +1,32 @@ +module Spec + module Matchers + # :call-seq: + # should be_close(expected, delta) + # should_not be_close(expected, delta) + # + # Passes if actual == expected +/- delta + # + # == Example + # + # result.should be_close(3.0, 0.5) + def be_close(expected, delta) + Matcher.new :be_close, expected, delta do |_expected_, _delta_| + match do |actual| + (actual - _expected_).abs < _delta_ + end + + failure_message_for_should do |actual| + "expected #{_expected_} +/- (< #{_delta_}), got #{actual}" + end + + failure_message_for_should_not do |actual| + "expected #{_expected_} +/- (< #{_delta_}), got #{actual}" + end + + description do + "be close to #{_expected_} (within +- #{_delta_})" + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_instance_of.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_instance_of.rb new file mode 100644 index 000000000..ffc238405 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_instance_of.rb @@ -0,0 +1,26 @@ +module Spec + module Matchers + # :call-seq: + # should be_instance_of(expected) + # should be_an_instance_of(expected) + # should_not be_instance_of(expected) + # should_not be_an_instance_of(expected) + # + # Passes if actual.instance_of?(expected) + # + # == Examples + # + # 5.should be_instance_of(Fixnum) + # 5.should_not be_instance_of(Numeric) + # 5.should_not be_instance_of(Float) + def be_an_instance_of(expected) + Matcher.new :be_an_instance_of, expected do |_expected_| + match do |actual| + actual.instance_of?(_expected_) + end + end + end + + alias_method :be_instance_of, :be_an_instance_of + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_kind_of.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_kind_of.rb new file mode 100644 index 000000000..6a1fddc13 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/be_kind_of.rb @@ -0,0 +1,26 @@ +module Spec + module Matchers + # :call-seq: + # should be_kind_of(expected) + # should be_a_kind_of(expected) + # should_not be_kind_of(expected) + # should_not be_a_kind_of(expected) + # + # Passes if actual.kind_of?(expected) + # + # == Examples + # + # 5.should be_kind_of(Fixnum) + # 5.should be_kind_of(Numeric) + # 5.should_not be_kind_of(Float) + def be_a_kind_of(expected) + Matcher.new :be_a_kind_of, expected do |_expected_| + match do |actual| + actual.kind_of?(_expected_) + end + end + end + + alias_method :be_kind_of, :be_a_kind_of + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/change.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/change.rb new file mode 100644 index 000000000..c8ab9e5cf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/change.rb @@ -0,0 +1,151 @@ +module Spec + module Matchers + + #Based on patch from Wilson Bilkovich + class Change #:nodoc: + def initialize(receiver=nil, message=nil, &block) + @message = message || "result" + @value_proc = block || lambda {receiver.__send__(message)} + @to = @from = @minimum = @maximum = @amount = nil + end + + def matches?(event_proc) + raise_block_syntax_error if block_given? + + @before = evaluate_value_proc + event_proc.call + @after = evaluate_value_proc + + return (@to = 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 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_for_should + if @to + "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}" + elsif @from + "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}" + elsif @amount + "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}" + elsif @minimum + "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}" + elsif @maximum + "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}" + else + "#{@message} should have changed, but is still #{@before.inspect}" + end + end + + def actual_delta + @after - @before + end + + def failure_message_for_should_not + "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}" + end + + def by(amount) + @amount = amount + self + end + + def by_at_least(minimum) + @minimum = minimum + self + end + + def by_at_most(maximum) + @maximum = maximum + self + end + + def to(to) + @to = to + self + end + + def from (from) + @from = from + self + end + + def description + "change ##{@message}" + end + end + + # :call-seq: + # should change(receiver, message, &block) + # should change(receiver, message, &block).by(value) + # should change(receiver, message, &block).from(old).to(new) + # should_not change(receiver, message, &block) + # + # Allows you to specify that a Proc will cause some value to change. + # + # == Examples + # + # lambda { + # team.add_player(player) + # }.should change(roster, :count) + # + # lambda { + # team.add_player(player) + # }.should change(roster, :count).by(1) + # + # lambda { + # team.add_player(player) + # }.should change(roster, :count).by_at_least(1) + # + # lambda { + # team.add_player(player) + # }.should change(roster, :count).by_at_most(1) + # + # string = "string" + # lambda { + # string.reverse! + # }.should change { string }.from("string").to("gnirts") + # + # lambda { + # person.happy_birthday + # }.should change(person, :birthday).from(32).to(33) + # + # lambda { + # employee.develop_great_new_social_networking_app + # }.should change(employee, :title).from("Mail Clerk").to("CEO") + # + # Evaluates <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. + # + # == 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>. + # + # 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). + # + def change(receiver=nil, message=nil, &block) + Matchers::Change.new(receiver, message, &block) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/compatibility.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/compatibility.rb new file mode 100644 index 000000000..3b3ddb9b6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/compatibility.rb @@ -0,0 +1,14 @@ +Spec::Matchers.constants.each do |c| + if Class === (klass = Spec::Matchers.const_get(c)) + if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)} + klass.class_eval do + alias_method :failure_message, :failure_message_for_should + end + end + if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)} + klass.class_eval do + alias_method :negative_failure_message, :failure_message_for_should_not + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/dsl.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/dsl.rb new file mode 100644 index 000000000..73f363457 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/dsl.rb @@ -0,0 +1,20 @@ +module Spec + module Matchers + module DSL + # See Spec::Matchers + def define(name, &declarations) + define_method name do |*expected| + Spec::Matchers::Matcher.new name, *expected, &declarations + end + end + + # Deprecated - use define + def create(name, &declarations) + Spec.deprecate("Spec::Matchers.create","Spec::Matchers.define") + define(name, &declarations) + end + end + end +end + +Spec::Matchers.extend Spec::Matchers::DSL diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/eql.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/eql.rb new file mode 100644 index 000000000..98ab198d9 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/eql.rb @@ -0,0 +1,42 @@ +module Spec + module Matchers + # :call-seq: + # should eql(expected) + # should_not eql(expected) + # + # Passes if actual and expected are of equal value, but not necessarily the same object. + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby. + # + # == Examples + # + # 5.should eql(5) + # 5.should_not eql(3) + def eql(expected) + Matcher.new :eql, expected do |_expected_| + match do |actual| + actual.eql?(_expected_) + end + + failure_message_for_should do |actual| + <<-MESSAGE + +expected #{_expected_.inspect} + got #{actual.inspect} + +(compared using eql?) +MESSAGE + end + + failure_message_for_should_not do |actual| + <<-MESSAGE + +expected #{actual.inspect} not to equal #{_expected_.inspect} + +(compared using eql?) +MESSAGE + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/equal.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/equal.rb new file mode 100644 index 000000000..3580a95af --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/equal.rb @@ -0,0 +1,53 @@ +module Spec + module Matchers + + # :call-seq: + # should equal(expected) + # should_not equal(expected) + # + # Passes if actual and expected are the same object (object identity). + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby. + # + # == Examples + # + # 5.should equal(5) #Fixnums are equal + # "5".should_not equal("5") #Strings that look the same are not the same object + def equal(expected) + Matcher.new :equal, expected do |_expected_| + match do |actual| + actual.equal?(_expected_) + end + + def inspect_object(o) + "#<#{o.class}:#{o.object_id}> => #{o.inspect}" + end + + failure_message_for_should do |actual| + <<-MESSAGE + +expected #{inspect_object(_expected_)} + got #{inspect_object(actual)} + +Compared using equal?, which compares object identity, +but expected and actual are not the same object. Use +'actual.should == expected' if you don't care about +object identity in this example. + +MESSAGE + end + + failure_message_for_should_not do |actual| + <<-MESSAGE + +expected not #{inspect_object(actual)} + got #{inspect_object(_expected_)} + +Compared using equal?, which compares object identity. + +MESSAGE + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/errors.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/errors.rb new file mode 100644 index 000000000..49c267797 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/errors.rb @@ -0,0 +1,5 @@ +module Spec + module Matchers + class MatcherError < StandardError; end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/exist.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/exist.rb new file mode 100644 index 000000000..dc69c683d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/exist.rb @@ -0,0 +1,16 @@ +module Spec + module Matchers + # :call-seq: + # should exist + # should_not exist + # + # Passes if actual.exist? + def exist(arg=nil) + Matcher.new :exist do + match do |actual| + arg ? actual.exist?(arg) : actual.exist? + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/generated_descriptions.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/generated_descriptions.rb new file mode 100644 index 000000000..2340f57d8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/generated_descriptions.rb @@ -0,0 +1,36 @@ +module Spec + module Matchers + class << self + attr_accessor :last_matcher, :last_should # :nodoc: + end + + def self.clear_generated_description + self.last_matcher = nil + self.last_should = nil + end + + def self.generated_description + return nil if last_should.nil? + "#{last_should.to_s.gsub('_',' ')} #{last_description}" + end + + private + + def self.last_description + last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE +When you call a matcher in an example without a String, like this: + +specify { object.should matcher } + +or this: + +it { should matcher } + +RSpec expects the matcher to have a #description method. You should either +add a String to the example this matcher is being used in, or give it a +description method. Then you won't have to suffer this lengthy warning again. +MESSAGE + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/has.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/has.rb new file mode 100644 index 000000000..283154fa6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/has.rb @@ -0,0 +1,35 @@ +module Spec + module Matchers + + class Has + + def initialize(expected, *args, &block) + @expected, @args, @block = expected, args, block + end + + def matches?(actual) + actual.__send__(predicate(@expected), *@args, &@block) + end + + def failure_message_for_should + "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false" + end + + def failure_message_for_should_not + "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true" + end + + def description + "have key #{@args[0].inspect}" + end + + private + + def predicate(sym) + "#{sym.to_s.sub("have_","has_")}?".to_sym + end + + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/have.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/have.rb new file mode 100644 index 000000000..0c936d617 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/have.rb @@ -0,0 +1,152 @@ +module Spec + module Matchers + class Have #:nodoc: + def initialize(expected, relativity=:exactly) + @expected = (expected == :no ? 0 : expected) + @relativity = relativity + @actual = nil + @plural_collection_name = nil + end + + def relativities + @relativities ||= { + :exactly => "", + :at_least => "at least ", + :at_most => "at most " + } + end + + def matches?(collection_owner) + if collection_owner.respond_to?(@collection_name) + collection = collection_owner.__send__(@collection_name, *@args, &@block) + elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name)) + collection = collection_owner.__send__(@plural_collection_name, *@args, &@block) + elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size)) + collection = collection_owner + else + collection_owner.__send__(@collection_name, *@args, &@block) + end + @actual = collection.size if collection.respond_to?(:size) + @actual = collection.length if collection.respond_to?(:length) + raise not_a_collection if @actual.nil? + return @actual >= @expected if @relativity == :at_least + return @actual <= @expected if @relativity == :at_most + return @actual == @expected + end + + def not_a_collection + "expected #{@collection_name} to be a collection but it does not respond to #length or #size" + end + + def failure_message_for_should + "expected #{relative_expectation} #{@collection_name}, got #{@actual}" + end + + def failure_message_for_should_not + if @relativity == :exactly + return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}" + elsif @relativity == :at_most + return <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_most(#{@expected}).#{@collection_name} +We recommend that you use this instead: + should have_at_least(#{@expected + 1}).#{@collection_name} +EOF + elsif @relativity == :at_least + return <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_least(#{@expected}).#{@collection_name} +We recommend that you use this instead: + should have_at_most(#{@expected - 1}).#{@collection_name} +EOF + end + end + + def description + "have #{relative_expectation} #{@collection_name}" + end + + 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 + end + + # :call-seq: + # should have(number).named_collection__or__sugar + # should_not have(number).named_collection__or__sugar + # + # Passes if receiver is a collection with the submitted + # number of items OR if the receiver OWNS a collection + # with the submitted number of items. + # + # If the receiver OWNS the collection, you must use the name + # of the collection. So if a <tt>Team</tt> instance has a + # collection named <tt>#players</tt>, you must use that name + # to set the expectation. + # + # If the receiver IS the collection, you can use any name + # you like for <tt>named_collection</tt>. We'd recommend using + # either "elements", "members", or "items" as these are all + # standard ways of describing the things IN a collection. + # + # This also works for Strings, letting you set an expectation + # about its length + # + # == Examples + # + # # Passes if team.players.size == 11 + # team.should have(11).players + # + # # Passes if [1,2,3].length == 3 + # [1,2,3].should have(3).items #"items" is pure sugar + # + # # Passes if "this string".length == 11 + # "this string".should have(11).characters #"characters" is pure sugar + def have(n) + Matchers::Have.new(n) + end + alias :have_exactly :have + + # :call-seq: + # should have_at_least(number).items + # + # Exactly like have() with >=. + # + # == Warning + # + # +should_not+ +have_at_least+ is not supported + def have_at_least(n) + Matchers::Have.new(n, :at_least) + end + + # :call-seq: + # should have_at_most(number).items + # + # Exactly like have() with <=. + # + # == Warning + # + # +should_not+ +have_at_most+ is not supported + def have_at_most(n) + Matchers::Have.new(n, :at_most) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/include.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/include.rb new file mode 100644 index 000000000..a2a7fe3db --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/include.rb @@ -0,0 +1,44 @@ +module Spec + module Matchers + # :call-seq: + # should include(expected) + # should_not include(expected) + # + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # == Examples + # + # [1,2,3].should include(3) + # [1,2,3].should include(2,3) #would pass + # [1,2,3].should include(2,3,4) #would fail + # [1,2,3].should_not include(4) + # "spread".should include("read") + # "spread".should_not include("red") + def include(*expected) + Matcher.new :include, *expected do |*_expected_| + match do |actual| + helper(actual, *_expected_) + end + + def helper(actual, *_expected_) + _expected_.each do |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 + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/match.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/match.rb new file mode 100644 index 000000000..b4b9ea864 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/match.rb @@ -0,0 +1,21 @@ +module Spec + module Matchers + # :call-seq: + # should match(pattern) + # should_not match(pattern) + # + # Given a Regexp or String, passes if actual.match(pattern) + # + # == Examples + # + # email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # email.should match("@example.com") + def match(expected) + Matcher.new :match, expected do |_expected_| + match do |actual| + actual.match(_expected_) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/match_array.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/match_array.rb new file mode 100644 index 000000000..51b4f3929 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/match_array.rb @@ -0,0 +1,71 @@ +module Spec + module Matchers + + class MatchArray #:nodoc: + include Spec::Matchers::Pretty + + def initialize(expected) + @expected = expected + end + + def matches?(actual) + @actual = actual + @extra_items = difference_between_arrays(@actual, @expected) + @missing_items = difference_between_arrays(@expected, @actual) + @extra_items.empty? & @missing_items.empty? + end + + def failure_message_for_should + message = "expected collection contained: #{safe_sort(@expected).inspect}\n" + message += "actual collection contained: #{safe_sort(@actual).inspect}\n" + message += "the missing elements were: #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty? + message += "the extra elements were: #{safe_sort(@extra_items).inspect}\n" unless @extra_items.empty? + message + end + + def failure_message_for_should_not + "Matcher does not support should_not" + end + + def description + "contain exactly #{_pretty_print(@expected)}" + end + + private + + def safe_sort(array) + array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array + end + + def difference_between_arrays(array_1, array_2) + difference = array_1.dup + array_2.each do |element| + if index = difference.index(element) + difference.delete_at(index) + end + end + difference + end + + + end + + # :call-seq: + # should =~ expected + # + # Passes if actual contains all of the expected regardless of order. + # This works for collections. Pass in multiple args and it will only + # pass if all args are found in collection. + # + # NOTE: there is no should_not version of array.should =~ other_array + # + # == Examples + # + # [1,2,3].should =~ [1,2,3] # => would pass + # [1,2,3].should =~ [2,3,1] # => would pass + # [1,2,3,4].should =~ [1,2,3] # => would fail + # [1,2,2,3].should =~ [1,2,3] # => would fail + # [1,2,3].should =~ [1,2,3,4] # => would fail + OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray) + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/matcher.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/matcher.rb new file mode 100644 index 000000000..4756e2fc3 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/matcher.rb @@ -0,0 +1,132 @@ +module Spec + module Matchers + class Matcher + include Spec::Matchers::InstanceExec + include Spec::Matchers::Pretty + include Spec::Matchers + + attr_reader :expected, :actual + + def initialize(name, *expected, &declarations) + @name = name + @expected = expected + @actual = nil + @diffable = false + @expected_exception = nil + @messages = { + :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"}, + :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"}, + :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"} + } + making_declared_methods_public do + instance_exec(*@expected, &declarations) + end + end + + #Used internally by objects returns by +should+ and +should_not+. + def matches?(actual) + @actual = actual + if @expected_exception + begin + instance_exec(actual, &@match_block) + true + rescue @expected_exception + false + end + else + begin + instance_exec(actual, &@match_block) + rescue Spec::Expectations::ExpectationNotMetError + false + end + end + end + + # See Spec::Matchers + def match(&block) + @match_block = block + end + + # See Spec::Matchers + def match_unless_raises(exception=Exception, &block) + @expected_exception = exception + match(&block) + end + + # See Spec::Matchers + def failure_message_for_should(&block) + cache_or_call_cached(:failure_message_for_should, &block) + end + + # See Spec::Matchers + def failure_message_for_should_not(&block) + cache_or_call_cached(:failure_message_for_should_not, &block) + end + + # See Spec::Matchers + def description(&block) + cache_or_call_cached(:description, &block) + end + + #Used internally by objects returns by +should+ and +should_not+. + def diffable? + @diffable + end + + # See Spec::Matchers + def diffable + @diffable = true + end + + # See Spec::Matchers + def chain(method, &block) + self.class.class_eval do + define_method method do |*args| + block.call(*args) + self + end + end + end + + private + + def making_declared_methods_public # :nodoc: + # Our home-grown instance_exec in ruby 1.8.6 results in any methods + # declared in the block eval'd by instance_exec in the block to which we + # are yielding here are scoped private. This is NOT the case for Ruby + # 1.8.7 or 1.9. + # + # Also, due some crazy scoping that I don't understand, these methods + # are actually available in the specs (something about the matcher being + # defined in the scope of Spec::Matchers or within an example), so not + # doing the following will not cause specs to fail, but they *will* + # cause features to fail and that will make users unhappy. So don't. + orig_private_methods = private_methods + yield + st = (class << self; self; end) + (private_methods - orig_private_methods).each {|m| st.__send__ :public, m} + end + + def cache_or_call_cached(key, &block) + block ? cache(key, &block) : call_cached(key) + end + + def cache(key, &block) + @messages[key] = block + end + + def call_cached(key) + @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call + end + + def name_to_sentence + split_words(@name) + end + + def expected_to_sentence + to_sentence(@expected) + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/method_missing.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/method_missing.rb new file mode 100644 index 000000000..74aad8071 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/method_missing.rb @@ -0,0 +1,9 @@ +module Spec + module Matchers + def method_missing(sym, *args, &block) # :nodoc: + return Matchers::BePredicate.new(sym, *args, &block) if sym.to_s =~ /^be_/ + return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/ + super + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/operator_matcher.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/operator_matcher.rb new file mode 100644 index 000000000..a0465ae75 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/operator_matcher.rb @@ -0,0 +1,83 @@ +module Spec + module Matchers + + class OperatorMatcher + class << self + def registry + @registry ||= {} + end + + def register(klass, operator, matcher) + registry[klass] ||= {} + registry[klass][operator] = matcher + end + + def get(klass, operator) + matcher = registry[klass] && registry[klass][operator] + unless matcher + parent_class = registry.keys.detect {|pc| klass <= pc } + matcher = registry[parent_class] && registry[parent_class][operator] + end + matcher + end + end + + def initialize(actual) + @actual = actual + end + + def self.use_custom_matcher_or_delegate(operator) + define_method(operator) do |expected| + if matcher = OperatorMatcher.get(@actual.class, operator) + @actual.send(::Spec::Matchers.last_should, matcher.new(expected)) + else + eval_match(@actual, operator, expected) + end + end + end + + ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator| + use_custom_matcher_or_delegate operator + end + + def fail_with_message(message) + Spec::Expectations.fail_with(message, @expected, @actual) + end + + def description + "#{@operator} #{@expected.inspect}" + end + + private + + def eval_match(actual, operator, expected) + ::Spec::Matchers.last_matcher = self + @operator, @expected = operator, expected + __delegate_operator(actual, operator, expected) + end + + end + + class PositiveOperatorMatcher < OperatorMatcher #:nodoc: + def __delegate_operator(actual, operator, expected) + if actual.__send__(operator, expected) + true + elsif ['==','===', '=~'].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 < OperatorMatcher #:nodoc: + def __delegate_operator(actual, operator, expected) + return false unless actual.__send__(operator, expected) + return fail_with_message("expected not: #{operator} #{expected.inspect},\n got: #{operator.gsub(/./, ' ')} #{actual.inspect}") + end + + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/pretty.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/pretty.rb new file mode 100644 index 000000000..6db1d051a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/pretty.rb @@ -0,0 +1,37 @@ +module Spec + module Matchers + module Pretty + def split_words(sym) + sym.to_s.gsub(/_/,' ') + end + + def to_sentence(words=[]) + words = words.map{|w| w.inspect} + case words.length + when 0 + "" + when 1 + " #{words[0]}" + when 2 + " #{words[0]} and #{words[1]}" + else + " #{words[0...-1].join(', ')}, and #{words[-1]}" + end + end + + def _pretty_print(array) + result = "" + array.each_with_index do |item, index| + if index < (array.length - 2) + result << "#{item.inspect}, " + elsif index < (array.length - 1) + result << "#{item.inspect} and " + else + result << "#{item.inspect}" + end + end + result + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/raise_exception.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/raise_exception.rb new file mode 100644 index 000000000..66741c64d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/raise_exception.rb @@ -0,0 +1,131 @@ +module Spec + module Matchers + class RaiseException #:nodoc: + def initialize(expected_exception_or_message=Exception, expected_message=nil, &block) + @block = block + @actual_exception = nil + case expected_exception_or_message + when String, Regexp + @expected_exception, @expected_message = Exception, expected_exception_or_message + else + @expected_exception, @expected_message = expected_exception_or_message, expected_message + end + end + + def matches?(given_proc) + @raised_expected_exception = false + @with_expected_message = false + @eval_block = false + @eval_block_passed = false + begin + given_proc.call + rescue @expected_exception => @actual_exception + @raised_expected_exception = true + @with_expected_message = verify_message + rescue Exception => @actual_exception + # This clause should be empty, but rcov will not report it as covered + # unless something (anything) is executed within the clause + rcov_exception_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0" + end + + unless negative_expectation? + eval_block if @raised_expected_exception && @with_expected_message && @block + end + + (@raised_expected_exception & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false + end + + def eval_block + @eval_block = true + begin + @block[@actual_exception] + @eval_block_passed = true + rescue Exception => err + @actual_exception = err + end + end + + def verify_message + case @expected_message + when nil + true + when Regexp + @expected_message =~ @actual_exception.message + else + @expected_message == @actual_exception.message + end + end + + def failure_message_for_should + @eval_block ? @actual_exception.message : "expected #{expected_exception}#{given_exception}" + end + + def failure_message_for_should_not + "expected no #{expected_exception}#{given_exception}" + end + + def description + "raise #{expected_exception}" + end + + private + def expected_exception + case @expected_message + when nil + @expected_exception + when Regexp + "#{@expected_exception} with message matching #{@expected_message.inspect}" + else + "#{@expected_exception} with #{@expected_message.inspect}" + end + end + + def given_exception + @actual_exception.nil? ? " but nothing was raised" : ", got #{@actual_exception.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 + + # :call-seq: + # should raise_exception() + # should raise_exception(NamedError) + # should raise_exception(NamedError, String) + # should raise_exception(NamedError, Regexp) + # should raise_exception() { |exception| ... } + # should raise_exception(NamedError) { |exception| ... } + # should raise_exception(NamedError, String) { |exception| ... } + # should raise_exception(NamedError, Regexp) { |exception| ... } + # should_not raise_exception() + # should_not raise_exception(NamedError) + # should_not raise_exception(NamedError, String) + # should_not raise_exception(NamedError, Regexp) + # + # With no args, matches if any exception is raised. + # With a named exception, matches only if that specific exception is raised. + # With a named exception and messsage specified as a String, matches only if both match. + # With a named exception 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_exception + # lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError) + # lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError) { |exception| exception.data.should == 42 } + # lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, "that was too risky") + # lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, /oo ri/) + # + # lambda { do_something_risky }.should_not raise_exception + # lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError) + # lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, "that was too risky") + # lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, /oo ri/) + def raise_exception(exception=Exception, message=nil, &block) + Matchers::RaiseException.new(exception, message, &block) + end + + alias_method :raise_error, :raise_exception + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/respond_to.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/respond_to.rb new file mode 100644 index 000000000..9161cb94e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/respond_to.rb @@ -0,0 +1,71 @@ +module Spec + module Matchers + + class RespondTo #:nodoc: + def initialize(*names) + @names = names + @expected_arity = nil + @names_not_responded_to = [] + end + + def matches?(actual) + @actual = actual + @names.each do |name| + @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name) + end + return @names_not_responded_to.empty? + end + + def failure_message_for_should + "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}" + end + + def failure_message_for_should_not + "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}" + end + + def description + "respond to #{pp_names}#{with_arity}" + end + + def with(n) + @expected_arity = n + self + end + + def argument + self + end + alias :arguments :argument + + private + + def matches_arity?(actual, name) + @expected_arity.nil?? true : @expected_arity == actual.method(name).arity + end + + def with_arity + @expected_arity.nil?? "" : + " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}" + end + + def pp_names + # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here + @names.length == 1 ? "##{@names.first}" : @names.inspect + end + end + + # :call-seq: + # should respond_to(*names) + # should_not respond_to(*names) + # + # Matches if the target object responds to all of the names + # provided. Names can be Strings or Symbols. + # + # == Examples + # + def respond_to(*names) + Matchers::RespondTo.new(*names) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/satisfy.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/satisfy.rb new file mode 100644 index 000000000..58e3f56aa --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/satisfy.rb @@ -0,0 +1,47 @@ +module Spec + module Matchers + + class Satisfy #:nodoc: + def initialize(&block) + @block = block + end + + def matches?(actual, &block) + @block = block if block + @actual = actual + @block.call(actual) + end + + def failure_message_for_should + "expected #{@actual} to satisfy block" + end + + def failure_message_for_should_not + "expected #{@actual} not to satisfy block" + end + end + + # :call-seq: + # should satisfy {} + # should_not satisfy {} + # + # Passes if the submitted block returns true. Yields target to the + # block. + # + # Generally speaking, this should be thought of as a last resort when + # you can't find any other way to specify the behaviour you wish to + # specify. + # + # If you do find yourself in such a situation, you could always write + # a custom matcher, which would likely make your specs more expressive. + # + # == Examples + # + # 5.should satisfy { |n| + # n > 3 + # } + def satisfy(&block) + Matchers::Satisfy.new(&block) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/simple_matcher.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/simple_matcher.rb new file mode 100644 index 000000000..9c77c0732 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/simple_matcher.rb @@ -0,0 +1,134 @@ +module Spec + module Matchers + class SimpleMatcher + attr_writer :failure_message, :negative_failure_message, :description + + def initialize(description, &match_block) + @description = description + @match_block = match_block + @failure_message = @negative_failure_message = nil + end + + 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_for_should + @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}]) + end + + def failure_message_for_should_not + @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 + + # 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) + Spec.deprecate("simple_matcher", "Matcher DSL (http://rspec.rubyforge.org/rspec/1.3.0/classes/Spec/Matchers.html)") + SimpleMatcher.new(description, &match_block) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/throw_symbol.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/throw_symbol.rb new file mode 100644 index 000000000..2e5dd62f0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/throw_symbol.rb @@ -0,0 +1,100 @@ +module Spec + module Matchers + + class ThrowSymbol #:nodoc: + def initialize(expected_symbol = nil, expected_arg=nil) + @expected_symbol = expected_symbol + @expected_arg = expected_arg + @caught_symbol = @caught_arg = nil + end + + def matches?(given_proc) + begin + 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 + end + if @expected_symbol.nil? + !@caught_symbol.nil? + elsif @expected_arg.nil? + @caught_symbol == @expected_symbol + else + (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg) + end + end + + def failure_message_for_should + if @caught_symbol + "expected #{expected}, got #{@caught_symbol.inspect}" + else + "expected #{expected} but nothing was thrown" + end + end + + def failure_message_for_should_not + if @expected_symbol + "expected #{expected} not to be thrown" + else + "expected no Symbol, got :#{@caught_symbol}" + end + end + + def description + "throw #{expected}" + end + + private + + def expected + @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}" + end + + def args + @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}" + end + + end + + # :call-seq: + # should throw_symbol() + # should throw_symbol(:sym) + # should throw_symbol(:sym, arg) + # should_not throw_symbol() + # should_not throw_symbol(:sym) + # 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(expected_symbol = nil, expected_arg=nil) + Matchers::ThrowSymbol.new(expected_symbol, expected_arg) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/matchers/wrap_expectation.rb b/vendor/gems/rspec-1.3.1/lib/spec/matchers/wrap_expectation.rb new file mode 100644 index 000000000..95162cae1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/matchers/wrap_expectation.rb @@ -0,0 +1,55 @@ +module Spec + module Matchers + # wraps an expectation in a block that will return true if the + # expectation passes and false if it fails (without bubbling up + # the failure). + # + # This is intended to be used in the context of a simple matcher, + # and is especially useful for wrapping multiple expectations or + # one or more assertions from test/unit extensions when running + # with test/unit. + # + # == Examples + # + # def eat_cheese(cheese) + # simple_matcher do |mouse, matcher| + # matcher.failure_message = "expected #{mouse} to eat cheese" + # wrap_expectation do |matcher| + # assert_eats_cheese(mouse) + # end + # end + # end + # + # describe Mouse do + # it "eats cheese" do + # Mouse.new.should eat_cheese + # end + # end + # + # You might be wondering "why would I do this if I could just say" + # assert_eats_cheese?", a fair question, indeed. You might prefer + # to replace the word assert with something more aligned with the + # rest of your code examples. You are using rspec, after all. + # + # The other benefit you get is that you can use the negative version + # of the matcher: + # + # describe Cat do + # it "does not eat cheese" do + # Cat.new.should_not eat_cheese + # end + # end + # + # So in the event there is no assert_does_not_eat_cheese available, + # you're all set! + def wrap_expectation(matcher, &block) + begin + block.call(matcher) + return true + rescue Exception => e + matcher.failure_message = e.message + return false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks.rb new file mode 100644 index 000000000..339c0cc50 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks.rb @@ -0,0 +1,200 @@ +require 'spec/mocks/framework' +require 'spec/mocks/extensions/object' + +module Spec + # == Mocks and Stubs + # + # RSpec will create Mock Objects and Stubs for you at runtime, or attach stub/mock behaviour + # to any of your real objects (Partial Mock/Stub). Because the underlying implementation + # for mocks and stubs is the same, you can intermingle mock and stub + # behaviour in either dynamically generated mocks or your pre-existing classes. + # There is a semantic difference in how they are created, however, + # which can help clarify the role it is playing within a given spec. + # + # == Mock Objects + # + # Mocks are objects that allow you to set and verify expectations that they will + # receive specific messages during run time. They are very useful for specifying how the subject of + # the spec interacts with its collaborators. This approach is widely known as "interaction + # testing". + # + # Mocks are also very powerful as a design tool. As you are + # driving the implementation of a given class, Mocks provide an anonymous + # collaborator that can change in behaviour as quickly as you can write an expectation in your + # spec. This flexibility allows you to design the interface of a collaborator that often + # does not yet exist. As the shape of the class being specified becomes more clear, so do the + # requirements for its collaborators - often leading to the discovery of new types that are + # needed in your system. + # + # Read Endo-Testing[http://www.mockobjects.com/files/endotesting.pdf] for a much + # more in depth description of this process. + # + # == Stubs + # + # Stubs are objects that allow you to set "stub" responses to + # messages. As Martin Fowler points out on his site, + # mocks_arent_stubs[http://www.martinfowler.com/articles/mocksArentStubs.html]. + # Paraphrasing Fowler's paraphrasing + # of Gerard Meszaros: Stubs provide canned responses to messages they might receive in a test, while + # mocks allow you to specify and, subsquently, verify that certain messages should be received during + # the execution of a test. + # + # == Partial Mocks/Stubs + # + # RSpec also supports partial mocking/stubbing, allowing you to add stub/mock behaviour + # to instances of your existing classes. This is generally + # something to be avoided, because changes to the class can have ripple effects on + # seemingly unrelated specs. When specs fail due to these ripple effects, the fact + # that some methods are being mocked can make it difficult to understand why a + # failure is occurring. + # + # That said, partials do allow you to expect and + # verify interactions with class methods such as +#find+ and +#create+ + # on Ruby on Rails model classes. + # + # == Further Reading + # + # There are many different viewpoints about the meaning of mocks and stubs. If you are interested + # in learning more, here is some recommended reading: + # + # * Mock Objects: http://www.mockobjects.com/ + # * Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf + # * Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf + # * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html + # * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html + # + # == Creating a Mock + # + # You can create a mock in any specification (or setup) using: + # + # mock(name, options={}) + # + # The optional +options+ argument is a +Hash+. Currently the only supported + # option is +:null_object+. Setting this to true instructs the mock to ignore + # any messages it hasn’t been told to expect – and quietly return itself. For example: + # + # mock("person", :null_object => true) + # + # == Creating a Stub + # + # You can create a stub in any specification (or setup) using: + # + # stub(name, stub_methods_and_values_hash) + # + # For example, if you wanted to create an object that always returns + # "More?!?!?!" to "please_sir_may_i_have_some_more" you would do this: + # + # stub("Mr Sykes", :please_sir_may_i_have_some_more => "More?!?!?!") + # + # == Creating a Partial Mock + # + # You don't really "create" a partial mock, you simply add method stubs and/or + # mock expectations to existing classes and objects: + # + # Factory.should_receive(:find).with(id).and_return(value) + # obj.stub!(:to_i).and_return(3) + # etc ... + # + # == Expecting Messages + # + # my_mock.should_receive(:sym) + # my_mock.should_not_receive(:sym) + # + # == Expecting Arguments + # + # my_mock.should_receive(:sym).with(*args) + # my_mock.should_not_receive(:sym).with(*args) + # + # == Argument Matchers + # + # Arguments that are passed to #with are compared with actual arguments received + # using == by default. In cases in which you want to specify things about the arguments + # rather than the arguments themselves, you can use any of RSpec's Expression Matchers. + # They don't all make syntactic sense (they were primarily designed for use with + # Spec::Expectations), but you are free to create your own custom Spec::Matchers. + # + # Spec::Mocks does provide one additional Matcher method named #ducktype. + # + # In addition, Spec::Mocks adds some keyword Symbols that you can use to + # specify certain kinds of arguments: + # + # my_mock.should_receive(:sym).with(no_args()) + # my_mock.should_receive(:sym).with(any_args()) + # my_mock.should_receive(:sym).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric + # my_mock.should_receive(:sym).with(1, boolean(), "b") #2nd argument can true or false + # my_mock.should_receive(:sym).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp + # my_mock.should_receive(:sym).with(1, anything(), "b") #2nd argument can be anything at all + # my_mock.should_receive(:sym).with(1, ducktype(:abs, :div), "b") + # #2nd argument can be object that responds to #abs and #div + # + # == Receive Counts + # + # my_mock.should_receive(:sym).once + # my_mock.should_receive(:sym).twice + # my_mock.should_receive(:sym).exactly(n).times + # my_mock.should_receive(:sym).at_least(:once) + # my_mock.should_receive(:sym).at_least(:twice) + # my_mock.should_receive(:sym).at_least(n).times + # my_mock.should_receive(:sym).at_most(:once) + # my_mock.should_receive(:sym).at_most(:twice) + # my_mock.should_receive(:sym).at_most(n).times + # my_mock.should_receive(:sym).any_number_of_times + # + # == Ordering + # + # my_mock.should_receive(:sym).ordered + # my_mock.should_receive(:other_sym).ordered + # #This will fail if the messages are received out of order + # + # == Setting Reponses + # + # Whether you are setting a mock expectation or a simple stub, you can tell the + # object precisely how to respond: + # + # my_mock.should_receive(:sym).and_return(value) + # my_mock.should_receive(:sym).exactly(3).times.and_return(value1, value2, value3) + # # returns value1 the first time, value2 the second, etc + # my_mock.should_receive(:sym).and_return { ... } #returns value returned by the block + # my_mock.should_receive(:sym).and_raise(error) + # #error can be an instantiated object or a class + # #if it is a class, it must be instantiable with no args + # my_mock.should_receive(:sym).and_throw(:sym) + # my_mock.should_receive(:sym).and_yield(values,to,yield) + # my_mock.should_receive(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time) + # # for methods that yield to a block multiple times + # + # Any of these responses can be applied to a stub as well, but stubs do + # not support any qualifiers about the message received (i.e. you can't specify arguments + # or receive counts): + # + # my_mock.stub!(:sym).and_return(value) + # my_mock.stub!(:sym).and_return(value1, value2, value3) + # my_mock.stub!(:sym).and_raise(error) + # my_mock.stub!(:sym).and_throw(:sym) + # my_mock.stub!(:sym).and_yield(values,to,yield) + # my_mock.stub!(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time) + # + # == Arbitrary Handling + # + # Once in a while you'll find that the available expectations don't solve the + # particular problem you are trying to solve. Imagine that you expect the message + # to come with an Array argument that has a specific length, but you don't care + # what is in it. You could do this: + # + # my_mock.should_receive(:sym) do |arg| + # arg.should be_an_istance_of(Array) + # arg.length.should == 7 + # end + # + # Note that this would fail if the number of arguments received was different from + # the number of block arguments (in this case 1). + # + # == Combining Expectation Details + # + # Combining the message name with specific arguments, receive counts and responses + # you can get quite a bit of detail in your expectations: + # + # my_mock.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError) + module Mocks + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_expectation.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_expectation.rb new file mode 100644 index 000000000..b51b7bae5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_expectation.rb @@ -0,0 +1,51 @@ +module Spec + module Mocks + + class ArgumentExpectation + attr_reader :args + + def initialize(args, &block) + @args = args + @matchers_block = block + @match_any_args = false + @matchers = nil + + if ArgumentMatchers::AnyArgsMatcher === args.first + @match_any_args = true + elsif ArgumentMatchers::NoArgsMatcher === args.first + @matchers = [] + else + @matchers = args.collect {|arg| matcher_for(arg)} + end + end + + def matcher_for(arg) + return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg) + return ArgumentMatchers::RegexpMatcher.new(arg) if arg.is_a?(Regexp) + return ArgumentMatchers::EqualityProxy.new(arg) + end + + def is_matcher?(obj) + return obj.respond_to?(:matches?) & obj.respond_to?(:description) + end + + def args_match?(given_args) + match_any_args? || matchers_block_matches?(given_args) || matchers_match?(given_args) + end + + def matchers_block_matches?(given_args) + @matchers_block ? @matchers_block.call(*given_args) : nil + end + + def matchers_match?(given_args) + @matchers == given_args + end + + def match_any_args? + @match_any_args + end + + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_matchers.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_matchers.rb new file mode 100644 index 000000000..f56551f21 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/argument_matchers.rb @@ -0,0 +1,237 @@ +module Spec + module Mocks + + # ArgumentMatchers are messages that you can include in message + # expectations to match arguments against a broader check than simple + # equality. + # + # With the exception of any_args() and no_args(), the matchers + # are all positional - they match against the arg in the given position. + module ArgumentMatchers + + class AnyArgsMatcher + def description + "any args" + end + end + + class NoArgsMatcher + def description + "no args" + end + end + + class AnyArgMatcher + def initialize(ignore) + end + + def ==(other) + true + end + + def description + "anything" + end + end + + class RegexpMatcher + def initialize(regexp) + @regexp = regexp + end + + def ==(value) + return value =~ @regexp unless value.is_a?(Regexp) + value == @regexp + end + end + + class BooleanMatcher + def initialize(ignore) + end + + def ==(value) + TrueClass === value || FalseClass === value + end + end + + class HashIncludingMatcher + def initialize(expected) + @expected = expected + end + + def ==(actual) + @expected.each do | key, value | + return false unless actual.has_key?(key) && value == actual[key] + end + true + rescue NoMethodError => ex + return false + end + + def description + "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})" + end + end + + class HashNotIncludingMatcher + def initialize(expected) + @expected = expected + end + + def ==(actual) + @expected.each do | key, value | + return false if actual.has_key?(key) && value == actual[key] + end + true + rescue NoMethodError => ex + return false + end + + def description + "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})" + end + end + + class DuckTypeMatcher + def initialize(*methods_to_respond_to) + @methods_to_respond_to = methods_to_respond_to + end + + def ==(value) + @methods_to_respond_to.all? { |sym| value.respond_to?(sym) } + end + end + + class MatcherMatcher + def initialize(matcher) + @matcher = matcher + end + + def ==(value) + @matcher.matches?(value) + end + end + + class EqualityProxy + def initialize(given) + @given = given + end + + def ==(expected) + @given == expected + end + end + + class InstanceOf + def initialize(klass) + @klass = klass + end + + def ==(actual) + actual.instance_of?(@klass) + end + end + + class KindOf + def initialize(klass) + @klass = klass + end + + def ==(actual) + actual.kind_of?(@klass) + end + end + + # :call-seq: + # object.should_receive(:message).with(no_args()) + # + # Passes if no arguments are passed along with the message + def no_args + NoArgsMatcher.new + end + + # :call-seq: + # object.should_receive(:message).with(any_args()) + # + # Passes if object receives :message with any args at all. This is + # really a more explicit variation of object.should_receive(:message) + def any_args + AnyArgsMatcher.new + end + + # :call-seq: + # object.should_receive(:message).with(anything()) + # + # Passes as long as there is an argument. + def anything + AnyArgMatcher.new(nil) + end + + # :call-seq: + # object.should_receive(:message).with(duck_type(:hello)) + # object.should_receive(:message).with(duck_type(:hello, :goodbye)) + # + # Passes if the argument responds to the specified messages. + # + # == Examples + # + # array = [] + # display = mock('display') + # display.should_receive(:present_names).with(duck_type(:length, :each)) + # => passes + def duck_type(*args) + DuckTypeMatcher.new(*args) + end + + # :call-seq: + # object.should_receive(:message).with(boolean()) + # + # Passes if the argument is boolean. + def boolean + BooleanMatcher.new(nil) + end + + # :call-seq: + # object.should_receive(:message).with(hash_including(:key => val)) + # object.should_receive(:message).with(hash_including(:key)) + # object.should_receive(:message).with(hash_including(:key, :key2 => val2)) + # Passes if the argument is a hash that includes the specified key(s) or key/value + # pairs. If the hash includes other keys, it will still pass. + def hash_including(*args) + HashIncludingMatcher.new(anythingize_lonely_keys(*args)) + end + + # :call-seq: + # object.should_receive(:message).with(hash_not_including(:key => val)) + # object.should_receive(:message).with(hash_not_including(:key)) + # object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2)) + # + # Passes if the argument is a hash that doesn't include the specified key(s) or key/value + def hash_not_including(*args) + HashNotIncludingMatcher.new(anythingize_lonely_keys(*args)) + end + + # Passes if arg.instance_of?(klass) + def instance_of(klass) + InstanceOf.new(klass) + end + + alias_method :an_instance_of, :instance_of + + # Passes if arg.kind_of?(klass) + def kind_of(klass) + KindOf.new(klass) + end + + alias_method :a_kind_of, :kind_of + + private + + def anythingize_lonely_keys(*args) + hash = args.last.class == Hash ? args.delete_at(-1) : {} + args.each { | arg | hash[arg] = anything } + hash + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/error_generator.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/error_generator.rb new file mode 100644 index 000000000..f63811fed --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/error_generator.rb @@ -0,0 +1,92 @@ +module Spec + module Mocks + class ErrorGenerator + attr_writer :opts + + def initialize(target, name, options={}) + @declared_as = options[:__declared_as] || 'Mock' + @target = target + @name = name + end + + def opts + @opts ||= {} + end + + def raise_unexpected_message_error(sym, *args) + __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}" + end + + def raise_unexpected_message_args_error(expectation, *args) + expected_args = format_args(*expectation.expected_args) + actual_args = args.empty? ? "(no args)" : format_args(*args) + __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n expected: #{expected_args}\n got: #{actual_args}" + end + + def raise_expectation_error(sym, expected_received_count, actual_received_count, *args) + __raise "#{intro} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{count_message(actual_received_count)}" + end + + def raise_out_of_order_error(sym) + __raise "#{intro} received :#{sym} out of order" + end + + def raise_block_failed_error(sym, detail) + __raise "#{intro} received :#{sym} but passed block failed with: #{detail}" + end + + def raise_missing_block_error(args_to_yield) + __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed" + end + + def raise_wrong_arity_error(args_to_yield, arity) + __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}" + end + + private + + def intro + if @name + "#{@declared_as} #{@name.inspect}" + elsif Mock === @target + @declared_as + elsif Class === @target + "<#{@target.inspect} (class)>" + elsif @target + @target + else + "nil" + end + end + + def __raise(message) + message = opts[:message] unless opts[:message].nil? + Kernel::raise(Spec::Mocks::MockExpectationError, message) + end + + def arg_message(*args) + " with " + format_args(*args) + end + + def format_args(*args) + args.empty? ? "(no args)" : "(" + arg_list(*args) + ")" + end + + def arg_list(*args) + args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ") + end + + def count_message(count) + return "at least #{pretty_print(count.abs)}" if count < 0 + return pretty_print(count) + end + + def pretty_print(count) + return "once" if count == 1 + return "twice" if count == 2 + return "#{count} times" + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/errors.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/errors.rb new file mode 100644 index 000000000..560b66a93 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/errors.rb @@ -0,0 +1,10 @@ +module Spec + module Mocks + class MockExpectationError < Exception + end + + class AmbiguousReturnError < StandardError + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/example_methods.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/example_methods.rb new file mode 100644 index 000000000..f6c68ab6a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/example_methods.rb @@ -0,0 +1,69 @@ +module Spec + module Mocks + module ExampleMethods + include Spec::Mocks::ArgumentMatchers + + # Shortcut for creating an instance of Spec::Mocks::Mock. + # + # +name+ is used for failure reporting, so you should use the + # role that the double 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 + # + # thing = double("thing", :a => "A") + # thing.a == "A" => true + # + # person = double("thing", :name => "Joe", :email => "joe@domain.com") + # person.name => "Joe" + # person.email => "joe@domain.com" + def double(*args) + __declare_double('Double', *args) + end + + # Alias for double + def mock(*args) + __declare_double('Mock', *args) + end + + # Alias for double + def stub(*args) + __declare_double('Stub', *args) + end + + def __declare_double(declared_as, *args) # :nodoc: + args << {} unless Hash === args.last + args.last[:__declared_as] = declared_as + Spec::Mocks::Mock.new(*args) + end + + # DEPRECATED - use double('name').as_null_object instead + # + # 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') + Spec.warn(<<-WARNING) + +DEPRECATION: stub_everything('#{name}') is deprecated and will be removed +from a future version of rspec. Please use double('#{name}').as_null_object +(or stub('#{name}').as_null_object or mock('#{name}').as_null_object instead. + +WARNING + 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 +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions.rb new file mode 100644 index 000000000..6fd51a272 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions.rb @@ -0,0 +1 @@ +require 'spec/mocks/extensions/object' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions/object.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions/object.rb new file mode 100644 index 000000000..4b7531066 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/extensions/object.rb @@ -0,0 +1,3 @@ +class Object + include Spec::Mocks::Methods +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/framework.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/framework.rb new file mode 100644 index 000000000..e25778655 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/framework.rb @@ -0,0 +1,15 @@ +# Require everything except the global extensions of class and object. This +# supports wrapping rspec's mocking functionality without invading every +# object in the system. + +require 'spec/mocks/methods' +require 'spec/mocks/argument_matchers' +require 'spec/mocks/example_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/space' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/message_expectation.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/message_expectation.rb new file mode 100644 index 000000000..cd8dc0f97 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/message_expectation.rb @@ -0,0 +1,344 @@ +module Spec + module Mocks + + 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={}, &implementation) + @error_generator = error_generator + @error_generator.opts = opts + @expected_from = expected_from + @sym = sym + @method_block = method_block + @actual_received_count = 0 + @expected_received_count = expected_received_count + @args_expectation = ArgumentExpectation.new([ArgumentMatchers::AnyArgsMatcher.new]) + @consecutive = false + @exception_to_raise = nil + @symbol_to_throw = nil + @order_group = expectation_ordering + @at_least = nil + @at_most = nil + @args_to_yield = [] + @failed_fast = nil + @args_to_yield_were_cloned = false + @return_block = implementation + @eval_context = nil + 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 + child.clear_actual_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 + + def and_return(*values, &return_block) + Kernel::raise AmbiguousReturnError unless @method_block.nil? + case values.size + when 0 then value = nil + when 1 then value = values[0] + else + value = values + @consecutive = true + @expected_received_count = values.size if !ignoring_args? && + @expected_received_count < values.size + end + @return_block = block_given? ? return_block : lambda { value } + end + + # :call-seq: + # and_raise() + # and_raise(Exception) #any exception class + # and_raise(exception) #any exception object + # + # == Warning + # + # When you pass an exception class, the MessageExpectation will + # raise an instance of it, creating it with +new+. If the exception + # class initializer requires any parameters, you must pass in an + # instance and not the class. + def and_raise(exception=Exception) + @exception_to_raise = exception + end + + def and_throw(symbol) + @symbol_to_throw = symbol + end + + def and_yield(*args, &block) + if @args_to_yield_were_cloned + @args_to_yield.clear + @args_to_yield_were_cloned = false + end + + if block + require 'spec/extensions/instance_exec' + @eval_context = Object.new + @eval_context.extend Spec::Matchers::InstanceExec + yield @eval_context + end + @args_to_yield << args + self + end + + def matches(sym, 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? + default_return_val = invoke_method_block(*args) + elsif @args_to_yield.size > 0 || @eval_context + 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 + + def invoke_return_block(*args, &block) + args << block unless block.nil? + # Ruby 1.9 - when we set @return_block to return values + # regardless of arguments, any arguments will result in + # a "wrong number of arguments" error + @return_block.arity == 0 ? @return_block.call : @return_block.call(*args) + end + + protected + + def invoke_method_block(*args) + begin + @method_block.call(*args) + rescue => detail + @error_generator.raise_block_failed_error @sym, detail.message + end + end + + def invoke_with_yield(&block) + if block.nil? + @error_generator.raise_missing_block_error @args_to_yield + end + 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 + value = eval_block(*args_to_yield_this_time, &block) + end + value + end + + def eval_block(*args, &block) + if @eval_context + @eval_context.instance_exec(*args, &block) + else + block.call(*args) + end + end + + def invoke_consecutive_return_block(*args, &block) + value = invoke_return_block(*args, &block) + index = [@actual_received_count, value.size-1].min + value[index] + 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?(sym) + @sym == sym + end + + def matches_name_but_not_args(sym, args) + matches_name?(sym) and not @args_expectation.args_match?(args) + end + + def verify_messages_received + return if expected_messages_received? || failed_fast? + + generate_error + rescue Spec::Mocks::MockExpectationError => error + error.backtrace.insert(0, @expected_from) + 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 + + def matches_at_least_count? + @at_least && @actual_received_count >= @expected_received_count + end + + def matches_at_most_count? + @at_most && @actual_received_count <= @expected_received_count + end + + def matches_exact_count? + @expected_received_count == @actual_received_count + end + + def similar_messages + @similar_messages ||= [] + end + + def advise(args, block) + similar_messages << args + end + + def generate_error + 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) + end + end + + def with(*args, &block) + @args_expectation = ArgumentExpectation.new(args, &block) + self + end + + def exactly(n) + set_expected_received_count :exactly, n + self + end + + def at_least(n) + set_expected_received_count :at_least, n + self + end + + def at_most(n) + set_expected_received_count :at_most, n + self + end + + def times(&block) + @method_block = block if block + self + end + + def any_number_of_times(&block) + @method_block = block if block + @expected_received_count = :any + self + end + + def never + @expected_received_count = 0 + self + end + + def once(&block) + @method_block = block if block + @expected_received_count = 1 + self + end + + def twice(&block) + @method_block = block if block + @expected_received_count = 2 + self + end + + def ordered(&block) + @method_block = block if block + @order_group.register(self) + @ordered = true + self + end + + def negative_expectation_for?(sym) + return false + end + + protected + def set_expected_received_count(relativity, n) + @at_least = (relativity == :at_least) + @at_most = (relativity == :at_most) + @expected_received_count = case n + when Numeric + n + when :once + 1 + when :twice + 2 + end + end + + def clear_actual_received_count! + @actual_received_count = 0 + end + + end + + class NegativeMessageExpectation < MessageExpectation + def initialize(message, expectation_ordering, expected_from, sym, method_block) + super(message, expectation_ordering, expected_from, sym, method_block, 0) + end + + def negative_expectation_for?(sym) + return @sym == sym + end + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/methods.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/methods.rb new file mode 100644 index 000000000..5d94cac37 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/methods.rb @@ -0,0 +1,94 @@ +module Spec + module Mocks + module Methods + def should_receive(sym, opts={}, &block) + __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym.to_sym, opts, &block) + end + + def should_not_receive(sym, &block) + __mock_proxy.add_negative_message_expectation(caller(1)[0], sym.to_sym, &block) + end + + def stub!(sym_or_hash, opts={}, &block) + 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, &block) + end + end + + alias_method :stub, :stub! + + def unstub!(message) + __mock_proxy.remove_stub(message) + end + + alias_method :unstub, :unstub! + + # :call-seq: + # object.stub_chain(:first, :second, :third).and_return(:this) + # + # Supports stubbing a chain of methods. Each argument represents + # a method name to stub, and each one returns a proxy object that + # can accept more stubs, until the last, which returns whatever + # is passed to +and_return_. + # + # == Examples + # + # # with this in an example ... + # article = double('article') + # Article.stub_chain(:authored_by, :published, :recent).and_return([article]) + # # then this will return an Array with the article double in it: + # Article.authored_by(params[:author_id]).published.recent + def stub_chain(*methods) + if methods.length > 1 + if matching_stub = __mock_proxy.find_matching_method_stub(methods[0]) + methods.shift + matching_stub.invoke_return_block.stub_chain(*methods) + else + next_in_chain = Object.new + stub!(methods.shift) {next_in_chain} + next_in_chain.stub_chain(*methods) + end + else + stub!(methods.shift) + end + end + + # Record and otherwise ignore all messages that aren't specified, + # with +stub+, +stub!+, or +should_receive+. + # + # == Returns + # self + def as_null_object + __mock_proxy.as_null_object + end + + def null_object? + __mock_proxy.null_object? + end + + def received_message?(sym, *args, &block) #:nodoc: + __mock_proxy.received_message?(sym.to_sym, *args, &block) + end + + def rspec_verify #:nodoc: + __mock_proxy.verify + end + + def rspec_reset #:nodoc: + __mock_proxy.reset + end + + private + + def __mock_proxy + if Mock === self + @mock_proxy ||= Proxy.new(self, @name, @options) + else + @mock_proxy ||= Proxy.new(self) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/mock.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/mock.rb new file mode 100644 index 000000000..35a6c798e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/mock.rb @@ -0,0 +1,71 @@ +module Spec + module Mocks + class Mock + include Methods + + # Creates a new mock with a +name+ (that will be used in error messages + # only) == Options: + # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving + # null object allowing any message to be sent to it. + def initialize(name=nil, stubs_and_options={}) + if name.is_a?(Hash) && stubs_and_options.empty? + stubs_and_options = name + @name = nil + else + @name = name + end + @options = extract_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. + def ==(other) + other == __mock_proxy + end + + def inspect + "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>" + end + + def to_s + inspect.gsub('<','[').gsub('>',']') + end + + private + + def method_missing(sym, *args, &block) + __mock_proxy.record_message_received(sym, args, block) + begin + return self if __mock_proxy.null_object? + super(sym, *args, &block) + rescue NameError + __mock_proxy.raise_unexpected_message_error sym, *args + end + end + + def extract_options(stubs_and_options) + options = {} + extract_option(stubs_and_options, options, :null_object) + extract_option(stubs_and_options, options, :__declared_as, 'Mock') + options + end + + def extract_option(source, target, key, default=nil) + if source[key] + target[key] = source.delete(key) + elsif default + target[key] = default + end + end + + def assign_stubs(stubs) + stubs.each_pair do |message, response| + stub!(message).and_return(response) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/order_group.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/order_group.rb new file mode 100644 index 000000000..9983207eb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/order_group.rb @@ -0,0 +1,29 @@ +module Spec + module Mocks + class OrderGroup + def initialize error_generator + @error_generator = error_generator + @ordering = Array.new + end + + def register(expectation) + @ordering << expectation + end + + def ready_for?(expectation) + return @ordering.first == expectation + end + + def consume + @ordering.shift + end + + def handle_order_constraint expectation + return unless @ordering.include? expectation + return consume if ready_for?(expectation) + @error_generator.raise_out_of_order_error expectation.sym + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/proxy.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/proxy.rb new file mode 100644 index 000000000..6c29a9cdd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/proxy.rb @@ -0,0 +1,268 @@ +module Spec + module Mocks + class Proxy + 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=nil, options={}) + @target = target + @name = name + @error_generator = ErrorGenerator.new target, name, options + @expectation_ordering = OrderGroup.new @error_generator + @expectations = [] + @messages_received = [] + @stubs = [] + @proxied_methods = [] + @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS + @already_proxied_respond_to = false + end + + 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) + __add sym + warn_if_nil_class sym + @expectations << build_expectation(expected_from, sym, opts, &block) + @expectations.last + end + + def build_expectation(expected_from, sym, opts, &block) + if stub = find_matching_method_stub(sym) + stub.build_child(expected_from, block_given?? block : nil, 1, opts) + else + MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts) + end + 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 + + def add_stub(expected_from, sym, opts={}, &implementation) + __add sym + @stubs.unshift MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, nil, :any, opts, &implementation) + @stubs.first + end + + def remove_stub(message) + message = message.to_sym + if stub_to_remove = @stubs.detect { |s| s.matches_name?(message) } + reset_proxied_method(message) + @stubs.delete(stub_to_remove) + else + raise MockExpectationError, "The method `#{message}` was not stubbed or was already unstubbed" + end + end + + def verify #:nodoc: + verify_expectations + ensure + reset + end + + def reset + clear_expectations + clear_stubs + reset_proxied_methods + clear_proxied_methods + reset_nil_expectations_warning + end + + def received_message?(sym, *args, &block) + @messages_received.any? {|array| array == [sym, args, block]} + end + + def has_negative_expectation?(sym) + @expectations.any? {|expectation| expectation.negative_expectation_for?(sym)} + end + + def record_message_received(sym, args, block) + @messages_received << [sym, args, block] + end + + def message_received(sym, *args, &block) + expectation = find_matching_expectation(sym, *args) + stub = find_matching_method_stub(sym, *args) + + if ok_to_invoke_stub?(stub, expectation) + record_stub(stub, sym, args, &block) + elsif expectation + invoke_expectation(expectation, *args, &block) + elsif expectation = find_almost_matching_expectation(sym, *args) + record_almost_matching_expectation(expectation, sym, *args, &block) + elsif @target.is_a?(Class) + @target.superclass.send(sym, *args, &block) + else + @target.__send__ :method_missing, sym, *args, &block + end + end + + def record_stub(stub, sym, args, &block) + almost_matching_expectation(sym, *args) do |e| + e.advise(args, block) + end + stub.invoke(*args, &block) + end + + def invoke_expectation(expectation, *args, &block) + expectation.invoke(*args, &block) + end + + def record_almost_matching_expectation(expectation, sym, *args, &block) + expectation.advise(args, block) + unless (null_object? or has_negative_expectation?(sym)) + raise_unexpected_message_args_error(expectation, *args) + end + end + + def ok_to_invoke_stub?(stub, expectation) + stub && (!expectation || expectation.called_max_times?) + end + + def raise_unexpected_message_args_error(expectation, *args) + @error_generator.raise_unexpected_message_args_error expectation, *args + end + + def raise_unexpected_message_error(sym, *args) + @error_generator.raise_unexpected_message_error sym, *args + end + + def find_matching_method_stub(sym, *args) + @stubs.find {|stub| stub.matches(sym, args)} + end + + private + + def __add(sym) + $rspec_mocks.add(@target) unless $rspec_mocks.nil? + 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) + unless @proxied_methods.include?(sym) + visibility_string = "#{visibility(sym)} :#{sym}" + if target_responds_to?(sym) + munged_sym = munge(sym) + target_metaclass.instance_eval do + alias_method munged_sym, sym if method_defined?(sym) + end + @proxied_methods << sym + end + target_metaclass.class_eval(<<-EOF, __FILE__, __LINE__) + def #{sym}(*args, &block) + __mock_proxy.message_received :#{sym}, *args, &block + end + #{visibility_string} + EOF + end + end + + def target_responds_to?(sym) + return @target.__send__(munge(:respond_to?),sym) if @already_proxied_respond_to + return @already_proxied_respond_to = true if sym == :respond_to? + return @target.respond_to?(sym, 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) + "proxied_by_rspec__#{sym}" + end + + def clear_expectations + @expectations.clear + end + + def clear_stubs + @stubs.clear + end + + def clear_proxied_methods + @proxied_methods.clear + end + + def target_metaclass + class << @target; self; end + end + + def verify_expectations + @expectations.map {|e| e.verify_messages_received} + end + + def reset_proxied_methods + @proxied_methods.map {|sym| reset_proxied_method(sym)} + end + + def reset_proxied_method(sym) + munged_sym = munge(sym) + target_metaclass.instance_eval do + remove_method sym + if method_defined?(munged_sym) + alias_method sym, munged_sym + remove_method munged_sym + 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) && !expectation.called_max_times?} || + @expectations.find {|expectation| expectation.matches(sym, args)} + end + + def almost_matching_expectation(sym, *args, &block) + if e = find_almost_matching_expectation(sym, *args) + yield e + end + end + + def find_almost_matching_expectation(sym, *args) + @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)} + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/mocks/space.rb b/vendor/gems/rspec-1.3.1/lib/spec/mocks/space.rb new file mode 100644 index 000000000..3e13224c7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/mocks/space.rb @@ -0,0 +1,28 @@ +module Spec + module Mocks + class Space + def add(obj) + mocks << obj unless mocks.detect {|m| m.equal? obj} + end + + def verify_all + mocks.each do |mock| + mock.rspec_verify + end + end + + def reset_all + mocks.each do |mock| + mock.rspec_reset + end + mocks.clear + end + + private + + def mocks + @mocks ||= [] + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/rake/spectask.rb b/vendor/gems/rspec-1.3.1/lib/spec/rake/spectask.rb new file mode 100644 index 000000000..9049fd08e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/rake/spectask.rb @@ -0,0 +1,230 @@ +#!/usr/bin/env ruby + +# Define a task library for running RSpec contexts. + +require 'rake' +require 'rake/tasklib' + +module Spec + module Rake + + # A Rake task that runs a set of specs. + # + # Example: + # + # Spec::Rake::SpecTask.new do |t| + # t.warning = true + # t.rcov = true + # end + # + # This will create a task that can be run with: + # + # rake spec + # + # If rake is invoked with a "SPEC=filename" command line option, + # then the list of spec files will be overridden to include only the + # filename specified on the command line. This provides an easy way + # to run just one spec. + # + # If rake is invoked with a "SPEC_OPTS=options" command line option, + # then the given options will override the value of the +spec_opts+ + # attribute. + # + # If rake is invoked with a "RCOV_OPTS=options" command line option, + # then the given options will override the value of the +rcov_opts+ + # attribute. + # + # Examples: + # + # rake spec # run specs normally + # rake spec SPEC=just_one_file.rb # run just one spec file. + # rake spec SPEC_OPTS="--diff" # enable diffing + # rake spec RCOV_OPTS="--aggregate myfile.txt" # see rcov --help for details + # + # Each attribute of this task may be a proc. This allows for lazy evaluation, + # which is sometimes handy if you want to defer the evaluation of an attribute value + # until the task is run (as opposed to when it is defined). + # + # This task can also be used to run existing Test::Unit tests and get RSpec + # output, for example like this: + # + # require '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 + def self.attr_accessor(*names) + super(*names) + names.each do |name| + module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs + end + end + + # Name of spec task. (default is :spec) + attr_accessor :name + + # Array of directories to be added to $LOAD_PATH before running the + # specs. Defaults to ['<the absolute path to RSpec's lib directory>'] + attr_accessor :libs + + # If true, requests that the specs be run with the warning flag set. + # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false. + attr_accessor :warning + + # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb') + # Setting the SPEC environment variable overrides this. + attr_accessor :pattern + + # Array of commandline options to pass to RSpec. Defaults to []. + # Setting the SPEC_OPTS environment variable overrides this. + attr_accessor :spec_opts + + # Whether or not to use RCov (default is false) + # See http://eigenclass.org/hiki.rb?rcov + attr_accessor :rcov + + # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec']. + # Ignored if rcov=false + # Setting the RCOV_OPTS environment variable overrides this. + attr_accessor :rcov_opts + + # Directory where the RCov report is written. Defaults to "coverage" + # Ignored if rcov=false + attr_accessor :rcov_dir + + # Array of commandline options to pass to ruby. Defaults to []. + attr_accessor :ruby_opts + + # Whether or not to fail Rake when an error occurs (typically when specs fail). + # Defaults to true. + attr_accessor :fail_on_error + + # A message to print to stderr when there are failures. + attr_accessor :failure_message + + # Where RSpec's output is written. Defaults to $stdout. + # DEPRECATED. Use --format FORMAT:WHERE in spec_opts. + attr_accessor :out + + # Explicitly define the list of spec files to be included in a + # spec. +spec_files+ is expected to be an array of file names (a + # FileList is acceptable). If both +pattern+ and +spec_files+ are + # used, then the list of spec files is the union of the two. + # Setting the SPEC environment variable overrides this. + attr_accessor :spec_files + + # Use verbose output. If this is set to true, the task will print + # the executed spec command to stdout. Defaults to false. + attr_accessor :verbose + + # Explicitly define the path to the ruby binary, or its proxy (e.g. multiruby) + attr_accessor :ruby_cmd + + # Defines a new task, using the name +name+. + def initialize(name=:spec) + @name = name + @libs = ['lib'] + @pattern = nil + @spec_files = nil + @spec_opts = [] + @warning = false + @ruby_opts = [] + @fail_on_error = true + @rcov = false + @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb'] + @rcov_dir = "coverage" + + yield self if block_given? + @pattern = 'spec/**/*_spec.rb' if pattern.nil? && spec_files.nil? + define + end + + def define # :nodoc: + spec_script = File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","bin","spec")) + + lib_path = libs.join(File::PATH_SEPARATOR) + actual_name = Hash === name ? name.keys.first : name + unless ::Rake.application.last_comment + desc "Run specs" + (rcov ? " using RCov" : "") + end + task name do + RakeFileUtils.verbose(verbose) do + unless spec_file_list.empty? + # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts] + # or + # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts] + cmd_parts = [ruby_cmd || 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_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 + 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 + end + end + end + end + + if rcov + desc "Remove rcov products for #{actual_name}" + task paste("clobber_", actual_name) do + rm_r rcov_dir rescue nil + end + + clobber_task = paste("clobber_", actual_name) + task :clobber => [clobber_task] + + task actual_name => clobber_task + end + self + end + + def rcov_option_list # :nodoc: + if rcov + ENV['RCOV_OPTS'] || rcov_opts.join(" ") || "" + else + "" + end + end + + def spec_option_list # :nodoc: + STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS'] + ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || "" + end + + def evaluate(o) # :nodoc: + case o + when Proc then o.call + else o + end + end + + def spec_file_list # :nodoc: + if ENV['SPEC'] + FileList[ ENV['SPEC'] ] + else + result = [] + result += spec_files.to_a if spec_files + result += FileList[ pattern ].to_a if pattern + FileList[result] + end + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/rake/verify_rcov.rb b/vendor/gems/rspec-1.3.1/lib/spec/rake/verify_rcov.rb new file mode 100644 index 000000000..199bd8546 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/rake/verify_rcov.rb @@ -0,0 +1,52 @@ +module RCov + # A task that can verify that the RCov coverage doesn't + # drop below a certain threshold. It should be run after + # running Spec::Rake::SpecTask. + class VerifyTask < Rake::TaskLib + # Name of the task. Defaults to :verify_rcov + attr_accessor :name + + # Path to the index.html file generated by RCov, which + # is the file containing the total coverage. + # Defaults to 'coverage/index.html' + attr_accessor :index_html + + # Whether or not to output details. Defaults to true. + attr_accessor :verbose + + # The threshold value (in percent) for coverage. If the + # actual coverage is not equal to this value, the task will raise an + # exception. + attr_accessor :threshold + + # Require the threshold value be met exactly. This is the default. + attr_accessor :require_exact_threshold + + def initialize(name=:verify_rcov) + @name = name + @index_html = 'coverage/index.html' + @verbose = true + @require_exact_threshold = true + yield self if block_given? + raise "Threshold must be set" if @threshold.nil? + define + end + + def define + desc "Verify that rcov coverage is at least #{threshold}%" + task @name do + total_coverage = 0 + + File.open(index_html).each_line do |line| + if line =~ /<tt class='coverage_total'>\s*(\d+\.\d+)%\s*<\/tt>/ + total_coverage = $1.to_f + break + end + end + puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose + raise "Coverage must be at least #{threshold}% but was #{total_coverage}%" if total_coverage < threshold + raise "Coverage has increased above the threshold of #{threshold}% to #{total_coverage}%. You should update your threshold value." if (total_coverage > threshold) and require_exact_threshold + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/ruby.rb b/vendor/gems/rspec-1.3.1/lib/spec/ruby.rb new file mode 100644 index 000000000..863877c7f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/ruby.rb @@ -0,0 +1,9 @@ +module Spec + module Ruby + class << self + def version + RUBY_VERSION + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner.rb new file mode 100644 index 000000000..519b536e2 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner.rb @@ -0,0 +1,66 @@ +require 'spec/runner/configuration' +require 'spec/runner/options' +require 'spec/runner/option_parser' +require 'spec/runner/example_group_runner' +require 'spec/runner/command_line' +require 'spec/runner/drb_command_line' +require 'spec/runner/backtrace_tweaker' +require 'spec/runner/reporter' +require 'spec/runner/line_number_query' +require 'spec/runner/class_and_arguments_parser' +require 'spec/runner/extensions/kernel' + +module Spec + module Runner + + class ExampleGroupCreationListener + def register_example_group(klass) + Spec::Runner.options.add_example_group klass + end + end + + Spec::Example::ExampleGroupFactory.example_group_creation_listeners << ExampleGroupCreationListener.new + + class << self + def configuration # :nodoc: + @configuration ||= Spec::Runner::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::Runner::Configuration instance. See its RDoc + # for details about what you can do with it. + # + def configure + yield configuration + end + + def autorun # :nodoc: + at_exit {exit run unless $!} + end + + def options # :nodoc: + @options ||= begin + parser = ::Spec::Runner::OptionParser.new($stderr, $stdout) + parser.order!(ARGV) + parser.options + end + end + + def use options + @options = options + end + + def run + options.examples_run? || options.run_examples + end + + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/backtrace_tweaker.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/backtrace_tweaker.rb new file mode 100644 index 000000000..5f19171bf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/backtrace_tweaker.rb @@ -0,0 +1,78 @@ +module Spec + module Runner + class BacktraceTweaker + def initialize(*patterns) + @ignore_patterns = [] + end + + def clean_up_double_slashes(line) + line.gsub!('//','/') + end + + def ignore_patterns(*patterns) + # do nothing. Only QuietBacktraceTweaker ignores patterns. + end + + def ignored_patterns + [] + end + + def tweak_backtrace(error) + return if error.backtrace.nil? + tweaked = error.backtrace.collect do |message| + clean_up_double_slashes(message) + kept_lines = message.split("\n").select do |line| + ignored_patterns.each do |ignore| + break if line =~ ignore + end + end + kept_lines.empty?? nil : kept_lines.join("\n") + end + error.set_backtrace(tweaked.select {|line| line}) + end + end + + class NoisyBacktraceTweaker < BacktraceTweaker + end + + # Tweaks raised Exceptions to mask noisy (unneeded) parts of the backtrace + class QuietBacktraceTweaker < BacktraceTweaker + unless defined?(IGNORE_PATTERNS) + root_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', '..')) + spec_files = Dir["#{root_dir}/lib/*"].map do |path| + subpath = path[root_dir.length..-1] + /#{subpath}/ + end + IGNORE_PATTERNS = spec_files + [ + /\/rspec-[^\/]*\/lib\/spec\//, + /\/spork-[^\/]*\/lib\/spork\//, + /\/lib\/ruby\//, + /bin\/spec:/, + /bin\/spork:/, + /bin\/rcov:/, + /lib\/rspec-rails/, + /vendor\/rails/, + # TextMate's Ruby and RSpec plugins + /Ruby\.tmbundle\/Support\/tmruby.rb:/, + /RSpec\.tmbundle\/Support\/lib/, + /temp_textmate\./, + /mock_frameworks\/rspec/, + /spec_server/ + ] + end + + def initialize(*patterns) + super + ignore_patterns(*patterns) + end + + def ignore_patterns(*patterns) + @ignore_patterns += patterns.flatten.map { |pattern| Regexp.new(pattern) } + end + + def ignored_patterns + IGNORE_PATTERNS + @ignore_patterns + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/class_and_arguments_parser.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/class_and_arguments_parser.rb new file mode 100644 index 000000000..a49ade26e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/class_and_arguments_parser.rb @@ -0,0 +1,14 @@ +module Spec + module Runner + class ClassAndArgumentsParser + 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 diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/command_line.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/command_line.rb new file mode 100644 index 000000000..35a7e3159 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/command_line.rb @@ -0,0 +1,15 @@ +require 'spec/runner/option_parser' + +module Spec + module Runner + class CommandLine + 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 +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/configuration.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/configuration.rb new file mode 100644 index 000000000..19db52435 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/configuration.rb @@ -0,0 +1,202 @@ +module Spec + module Runner + class Configuration + include Spec::Example::ArgsAndOptions + + # Chooses what mock framework to use. Example: + # + # Spec::Runner.configure do |config| + # config.mock_with :rspec, :mocha, :flexmock, or :rr + # end + # + # To use any other mock framework, you'll have to provide your own + # adapter. This is simply a module that responds to the following + # methods: + # + # setup_mocks_for_rspec + # verify_mocks_for_rspec + # teardown_mocks_for_rspec. + # + # These are your hooks into the lifecycle of a given example. RSpec will + # call setup_mocks_for_rspec before running anything else in each + # Example. After executing the #after methods, RSpec will then call + # verify_mocks_for_rspec and teardown_mocks_for_rspec (this is + # guaranteed to run even if there are failures in + # verify_mocks_for_rspec). + # + # Once you've defined this module, you can pass that to mock_with: + # + # Spec::Runner.configure do |config| + # config.mock_with MyMockFrameworkAdapter + # end + # + def mock_with(mock_framework) + @mock_framework = case mock_framework + when Symbol + mock_framework_path(mock_framework.to_s) + else + mock_framework + end + end + + def mock_framework # :nodoc: + @mock_framework ||= mock_framework_path("rspec") + end + + # :call-seq: + # include(Some::Helpers) + # include(Some::Helpers, More::Helpers) + # include(My::Helpers, :type => :key) + # + # Declares modules to be included in multiple example groups + # (<tt>describe</tt> blocks). With no <tt>:type</tt>, the modules listed + # will be included in all example groups. + # + # 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. + # + # 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(ControllerExampleHelpers, :type => :controller) + # + # Only example groups that have that type will get the modules included: + # + # describe Account, :type => :model do + # # Will *not* include ControllerExampleHelpers + # end + # + # describe AccountsController, :type => :controller do + # # *Will* include ControllerExampleHelpers + # end + # + def include(*modules_and_options) + include_or_extend(:include, *modules_and_options) + 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(*modules_and_options) + include_or_extend(:extend, *modules_and_options) + end + + # Appends a global <tt>before</tt> block to all example groups. + # <tt>scope</tt> can be any of <tt>:each</tt> (default), <tt>:all</tt>, or + # <tt>:suite</tt>. When <tt>:each</tt>, the block is executed before each + # example. When <tt>:all</tt>, the block is executed once per example + # group, before any of its examples are run. When <tt>:suite</tt> the + # block is run once before the entire suite is run. + def append_before(scope = :each, options={}, &proc) + add_callback(:append_before, scope, options, &proc) + end + alias_method :before, :append_before + + # Prepends a global <tt>before</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_before(scope = :each, options={}, &proc) + add_callback(:prepend_before, scope, options, &proc) + end + + # Prepends a global <tt>after</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_after(scope = :each, options={}, &proc) + add_callback(:prepend_after, scope, options, &proc) + end + alias_method :after, :prepend_after + + # Appends a global <tt>after</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def append_after(scope = :each, options={}, &proc) + add_callback(:append_after, scope, options, &proc) + end + + # DEPRECATED - use Spec::Matchers::DSL instead + # + # Defines global predicate matchers. Example: + # + # config.predicate_matchers[:swim] = :can_swim? + # + # This makes it possible to say: + # + # person.should swim # passes if person.can_swim? returns true + # + def predicate_matchers + @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL") + end + + # Adds patterns to the list of patterns ignored in the backtrace when a + # failure is output by rspec. Example: + # + # config.ignore_backtrace_patterns /spork/, /shoulda/, "/some/weird/path/" + # + # When quiet backtraces are turned on (default), this will exclude any + # lines that match any of the Regexps and Strings passed. + # + def ignore_backtrace_patterns(*patterns) + @ignored_backtrace_patterns ||= [] + @ignored_backtrace_patterns += patterns + end + + def ignored_backtrace_patterns # :nodoc: + @ignored_backtrace_patterns ||= [] + end + + def suppress_deprecation_warnings! + @suppress_deprecation_warnings = true + end + + def suppress_deprecation_warnings? + @suppress_deprecation_warnings ||= false + end + + private + + def include_or_extend(action, *args) + modules, options = args_and_options(*args) + [get_type_from_options(options)].flatten.each do |required_example_group| + required_example_group = required_example_group.to_sym if required_example_group + modules.each do |mod| + Spec::Example::ExampleGroupFactory[required_example_group].__send__(action, mod) + end + end + end + + def add_callback(sym, *args, &proc) + scope, options = scope_and_options(*args) + example_group = Spec::Example::ExampleGroupFactory[get_type_from_options(options)] + example_group.__send__(sym, scope, &proc) + end + + def get_type_from_options(options) + options[:type] || options[:behaviour_type] + end + + def mock_framework_path(framework_name) + "spec/adapters/mock_frameworks/#{framework_name}" + end + + def scope_and_options(*args) # :nodoc: + args, options = args_and_options(*args) + return scope_from(*args), options + end + + def scope_from(*args) # :nodoc: + args[0] || :each + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/default.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/default.rb new file mode 100644 index 000000000..3a05da9d1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/default.rb @@ -0,0 +1,93 @@ +require 'spec/runner/differs/load-diff-lcs' +require 'pp' + +module Spec + module Expectations + module Differs + unless defined?(Spec::Expectations::Differs::Default) + class Default + def initialize(options) + @options = options + end + + # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool) + def diff_as_string(data_new, data_old) + data_old = data_old.split(/\n/).map! { |e| e.chomp } + data_new = data_new.split(/\n/).map! { |e| e.chomp } + output = "" + diffs = Diff::LCS.diff(data_old, data_new) + return output if diffs.empty? + oldhunk = hunk = nil + file_length_difference = 0 + diffs.each do |piece| + begin + hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines, + file_length_difference) + file_length_difference = hunk.file_length_difference + next unless oldhunk + # Hunks may overlap, which is why we need to be careful when our + # diff includes lines of context. Otherwise, we might print + # redundant lines. + if (context_lines > 0) and hunk.overlaps?(oldhunk) + hunk.unshift(oldhunk) + else + output << oldhunk.diff(format) + end + ensure + oldhunk = hunk + output << "\n" + end + end + #Handle the last remaining hunk + output << oldhunk.diff(format) << "\n" + end + + def diff_as_object(target,expected) + diff_as_string(PP.pp(target,""), PP.pp(expected,"")) + end + + def diff_as_hash(target, expected) + contains_hash = false + contains_array = false + + extra_expected_keys = expected.keys - target.keys + extra_target_keys = target.keys - expected.keys + + o = "\n" + + o << "Expected hash contains keys that target hash does not: " << extra_expected_keys.inspect << "\n" if !extra_expected_keys.empty? + o << "Target hash contains keys that expected hash does not: " << extra_target_keys.inspect << "\n" if !extra_target_keys.empty? + + expected.delete_if do |key, value| + contains_hash = true if value.is_a?(Hash) + contains_array = true if value.is_a?(Array) + target[key] == value + end + + expected.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key| + o << "Expected the key #{key.inspect} to be #{expected[key].inspect}, but was #{target[key].inspect}\n" + end + + o << "\n" + + if contains_hash || contains_array + o << diff_as_object(target, expected) + else + o + end + end + + protected + def format + @options.diff_format + end + + def context_lines + @options.context_lines + end + end + + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/load-diff-lcs.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/load-diff-lcs.rb new file mode 100644 index 000000000..f708bc9b4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/differs/load-diff-lcs.rb @@ -0,0 +1,12 @@ +begin + require 'diff/lcs' +rescue LoadError + begin + require 'rubygems' unless ENV['NO_RUBYGEMS'] + require 'diff/lcs' + rescue LoadError + raise "You must gem install diff-lcs to use diffing" + end +end + +require 'diff/lcs/hunk' diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/drb_command_line.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/drb_command_line.rb new file mode 100644 index 000000000..cbc0f2d9a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/drb_command_line.rb @@ -0,0 +1,32 @@ +require "drb/drb" + +module Spec + module Runner + # Facade to run specs by connecting to a DRB server + class DrbCommandLine + + def self.port(options) + (options.drb_port || ENV["RSPEC_DRB"] || 8989).to_i + end + + # Runs specs on a DRB server. Note that this API is similar to that of + # CommandLine - making it possible for clients to use both interchangeably. + def self.run(options) + begin + begin; \ + DRb.start_service("druby://localhost:0"); \ + rescue SocketError, Errno::EADDRNOTAVAIL; \ + DRb.start_service("druby://:0"); \ + end + spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{port(options)}") + spec_server.run(options.argv, options.error_stream, options.output_stream) + true + rescue DRb::DRbConnError + options.error_stream.puts "No server is running" + false + end + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/example_group_runner.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/example_group_runner.rb new file mode 100644 index 000000000..4de043f08 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/example_group_runner.rb @@ -0,0 +1,58 @@ +module Spec + module Runner + class ExampleGroupRunner + def initialize(options) + @options = options + end + + def load_files(files) + $KCODE = 'u' if RUBY_VERSION.to_f < 1.9 + # It's important that loading files (or choosing not to) stays the + # responsibility of the ExampleGroupRunner. Some implementations (like) + # the one using DRb may choose *not* to load files, but instead tell + # someone else to do it over the wire. + files.each do |file| + load file + end + end + + def run + prepare + success = true + example_groups.each do |example_group| + success = success & example_group.run(@options) + end + finish + success + end + + protected + + def prepare + reporter.start(number_of_examples) + example_groups.reverse! if reverse + end + + def finish + reporter.end + reporter.dump + end + + def reporter + @options.reporter + end + + def reverse + @options.reverse + end + + def example_groups + @options.example_groups + end + + def number_of_examples + @options.number_of_examples + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/extensions/kernel.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/extensions/kernel.rb new file mode 100644 index 000000000..4e23cdf22 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/extensions/kernel.rb @@ -0,0 +1,9 @@ +module Kernel + unless respond_to?(:debugger) + # Start a debugging session if ruby-debug is loaded with the -u/--debugger option + def debugger(steps=1) + # If not then just comment and proceed + $stderr.puts "debugger statement ignored, use -u or --debugger option on rspec to enable debugging" + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_formatter.rb new file mode 100644 index 000000000..0fbc12ce4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_formatter.rb @@ -0,0 +1,139 @@ +module Spec + module Runner + module Formatter + # Formatter base-class, which implements all required methods as no-ops, with the exception + class BaseFormatter + # Formatters are initialized with <tt>options</tt> and <tt>output</tt> + # arguments. RSpec's built-in formatters already expect this, and any + # custom formatters should as well. + # + # ==== Parameters + # options:: + # A struct containing boolean values for colour, autospec, + # and dry_run + # output:: + # Used by RSpec's built-in formatters to determine where to + # write the output. Default is <tt>STDOUT</tt>, otherwise a + # filename is expected. + # + # === Example + # If you invoke the <tt>spec</tt> command with: + # + # --format progress:progress_report.txt + # + # ... the value of <tt>output</tt> will be progress_report.txt. If you + # don't identify an output destination, the default is STDOUT. + def initialize(options, output) + end + + # This method is invoked before any examples are run, right after + # they have all been collected. This can be useful for special + # formatters that need to provide progress on feedback (graphical ones) + # + # This method will only be invoked once, and the next one to be invoked + # is #example_group_started + # + # ==== Parameters + # example_count:: the total number of examples to be run + def start(example_count) + end + + # This method is invoked at the beginning of the execution of each + # example_group. The next method to be invoked after this is + # #example_started + # + # ==== Parameters + # example_group_proxy:: instance of Spec::Example::ExampleGroupProxy + def example_group_started(example_group_proxy) + end + + # Deprecated - use example_group_started instead + def add_example_group(example_group_proxy) + Spec.deprecate("BaseFormatter#add_example_group", "BaseFormatter#example_group_started") + example_group_started(example_group_proxy) + end + + # This method is invoked when an +example+ starts. The next method to be + # invoked after this is #example_passed, #example_failed, or + # #example_pending + # + # ==== Parameters + # example_proxy:: instance of Spec::Example::ExampleProxy + def example_started(example_proxy) + end + + # This method is invoked when an +example+ passes. + # +example_proxy+ is the same instance of Spec::Example::ExampleProxy + # that was passed to example_started + # + # ==== Parameters + # example_proxy:: instance of Spec::Example::ExampleProxy + def example_passed(example_proxy) + end + + # This method is invoked when an +example+ fails, i.e. an exception occurred + # inside it (such as a failed should or other exception). + # + # ==== Parameters + # example_proxy:: + # The same instance of Spec::Example::ExampleProxy that was passed + # to <tt>example_started</tt> + # + # counter:: the sequential number of this failure + # + # failure:: instance of Spec::Runner::Reporter::Failure + def example_failed(example_proxy, counter, failure) + end + + # This method is invoked when an example is not yet implemented (i.e. has not + # been provided a block), or when an ExamplePendingError is raised. + # +message+ is the message from the ExamplePendingError, if it exists, or the + # default value of "Not Yet Implemented". +deprecated_pending_location+ is + # deprecated - use example_proxy.location instead + # + # ==== Parameters + # example_proxy:: instance of Spec::Example::ExampleProxy + # message:: + # the message passed to the pending message, or an internal + # default + # + def example_pending(example_proxy, message, deprecated_pending_location=nil) + end + + # This method is invoked after all of the examples have executed. The next method + # to be invoked after this one is #dump_failure (once for each failed example) + def start_dump + end + + # Dumps detailed information about an example failure. + # This method is invoked for each failed example after all examples have run. +counter+ is the sequence number + # of the associated example. +failure+ is a Failure object, which contains detailed + # information about the failure. + # + # ==== Parameters + # counter:: the sequential number of this failure + # failure:: instance of Spec::Runner::Reporter::Failure + def dump_failure(counter, failure) + end + + # This method is invoked after the dumping of examples and failures. + # + # ==== Parameters + # duration:: the total time for the entire run + # example_count:: the number of examples run + # failure_count:: the number of examples that failed + # pending_count:: the number of examples that are pending + def dump_summary(duration, example_count, failure_count, pending_count) + end + + # This gets invoked after the summary + def dump_pending + end + + # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams. + def close + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_text_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_text_formatter.rb new file mode 100644 index 000000000..ee8db75a4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/base_text_formatter.rb @@ -0,0 +1,142 @@ +require 'spec/runner/formatter/base_formatter' +require 'fileutils' + +module Spec + module Runner + module Formatter + # Baseclass for text-based formatters. Can in fact be used for + # non-text based ones too - just ignore the +output+ constructor + # argument. + class BaseTextFormatter < BaseFormatter + attr_reader :output, :example_group + # Creates a new instance that will write to +output+. If +output+ is a + # String, output will be written to the File with that name, otherwise + # +output+ is exected to be an IO (or an object that responds to #puts + # and #write). + def initialize(options, output) + @options = options + if String === output + FileUtils.mkdir_p(File.dirname(output)) + @output = File.open(output, 'w') + else + @output = output + end + @pending_examples = [] + end + + def example_group_started(example_group_proxy) + @example_group = example_group_proxy + end + + def example_pending(example, message, deprecated_pending_location=nil) + @pending_examples << ["#{@example_group.description} #{example.description}", message, example.location] + end + + def dump_failure(counter, failure) + @output.puts + @output.puts "#{counter.to_s})" + @output.puts colorize_failure("#{failure.header}\n#{failure.exception.message}", failure) + @output.puts format_backtrace(failure.exception.backtrace) + @output.flush + end + + def colorize_failure(message, failure) + failure.pending_fixed? ? blue(message) : red(message) + end + + def colourise(message, failure) + Spec::deprecate("BaseTextFormatter#colourise", "colorize_failure") + colorize_failure(message, failure) + end + + def dump_summary(duration, example_count, failure_count, pending_count) + return if dry_run? + @output.puts + @output.puts "Finished in #{duration} seconds" + @output.puts + + summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}" + summary << ", #{pending_count} pending" if pending_count > 0 + + if failure_count == 0 + if pending_count > 0 + @output.puts yellow(summary) + else + @output.puts green(summary) + end + else + @output.puts red(summary) + end + @output.flush + end + + def dump_pending + unless @pending_examples.empty? + @output.puts + @output.puts "Pending:" + @pending_examples.each do |pending_example| + @output.puts "\n#{pending_example[0]} (#{pending_example[1]})" + @output.puts "#{pending_example[2]}\n" + end + end + @output.flush + end + + def close + @output.close if (IO === @output) & (@output != $stdout) + end + + def format_backtrace(backtrace) + return "" if backtrace.nil? + backtrace.map { |line| backtrace_line(line) }.join("\n") + end + + protected + + def colour? + !!@options.colour + end + + def dry_run? + !!@options.dry_run + end + + def autospec? + !!@options.autospec || ENV.has_key?("AUTOTEST") + end + + def backtrace_line(line) + line.sub(/\A([^:]+:\d+)$/, '\\1:') + end + + def colour(text, colour_code) + return text if output_to_file? + return text unless ENV['RSPEC_COLOR'] || (colour? & (autospec? || output_to_tty?)) + "#{colour_code}#{text}\e[0m" + end + + def output_to_file? + File === @output + end + + def output_to_tty? + begin + @output.tty? + rescue NoMethodError + false + end + end + + def green(text); colour(text, "\e[32m"); end + def red(text); colour(text, "\e[31m"); end + def yellow(text); colour(text, "\e[33m"); end + def blue(text); colour(text, "\e[34m"); end + + def magenta(text) + Spec::deprecate("BaseTextFormatter#magenta") + red(text) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_example_groups_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_example_groups_formatter.rb new file mode 100644 index 000000000..31729438b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_example_groups_formatter.rb @@ -0,0 +1,25 @@ +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + class FailingExampleGroupsFormatter < BaseTextFormatter + def example_failed(example, counter, failure) + if @example_group + @output.puts @example_group.description.gsub(/ \(druby.*\)/,"") + + @output.flush + @example_group = nil + end + end + + def dump_failure(counter, failure) + end + + def dump_summary(duration, example_count, failure_count, pending_count) + end + + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_examples_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_examples_formatter.rb new file mode 100644 index 000000000..e3a271c8b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/failing_examples_formatter.rb @@ -0,0 +1,20 @@ +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + class FailingExamplesFormatter < BaseTextFormatter + def example_failed(example, counter, failure) + @output.puts "#{example_group.description} #{example.description}" + @output.flush + end + + def dump_failure(counter, failure) + end + + def dump_summary(duration, example_count, failure_count, pending_count) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/html_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/html_formatter.rb new file mode 100644 index 000000000..2d0c65d1b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/html_formatter.rb @@ -0,0 +1,338 @@ +require 'erb' +require 'spec/runner/formatter/base_text_formatter' +require 'spec/runner/formatter/no_op_method_missing' + +module Spec + module Runner + module Formatter + class HtmlFormatter < BaseTextFormatter + include ERB::Util # for the #h method + include NOOPMethodMissing + + def initialize(options, output) + super + @example_group_number = 0 + @example_number = 0 + @header_red = nil + end + + # 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 example_number + @example_number + end + + def start(example_count) + @example_count = example_count + + @output.puts html_header + @output.puts report_header + @output.flush + end + + def example_group_started(example_group) + super + @example_group_red = false + @example_group_number += 1 + unless example_group_number == 1 + @output.puts " </dl>" + @output.puts "</div>" + end + @output.puts "<div class=\"example_group\">" + @output.puts " <dl>" + @output.puts " <dt id=\"example_group_#{example_group_number}\">#{h(example_group.description)}</dt>" + @output.flush + end + + def start_dump + @output.puts " </dl>" + @output.puts "</div>" + @output.flush + end + + def example_started(example) + @example_number += 1 + end + + def example_passed(example) + move_progress + @output.puts " <dd class=\"spec passed\"><span class=\"passed_spec_name\">#{h(example.description)}</span></dd>" + @output.flush + end + + def example_failed(example, counter, failure) + extra = extra_failure_content(failure) + failure_style = failure.pending_fixed? ? 'pending_fixed' : 'failed' + @output.puts " <script type=\"text/javascript\">makeRed('rspec-header');</script>" unless @header_red + @header_red = true + @output.puts " <script type=\"text/javascript\">makeRed('example_group_#{example_group_number}');</script>" unless @example_group_red + @example_group_red = true + move_progress + @output.puts " <dd class=\"spec #{failure_style}\">" + @output.puts " <span class=\"failed_spec_name\">#{h(example.description)}</span>" + @output.puts " <div class=\"failure\" id=\"failure_#{counter}\">" + @output.puts " <div class=\"message\"><pre>#{h(failure.exception.message)}</pre></div>" unless failure.exception.nil? + @output.puts " <div class=\"backtrace\"><pre>#{format_backtrace(failure.exception.backtrace)}</pre></div>" unless failure.exception.nil? + @output.puts extra unless extra == "" + @output.puts " </div>" + @output.puts " </dd>" + @output.flush + end + + def example_pending(example, message, deprecated_pending_location=nil) + @output.puts " <script type=\"text/javascript\">makeYellow('rspec-header');</script>" unless @header_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.description)} (PENDING: #{h(message)})</span></dd>" + @output.flush + end + + # Override this method if you wish to output extra HTML for a failed spec. For example, you + # could output links to images or other files produced during the specs. + # + def extra_failure_content(failure) + require 'spec/runner/formatter/snippet_extractor' + @snippet_extractor ||= SnippetExtractor.new + " <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(failure.exception)}</code></pre>" + end + + def move_progress + @output.puts " <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>" + @output.flush + end + + def percent_done + result = 100.0 + if @example_count != 0 + result = ((example_number).to_f / @example_count.to_f * 1000).to_i / 10.0 + end + result + end + + def dump_failure(counter, failure) + end + + def dump_summary(duration, example_count, failure_count, pending_count) + if dry_run? + totals = "This was a dry-run" + else + totals = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}" + totals << ", #{pending_count} pending" if pending_count > 0 + end + @output.puts "<script type=\"text/javascript\">document.getElementById('duration').innerHTML = \"Finished in <strong>#{duration} seconds</strong>\";</script>" + @output.puts "<script type=\"text/javascript\">document.getElementById('totals').innerHTML = \"#{totals}\";</script>" + @output.puts "</div>" + @output.puts "</div>" + @output.puts "</body>" + @output.puts "</html>" + @output.flush + end + + def html_header + <<-EOF +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +#{global_scripts} + // ]]> + </script> + <style type="text/css"> +#{global_styles} + </style> +</head> +<body> +EOF + end + + def report_header + <<-EOF +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +EOF + end + + def global_scripts + <<-EOF +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} +EOF + end + + def global_styles + <<-EOF +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} +EOF + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/nested_text_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/nested_text_formatter.rb new file mode 100644 index 000000000..df5274591 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/nested_text_formatter.rb @@ -0,0 +1,50 @@ +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + class NestedTextFormatter < BaseTextFormatter + + INDENT = ' ' + + def initialize(options, where) + super + @last_nested_descriptions = [] + end + + def example_group_started(example_group) + super + + example_group.nested_descriptions.each_with_index do |nested_description, i| + unless example_group.nested_descriptions[0..i] == @last_nested_descriptions[0..i] + output.puts "#{INDENT*i}#{nested_description}" + end + end + + @last_nested_descriptions = example_group.nested_descriptions + end + + def example_failed(example, counter, failure) + output.puts(red("#{current_indentation}#{example.description} (FAILED - #{counter})")) + output.flush + end + + def example_passed(example) + message = "#{current_indentation}#{example.description}" + output.puts green(message) + output.flush + end + + def example_pending(example, message, deprecated_pending_location=nil) + super + output.puts yellow("#{current_indentation}#{example.description} (PENDING: #{message})") + output.flush + end + + def current_indentation + INDENT*@last_nested_descriptions.length + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/no_op_method_missing.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/no_op_method_missing.rb new file mode 100644 index 000000000..350e29f73 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/no_op_method_missing.rb @@ -0,0 +1,21 @@ +module Spec + module Runner + module Formatter + module NOOPMethodMissing + def respond_to?(message, include_private = false) + if include_private + true + else + !private_methods.any? {|m| [message.to_s, message.to_sym].include?(m)} + end + end + + private + + def method_missing(sym, *args) + # a no-op + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/profile_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/profile_formatter.rb new file mode 100644 index 000000000..3784f3ac7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/profile_formatter.rb @@ -0,0 +1,47 @@ +require 'spec/runner/formatter/progress_bar_formatter' + +module Spec + module Runner + module Formatter + class ProfileFormatter < ProgressBarFormatter + + def initialize(options, where) + super + @example_times = [] + end + + def start(count) + @output.puts "Profiling enabled." + end + + def example_started(example) + @time = Time.now + end + + def example_passed(example) + super + @example_times << [ + example_group.description, + example.description, + Time.now - @time + ] + end + + def start_dump + super + @output.puts "\n\nTop 10 slowest examples:\n" + + @example_times = @example_times.sort_by do |description, example, time| + time + end.reverse + + @example_times[0..9].each do |description, example, time| + @output.print red(sprintf("%.7f", time)) + @output.puts " #{description} #{example}" + end + @output.flush + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/progress_bar_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/progress_bar_formatter.rb new file mode 100644 index 000000000..862f87a44 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/progress_bar_formatter.rb @@ -0,0 +1,33 @@ +require 'spec/runner/formatter/base_text_formatter' +require 'spec/runner/formatter/no_op_method_missing' + +module Spec + module Runner + module Formatter + class ProgressBarFormatter < BaseTextFormatter + include NOOPMethodMissing + + def example_failed(example, counter, failure) + @output.print colorize_failure('F', failure) + @output.flush + end + + def example_passed(example) + @output.print green('.') + @output.flush + end + + def example_pending(example, message, deprecated_pending_location=nil) + super + @output.print yellow('*') + @output.flush + end + + def start_dump + @output.puts + @output.flush + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/silent_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/silent_formatter.rb new file mode 100644 index 000000000..43cce33bb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/silent_formatter.rb @@ -0,0 +1,10 @@ +require 'spec/runner/formatter/base_formatter' + +module Spec + module Runner + module Formatter + class SilentFormatter < BaseFormatter + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/snippet_extractor.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/snippet_extractor.rb new file mode 100644 index 000000000..4f34e5fee --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/snippet_extractor.rb @@ -0,0 +1,52 @@ +module Spec + module Runner + module Formatter + # This class extracts code snippets by looking at the backtrace of the passed error + class SnippetExtractor #:nodoc: + class NullConverter; def convert(code, pre); code; end; end #:nodoc: + begin; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end + + def snippet(error) + raw_code, line = snippet_for(error.backtrace[0]) + highlighted = @@converter.convert(raw_code, false) + highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter) + post_process(highlighted, line) + end + + def snippet_for(error_line) + if error_line =~ /(.*):(\d+)/ + file = $1 + line = $2.to_i + [lines_around(file, line), line] + else + ["# Couldn't get snippet for #{error_line}", 1] + end + end + + def lines_around(file, line) + if File.file?(file) + lines = File.open(file).read.split("\n") + min = [0, line-3].max + max = [line+1, lines.length-1].min + selected_lines = [] + selected_lines.join("\n") + lines[min..max].join("\n") + else + "# Couldn't get snippet for #{file}" + end + end + + def post_process(highlighted, offending_line) + new_lines = [] + highlighted.split("\n").each_with_index do |line, i| + new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}" + new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2 + new_lines << new_line + end + new_lines.join("\n") + end + + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/specdoc_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/specdoc_formatter.rb new file mode 100644 index 000000000..7204f2147 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/specdoc_formatter.rb @@ -0,0 +1,33 @@ +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + class SpecdocFormatter < BaseTextFormatter + def example_group_started(example_group) + super + output.puts + output.puts example_group.description + output.flush + end + + def example_failed(example, counter, failure) + output.puts(red("- #{example.description} (FAILED - #{counter})")) + output.flush + end + + def example_passed(example) + message = "- #{example.description}" + output.puts green(message) + output.flush + end + + def example_pending(example, message, deprecated_pending_location=nil) + super + output.puts yellow("- #{example.description} (PENDING: #{message})") + output.flush + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/text_mate_formatter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/text_mate_formatter.rb new file mode 100644 index 000000000..4c0a9c7de --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/formatter/text_mate_formatter.rb @@ -0,0 +1,16 @@ +require 'spec/runner/formatter/html_formatter' + +module Spec + module Runner + module Formatter + # Formats backtraces so they're clickable by TextMate + class TextMateFormatter < HtmlFormatter + def backtrace_line(line) + line.gsub(/([^:]*\.rb):(\d*)/) do + "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> " + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner.rb new file mode 100644 index 000000000..5c81ea846 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner.rb @@ -0,0 +1,72 @@ +if Spec::Ruby.version.to_f < 1.9 + begin + require 'rubygems' unless ENV['NO_RUBYGEMS'] + require 'heckle' + rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end + + module Spec + module Runner + # Creates a new Heckler configured to heckle all methods in the classes + # whose name matches +filter+ + class HeckleRunner + def initialize(filter, heckle_class=Heckler) + @filter = filter + @heckle_class = heckle_class + end + + # Runs all the example groups held by +rspec_options+ once for each of the + # methods in the matched classes. + def heckle_with + if @filter =~ /(.*)[#\.](.*)/ + heckle_method($1, $2) + else + heckle_class_or_module(@filter) + end + end + + def heckle_method(class_name, method_name) + verify_constant(class_name) + heckle = @heckle_class.new(class_name, method_name, Spec::Runner.options) + heckle.validate + end + + def heckle_class_or_module(class_or_module_name) + verify_constant(class_or_module_name) + pattern = /^#{class_or_module_name}/ + classes = [] + ObjectSpace.each_object(Class) do |klass| + classes << klass if klass.name =~ pattern + end + + classes.each do |klass| + klass.instance_methods(false).each do |method_name| + heckle = @heckle_class.new(klass.name, method_name, Spec::Runner.options) + heckle.validate + end + end + end + + def verify_constant(name) + begin + # This is defined in Heckle + name.to_class + rescue + raise "Heckling failed - \"#{name}\" is not a known class or module" + end + end + end + + class Heckler < Heckle + def initialize(klass_name, method_name, rspec_options) + super(klass_name, method_name) + @rspec_options = rspec_options + end + + def tests_pass? + @rspec_options.run_examples + end + + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner_unsupported.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner_unsupported.rb new file mode 100644 index 000000000..35ff86e10 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/heckle_runner_unsupported.rb @@ -0,0 +1,10 @@ +module Spec + module Runner + # Dummy implementation for Windows that just fails (Heckle is not supported on Windows) + class HeckleRunner + def initialize(filter) + raise "Heckle is not supported on Windows or Ruby 1.9" + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/line_number_query.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/line_number_query.rb new file mode 100644 index 000000000..0a907d3fe --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/line_number_query.rb @@ -0,0 +1,78 @@ +module Spec + module Runner + # Parses a spec file and finds the nearest example for a given line number. + class LineNumberQuery + attr_reader :best_match + + def initialize(run_options) + @best_match = {} + @run_options = run_options + end + + def spec_name_for(file, line_number) + best_match.clear + file = File.expand_path(file) + determine_best_match(file, line_number) + 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 + end + + def example_line_for(file, line_number) + determine_best_match(file, line_number) + best_match[:line] + end + + protected + + def determine_best_match(file, line_number) + best_match.clear + file = File.expand_path(file) + @run_options.example_groups.each do |example_group| + next unless example_group.location + 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 + end + + def consider_example_group_for_best_match(example_group, file, line_number) + example_group_file, example_group_line = parse_location(example_group.location) + if is_best_match?(file, line_number, example_group_file, example_group_line) + best_match.clear + best_match[:example_group] = example_group + best_match[:line] = example_group_line + end + end + + def consider_example_for_best_match(example, example_group, file, line_number) + example_file, example_line = parse_location(example.location) + 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 + + 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_location(location) + location =~ /(.*)\:(\d*)(\:|$)/ + return $1, Integer($2) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/option_parser.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/option_parser.rb new file mode 100644 index 000000000..87c9522c2 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/option_parser.rb @@ -0,0 +1,225 @@ +require 'optparse' +require 'stringio' + +module Spec + module Runner + class OptionParser < ::OptionParser + class << self + def parse(args, err, out) + parser = new(err, out) + parser.parse(args) + parser.options + end + + def spec_command? + $0.split('/').last == 'spec' + end + end + + attr_reader :options + + OPTIONS = { + :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)"], + :colour => ["-c", "--colour", "--color", "Show coloured (red/green) output"], + :example => ["-e", "--example [NAME|FILE_NAME]", "Execute example(s) with matching name(s). If the argument is", + "the path to an existing file (typically generated by a previous", + "run using --format failing_examples:file.txt), then the examples", + "on each line of that file will be executed. If the file is empty,", + "all examples will be run (as if --example was not specified).", + " ", + "If the argument is not an existing file, then it is treated as", + "an example name directly, causing RSpec to run just the example", + "matching that name"], + :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"], + :line => ["-l", "--line LINE_NUMBER", Integer, "Execute 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", + "not specified. The --format option may be specified several times", + "if you want several outputs", + " ", + "Builtin formats:", + "silent|l : No output", "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 indented", + "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", + " ", + "FORMAT can also be the name of a custom formatter class", + "(in which case you should also specify --require to load it)"], + :require => ["-r", "--require FILE", "Require FILE before running specs", + "Useful for loading custom formatters or other extensions.", + "If this option is used it must come before the others"], + :backtrace => ["-b", "--backtrace", "Output full backtrace"], + :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.", + "STRATEGY can currently only be 'mtime' (File modification time)", + "By default, spec files are loaded in alphabetical order if --loadby", + "is not specified."], + :reverse => ["-R", "--reverse", "Run examples in reverse order"], + :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the", + "specified time"], + :heckle => ["-H", "--heckle CODE", "If all examples pass, this will mutate the classes and methods", + "identified by CODE little by little and run all the examples again", + "for each mutation. The intent is that for each mutation, at least", + "one example *should* fail, and RSpec will tell you if this is not the", + "case. CODE should be either Some::Module, Some::Class or", + "Some::Fabulous#method}"], + :dry_run => ["-d", "--dry-run", "Invokes formatters without executing the examples."], + :options_file => ["-O", "--options PATH", "Read options from a file"], + :generate_options => ["-G", "--generate-options PATH", "Generate an options file for --options"], + :runner => ["-U", "--runner RUNNER", "Use a custom Runner."], + :debug => ["-u", "--debugger", "Enable ruby-debugging."], + :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"], + :drb_port => ["--port PORT", "Port for DRb server. (Ignored without --drb)"], + :version => ["-v", "--version", "Show version"], + :help => ["-h", "--help", "You're looking at it"] + } + + def initialize(err, out) + super() + @error_stream = err + @out_stream = out + @options = Options.new(@error_stream, @out_stream) + + @file_factory = File + + self.banner = "Usage: spec (FILE(:LINE)?|DIRECTORY|GLOB)+ [options]" + self.separator "" + 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|} + on(*OPTIONS[:generate_options]) {|options_file|} + on(*OPTIONS[:runner]) {|runner| @options.user_input_for_runner = runner} + on(*OPTIONS[:debug]) {@options.debug = true} + on(*OPTIONS[:drb]) {} + on(*OPTIONS[:drb_port]) {|port| @options.drb_port = port} + on(*OPTIONS[:version]) {parse_version} + on("--autospec") {@options.autospec = true} + on_tail(*OPTIONS[:help]) {parse_help} + end + + def order!(argv, &blk) + @argv = argv.dup + @argv = (@argv.empty? & self.class.spec_command?) ? ['--help'] : @argv + + # Parse options file first + parse_file_options(:options_file, :parse_options_file) + + @options.argv = @argv.dup + return if parse_file_options(:generate_options, :write_options_file) + return if parse_drb + + super(@argv) do |file| + if file =~ /^(.+):(\d+)$/ + file = $1 + @options.line_number = $2.to_i + end + + @options.files << file + blk.call(file) if blk + end + + @options + end + + protected + + def invoke_requires(requires) + requires.split(",").each do |file| + require file + end + end + + def parse_file_options(option_name, action) + # Remove the file option and the argument before handling the file + options_file = nil + options_list = OPTIONS[option_name][0..1] + options_list[1].gsub!(" PATH", "") + options_list.each do |option| + if index = @argv.index(option) + @argv.delete_at(index) + options_file = @argv.delete_at(index) + end + end + + if options_file.nil? && + File.exist?('spec/spec.opts') && + !@argv.any?{|a| a =~ /^\-/ } + options_file = 'spec/spec.opts' + end + + if options_file + send(action, options_file) + return true + else + return false + end + end + + def parse_options_file(options_file) + option_file_args = File.readlines(options_file).map {|l| l.chomp.split " "}.flatten + @argv.push(*option_file_args) + end + + def write_options_file(options_file) + File.open(options_file, 'w') do |io| + io.puts @argv.join("\n") + end + @out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:" + @out_stream.puts "spec --options #{options_file}" + @options.examples_should_not_be_run + end + + def parse_drb + argv = @options.argv + is_drb = false + is_drb ||= argv.delete(OPTIONS[:drb][0]) + is_drb ||= argv.delete(OPTIONS[:drb][1]) + return false unless is_drb + if DrbCommandLine.run(self.class.parse(argv, @error_stream, @out_stream)) + @options.examples_should_not_be_run + true + else + @error_stream.puts "Running specs locally:" + false + end + end + + def parse_version + @out_stream.puts ::Spec::VERSION::SUMMARY + exit if stdout? + end + + def parse_help + @out_stream.puts self + exit if stdout? + end + + def stdout? + @out_stream == $stdout + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/options.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/options.rb new file mode 100644 index 000000000..6e23da7da --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/options.rb @@ -0,0 +1,406 @@ +require 'ostruct' +require 'rbconfig' + +module Spec + module Runner + class Options + FILE_SORTERS = { + 'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)} + } + + EXAMPLE_FORMATTERS = { # Load these lazily for better speed + 'silent' => ['spec/runner/formatter/silent_formatter', 'Formatter::SilentFormatter'], + 'l' => ['spec/runner/formatter/silent_formatter', 'Formatter::SilentFormatter'], + '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'] + } + + attr_accessor( + :autospec, # hack to tell + :filename_pattern, + :backtrace_tweaker, + :context_lines, + :diff_format, + :dry_run, + :profile, + :heckle_runner, + :debug, + :line_number, + :loadby, + :reporter, + :reverse, + :timeout, + :verbose, + :user_input_for_runner, + :error_stream, + :output_stream, + # TODO: BT - Figure out a better name + :argv + ) + attr_reader :colour, :differ_class, :files, :examples, :example_groups + attr_writer :drb_port + + 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 + @profile = false + @dry_run = false + @debug = false + @reporter = Reporter.new(self) + @context_lines = 3 + @diff_format = :unified + @files = [] + @example_groups = [] + @result = nil + @examples_run = false + @examples_should_be_run = nil + @user_input_for_runner = nil + @after_suite_parts = [] + @files_loaded = false + @out_used = nil + end + + def add_example_group(example_group) + @example_groups << example_group + end + + def line_number_requested? + !!line_number + end + + def example_line + Spec::Runner::LineNumberQuery.new(self).example_line_for(files.first, line_number) + end + + def remove_example_group(example_group) + @example_groups.delete(example_group) + end + + def require_ruby_debug + require 'rubygems' unless ENV['NO_RUBYGEMS'] + require 'ruby-debug' + end + + def project_root # :nodoc: + require 'pathname' + @project_root ||= determine_project_root + end + + def determine_project_root # :nodoc: + # This is borrowed (slightly modified) from Scott Taylors + # project_path project: + # http://github.com/smtlaissezfaire/project_path + Pathname(File.expand_path('.')).ascend do |path| + if File.exists?(File.join(path, "spec")) + return path + end + end + end + + def add_dir_from_project_root_to_load_path(dir, load_path=$LOAD_PATH) # :nodoc: + return if project_root.nil? + full_dir = File.join(project_root, dir) + load_path.unshift full_dir unless load_path.include?(full_dir) + end + + def run_examples + require_ruby_debug if debug + return true unless examples_should_be_run? + success = true + begin + runner = custom_runner || ExampleGroupRunner.new(self) + + unless @files_loaded + ['spec','lib'].each do |dir| + add_dir_from_project_root_to_load_path(dir) + end + runner.load_files(files_to_load) + @files_loaded = true + end + + define_predicate_matchers + plugin_mock_framework + ignore_backtrace_patterns + + # 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 features/before_and_after_blocks/before_and_after_blocks.story + # will fail if this happens before the files are loaded. + before_suite_parts.each { |part| part.call } + + 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.arity < 1 ? part.call : part.call(success) + end + end + end + + def before_suite_parts + Spec::Example::BeforeAndAfterHooks.before_suite_parts + end + + def after_suite_parts + Spec::Example::BeforeAndAfterHooks.after_suite_parts + end + + def examples_run? + @examples_run + end + + def examples_should_not_be_run + @examples_should_be_run = false + end + + def mock_framework + # TODO - don't like this dependency - perhaps store this in here instead? + Spec::Runner.configuration.mock_framework + end + + def colour=(colour) + @colour = colour + if @colour && Config::CONFIG['host_os'] =~ /mswin|mingw/ ;\ + begin ;\ + replace_output = @output_stream.equal?($stdout) ;\ + require 'rubygems' unless ENV['NO_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 + + def parse_diff(format) + case format + when :context, 'context', 'c' + @diff_format = :context + default_differ + when :unified, 'unified', 'u', '', nil + @diff_format = :unified + default_differ + else + @diff_format = :custom + self.differ_class = load_class(format, 'differ', '--diff') + end + end + + def parse_example(example) + if(File.file?(example)) + @examples = [File.open(example).read.split("\n")].flatten + else + @examples = [example] + end + end + + def parse_format(format_arg) + format, where = ClassAndArgumentsParser.parse(format_arg) + unless where + raise "When using several --format options only one of them can be without a file" if @out_used + where = @output_stream + @out_used = true + end + @format_options ||= [] + @format_options << [format, where] + end + + def formatters + @format_options ||= [['progress', @output_stream]] + @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS) + end + + def 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(formatter_options, where) + end + end + + def formatter_options + @formatter_options ||= OpenStruct.new( + :colour => colour, + :autospec => autospec, + :dry_run => dry_run + ) + end + + def which_heckle_runner + ([/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} || Spec::Ruby.version.to_f == 1.9) ? "spec/runner/heckle_runner_unsupported" : "spec/runner/heckle_runner" + end + + def load_heckle_runner(heckle) + @format_options ||= [['silent', @output_stream]] + require which_heckle_runner + @heckle_runner = ::Spec::Runner::HeckleRunner.new(heckle) + end + + def number_of_examples + return examples.size unless examples.empty? + @example_groups.inject(0) {|sum, group| sum + group.number_of_examples} + 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 + + def dry_run? + @dry_run == true + end + + def drb_port + @drb_port.to_i if defined?(@drb_port) + end + + protected + + def define_predicate_matchers + Spec::Runner.configuration.predicate_matchers.each_pair do |matcher_method, method_on_object| + Spec::Example::ExampleMethods::__send__ :define_method, matcher_method do |*args| + eval("be_#{method_on_object.to_s.gsub('?','')}(*args)") + end + end + end + + def plugin_mock_framework + case mock_framework + when Module + Spec::Example::ExampleMethods.__send__ :include, mock_framework + else + require mock_framework + Spec::Example::ExampleMethods.__send__ :include, Spec::Adapters::MockFramework + end + end + + def ignore_backtrace_patterns + @backtrace_tweaker.ignore_patterns Spec::Runner.configuration.ignored_backtrace_patterns + end + + def examples_should_be_run? + return @examples_should_be_run unless @examples_should_be_run.nil? + @examples_should_be_run = true + end + + def differ_class=(klass) + return unless klass + @differ_class = klass + Spec::Expectations.differ = self.differ_class.new(self) + end + + def load_class(name, kind, option) + if name =~ /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ + arg = $2 == "" ? nil : $2 + [$1, arg] + else + m = "#{name.inspect} is not a valid class name" + @error_stream.puts m + raise m + end + begin + eval(name, binding, __FILE__, __LINE__) + rescue NameError => e + @error_stream.puts "Couldn't find #{kind} class #{name}" + @error_stream.puts "Make sure the --require option is specified *before* #{option}" + if $_spec_spec ; raise e ; else exit(1) ; end + end + end + + def custom_runner + return nil unless custom_runner? + klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner) + runner_type = load_class(klass_name, 'example group runner', '--runner') + return runner_type.new(self, arg) + end + + def custom_runner? + return user_input_for_runner ? true : false + end + + def heckle + heckle_runner = self.heckle_runner + self.heckle_runner = nil + heckle_runner.heckle_with + end + + def sorted_files + return sorter ? files.sort(&sorter) : files + end + + def sorter + FILE_SORTERS[loadby] + end + + def default_differ + require 'spec/runner/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 providing a line number" + exit(1) if stderr? + else + example = LineNumberQuery.new(self).spec_name_for(files[0], line_number) + @examples = [example] + end + else + error_stream.puts "Only one file can be specified when providing a line number: #{files.inspect}" + exit(3) if stderr? + end + else + error_stream.puts "You cannot use --example and specify a line number" + exit(4) if stderr? + end + end + + def stderr? + @error_stream == $stderr + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/runner/reporter.rb b/vendor/gems/rspec-1.3.1/lib/spec/runner/reporter.rb new file mode 100644 index 000000000..0fae7d137 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/runner/reporter.rb @@ -0,0 +1,171 @@ +module Spec + module Runner + class Reporter + attr_reader :options + + def initialize(options) + @options = options + @options.reporter = self + @failures = [] + @pending_count = 0 + @example_count = 0 + @start_time = nil + @end_time = nil + end + + def example_group_started(example_group) + @example_group = example_group + formatters.each do |f| + f.example_group_started(example_group) + end + end + + def example_started(example) + formatters.each{|f| f.example_started(example)} + end + + def example_finished(example, error=nil) + @example_count += 1 + + if error.nil? + example_passed(example) + elsif Spec::Example::ExamplePendingError === error + example_pending(example, example.location, error.message) + else + example_failed(example, error) + end + end + + def example_failed(example, error) + backtrace_tweaker.tweak_backtrace(error) + failure = Failure.new(@example_group.description, example.description, error) + @failures << failure + formatters.each do |f| + f.example_failed(example, @failures.length, failure) + end + end + + def start(number_of_examples) + @start_time = Time.new + formatters.each{|f| f.start(number_of_examples)} + end + + def end + @end_time = Time.new + end + + # Dumps the summary and returns the total number of failures + def dump + formatters.each{|f| f.start_dump} + dump_pending + dump_failures + formatters.each do |f| + f.dump_summary(duration, @example_count, @failures.length, @pending_count) + f.close + end + @failures.length + end + + class Failure + def initialize(group_description, example_description, exception) # :nodoc: + @example_name = "#{group_description} #{example_description}" + @exception = exception + end + + # The Exception object raised + attr_reader :exception + + # Header messsage for reporting this failure, including the name of the + # example and an indicator of the type of failure. FAILED indicates a + # failed expectation. FIXED indicates a pending example that passes, and + # no longer needs to be pending. RuntimeError indicates that a + # RuntimeError occured. + # + # == Examples + # + # 'A new account should have a zero balance' FAILED + # 'A new account should have a zero balance' FIXED + # RuntimeError in 'A new account should have a zero balance' + def header + if expectation_not_met? + "'#{@example_name}' FAILED" + elsif pending_fixed? + "'#{@example_name}' FIXED" + else + "#{@exception.class.name} in '#{@example_name}'" + end + end + + def pending_fixed? # :nodoc: + @exception.is_a?(Spec::Example::PendingExampleFixedError) + end + + def expectation_not_met? # :nodoc: + @exception.is_a?(Spec::Expectations::ExpectationNotMetError) + end + end + + private + + def formatters + @options.formatters + end + + def backtrace_tweaker + @options.backtrace_tweaker + end + + def dump_failures + return if @failures.empty? + @failures.inject(1) do |index, failure| + formatters.each{|f| f.dump_failure(index, failure)} + index + 1 + end + end + + def dump_pending + formatters.each{|f| f.dump_pending} + end + + def duration + return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?) + return "0.0" + end + + def example_passed(example) + formatters.each{|f| f.example_passed(example)} + end + + EXAMPLE_PENDING_DEPRECATION_WARNING = <<-WARNING + +********************************************************************* +DEPRECATION WARNING: RSpec's formatters have changed example_pending +to accept two arguments instead of three. Please see the rdoc +for Spec::Runner::Formatter::BaseFormatter#example_pending +for more information. + +Please update any custom formatters to accept only two arguments +to example_pending. Support for example_pending with two arguments +and this warning message will be removed after the RSpec 2.0 release. +********************************************************************* +WARNING + + def example_pending(example, ignore, message="Not Yet Implemented") + @pending_count += 1 + formatters.each do |formatter| + if formatter_uses_deprecated_example_pending_method?(formatter) + Spec.warn EXAMPLE_PENDING_DEPRECATION_WARNING + formatter.example_pending(example, message, example.location) + else + formatter.example_pending(example, message) + end + end + end + + def formatter_uses_deprecated_example_pending_method?(formatter) + formatter.method(:example_pending).arity == 3 + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/stubs/cucumber.rb b/vendor/gems/rspec-1.3.1/lib/spec/stubs/cucumber.rb new file mode 100644 index 000000000..ed294ed66 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/stubs/cucumber.rb @@ -0,0 +1,5 @@ +# This plugs RSpec's mocking/stubbing framework into cucumber +require 'spec/mocks' +Before {$rspec_mocks ||= Spec::Mocks::Space.new} +After {$rspec_mocks.reset_all} +World(Spec::Mocks::ExampleMethods) diff --git a/vendor/gems/rspec-1.3.1/lib/spec/test/unit.rb b/vendor/gems/rspec-1.3.1/lib/spec/test/unit.rb new file mode 100644 index 000000000..fb4eb4932 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/test/unit.rb @@ -0,0 +1,10 @@ +require 'spec/interop/test' + +# Hack to stop active_support/dependencies from complaining about +# 'spec/test/unit' not defining Spec::Test::Unit +module Spec + module Test + module Unit + end + end +end diff --git a/vendor/gems/rspec-1.3.1/lib/spec/version.rb b/vendor/gems/rspec-1.3.1/lib/spec/version.rb new file mode 100644 index 000000000..122c45101 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/lib/spec/version.rb @@ -0,0 +1,14 @@ +module Spec # :nodoc: + module VERSION # :nodoc: + unless defined? MAJOR + MAJOR = 1 + MINOR = 3 + TINY = 1 + PRE = nil + + STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.') + + SUMMARY = "rspec #{STRING}" + end + end +end diff --git a/vendor/gems/rspec-1.3.1/resources/helpers/cmdline.rb b/vendor/gems/rspec-1.3.1/resources/helpers/cmdline.rb new file mode 100644 index 000000000..0e337579b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/resources/helpers/cmdline.rb @@ -0,0 +1,8 @@ +require 'spec' + +# Uncommenting next line will break the output feature (no output!!) +# rspec_options +options = Spec::Runner::OptionParser.parse( + ARGV, $stderr, $stdout +) +Spec::Runner::CommandLine.run(options) diff --git a/vendor/gems/rspec-1.3.1/resources/rake/examples.rake b/vendor/gems/rspec-1.3.1/resources/rake/examples.rake new file mode 100644 index 000000000..32d0ad0e6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/resources/rake/examples.rake @@ -0,0 +1,7 @@ +require 'rake' +require 'spec/rake/spectask' + +desc "Run all examples" +Spec::Rake::SpecTask.new('examples') do |t| + t.spec_files = FileList['examples/**/*.rb'] +end diff --git a/vendor/gems/rspec-1.3.1/resources/rake/examples_with_rcov.rake b/vendor/gems/rspec-1.3.1/resources/rake/examples_with_rcov.rake new file mode 100644 index 000000000..4bf35c6b8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/resources/rake/examples_with_rcov.rake @@ -0,0 +1,9 @@ +require 'rake' +require 'spec/rake/spectask' + +desc "Run all examples with RCov" +Spec::Rake::SpecTask.new('examples_with_rcov') do |t| + t.spec_files = FileList['examples/**/*.rb'] + t.rcov = true + t.rcov_opts = ['--exclude', 'examples'] +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/resources/rake/failing_examples_with_html.rake b/vendor/gems/rspec-1.3.1/resources/rake/failing_examples_with_html.rake new file mode 100644 index 000000000..6e53551f3 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/resources/rake/failing_examples_with_html.rake @@ -0,0 +1,9 @@ +require 'rake' +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/reports/tools/failing_examples.html", "--diff"] + t.fail_on_error = false +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/resources/rake/verify_rcov.rake b/vendor/gems/rspec-1.3.1/resources/rake/verify_rcov.rake new file mode 100644 index 000000000..a2fab00bc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/resources/rake/verify_rcov.rake @@ -0,0 +1,7 @@ +require 'rake' +require 'spec/rake/verify_rcov' + +RCov::VerifyTask.new(:verify_rcov => 'spec:rcov') do |t| + t.threshold = 100.0 + t.index_html = 'coverage/index.html' +end diff --git a/vendor/gems/rspec-1.3.1/spec/README.jruby b/vendor/gems/rspec-1.3.1/spec/README.jruby new file mode 100644 index 000000000..7eddb5671 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/README.jruby @@ -0,0 +1,15 @@ += Running specs on JRuby = + +svn co http://svn.codehaus.org/jruby/trunk jruby +cd jruby/jruby +ant clean +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 +cd target/rspec +jruby bin/spec spec -c diff --git a/vendor/gems/rspec-1.3.1/spec/autotest/autotest_helper.rb b/vendor/gems/rspec-1.3.1/spec/autotest/autotest_helper.rb new file mode 100644 index 000000000..3af9295de --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/autotest/autotest_helper.rb @@ -0,0 +1,8 @@ +require 'spec_helper' +begin + require 'autotest' +rescue LoadError + raise "You must install ZenTest to use autotest" +end +require 'autotest/rspec' +require 'autotest/autotest_matchers' diff --git a/vendor/gems/rspec-1.3.1/spec/autotest/autotest_matchers.rb b/vendor/gems/rspec-1.3.1/spec/autotest/autotest_matchers.rb new file mode 100644 index 000000000..2bfca4ac3 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/autotest/autotest_matchers.rb @@ -0,0 +1,38 @@ +module Spec + module Matchers + class AutotestMappingMatcher + def initialize(specs) + @specs = specs + end + + def to(file) + @file = file + self + end + + def matches?(autotest) + @autotest = prepare(autotest) + @actual = autotest.test_files_for(@file) + @actual == @specs + end + + def failure_message + "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}" + end + + private + + def prepare(autotest) + find_order = @specs.dup << @file + autotest.instance_eval { @find_order = find_order } + autotest + end + + end + + def map_specs(specs) + AutotestMappingMatcher.new(specs) + end + + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/autotest/discover_spec.rb b/vendor/gems/rspec-1.3.1/spec/autotest/discover_spec.rb new file mode 100644 index 000000000..46b872c17 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/autotest/discover_spec.rb @@ -0,0 +1,8 @@ +require 'autotest/autotest_helper' + +describe Autotest::Rspec, "discovery" do + it "adds the rspec autotest plugin" do + Autotest.should_receive(:add_discovery) + load File.expand_path("../../../lib/autotest/discover.rb", __FILE__) + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/autotest/failed_results_re_spec.rb b/vendor/gems/rspec-1.3.1/spec/autotest/failed_results_re_spec.rb new file mode 100644 index 000000000..87c65d407 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/autotest/failed_results_re_spec.rb @@ -0,0 +1,31 @@ +require 'autotest/autotest_helper' + +describe "failed_results_re" do + it "should match a failure" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\n'this example' FAILED\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end + + it "should match a failure when matcher outputs multiple lines" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\n'other example' FAILED\n\nreason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:\n\n" + $1.should == "other example" + $2.should == "reason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:" + end + + it "should match an Error" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\nRuntimeError in 'this example'\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end + + it "should match an Error that doesn't end in Error" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\nInvalidArgument in 'this example'\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/autotest/rspec_spec.rb b/vendor/gems/rspec-1.3.1/spec/autotest/rspec_spec.rb new file mode 100644 index 000000000..27fa600cc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/autotest/rspec_spec.rb @@ -0,0 +1,126 @@ +require 'autotest/autotest_helper' + +describe Autotest::Rspec do + describe "adding spec.opts --options" do + before(:each) do + @rspec_autotest = Autotest::Rspec.new + end + + it "should return the command line option to add spec.opts if the options file exists" do + File.stub!(:exist?).and_return true + @rspec_autotest.add_options_if_present.should == "-O spec/spec.opts " + end + + it "should return an empty string if no spec.opts exists" do + File.stub!(:exist?).and_return false + Autotest::Rspec.new.add_options_if_present.should == "" + end + end + + describe "commands" do + before(:each) do + @rspec_autotest = 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_cmd = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')) + @options = @rspec_autotest.add_options_if_present + files = %w[file_one file_two] + @files_to_test = { + files[0] => [], + files[1] => [] + } + # this is not the inner representation of Autotest! + @rspec_autotest.files_to_test = @files_to_test + @to_test = files.map { |f| File.expand_path(f) }.join ' ' + end + + it "should make the appropriate test command" do + cmd = @rspec_autotest.make_test_cmd(@files_to_test) + (cmd =~ /#{@ruby} #{@spec_cmd} --autospec (.*) #{@options}/).should be_true + $1.should =~ /#{File.expand_path('file_one')}/ + $1.should =~ /#{File.expand_path('file_two')}/ + end + + it "should return a blank command for no files" do + @rspec_autotest.make_test_cmd({}).should == '' + end + end + + describe "mappings" do + + before(:each) do + @lib_file = "lib/something.rb" + @spec_file = "spec/something_spec.rb" + @rspec_autotest = Autotest::Rspec.new + @rspec_autotest.hook :initialize + 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 if given a spec file" do + @rspec_autotest.should map_specs([@spec_file]).to(@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 ignore untracked files (in @file)" do + @rspec_autotest.should map_specs([]).to("lib/untracked_file") + end + end + + describe "consolidating failures" do + before(:each) do + @rspec_autotest = Autotest::Rspec.new + + @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(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 + + describe "normalizing file names" do + it "should ensure that a single file appears in files_to_test only once" do + @rspec_autotest = Autotest::Rspec.new + @files_to_test = {} + ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file| + @files_to_test[file] = [] + end + @rspec_autotest.normalize(@files_to_test).should have(1).file + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/ruby_forker.rb b/vendor/gems/rspec-1.3.1/spec/ruby_forker.rb new file mode 100644 index 000000000..6ab038750 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/ruby_forker.rb @@ -0,0 +1,13 @@ +require 'rbconfig' + +module RubyForker + # Forks a ruby interpreter with same type as ourself. + # juby will fork jruby, ruby will fork ruby etc. + def ruby(args, stderr=nil) + config = ::Config::CONFIG + interpreter = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT'] + cmd = "#{interpreter} #{args}" + cmd << " 2> #{stderr}" unless stderr.nil? + `#{cmd}` + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec.opts b/vendor/gems/rspec-1.3.1/spec/spec.opts new file mode 100644 index 000000000..48e51f93b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec.opts @@ -0,0 +1,6 @@ +--colour +--format +profile +--timeout +20 +--diff
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/dsl/main_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/dsl/main_spec.rb new file mode 100644 index 000000000..1edd8695e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/dsl/main_spec.rb @@ -0,0 +1,103 @@ +require 'spec_helper' + +module Spec + module DSL + describe Main do + before(:each) do + @main = Class.new do; include Spec::DSL::Main; end + end + + [:describe, :context].each do |method| + describe "##{method}" do + it "should delegate to Spec::Example::ExampleGroupFactory.create_example_group" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_example_group).with( + "The ExampleGroup", hash_including(:location), &block + ) + @main.__send__ method, "The ExampleGroup", &block + end + + it "raises with no description" do + block = lambda {|a,b|} + lambda do + @main.__send__ method, &block + end.should raise_error(ArgumentError, /No description supplied for example group declared on #{__FILE__}:#{__LINE__ - 1}/) + end + end + end + + [:share_examples_for, :shared_examples_for].each do |method| + describe "##{method}" do + it "should create a shared ExampleGroup" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with( + "shared group", hash_including(:location), &block + ) + @main.__send__ method, "shared group", &block + end + end + end + + describe "#describe; with RUBY_VERSION = 1.9" do + it "includes an enclosing module into the block's scope" do + Spec::Ruby.stub!(:version).and_return("1.9") + + module Foo; module Bar; end; end + + Foo::Bar.should_receive(:included).with do |*args| + included_by = args.last + included_by.description.should == "this example group" + end + + module Foo + module Bar + describe("this example group") do; end + end + end + end + end + + describe "#share_as" do + def self.next_group_name + @group_number ||= 0 + @group_number += 1 + "Group#{@group_number}" + end + + def group_name + @group_name ||= self.class.next_group_name + end + + before(:each) do + Spec.stub(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + share_as group_name do; end + end + + it "registers a shared ExampleGroup" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with( + group_name, hash_including(:location), &block + ) + @main.share_as group_name, &block + end + + it "creates a constant that points to a Module" do + group = @main.share_as group_name do end + Object.const_get(group_name).should equal(group) + end + + it "complains if you pass it a not-constantizable name" do + lambda do + @group = @main.share_as "Non Constant" do end + end.should raise_error(NameError, /The first argument to share_as must be a legal name for a constant/) + end + + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_class_definition_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_class_definition_spec.rb new file mode 100644 index 000000000..96bd21110 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_class_definition_spec.rb @@ -0,0 +1,51 @@ +require 'spec_helper' + +module Spec + module Example + class ExampleGroupSubclass < ExampleGroup + class << self + attr_accessor :examples_ran + end + + @@class_variable = :class_variable + CONSTANT = :constant + + before(:each) do + @instance_variable = :instance_variable + end + + after(:all) do + self.class.examples_ran = true + end + + def a_method + 22 + end + + it "can access instance variables defined before(:each)" do + @instance_variable.should == :instance_variable + end + + it "can access class variables (Ruby 1.8 only)" do + with_ruby 1.8 do + @@class_variable.should == :class_variable + end + end + + it "can access constants" do + CONSTANT.should == :constant + end + + it "can access methods defined in the Example Group" do + a_method.should == 22 + end + + end + + describe ExampleGroupSubclass do + it "should run" do + ExampleGroupSubclass.examples_ran.should be_true + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_factory_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_factory_spec.rb new file mode 100644 index 000000000..0819d3a3e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_factory_spec.rb @@ -0,0 +1,180 @@ +require 'spec_helper' + +module Spec + module Example + describe ExampleGroupFactory do + describe "#get" do + attr_reader :example_group + before(:each) do + @example_group_class = Class.new(ExampleGroupDouble) + ExampleGroupFactory.register(:registered_type, @example_group_class) + end + + after(:each) do + ExampleGroupFactory.reset + end + + it "should return the default ExampleGroup type for nil" do + ExampleGroupFactory[nil].should == ExampleGroup + end + + it "should return the default ExampleGroup for an unregistered non-nil value" do + ExampleGroupFactory[:does_not_exist].should == ExampleGroup + end + + it "should return custom type if registered" do + ExampleGroupFactory[:registered_type].should == @example_group_class + end + + it "should get the custom type after setting the default" do + @alternate_example_group_class = Class.new(ExampleGroupDouble) + ExampleGroupFactory.default(@alternate_example_group_class) + ExampleGroupFactory[:registered_type].should == @example_group_class + end + end + + describe "#create_example_group" do + attr_reader :parent_example_group + before do + @parent_example_group = Class.new(ExampleGroupDouble) do + def initialize(*args, &block) + ; + end + end + 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 + example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {} + example_group.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 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 not run unregistered ExampleGroups" do + example_group = Spec::Example::ExampleGroupFactory.create_example_group "The ExampleGroup" do Spec::Runner.options.remove_example_group self; end + Spec::Runner.options.example_groups.should_not include(example_group) + 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 + + 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 + + it "should create a type indicated by :location" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :location => "./spec/something_other_than_default/some_spec.rb" + ) {} + custom_example_group.superclass.should == parent_example_group + end + + it "should create a type indicated by :location (with location 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", + :location => "./spec\\something_other_than_default\\some_spec.rb" + ) {} + custom_example_group.superclass.should == parent_example_group + end + + it "should create a type indicated by location for a path-like key" do + Spec::Example::ExampleGroupFactory.register('path/to/custom/', parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :location => "./spec/path/to/custom/some_spec.rb" + ) {} + custom_example_group.superclass.should == parent_example_group + end + + it "should use the longest key that matches when creating a type indicated by location" do + longer = Class.new parent_example_group + Spec::Example::ExampleGroupFactory.register(:longer, longer) + long = Class.new parent_example_group + Spec::Example::ExampleGroupFactory.register(:long, long) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "example_group", :location => "./spec/longer/some_spec.rb" + ) {} + custom_example_group.superclass.should == longer + end + + describe "with :shared => true" do + def shared_example_group + @shared_example_group ||= Spec::Example::ExampleGroupFactory.create_example_group( + "name", :location => '/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 :location" do + Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group) + custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group( + "name", :location => '/blah/spec/models/blah.rb', :type => :something_other_than_default + ) {} + custom_example_group.superclass.should == parent_example_group + end + + 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 + Spec::Runner.options.remove_example_group self + end + Spec::Runner.options.example_groups.should_not include(example_group) + end + + after(:each) do + Spec::Example::ExampleGroupFactory.reset + end + end + + describe "#create_shared_example_group" do + it "registers a new shared example group" do + shared_example_group = Spec::Example::ExampleGroupFactory.create_shared_example_group("something shared") {} + shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup) + SharedExampleGroup.should include(shared_example_group) + end + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_methods_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_methods_spec.rb new file mode 100644 index 000000000..32eaee6a7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_methods_spec.rb @@ -0,0 +1,778 @@ +require 'spec_helper' + +module Spec + module Example + describe 'ExampleGroupMethods' do + with_sandboxed_options do + attr_reader :example_group, :result, :reporter + before(:each) do + # See http://rspec.lighthouseapp.com/projects/5645-rspec/tickets/525-arity-changed-on-partial-mocks#ticket-525-2 + method_with_three_args = lambda { |arg1, arg2, arg3| } + options.formatters << mock("formatter", :null_object => true, :example_pending => method_with_three_args) + options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true) + @reporter = FakeReporter.new(@options) + options.reporter = reporter + @example_group = Class.new(ExampleGroupDouble) do + describe("ExampleGroup") + it "does nothing" + end + end + + after(:each) do + ExampleGroupDouble.reset + end + + ["describe","context"].each do |method| + describe "##{method}" do + describe "when creating an ExampleGroup" do + before(:each) do + @parent_example_group = Class.new(ExampleGroupDouble) do + example "first example" do; end + end + @child_example_group = @parent_example_group.__send__ method, "Child" do + example "second example" do; end + end + end + + it "should create a subclass of the ExampleGroup when passed a block" do + @child_example_group.superclass.should == @parent_example_group + options.example_groups.should include(@child_example_group) + end + + it "should not inherit examples" do + @child_example_group.should have(1).examples + end + + it "records the spec path" do + @child_example_group.location.should =~ /#{__FILE__}:#{__LINE__ - 15}/ + end + end + + describe "when creating an example group with no description" do + it "raises an ArgumentError" do + lambda do + Class.new(ExampleGroupDouble).describe + end.should raise_error(Spec::Example::NoDescriptionError, /No description supplied for example group declared on #{__FILE__}:#{__LINE__ - 1}/) + end + end + + describe "when creating a SharedExampleGroup" do + before(:each) do + @shared_example_group = @example_group.__send__ method, "A Shared ExampleGroup", :shared => true do; end + end + + after(:each) do + SharedExampleGroup.instance_eval{@shared_example_groups}.delete @shared_example_group + end + + it "should create a SharedExampleGroup" do + @shared_example_group.should_not be_nil + SharedExampleGroup.find("A Shared ExampleGroup").should == @shared_example_group + end + end + + end + end + + [:example, :specify, :it].each do |method| + describe "##{method.to_s}" do + it "should add an example" do + lambda { + @example_group.__send__(method, "") + }.should change { @example_group.examples.length }.by(1) + end + + describe "with no location supplied" do + describe "creates an ExampleProxy" do + before(:all) do + @example_group = Class.new(ExampleGroupDouble).describe("bar") + @example_proxy = @example_group.__send__(method, "foo", {:this => :that}) {} + @location = "#{__FILE__}:#{__LINE__ - 1}" + end + + specify "with a description" do + @example_proxy.description.should == "foo" + end + + specify "with options" do + @example_proxy.options.should == {:this => :that} + end + + specify "with a default backtrace (DEPRECATED)" do + Spec.stub!(:deprecate) + @example_proxy.backtrace.should =~ /#{@location}/ + end + + specify "with a default location" do + @example_proxy.location.should =~ /#{@location}/ + end + end + end + + describe "with a location supplied" do + describe "creates an ExampleProxy" do + before(:all) do + @example_group = Class.new(ExampleGroupDouble).describe("bar") + @example_proxy = @example_group.__send__(method, "foo", {:this => :that}, "the location") {} + end + + specify "with the supplied location as #backtrace (DEPRECATED)" do + Spec.stub!(:deprecate) + @example_proxy.backtrace.should == "the location" + end + + specify "with the supplied location as #location" do + @example_proxy.location.should == "the location" + end + end + end + + + end + end + + [:xexample, :xit, :xspecify].each do |method| + describe "##{method.to_s}" do + before(:each) do + Kernel.stub!(:warn) + end + + it "should NOT create an example" do + lambda { + @example_group.__send__(method,"") + }.should_not change(@example_group.examples, :length) + end + + it "should warn that the example is disabled" do + Kernel.should_receive(:warn).with("Example disabled: foo") + @example_group.__send__(method,"foo") + end + end + end + + describe "#examples" do + it "should have Examples" do + example_group = Class.new(ExampleGroupDouble) do + it "should exist" do; end + end + example_group.examples.length.should == 1 + example_group.examples.first.description.should == "should exist" + end + + it "should not include methods that begin with test (only when TU interop is loaded)" do + example_group = Class.new(ExampleGroupDouble) do + 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 + def should_something + # forces the run + end + end + + example_group.examples.length.should == 1 + example_group.run(options).should be_true + end + + it "should include methods that begin with should and has an arity of 0 in suite" do + example_group = Class.new(ExampleGroupDouble) do + def shouldCamelCase + true.should be_true + end + def should_any_args(*args) + true.should be_true + end + def should_something + 1.should == 1 + end + def should_not_something + 1.should_not == 2 + end + def should + raise "This is not a real example" + end + def should_not + raise "This is not a real example" + end + end + example_group.should have(4).examples + descriptions = example_group.examples.collect {|e| e.description} + descriptions.should include( + "shouldCamelCase", + "should_any_args", + "should_something", + "should_not_something") + descriptions.should_not include( + "should", + "should_not" + ) + end + + it "should not include methods that begin with test_ and has an arity > 0 in suite" do + example_group = Class.new(ExampleGroupDouble) do + def test_invalid(foo) + 1.should == 1 + end + def testInvalidCamelCase(foo) + 1.should == 1 + end + end + example_group.should have(:no).examples + end + + it "should not include methods that begin with should_ and has an arity > 0 in suite" do + example_group = Class.new(ExampleGroupDouble) do + def should_invalid(foo) + 1.should == 2 + end + def shouldInvalidCamelCase(foo) + 1.should == 3 + end + def should_not_invalid(foo) + 1.should == 4 + end + def should_valid + 1.should == 1 + end + end + example_group.should have(1).examples + example_group.run(options).should be_true + end + + it "should run should_methods" do + example_group = Class.new(ExampleGroupDouble) do + def should_valid + 1.should == 2 + end + end + example_group.should have(1).examples + example_group.run(options).should be_false + end + end + + describe "#set_description" do + attr_reader :example_group + before do + class << example_group + public :set_description + end + end + + describe "given a String" do + before(:each) do + example_group.set_description("abc") + end + + specify ".description should return the String passed into .set_description" do + example_group.description.should == "abc" + end + + specify ".described_type should provide nil as its type" do + example_group.described_type.should be_nil + end + end + + describe "given a Class" do + before(:each) do + example_group.set_description(ExampleGroup) + end + + specify ".description should return a String representation of that type (fully qualified) as its name" do + example_group.description.should == "Spec::Example::ExampleGroup" + end + + specify ".described_type should return the passed in type" do + example_group.described_type.should == Spec::Example::ExampleGroup + end + end + + describe "given a String and a Class" do + before(:each) do + example_group.set_description("behaving", ExampleGroup) + end + + specify ".description should return String then space then Type" do + example_group.description.should == "behaving Spec::Example::ExampleGroup" + end + + specify ".described_type should return the passed in type" do + example_group.described_type.should == Spec::Example::ExampleGroup + end + end + + describe "given a Class and a String (starting with an alpha char)" do + before(:each) do + example_group.set_description(ExampleGroup, "behaving") + end + + specify ".description should return the Type then space then String" do + example_group.description.should == "Spec::Example::ExampleGroup behaving" + end + end + + describe "given a Class and a String (starting with a '.')" do + before(:each) do + example_group.set_description(ExampleGroup, ".behaving") + end + + specify ".description should return the Type then String" do + example_group.description.should == "Spec::Example::ExampleGroup.behaving" + end + end + + describe "#set_description(Class, String starting with #)" do + before(:each) do + example_group.set_description(ExampleGroup, "#behaving") + end + + specify "should return the Class then String" do + example_group.description.should == "Spec::Example::ExampleGroup#behaving" + end + end + + describe "#set_description(Class, String containing .)" do + before(:each) do + example_group.set_description(ExampleGroup, "calling a.b") + end + + specify ".description should return the Type then space then String" do + example_group.description.should == "Spec::Example::ExampleGroup calling a.b" + end + end + + describe "#set_description(Class, String containing #)" do + before(:each) do + example_group.set_description(ExampleGroup, "is #1") + end + + specify ".description should return the Type then space then String" do + example_group.description.should == "Spec::Example::ExampleGroup is #1" + end + end + + describe "#set_description(String, Type, String)" do + before(:each) do + example_group.set_description("A", Hash, "with one entry") + end + + specify ".description should return the first String then space then Type then second String" do + example_group.description.should == "A Hash with one entry" + end + end + + describe "#set_description(Hash representing options)" do + before(:each) do + example_group.set_description(:a => "b", :location => "blah") + end + + it ".location should expand the passed in :location option passed into the constructor" do + example_group.location.should == File.expand_path("blah") + end + + it ".options should return all the options passed in" do + example_group.options.should == {:a => "b", :location => "blah"} + end + + end + end + + describe "#description" do + it "should return the same description instance for each call" do + example_group.description.should eql(example_group.description) + end + + it "should not add a space when description begins with #" do + child_example_group = Class.new(example_group) do + describe("#foobar", "Does something") + end + child_example_group.description.should == "ExampleGroup#foobar Does something" + end + + it "should not add a space when description begins with ." do + child_example_group = Class.new(example_group) do + describe(".foobar", "Does something") + end + child_example_group.description.should == "ExampleGroup.foobar Does something" + end + + it "should return the class name if nil" do + example_group.set_description(nil) + example_group.description.should =~ /Class:/ + end + + it "should return the class name if nil" do + example_group.set_description("") + example_group.description.should =~ /Class:/ + end + + it "is cached" do + example_group.set_description("describe me") + example_group.description.should be(example_group.description) + end + end + + describe "#description_parts" do + it "should return an Array of the current class description args" do + example_group.description_parts.should == [example_group.description] + end + + it "should return an Array of the description args from each class in the hierarchy" do + parent_example_group = Class.new(ExampleGroupDouble) do + describe("Parent") + end + + child_example_group = Class.new(parent_example_group) + child_example_group.describe("Child", ExampleGroup) + child_example_group.description.should_not be_empty + + grand_child_example_group = Class.new(child_example_group) + grand_child_example_group.describe("GrandChild", ExampleGroup) + grand_child_example_group.description.should_not be_empty + + grand_child_example_group.description_parts.should == [ + "Parent", + "Child", + Spec::Example::ExampleGroup, + "GrandChild", + Spec::Example::ExampleGroup + ] + end + + it "caches the description parts" do + example_group.description_parts.should equal(example_group.description_parts) + end + end + + describe "#described_type" do + it "should return passed in type" do + child_example_group = Class.new(example_group) do + describe Object + end + child_example_group.described_type.should == Object + end + + it "should return #described_type of superclass when no passed in type" do + parent_example_group = Class.new(ExampleGroupDouble) do + describe Object, "#foobar" + end + child_example_group = Class.new(parent_example_group) do + describe "not a type" + end + child_example_group.described_type.should == Object + end + + it "is cached per example group" do + klass = Class.new + group = Class.new(ExampleGroupDouble) do + describe(klass) + end + group.should_receive(:description_parts).once.and_return([klass]) + group.described_type + group.described_type + end + end + + describe "#include" do + it "should have accessible class methods from included module" do + mod_method_called = false + mod = Module.new do + class_methods = Module.new do + define_method :mod_method do + mod_method_called = true + end + end + + self.class.class_eval do + define_method(:included) do |receiver| + receiver.extend class_methods + end + end + end + + @example_group.__send__ :include, mod + + @example_group.mod_method + mod_method_called.should be_true + end + end + + describe "#number_of_examples" do + it "should count number of examples" do + proc do + @example_group.it("one") {} + @example_group.it("two") {} + @example_group.it("three") {} + @example_group.it("four") {} + end.should change {@example_group.number_of_examples}.by(4) + end + end + + describe "#class_eval" do + it "should allow constants to be defined" do + example_group = Class.new(ExampleGroupDouble) do + FOO = 1 + it "should reference FOO" do + FOO.should == 1 + end + end + success = example_group.run(options) + success.should be_true + Object.const_defined?(:FOO).should == false + end + end + + describe '#register' do + after(:each) do + Spec::Runner.options.remove_example_group example_group + end + it "should add ExampleGroup to set of ExampleGroups to be run" do + Spec::Runner.options.add_example_group example_group + options.example_groups.should include(example_group) + end + end + + describe '#remove_example_group' do + before(:each) do + Spec::Runner.options.add_example_group example_group + end + it "should remove ExampleGroup from set of ExampleGroups to be run" do + Spec::Runner.options.remove_example_group example_group + options.example_groups.should_not include(example_group) + end + end + + describe "#run" do + describe "given an example group with at least one example" do + it "should call add_example_group" do + example_group = Class.new(ExampleGroupDouble) do + example("anything") {} + end + reporter.should_receive(:add_example_group) + example_group.run(options) + end + end + + describe "given an example group with no examples" do + it "should NOT call add_example_group" do + example_group = Class.new(ExampleGroupDouble) do end + reporter.should_not_receive(:add_example_group) + example_group.run(options) + end + end + end + + describe "#matcher_class=" do + it "should call new and matches? on the class used for matching examples" do + example_group = Class.new(ExampleGroupDouble) do + it "should do something" do end + def self.specified_examples + ["something"] + end + def self.to_s + "TestMatcher" + end + end + + matcher = mock("matcher") + matcher.should_receive(:matches?).with(["something"]).any_number_of_times + + matcher_class = Class.new + matcher_class.should_receive(:new).with("TestMatcher", "should do something").and_return(matcher) + + begin + ExampleGroupMethods.matcher_class = matcher_class + + example_group.run(options) + ensure + ExampleGroupMethods.matcher_class = ExampleMatcher + end + end + end + + describe "#options" do + it "should expose the options hash" do + group = describe("group", :this => 'hash') {} + group.options[:this].should == 'hash' + end + end + + describe "#before" do + it "stores before(:each) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + block = lambda {} + example_group.before(:each, &block) + example_group.before_each_parts.should include(block) + end + + it "stores before(:all) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + block = lambda {} + example_group.before(:all, &block) + example_group.before_all_parts.should include(block) + end + + it "stores before(:suite) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + parts = [] + ExampleGroupMethods.stub!(:before_suite_parts).and_return(parts) + block = lambda {} + example_group.before(:suite, &block) + example_group.before_suite_parts.should include(block) + end + end + + + describe "#after" do + it "stores after(:each) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + block = lambda {} + example_group.after(:each, &block) + example_group.after_each_parts.should include(block) + end + + it "stores after(:all) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + block = lambda {} + example_group.after(:all, &block) + example_group.after_all_parts.should include(block) + end + + it "stores after(:suite) blocks" do + example_group = Class.new(ExampleGroupDouble) {} + parts = [] + ExampleGroupMethods.stub!(:after_suite_parts).and_return(parts) + block = lambda {} + example_group.after(:suite, &block) + example_group.after_suite_parts.should include(block) + end + end + + describe "#run_before_all" do + it "does not create an instance if before_all_parts are empty" do + example_group = Class.new(ExampleGroupDouble) { example("one example") {} } + example_group.should_not_receive(:new) + example_group.__send__ :run_before_all, nil + end + end + + describe "#run_after_all" do + it "does not create an instance if after_all_parts are empty" do + example_group = Class.new(ExampleGroupDouble) { example("one example") {} } + example_group.should_not_receive(:new) + example_group.__send__ :run_after_all, true, {}, nil + end + end + + describe "#examples_to_run" do + it "runs only the example identified by a line number" do + example_group = Class.new(ExampleGroupDouble).describe("this") do + it { 3.should == 3 } + it "has another example which raises" do + raise "this shouldn't have run" + end + end + options.examples << :ignore + options.line_number = __LINE__ - 6 + options.files << __FILE__ + example_group.run(options).should be_true + end + + it "runs the example identified by a line number even if it's not the example line number" do + example_group = Class.new(ExampleGroupDouble).describe("this") do + + it { raise "foo" } + + end + options.examples << :ignore + options.line_number = __LINE__ - 3 + options.files << __FILE__ + example_group.run(options).should be_false + end + + it "runs all the examples in the group " do + first_example_ran = false + second_example_ran = false + example_group = Class.new(ExampleGroupDouble).describe("this") do + + it { first_example_ran = true } + it { second_example_ran = true } + + end + options.line_number = __LINE__ - 6 + options.files << __FILE__ + options.examples << :ignore + example_group.run(options) + first_example_ran.should be_true + second_example_ran.should be_true + end + + it "doesn't run any examples in another group" do + example_ran = false + example_group_1 = Class.new(ExampleGroupDouble).describe("this") do + it "ignore" do + example_ran = true + end + end + example_group_2 = Class.new(ExampleGroupDouble).describe("that") do + end + options.examples << :ignore + options.line_number = __LINE__ - 3 + options.files << __FILE__ + example_group_1.run(options) + example_group_2.run(options) + example_ran.should be_false + end + end + + describe "#let" do + let(:counter) do + Class.new do + def initialize + @count = 0 + end + def count + @count += 1 + end + end.new + end + + it "generates an instance method" do + counter.count.should == 1 + end + + it "caches the value" do + counter.count.should == 1 + counter.count.should == 2 + end + end + + describe "#let!" do + let!(:creator) do + class Creator + @count = 0 + def self.count + @count += 1 + end + end + end + + it "evaluates the value non-lazily" do + lambda { Creator.count }.should_not raise_error + end + + it "does not interfere between tests" do + Creator.count.should == 1 + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_proxy_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_proxy_spec.rb new file mode 100644 index 000000000..8d42f3a04 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_proxy_spec.rb @@ -0,0 +1,107 @@ +require 'spec_helper' + +module Spec + module Example + describe ExampleGroupProxy do + before(:each) do + @group = stub("example group",:nested_descriptions => []).as_null_object + end + + attr_reader :group + def proxy + @proxy ||= ExampleGroupProxy.new(@group) + end + + describe "#description" do + it "provides the example group's description" do + group.stub!(:description => "the description") + proxy.description.should == "the description" + end + end + + describe "#nested_descriptions" do + it "provides the example group's nested_descriptions" do + group.stub!(:nested_descriptions => ["the description"]) + proxy.nested_descriptions.should == ["the description"] + end + end + + describe "#filtered_description (DEPRECATED)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + proxy.filtered_description(/(ignore)/) + end + + it "builds the description from the group's nested_descriptions" do + group.stub!(:nested_descriptions => ["ignore","the","description"]) + proxy.filtered_description(/(ignore)/).should == "the description" + end + + it "filters out description parts that match the supplied regexp" do + group.stub!(:nested_descriptions => ["ignore the","description"]) + proxy.filtered_description(/(ignore )/).should == "the description" + end + end + + describe "#examples" do + it "provides a collection of example group proxies" do + group.stub!(:example_proxies => ["array","of","proxies"]) + proxy.examples.should == ["array","of","proxies"] + end + end + + describe "#backtrace (deprecated - use #location)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "provides the location of the declaration of this group" do + group.stub!(:location => "path/to/location:37") + proxy.backtrace.should == "path/to/location:37" + end + + it "warns deprecation" do + Spec.should_receive(:deprecate) + group.stub!(:location => "path/to/location:37") + proxy.backtrace + end + end + + describe "#location" do + it "provides the location of the declaration of this group" do + group.stub!(:location => "path/to/location:37") + proxy.location.should == "path/to/location:37" + end + end + + describe "#options" do + it "provides the options passed to the example group declaration" do + group.stub!(:options => {:a => 'b'}) + proxy.options.should == {:a => 'b'} + end + + it "excludes :location" do + group.stub!(:options => {:location => 'b'}) + proxy.options.should == {} + end + + it "excludes :scope" do + group.stub!(:options => {:scope => 'b'}) + proxy.options.should == {} + end + + it "preserves the original hash" do + hash = {:a => 'b', :location => 'here', :scope => 'tiny'} + group.stub!(:options => hash) + proxy.options.should == {:a => 'b'} + hash.should == {:a => 'b', :location => 'here', :scope => 'tiny'} + end + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_spec.rb new file mode 100644 index 000000000..da04a3803 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_group_spec.rb @@ -0,0 +1,632 @@ +require 'spec_helper' + +module Spec + module Example + class ExampleModuleScopingSpec < ExampleGroup + describe ExampleGroup, "via a class definition" + + module Foo + module Bar + def self.loaded?; true; end + end + end + include Foo + + it "should understand module scoping" do + Bar.should be_loaded + end + + @@class_variable = "a class variable" + + it "can access class variables in examples in Ruby 1.8" do + @@class_variable.should == "a class variable" + end + + end + + class ExampleClassVariablePollutionSpec < ExampleGroup + describe ExampleGroup, "via a class definition without a class variable" + + it "should not retain class variables from other Example classes" do + proc do + @@class_variable + end.should raise_error + end + end + + describe ExampleGroup, "#pending" do + it "should raise a Pending error when its block fails" do + block_ran = false + lambda { + pending("something") do + block_ran = true + raise "something wrong with my example" + end + }.should raise_error(Spec::Example::ExamplePendingError, "something") + block_ran.should == true + end + + it "should raise Spec::Example::PendingExampleFixedError when its block does not fail" do + block_ran = false + lambda { + pending("something") do + block_ran = true + end + }.should raise_error(Spec::Example::PendingExampleFixedError, "Expected pending 'something' to fail. No Error was raised.") + block_ran.should == true + end + end + + describe ExampleGroup, "#run with failure in example", :shared => true do + it "should add an example failure to the TestResult" do + example_group.run(options).should be_false + end + end + + 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(ExampleGroupDouble) do + describe("example") + it "does nothing" do + end + end + class << example_group + public :include + end + end + + after :each do + ExampleGroup.reset + end + + it "should not run when there are no examples" do + example_group = Class.new(ExampleGroupDouble) do + describe("Foobar") + end + example_group.examples.should be_empty + + reporter = mock("Reporter") + reporter.should_not_receive(:add_example_group) + example_group.run(options) + end + + it "should report the start of an example run" do + reporter.should_receive(:example_started) do |example| + example.should equal(example_group.examples[0]) + end + example_group.run(options) + end + + it "should report the end of an example run" do + reporter.should_receive(:example_finished) do |example, execution_error| + example.should equal(example_group.examples[0]) + execution_error.should be_nil + end + example_group.run(options) + end + + describe "when before_each fails" do + before(:each) do + $example_ran = $after_each_ran = false + @example_group = describe("Foobar") do + before(:each) {raise} + it "should not be run" do + $example_ran = true + end + after(:each) do + $after_each_ran = true + end + end + end + + it "should not run example block" do + example_group.run(options) + $example_ran.should be_false + end + + it "should run after_each" do + example_group.run(options) + $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(options) + end + end + + describe ExampleGroup, "#run on dry run" do + before do + @options.dry_run = true + end + + it "should not run before(:all) or after(:all)" do + before_all_ran = false + after_all_ran = false + ExampleGroup.before(:all) { before_all_ran = true } + ExampleGroup.after(:all) { after_all_ran = true } + example_group.it("should") {} + example_group.run(options) + 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(options) + example_ran.should be_false + end + end + + describe ExampleGroup, "#run with specified examples" do + attr_reader :examples_that_were_run + before do + @examples_that_were_run = [] + end + + describe "when specified_examples matches entire ExampleGroup" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroupDouble) 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.parse_example "the ExampleGroup" + end + + it "should not run the Examples in the ExampleGroup" do + example_group.run(options) + examples_that_were_run.should == ['should be run', 'should also be run'] + end + end + + describe ExampleGroup, "#run when specified_examples matches only Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroupDouble) do + describe("example") + it("should be run") do + examples_that_were_run << 'should be run' + end + end + options.parse_example "should be run" + end + + it "should not run the example" do + example_group.run(options) + examples_that_were_run.should == ['should be run'] + end + end + + describe ExampleGroup, "#run when specified_examples does not match an Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroupDouble) do + describe("example") + it("should be something else") do + examples_that_were_run << 'should be something else' + end + end + options.parse_example "does not match anything" + end + + it "should not run the example" do + example_group.run(options) + examples_that_were_run.should == [] + end + end + + describe ExampleGroup, "#run when specified_examples matches an Example description" do + before do + examples_that_were_run = @examples_that_were_run + @example_group = Class.new(ExampleGroupDouble) 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.parse_example "should be run" + end + + it "should run only the example" do + example_group.run(options) + examples_that_were_run.should == ["should be run"] + end + end + end + + describe ExampleGroup, "#run with success" do + before do + @special_example_group = Class.new(ExampleGroupDouble) + ExampleGroupFactory.register(:special, @special_example_group) + @not_special_example_group = Class.new(ExampleGroupDouble) + ExampleGroupFactory.register(:not_special, @not_special_example_group) + end + + after do + ExampleGroupFactory.reset + end + + it "should send reporter example_group_started" do + reporter.should_receive(:example_group_started) + example_group.run(options) + end + + it "should run example on run" do + example_ran = false + example_group.it("should") {example_ran = true} + example_group.run(options) + 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(options) + 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(options) + 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(options) + 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(options) + 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(ExampleGroupDouble) do + describe("I'm not special", :type => :not_special) + it "does nothing" + end + example_group.run(options) + fiddle.should == [ + 'Example.prepend_before(:all)', + 'Example.before(:all)', + ] + end + + it "should add global before callbacks for targetted example_groups" do + fiddle = [] + + ExampleGroup.before(:all) { fiddle << "Example.before(:all)" } + ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" } + @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" } + @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" } + @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" } + @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" } + @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" } + + example_group = Class.new(@special_example_group).describe("I'm a special example_group") {} + example_group.it("test") {true} + example_group.run(options) + fiddle.should == [ + 'Example.prepend_before(:all)', + 'Example.before(:all)', + 'special.prepend_before(:all, :type => :special)', + 'special.before(:all, :type => :special)', + 'special.prepend_before(:each, :type => :special)', + 'special.before(:each, :type => :special)', + 'special.append_before(:each, :type => :special)', + ] + end + + it "should order before callbacks from global to local" do + fiddle = [] + ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" } + ExampleGroup.before(:all) { fiddle << "Example.before(:all)" } + example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" } + example_group.before(:all) { fiddle << "before(:all)" } + example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" } + example_group.before(:each) { fiddle << "before(:each)" } + example_group.run(options) + 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(options) + fiddle.should == [ + 'after(:each)', + 'append_after(:each)', + 'after(:all)', + 'append_after(:all)', + 'Example.after(:all)', + 'Example.append_after(:all)' + ] + end + + it "should have accessible instance methods from included module" do + mod1_method_called = false + mod1 = Module.new do + define_method :mod1_method do + mod1_method_called = true + end + end + + mod2_method_called = false + mod2 = Module.new do + define_method :mod2_method do + mod2_method_called = true + end + end + + example_group.include mod1, mod2 + + example_group.it("test") do + mod1_method + mod2_method + end + example_group.run(options) + mod1_method_called.should be_true + mod2_method_called.should be_true + end + + it "should include targetted modules included using configuration" do + mod1 = Module.new + mod2 = Module.new + mod3 = Module.new + Spec::Runner.configuration.include(mod1, mod2) + Spec::Runner.configuration.include(mod3, :type => :not_special) + + example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do + it "does nothing" + end + example_group.run(options) + + example_group.included_modules.should include(mod1) + example_group.included_modules.should include(mod2) + example_group.included_modules.should_not include(mod3) + end + + end + + describe ExampleGroup, "#run with pending example that has a failing assertion" do + before do + example_group.it("should be pending") do + pending("Example fails") {false.should be_true} + end + end + + it "should send example_pending to formatter" do + @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails") + example_group.run(options) + end + end + + describe ExampleGroup, "#run with pending example that does not have a failing assertion" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + example_group.it("should be pending") do + pending("Example passes") {true.should be_true} + end + end + + it "should send example_pending to formatter" do + @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes") + example_group.run(options) + end + end + + describe ExampleGroup, "#run when before(:all) fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" } + end + + it "should not run any example" do + spec_ran = false + example_group.it("test") {spec_ran = true} + example_group.run(options) + spec_ran.should be_false + end + + it "should run ExampleGroup after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run(options) + after_all_ran.should be_true + end + + it "should run example_group after(:all)" do + after_all_ran = false + example_group.after(:all) { after_all_ran = true } + example_group.run(options) + after_all_ran.should be_true + end + + it "should supply before(:all) as description" do + @reporter.should_receive(:example_failed) do |example, error| + example.description.should eql("before(:all)") + error.message.should eql("before(:all) failure") + end + + example_group.it("test") {true} + example_group.run(options) + end + end + + describe ExampleGroup, "#run when before(:each) fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + ExampleGroup.before(:each) { raise NonStandardError } + end + + it "should run after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run(options) + after_all_ran.should be_true + end + end + + describe ExampleGroup, "#run when any example fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + example_group.it("should") { raise NonStandardError } + end + + it "should run after(:all)" do + after_all_ran = false + ExampleGroup.after(:all) { after_all_ran = true } + example_group.run(options) + after_all_ran.should be_true + end + end + + describe ExampleGroup, "#run when first after(:each) block fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + class << example_group + attr_accessor :first_after_ran, :second_after_ran + end + example_group.first_after_ran = false + example_group.second_after_ran = false + + example_group.after(:each) do + self.class.second_after_ran = true + end + example_group.after(:each) do + self.class.first_after_ran = true + raise "first" + end + end + + it "should run second after(:each) block" do + reporter.should_receive(:example_finished) do |example, error| + example.should equal(example) + error.message.should eql("first") + end + example_group.run(options) + example_group.first_after_ran.should be_true + example_group.second_after_ran.should be_true + end + end + + describe ExampleGroup, "#run when first before(:each) block fails" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + class << example_group + attr_accessor :first_before_ran, :second_before_ran + end + example_group.first_before_ran = false + example_group.second_before_ran = false + + example_group.before(:each) do + self.class.first_before_ran = true + raise "first" + end + example_group.before(:each) do + self.class.second_before_ran = true + end + end + + it "should not run second before(:each)" do + reporter.should_receive(:example_finished) do |name, error| + error.message.should eql("first") + end + example_group.run(options) + example_group.first_before_ran.should be_true + example_group.second_before_ran.should be_false + end + end + + describe ExampleGroup, "#run when failure in after(:all)" do + it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example" + + before do + ExampleGroup.after(:all) { raise NonStandardError, "in after(:all)" } + end + + it "should return false" do + example_group.run(options).should be_false + end + end + end + end + + describe ExampleGroup, "subclasses" do + it "should have access to the described_type" do + example_group = Class.new(ExampleGroupDouble).describe(Array) + example_group.__send__(:described_type).should == Array + end + + it "should concat descriptions when nested" do + example_group = Class.new(ExampleGroupDouble).describe(Array) + nested_group = example_group.describe("when empty") do; end + nested_group.description.to_s.should == "Array when empty" + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_matcher_spec.rb new file mode 100644 index 000000000..d82224f7a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_matcher_spec.rb @@ -0,0 +1,85 @@ +require 'spec_helper' + +module Spec + module Example + describe ExampleMatcher, "#matches?" do + + Spec::Matchers.define :match_examples do |examples| + match do |actual| + actual.matches?(examples) + end + end + + it "should match correct example_group and example" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_examples(["example_group example"]) + end + + it "should not match wrong example" do + matcher = ExampleMatcher.new("example_group", "other example") + matcher.should_not match_examples(["example_group example"]) + end + + it "should not match wrong example_group" do + matcher = ExampleMatcher.new("other example_group", "example") + matcher.should_not match_examples(["example_group example"]) + end + + it "should match example only" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_examples(["example"]) + end + + it "should match example_group only" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_examples(["example_group"]) + end + + it "should match example_group ending with before(:all)" do + matcher = ExampleMatcher.new("example_group", "example") + matcher.should match_examples(["example_group before(:all)"]) + end + + it "should escape regexp chars" do + matcher = ExampleMatcher.new("(con|text)", "[example]") + matcher.should_not match_examples(["con p"]) + end + + it "should match when example_group is modularized" do + matcher = ExampleMatcher.new("MyModule::MyClass", "example") + matcher.should match_examples(["MyClass example"]) + end + end + + describe ExampleMatcher, "#matches? normal case" do + it "matches when passed in example matches" do + matcher = ExampleMatcher.new("Foo", "bar") + matcher.matches?(["no match", "Foo bar"]).should == true + end + + it "does not match when no passed in examples match" do + matcher = ExampleMatcher.new("Foo", "bar") + matcher.matches?(["no match1", "no match2"]).should == false + end + end + + describe ExampleMatcher, "#matches? where description has '::' in it" do + it "matches when passed in example matches" do + matcher = ExampleMatcher.new("Foo::Bar", "baz") + matcher.matches?(["no match", "Foo::Bar baz"]).should == true + end + + it "does not match when no passed in examples match" do + matcher = ExampleMatcher.new("Foo::Bar", "baz") + matcher.matches?(["no match1", "no match2"]).should == false + end + end + + describe ExampleMatcher, "called with nil example" do + it "does not puke" do + matcher = ExampleMatcher.new("Foo::Bar", nil) + matcher.matches?(["anything"]).should == false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_methods_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_methods_spec.rb new file mode 100644 index 000000000..9a6810952 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_methods_spec.rb @@ -0,0 +1,162 @@ +require 'spec_helper' + +class Thing + attr_reader :arg + def initialize(arg=nil) + @arg = arg || :default + end + def ==(other) + @arg == other.arg + end + def eql?(other) + @arg == other.arg + end +end + +module Spec + module Example + describe ExampleMethods do + module ModuleThatIsReopened; end + + module Spec::Example::ExampleMethods + include ModuleThatIsReopened + end + + module ModuleThatIsReopened + def module_that_is_reopened_method; end + end + + describe "with an included module that is reopened" do + it "should have reopened methods" do + method(:module_that_is_reopened_method).should_not be_nil + end + end + + describe "#should" do + before(:each) do + @example_group = Class.new(ExampleGroupDouble) + @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) + end + + context "in an ExampleGroup with an implicit subject" do + it "delegates matcher to the implied subject" do + @example_group.describe(::Thing) + @example_group.example { should == ::Thing.new(:default) } + @example_group.example { should eql(::Thing.new(:default)) } + @example_group.run(@options).should be_true + end + end + + context "in an ExampleGroup using an explicit subject" do + it "delegates matcher to the declared subject" do + @example_group.describe(::Thing) + @example_group.subject { ::Thing.new(:other) } + @example_group.example { should == ::Thing.new(:other) } + @example_group.example { should eql(::Thing.new(:other)) } + @example_group.run(@options).should be_true + end + end + + context "in an ExampleGroup using 'self' as an explicit subject" do + it "delegates matcher to the ExampleGroup" do + @example_group.describe(::Thing) + @example_group.subject { self } + @example_group.example { should == self } + @example_group.example { should eql(self) } + @example_group.example do + self.instance_eval("def method_ok?; true end") + should be_method_ok + end + @example_group.run(@options).should be_true + end + end + end + + describe "#should_not" do + before(:each) do + @example_group = Class.new(ExampleGroupDouble) + @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) + end + + context "in an ExampleGroup with an implicit subject" do + it "delegates matcher to the implied subject" do + @example_group.describe(::Thing) + @example_group.example { should_not == ::Thing.new(:other) } + @example_group.example { should_not eql(::Thing.new(:other)) } + @example_group.run(@options).should be_true + end + end + + context "in an ExampleGroup using an explicit subject" do + it "delegates matcher to the declared subject" do + @example_group.describe(::Thing) + @example_group.subject { ::Thing.new(:other) } + @example_group.example { should_not == ::Thing.new(:default) } + @example_group.example { should_not eql(::Thing.new(:default)) } + @example_group.run(@options).should be_true + end + end + + context "in an ExampleGroup using 'self' as an explicit subject" do + it "delegates matcher to the ExampleGroup" do + @example_group.describe(::Thing) + @example_group.subject { self } + @example_group.example { should_not == ::Thing.new(:default) } + @example_group.example { should_not eql(::Thing.new(:default)) } + @example_group.example do + self.instance_eval("def method_ok?; false end") + should_not be_method_ok + end + @example_group.run(@options).should be_true + end + end + end + end + + describe "#options" do + it "should expose the options hash" do + example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end + example.options[:this].should == 'that' + end + end + + describe "#set_instance_variables_from_hash" do + it "preserves the options" do + example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end + example.set_instance_variables_from_hash({:@_options => {}}) + example.options[:this].should == 'that' + end + end + + describe "#description" do + it "returns the supplied description" do + example = ExampleGroupDouble.new ExampleProxy.new("name") do; end + example.description.should == "name" + end + it "returns the generated description if there is no description supplied" do + example = ExampleGroupDouble.new ExampleProxy.new do; end + Spec::Matchers.stub!(:generated_description).and_return('this message') + example.description.should == "this message" + end + it "warns if there is no supplied or generated description" do + example = ExampleGroupDouble.new ExampleProxy.new(nil, {}, "this backtrace") do; end + Spec::Matchers.stub!(:generated_description).and_return(nil) + Spec.should_receive(:warn).with("No description supplied for example declared on this backtrace") + example.description + end + end + + describe "#expect" do + it "aliases #should with #to on the proc" do + a = 3 + expect { a += 1 }.to change{a}.from(3).to(4) + end + + it "aliases #should_not with #to_not on the proc" do + a = 3 + expect { nil }.to_not change{a} + end + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/example_proxy_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/example_proxy_spec.rb new file mode 100644 index 000000000..de845c9e2 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/example_proxy_spec.rb @@ -0,0 +1,57 @@ +require 'spec_helper' + +module Spec + module Example + + describe ExampleProxy do + + describe "#description" do + it "provides the submitted description" do + proxy = ExampleProxy.new("the description") + proxy.description.should == "the description" + end + end + + describe "#update" do + it "updates the description" do + proxy = ExampleProxy.new("old description") + proxy.update("new description") + proxy.description.should == "new description" + end + end + + describe "#options" do + it "provides the submitted options" do + proxy = ExampleProxy.new(:ignore, {:these => :options}) + proxy.options.should == {:these => :options} + end + end + + describe "#backtrace (DEPRECATED - use #location)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.backtrace + end + + it "provides the location of the declaration of this group" do + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.backtrace.should == "path/to/location:37" + end + end + + describe "#location" do + it "provides the location of the declaration of this group" do + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.location.should == "path/to/location:37" + end + end + + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/helper_method_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/helper_method_spec.rb new file mode 100644 index 000000000..3653aec71 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/helper_method_spec.rb @@ -0,0 +1,24 @@ +require 'spec_helper' + +# This was added to prove that http://rspec.lighthouseapp.com/projects/5645/tickets/211 +# was fixed in ruby 1.9.1 + +module HelperMethodExample + describe "a helper method" do + def helper_method + "received call" + end + + it "is available to examples in the same group" do + helper_method.should == "received call" + end + + describe "from a nested group" do + it "is available to examples in a nested group" do + helper_method.should == "received call" + end + end + + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/nested_example_group_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/nested_example_group_spec.rb new file mode 100644 index 000000000..83e4a9d7c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/nested_example_group_spec.rb @@ -0,0 +1,71 @@ +require 'spec_helper' + +module Spec + module Example + describe 'Nested Example Groups' do + parent = self + + def count + @count ||= 0 + @count = @count + 1 + @count + end + + before(:all) do + count.should == 1 + end + + before(:all) do + count.should == 2 + end + + before(:each) do + count.should == 3 + end + + before(:each) do + count.should == 4 + end + + it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do + count.should == 5 + end + + after(:each) do + count.should == 7 + end + + after(:each) do + count.should == 6 + end + + after(:all) do + count.should == 9 + end + + after(:all) do + count.should == 8 + end + + describe 'nested example group' do + self.superclass.should == parent + + it "should run all before and after callbacks" do + count.should == 5 + end + end + end + + describe "Nested Example Groups" do + describe "description options", :other_options => "other options" do + it "includes :location" do + self.class.options[:location].should match(/#{__FILE__}/) + end + + it "includes any other options" do + self.class.options[:other_options].should == "other options" + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/pending_module_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/pending_module_spec.rb new file mode 100644 index 000000000..275abc7d6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/pending_module_spec.rb @@ -0,0 +1,58 @@ +module Spec + module Example + describe Pending do + + context "when no block is supplied" do + it "raises an ExamplePendingError if no block is supplied" do + lambda { + pending "TODO" + }.should raise_error(ExamplePendingError, /TODO/) + end + end + + context "when the supplied block fails" do + it "raises an ExamplePendingError if a supplied block fails as expected" do + lambda { + pending "TODO" do + raise "oops" + end + }.should raise_error(ExamplePendingError, /TODO/) + end + end + + context "when the supplied block fails with a mock" do + it "raises 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 + end + + context "when the supplied block passes" do + it "raises a PendingExampleFixedError" do + lambda { + pending "TODO" do + # success! + end + }.should raise_error(PendingExampleFixedError, /TODO/) + end + end + end + + describe ExamplePendingError do + it "should have the message provided" do + ExamplePendingError.new("a message").message.should == "a message" + end + end + + describe NotYetImplementedError do + it "should have the message 'Not Yet Implemented'" do + NotYetImplementedError.new.message.should == "Not Yet Implemented" + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/predicate_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/predicate_matcher_spec.rb new file mode 100644 index 000000000..a01858502 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/predicate_matcher_spec.rb @@ -0,0 +1,41 @@ +require 'spec_helper' + +module Spec + module Example + class Fish + def can_swim?(distance_in_yards) + distance_in_yards < 1000 + end + end + + describe "predicate_matcher[method_on_object] = matcher_method" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + group = ExampleGroupDouble.describe("foo") do + predicate_matchers[:swim] = :can_swim? + end + group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new)) + end + + it "should match matcher_method if method_on_object returns true" do + group = ExampleGroupDouble.describe(Fish) do + predicate_matchers[:swim] = :can_swim? + it { should swim(100) } + end + group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new)) + end + + it "should not match matcher_method if method_on_object returns false" do + group = ExampleGroupDouble.describe(Fish) do + predicate_matchers[:swim] = :can_swim? + it { should_not swim(1000) } + end + group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new)) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/shared_example_group_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/shared_example_group_spec.rb new file mode 100644 index 000000000..bbebbf15c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/shared_example_group_spec.rb @@ -0,0 +1,257 @@ +require 'spec_helper' + +module Spec + module Example + describe ExampleGroup, "with :shared => true" do + 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(ExampleGroupDouble).describe("example_group") + class << example_group + public :include + end + end + + after(:each) do + @formatter.rspec_verify + @example_group = nil + Spec::Example::SharedExampleGroup.clear + end + + describe "#register" do + it "creates a new shared example group with the submitted args" do + block = lambda {|a|} + 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 + + 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 + + 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 + + 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 + + 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, + :location => "/my/spec/a/../shared.rb" + ) + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :location => "/my/spec/b/../shared.rb" + ) + end + + 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, + :location => "/my/spec/a/shared.rb" + ) + lambda do + SharedExampleGroup.register( + "shared example_group", + :shared => true, + :location => "/my/spec/b/shared.rb" + ) + end.should raise_error(ArgumentError, /already exists/) + end + + 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 + + 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 "adds examples to from two shared groups" do + shared_example_group_1 = SharedExampleGroup.register("shared example_group 1") do + it("shared example 1") {} + end + + shared_example_group_1 = SharedExampleGroup.register("shared example_group 2") do + it("shared example 2") {} + end + + example_group.it("example") {} + example_group.number_of_examples.should == 1 + example_group.it_should_behave_like("shared example_group 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 + + example_group = describe "one thing" do + include shared_example_group + 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 + + example_group = describe "one thing" do + it_should_behave_like ::AllThings + end + + example_group.number_of_examples.should == 1 + end + + 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 + + example_ran = false + + example_group.it_should_behave_like("shared example_group") + example_group.it("example") {example_ran = true} + example_group.run(options) + example_ran.should be_true + shared_example_ran.should be_true + 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 + + example_ran = false + + example_group.it_should_behave_like("shared example_group") + example_group.it("example") {example_ran = true} + example_group.run(options) + example_ran.should be_true + shared_setup_ran.should be_true + shared_teardown_ran.should be_true + end + + it "should run before(:all) and after(:all) only once from shared example_group" do + shared_before_all_run_count = 0 + shared_after_all_run_count = 0 + shared_example_group = 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(options) + example_ran.should be_true + shared_before_all_run_count.should == 1 + shared_after_all_run_count.should == 1 + end + + it "should include modules, included into shared example_group, into current example_group" do + @formatter.should_receive(:add_example_group).with(any_args) + + shared_example_group = 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 + + mod2_method_called = false + mod2 = Module.new do + define_method :mod2_method do + mod2_method_called = true + end + end + + shared_example_group.__send__ :include, mod2 + + example_group.it_should_behave_like("shared example_group") + example_group.include mod1 + + example_group.it("test") do + mod1_method + mod2_method + end + example_group.run(options) + mod1_method_called.should be_true + mod2_method_called.should be_true + end + + it "should make methods defined in the shared example_group available in consuming example_group" do + shared_example_group = 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(options) + success.should be_true + end + + it "should raise when named shared example_group can not be found" do + lambda { + example_group.it_should_behave_like("non-existent shared example group") + violated + }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found") + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/subclassing_example_group_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/subclassing_example_group_spec.rb new file mode 100644 index 000000000..969014a73 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/subclassing_example_group_spec.rb @@ -0,0 +1,25 @@ +require 'spec_helper' + +module Spec + module Example + class GrandParentExampleGroup < Spec::Example::ExampleGroup + describe "Grandparent ExampleGroup" + end + + class ParentExampleGroup < GrandParentExampleGroup + describe "Parent ExampleGroup" + it "should bar" do + end + end + + class ChildExampleGroup < ParentExampleGroup + describe "Child ExampleGroup" + it "should bam" do + end + end + + describe ChildExampleGroup do + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/example/subject_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/example/subject_spec.rb new file mode 100644 index 000000000..e1889cb36 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/example/subject_spec.rb @@ -0,0 +1,110 @@ +require 'spec_helper' + +module Spec + module Example + describe "implicit subject" do + describe "with a class" do + it "returns an instance of the class" do + group = Class.new(ExampleGroupDouble).describe(Array) + example = group.new(ExampleProxy.new) + example.subject.should == [] + end + end + + describe "with a Module" do + it "returns the Module" do + group = Class.new(ExampleGroupDouble).describe(Enumerable) + example = group.new(ExampleProxy.new) + example.subject.should == Enumerable + end + end + + describe "with a string" do + it "return the string" do + group = Class.new(ExampleGroupDouble).describe('foo') + example = group.new(ExampleProxy.new) + example.subject.should == 'foo' + end + end + + describe "with a number" do + it "returns the number" do + group = Class.new(ExampleGroupDouble).describe(15) + example = group.new(ExampleProxy.new) + example.subject.should == 15 + end + end + + end + + describe "explicit subject" do + describe "defined in a top level group" do + it "replaces the implicit subject in that group" do + group = Class.new(ExampleGroupDouble).describe(Array) + group.subject { [1,2,3] } + example = group.new(ExampleProxy.new) + example.subject.should == [1,2,3] + end + end + + describe "defined in a top level group" do + before(:each) do + @group = Class.new do + extend Spec::Example::Subject::ExampleGroupMethods + include Spec::Example::Subject::ExampleMethods + class << self + def described_class + Array + end + end + def described_class + self.class.described_class + end + + subject { + [1,2,3] + } + end + end + + it "is available in a nested group (subclass)" do + nested_group = Class.new(@group) + + example = nested_group.new + example.subject.should == [1,2,3] + end + + it "is available in a doubly nested group (subclass)" do + nested_group = Class.new(@group) + doubly_nested_group = Class.new(nested_group) + + example = doubly_nested_group.new + example.subject.should == [1,2,3] + end + end + end + + describe ".its (to access subject's attributes)" do + with_sandboxed_options do + it "allows before(:each) blocks on subjects in outer scope" do + group = Class.new(ExampleGroupDouble).describe(Array) + group.before(:each) { subject << 1 } + child = group.its(:length) { should == 1 } + child.run(options).should == true + end + + it "passes when expectation should pass" do + group = Class.new(ExampleGroupDouble).describe(Array) + child = group.its(:length) { should == 0 } + child.run(options).should == true + end + + it "fails when expectation should fail" do + group = Class.new(ExampleGroupDouble).describe(Array) + child = group.its(:length) { should == 1 } + child.run(options).should == false + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/expectations/differs/default_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/expectations/differs/default_spec.rb new file mode 100644 index 000000000..3bc3c45ab --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/expectations/differs/default_spec.rb @@ -0,0 +1,194 @@ +require 'spec_helper' + +module Spec + module Fixtures + class Animal + def initialize(name,species) + @name,@species = name,species + end + + def inspect + <<-EOA +<Animal + name=#{@name}, + species=#{@species} +> + EOA + end + end + end +end + +describe "Diff" do + before(:each) do + @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new) + @differ = Spec::Expectations::Differs::Default.new(@options) + end + + it "should output unified diff of two strings" do + expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n" + actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n" + expected_diff= <<'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 + + it "should output unified diff message of two arrays" do + expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ] + actual = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango' , :width, 'very wide' ] + + expected_diff = <<'EOD' + + +@@ -5,7 +5,7 @@ + :metasyntactic, + "variable", + :delta, +- "tango", ++ "charlie", + :width, +- "very wide"] ++ "quite wide"] +EOD + + + diff = @differ.diff_as_object(expected,actual) + diff.should == expected_diff + end + + it "should output a friendly message if comparing simple hashes" do + expected = { "foo" => "bar" } + actual = { "foo" => "baz" } + + expected_diff = <<'EOD' + +Expected the key "foo" to be "bar", but was "baz" + +EOD + + + diff = @differ.diff_as_hash(actual, expected) + diff.should == expected_diff + end + + + it "should output a friendly message if comparing simple hashes that contain different keys" do + expected = { "bar" => "foo" } + actual = { "foo" => "baz" } + + expected_diff = <<'EOD' + +Expected hash contains keys that target hash does not: ["bar"] +Target hash contains keys that expected hash does not: ["foo"] +Expected the key "bar" to be "foo", but was nil + +EOD + + + diff = @differ.diff_as_hash(actual, expected) + diff.should == expected_diff + end + + it "should output diff message if the hash is complex (containing Array or Hash)" do + expected = { "foo" => "bar", "fizz" => [1, 2, 3] } + actual = { "foo" => "baz", "fizz" => [1, 2] } + + # UGH - 1.8.7 seems to order hash keys differently than the others + if RUBY_VERSION =~ /^1.8.7/ + expected_diff = <<'EOD' + +Expected the key "fizz" to be [1, 2, 3], but was [1, 2] +Expected the key "foo" to be "bar", but was "baz" + + +@@ -1,2 +1,2 @@ +-{"fizz"=>[1, 2, 3], "foo"=>"bar"} ++{"fizz"=>[1, 2], "foo"=>"baz"} +EOD + else + expected_diff = <<'EOD' + +Expected the key "fizz" to be [1, 2, 3], but was [1, 2] +Expected the key "foo" to be "bar", but was "baz" + + +@@ -1,2 +1,2 @@ +-{"foo"=>"bar", "fizz"=>[1, 2, 3]} ++{"foo"=>"baz", "fizz"=>[1, 2]} +EOD + end + + diff = @differ.diff_as_hash(actual, expected) + diff.should == expected_diff + end + + + it "should output unified diff message of two objects" do + expected = Spec::Fixtures::Animal.new "bob", "giraffe" + actual = Spec::Fixtures::Animal.new "bob", "tortoise" + + expected_diff = <<'EOD' + +@@ -1,5 +1,5 @@ + <Animal + name=bob, +- species=tortoise ++ species=giraffe + > +EOD + + diff = @differ.diff_as_object(expected,actual) + diff.should == expected_diff + end + +end + + +describe "Diff in context format" do + before(:each) do + @options = Spec::Runner::Options.new(StringIO.new, StringIO.new) + @options.diff_format = :context + @differ = Spec::Expectations::Differs::Default.new(@options) + end + + it "should output unified diff message of two objects" do + expected = Spec::Fixtures::Animal.new "bob", "giraffe" + actual = Spec::Fixtures::Animal.new "bob", "tortoise" + + expected_diff = <<'EOD' + +*************** +*** 1,5 **** + <Animal + name=bob, +! species=tortoise + > +--- 1,5 ---- + <Animal + name=bob, +! species=giraffe + > +EOD + + diff = @differ.diff_as_object(expected,actual) + diff.should == expected_diff + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/expectations/extensions/kernel_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/expectations/extensions/kernel_spec.rb new file mode 100644 index 000000000..9a0ed3ce5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/expectations/extensions/kernel_spec.rb @@ -0,0 +1,45 @@ +require 'spec_helper' + +describe Object, "#should" do + before(:each) do + @target = "target" + @matcher = mock("matcher") + @matcher.stub!(:matches?).and_return(true) + @matcher.stub!(:failure_message_for_should) + end + + it "accepts and interacts with a matcher" do + @matcher.should_receive(:matches?).with(@target).and_return(true) + @target.should @matcher + end + + it "asks for a failure_message_for_should when matches? returns false" do + @matcher.should_receive(:matches?).with(@target).and_return(false) + @matcher.should_receive(:failure_message_for_should).and_return("the failure message") + lambda { + @target.should @matcher + }.should fail_with("the failure message") + end +end + +describe Object, "#should_not" do + before(:each) do + @target = "target" + @matcher = mock("matcher") + end + + it "accepts and interacts with a matcher" do + @matcher.should_receive(:matches?).with(@target).and_return(false) + @matcher.stub!(:failure_message_for_should_not) + + @target.should_not @matcher + end + + it "asks for a failure_message_for_should_not when matches? returns true" do + @matcher.should_receive(:matches?).with(@target).and_return(true) + @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not") + lambda { + @target.should_not @matcher + }.should fail_with("the failure message for should not") + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/expectations/fail_with_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/expectations/fail_with_spec.rb new file mode 100644 index 000000000..639b7f950 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/expectations/fail_with_spec.rb @@ -0,0 +1,96 @@ +require 'spec_helper' + +describe Spec::Expectations, "#fail_with with no diff" do + before(:each) do + @old_differ = Spec::Expectations.differ + Spec::Expectations.differ = nil + end + + it "should handle just a message" do + lambda { + Spec::Expectations.fail_with "the message" + }.should fail_with("the message") + end + + after(:each) do + Spec::Expectations.differ = @old_differ + end +end + +describe Spec::Expectations, "#fail_with with Array" do + before(:each) do + Spec.stub!(:warn) + end + + it "is deprecated" do + Spec.should_receive(:warn) + lambda { + Spec::Expectations.fail_with ["message", "expected", "actual"] + }.should raise_error + end +end + +describe Spec::Expectations, "#fail_with with diff" do + before(:each) do + @old_differ = Spec::Expectations.differ + @differ = mock("differ") + Spec::Expectations.differ = @differ + end + + it "should not call differ if no expected/actual" do + lambda { + Spec::Expectations.fail_with "the message" + }.should fail_with("the message") + end + + it "should call differ if expected/actual are presented separately" do + @differ.should_receive(:diff_as_string).and_return("diff") + lambda { + Spec::Expectations.fail_with "the message", "expected", "actual" + }.should fail_with("the message\n\n Diff:diff") + end + + it "should call differ if expected/actual are not strings" do + @differ.should_receive(:diff_as_object).and_return("diff") + lambda { + Spec::Expectations.fail_with "the message", :expected, :actual + }.should fail_with("the message\n\n Diff:diff") + end + + it "should call differ if expected/actual are both hashes" do + @differ.should_receive(:diff_as_hash).and_return("diff") + lambda { + Spec::Expectations.fail_with "the message", {:a => :b}, {:a => 'b'} + }.should fail_with("the message\n\n Diff:diff") + end + + it "should not call differ if expected or actual are procs" do + @differ.should_not_receive(:diff_as_string) + @differ.should_not_receive(:diff_as_object) + @differ.should_not_receive(:diff_as_hash) + lambda { + Spec::Expectations.fail_with "the message", lambda {}, lambda {} + }.should fail_with("the message") + end + + after(:each) do + Spec::Expectations.differ = @old_differ + end +end + +describe Spec::Expectations, "#fail_with with a nil message" do + before(:each) do + @old_differ = Spec::Expectations.differ + Spec::Expectations.differ = nil + end + + it "should handle just a message" do + lambda { + Spec::Expectations.fail_with nil + }.should raise_error(ArgumentError, /Failure message is nil\. Does your matcher define the appropriate failure_message_for_\* method to return a string\?/) + end + + after(:each) do + Spec::Expectations.differ = @old_differ + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/expectations/handler_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/expectations/handler_spec.rb new file mode 100644 index 000000000..e7d6a6ed1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/expectations/handler_spec.rb @@ -0,0 +1,206 @@ +require 'spec_helper' + +module ExampleExpectations + + class ArbitraryMatcher + def initialize(*args, &block) + if args.last.is_a? Hash + @expected = args.last[:expected] + end + @expected = block.call if block + @block = block + end + + def matches?(target) + @target = target + return @expected == target + end + + def with(new_value) + @expected = new_value + self + end + + def failure_message + "expected #{@expected}, got #{@target}" + end + + def negative_failure_message + "expected not #{@expected}, got #{@target}" + end + end + + class PositiveOnlyMatcher < ArbitraryMatcher + undef negative_failure_message rescue nil + end + + def arbitrary_matcher(*args, &block) + ArbitraryMatcher.new(*args, &block) + end + + def positive_only_matcher(*args, &block) + PositiveOnlyMatcher.new(*args, &block) + end + +end + +module Spec + module Expectations + describe PositiveExpectationHandler do + describe "#handle_matcher" do + it "asks the matcher if it matches" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(true) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "returns the match value" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(:this_value) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value + end + + it "calls failure_message_for_should if the matcher implements it" do + matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "calls fail if matcher.diffable?" do + matcher = mock("matcher", + :diffable? => true, + :failure_message_for_should => "message", + :matches? => false, + :expected => [1], + :actual => 2 + ) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2) + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "calls failure_message if the matcher does not implement failure_message_for_should" do + matcher = mock("matcher", :failure_message => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + + end + + it "appends the :or message in the options hash passed to should" do + matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("custom") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom") + end + end + end + + describe NegativeExpectationHandler do + describe "#handle_matcher" do + it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do + matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil) + actual = Object.new + matcher.should_receive(:does_not_match?).with(actual).and_return(true) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do + matcher = mock("matcher") + actual = Object.new + matcher.stub!(:negative_failure_message) + matcher.should_receive(:matches?).with(actual).and_return(false) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "returns 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::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false + end + + + it "calls failure_message_for_should_not if the matcher implements it" do + matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + + end + + it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do + matcher = mock("matcher", :negative_failure_message => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + + end + + + it "calls fail if matcher.diffable?" do + matcher = mock("matcher", + :diffable? => true, + :failure_message_for_should_not => "message", + :matches? => true, + :expected => [1], + :actual => 2 + ) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2) + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "appends the :or message in the options hash passed to should" do + matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("custom") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom") + end + + end + end + + describe PositiveExpectationHandler do + include ExampleExpectations + + it "should handle submitted args" do + 5.should arbitrary_matcher(:expected => 5) + 5.should arbitrary_matcher(:expected => "wrong").with(5) + lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5") + lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5") + 5.should_not arbitrary_matcher(:expected => 4) + 5.should_not arbitrary_matcher(:expected => 5).with(4) + lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5") + lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5") + end + + it "should handle the submitted block" do + 5.should arbitrary_matcher { 5 } + 5.should arbitrary_matcher(:expected => 4) { 5 } + 5.should arbitrary_matcher(:expected => 4).with(5) { 3 } + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/expectations/wrap_expectation_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/expectations/wrap_expectation_spec.rb new file mode 100644 index 000000000..bcd0d53c9 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/expectations/wrap_expectation_spec.rb @@ -0,0 +1,31 @@ +require 'spec_helper' + +module Spec + module Matchers + describe "wrap_expectation" do + before { Spec.stub(:deprecate) } + + def stub_matcher + @_stub_matcher ||= simple_matcher do + end + end + + def failing_matcher + @_failing_matcher ||= simple_matcher do + 1.should == 2 + end + end + + it "should return true if there is no error" do + wrap_expectation stub_matcher do + end.should be_true + end + + it "should return false if there is an error" do + wrap_expectation failing_matcher do + raise "error" + end.should be_false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_fails.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_fails.rb new file mode 100644 index 000000000..b2c484109 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_fails.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +describe "example group with failures" do + it "should fail" do + false.should be_true + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_passes.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_passes.rb new file mode 100644 index 000000000..4203af3a5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_that_passes.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +describe "example group with passing examples" do + it "should pass" do + true.should be_true + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_errors.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_errors.rb new file mode 100644 index 000000000..a18ce72f7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_errors.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +describe "example group with errors" do + it "should raise errors" do + raise "error raised in example group with errors" + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb new file mode 100644 index 000000000..7dc344bdd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb @@ -0,0 +1,13 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +describe "options hash" do + describe "#options" do + it "should expose the options hash" do + group = describe("group", :this => 'hash') {} + group.options[:this].should == 'hash' + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_fails.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_fails.rb new file mode 100644 index 000000000..0a977cb15 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_fails.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +class TestCaseThatFails < Test::Unit::TestCase + def test_that_fails + false.should be_true + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_passes.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_passes.rb new file mode 100644 index 000000000..078a5f778 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_that_passes.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +class TestCaseThatPasses < Test::Unit::TestCase + def test_that_passes + true.should be_true + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_errors.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_errors.rb new file mode 100644 index 000000000..dc5f52e47 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_errors.rb @@ -0,0 +1,10 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +class TestCaseWithErrors < Test::Unit::TestCase + def test_with_error + raise "error raised in TestCaseWithErrors" + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb new file mode 100644 index 000000000..186db49d5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb @@ -0,0 +1,22 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +class TestCaseThatPasses < Test::Unit::TestCase + def test_should_allow_underscore + assert true + end + + def testShouldAllowUppercaseLetter + assert true + end + + def testshouldallowlowercaseletter + assert true + end + + define_method :"test: should allow punctuation" do + assert true + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb new file mode 100644 index 000000000..5182b8203 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb @@ -0,0 +1,38 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +module Test + module Unit + describe TestSuiteAdapter do + def create_adapter(group) + TestSuiteAdapter.new(group) + end + + describe "#size" do + it "should return the number of examples in the example group" do + group = Class.new(Spec::ExampleGroup) do + describe("some examples") + it("bar") {} + it("baz") {} + end + adapter = create_adapter(group) + adapter.size.should == 2 + end + end + + describe "#delete" do + it "should do nothing" do + group = Class.new(Spec::ExampleGroup) do + describe("Some Examples") + it("does something") {} + end + adapter = create_adapter(group) + adapter.delete(adapter.examples.first) + adapter.should be_empty + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/spec_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/spec_spec.rb new file mode 100644 index 000000000..d4d3d2c65 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/spec_spec.rb @@ -0,0 +1,48 @@ +require 'spec/interop/test/unit/test_unit_spec_helper' + +describe "ExampleGroup with test/unit/interop" do + include TestUnitSpecHelper + + describe "with passing examples" do + it "should output 0 failures" do + output = ruby("'#{resources}/spec_that_passes.rb'") + output.should include("1 example, 0 failures") + end + + it "should return an exit code of 0" do + ruby("'#{resources}/spec_that_passes.rb'") + $?.should == 0 + end + end + + describe "with failing examples" do + it "should output 1 failure" do + output = ruby("'#{resources}/spec_that_fails.rb'") + output.should include("1 example, 1 failure") + end + + it "should return an exit code of 256" do + ruby("'#{resources}/spec_that_fails.rb'") + $?.should == 256 + end + end + + describe "with example that raises an error" do + it "should output 1 failure" do + output = ruby("'#{resources}/spec_with_errors.rb'") + output.should include("1 example, 1 failure") + end + + it "should return an exit code of 256" do + ruby("'#{resources}/spec_with_errors.rb'") + $?.should == 256 + end + end + + describe "options hash" do + it "should be exposed" do + output = ruby("'#{resources}/spec_with_options_hash.rb'") + output.should include("1 example, 0 failures") + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/test_unit_spec_helper.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/test_unit_spec_helper.rb new file mode 100644 index 000000000..1f6c223eb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/test_unit_spec_helper.rb @@ -0,0 +1,18 @@ +require 'spec_helper' +require 'ruby_forker' + +module TestUnitSpecHelper + include RubyForker + + def resources + File.dirname(__FILE__) + "/resources" + end + + def run_script(file_name) + output = ruby(file_name) + if !$?.success? || output.include?("FAILED") || output.include?("Error") + raise output + end + output + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testcase_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testcase_spec.rb new file mode 100644 index 000000000..1ab57a37a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testcase_spec.rb @@ -0,0 +1,50 @@ +require 'spec/interop/test/unit/test_unit_spec_helper' + +describe "Test::Unit::TestCase" do + include TestUnitSpecHelper + + before(:each) do + @dir = File.dirname(__FILE__) + "/resources" + end + + describe "with passing test case" do + it "should output 0 failures" do + output = ruby("'#{@dir}/test_case_that_passes.rb'") + output.should include("1 example, 0 failures") + end + + it "should return an exit code of 0" do + ruby("'#{@dir}/test_case_that_passes.rb'") + $?.should == 0 + end + end + + describe "with failing test case" do + it "should output 1 failure" do + output = ruby("'#{@dir}/test_case_that_fails.rb'") + output.should include("1 example, 1 failure") + end + + it "should return an exit code of 256" do + ruby("'#{@dir}/test_case_that_fails.rb'") + $?.should == 256 + end + end + + describe "with test case that raises an error" do + it "should output 1 failure" do + output = ruby("'#{@dir}/test_case_with_errors.rb'") + output.should include("1 example, 1 failure") + end + + it "should return an exit code of 256" do + ruby("'#{@dir}/test_case_with_errors.rb'") + $?.should == 256 + end + end + + it "should find all Test::Unit test methods" do + output = ruby("'#{@dir}/test_case_with_various_names.rb'") + output.should include("4 examples, 0 failures") + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testsuite_adapter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testsuite_adapter_spec.rb new file mode 100644 index 000000000..57af21e8f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/interop/test/unit/testsuite_adapter_spec.rb @@ -0,0 +1,9 @@ +require 'spec/interop/test/unit/test_unit_spec_helper' + +describe "TestSuiteAdapter" do + include TestUnitSpecHelper + it "should pass" do + dir = File.dirname(__FILE__) + run_script "'#{dir}/resources/testsuite_adapter_spec_with_test_unit.rb'" + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_close_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_close_spec.rb new file mode 100644 index 000000000..cc0e5bd44 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_close_spec.rb @@ -0,0 +1,50 @@ +require 'spec_helper' +module Spec + module Matchers + describe "[actual.should] be_close(expected, delta)" do + it "matches when actual == expected" do + be_close(5.0, 0.5).matches?(5.0).should be_true + end + it "matches when actual < (expected + delta)" do + be_close(5.0, 0.5).matches?(5.49).should be_true + end + it "matches when actual > (expected - delta)" do + be_close(5.0, 0.5).matches?(4.51).should be_true + end + it "does not match when actual == (expected - delta)" do + be_close(5.0, 0.5).matches?(4.5).should be_false + end + it "does not match when actual < (expected - delta)" do + be_close(5.0, 0.5).matches?(4.49).should be_false + end + it "does not match when actual == (expected + delta)" do + be_close(5.0, 0.5).matches?(5.5).should be_false + end + it "does not match when actual > (expected + delta)" do + be_close(5.0, 0.5).matches?(5.51).should be_false + end + it "provides a failure message for should" do + #given + matcher = be_close(5.0, 0.5) + #when + matcher.matches?(5.51) + #then + matcher.failure_message_for_should.should == "expected 5.0 +/- (< 0.5), got 5.51" + end + + it "provides a failure message for should tno" do + #given + matcher = be_close(5.0, 0.5) + #when + matcher.matches?(5.49) + #then + matcher.failure_message_for_should_not.should == "expected 5.0 +/- (< 0.5), got 5.49" + end + it "provides a description" do + 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 +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_instance_of_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_instance_of_spec.rb new file mode 100644 index 000000000..e6abd0b16 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_instance_of_spec.rb @@ -0,0 +1,36 @@ +require 'spec_helper' + +module Spec + module Matchers + [:be_an_instance_of, :be_instance_of].each do |method| + describe "actual.should #{method}(expected)" do + it "passes if actual is instance of expected class" do + 5.should send(method, Fixnum) + end + + it "fails if actual is instance of subclass of expected class" do + lambda { 5.should send(method, Numeric) }.should fail_with(%Q{expected 5 to be an instance of Numeric}) + end + + it "fails with failure message for should unless actual is instance of expected class" do + lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be an instance of Array}) + end + + it "provides a description" do + matcher = be_an_instance_of(Fixnum) + matcher.matches?(Numeric) + matcher.description.should == "be an instance of Fixnum" + end + end + + describe "actual.should_not #{method}(expected)" do + + it "fails with failure message for should_not if actual is instance of expected class" do + lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be an instance of String}) + end + + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_kind_of_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_kind_of_spec.rb new file mode 100644 index 000000000..d3f05e806 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_kind_of_spec.rb @@ -0,0 +1,33 @@ +require 'spec_helper' + +module Spec + module Matchers + [:be_a_kind_of, :be_kind_of].each do |method| + describe "actual.should #{method}(expected)" do + it "passes if actual is instance of expected class" do + 5.should send(method, Fixnum) + end + + it "passes if actual is instance of subclass of expected class" do + 5.should send(method, Numeric) + end + + it "fails with failure message for should unless actual is kind of expected class" do + lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be a kind of Array}) + end + + it "provides a description" do + matcher = be_a_kind_of(String) + matcher.matches?("this") + matcher.description.should == "be a kind of String" + end + end + + describe "actual.should_not #{method}(expected)" do + it "fails with failure message for should_not if actual is kind of expected class" do + lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be a kind of String}) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_spec.rb new file mode 100644 index 000000000..e1d10b854 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/be_spec.rb @@ -0,0 +1,460 @@ +require 'spec_helper' + +describe "should be_predicate" do + it "should pass when actual returns true for :predicate?" do + actual = stub("actual", :happy? => true) + actual.should be_happy + end + + it "should pass when actual returns true for :predicates? (present tense)" do + actual = stub("actual", :exists? => true, :exist? => true) + actual.should be_exist + end + + it "should fail when actual returns false for :predicate?" do + actual = stub("actual", :happy? => false) + lambda { + actual.should be_happy + }.should fail_with("expected happy? to return true, got false") + end + + it "should fail when actual returns false for :predicate?" do + actual = stub("actual", :happy? => nil) + lambda { + actual.should be_happy + }.should fail_with("expected happy? to return true, got nil") + end + + it "should fail when actual does not respond to :predicate?" do + lambda { + Object.new.should be_happy + }.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 + +describe "should_not be_predicate" do + it "should pass when actual returns false for :sym?" do + actual = stub("actual", :happy? => false) + actual.should_not be_happy + end + + it "should pass when actual returns nil for :sym?" do + actual = stub("actual", :happy? => nil) + actual.should_not be_happy + end + + it "should fail when actual returns true for :sym?" do + actual = stub("actual", :happy? => true) + lambda { + actual.should_not be_happy + }.should fail_with("expected happy? to return false, got true") + end + + it "should fail when actual does not respond to :sym?" do + lambda { + Object.new.should_not be_happy + }.should raise_error(NameError) + end +end + +describe "should be_predicate(*args)" do + it "should pass when actual returns true for :predicate?(*args)" do + actual = mock("actual") + actual.should_receive(:older_than?).with(3).and_return(true) + actual.should be_older_than(3) + end + + it "should fail when actual returns false for :predicate?(*args)" do + actual = mock("actual") + actual.should_receive(:older_than?).with(3).and_return(false) + lambda { + actual.should be_older_than(3) + }.should fail_with("expected older_than?(3) to return true, got false") + end + + it "should fail when actual does not respond to :predicate?" do + lambda { + Object.new.should be_older_than(3) + }.should raise_error(NameError) + end +end + +describe "should_not be_predicate(*args)" do + it "should pass when actual returns false for :predicate?(*args)" do + actual = mock("actual") + actual.should_receive(:older_than?).with(3).and_return(false) + actual.should_not be_older_than(3) + end + + it "should fail when actual returns true for :predicate?(*args)" do + actual = mock("actual") + actual.should_receive(:older_than?).with(3).and_return(true) + lambda { + actual.should_not be_older_than(3) + }.should fail_with("expected older_than?(3) to return false, got true") + end + + it "should fail when actual does not respond to :predicate?" do + lambda { + Object.new.should_not be_older_than(3) + }.should raise_error(NameError) + end +end + +describe "should be_predicate(&block)" do + it "should pass when actual returns true for :predicate?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:happy?).and_yield + delegate.should_receive(:check_happy).and_return(true) + actual.should be_happy { delegate.check_happy } + end + + it "should fail when actual returns false for :predicate?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:happy?).and_yield + delegate.should_receive(:check_happy).and_return(false) + lambda { + actual.should be_happy { delegate.check_happy } + }.should fail_with("expected happy? to return true, got false") + end + + it "should fail when actual does not respond to :predicate?" do + delegate = mock("delegate", :check_happy => true) + lambda { + Object.new.should be_happy { delegate.check_happy } + }.should raise_error(NameError) + end +end + +describe "should_not be_predicate(&block)" do + it "should pass when actual returns false for :predicate?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:happy?).and_yield + delegate.should_receive(:check_happy).and_return(false) + actual.should_not be_happy { delegate.check_happy } + end + + it "should fail when actual returns true for :predicate?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:happy?).and_yield + delegate.should_receive(:check_happy).and_return(true) + lambda { + actual.should_not be_happy { delegate.check_happy } + }.should fail_with("expected happy? to return false, got true") + end + + it "should fail when actual does not respond to :predicate?" do + delegate = mock("delegate", :check_happy => true) + lambda { + Object.new.should_not be_happy { delegate.check_happy } + }.should raise_error(NameError) + end +end + +describe "should be_predicate(*args, &block)" do + it "should pass when actual returns true for :predicate?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:older_than?).with(3).and_yield(3) + delegate.should_receive(:check_older_than).with(3).and_return(true) + actual.should be_older_than(3) { |age| delegate.check_older_than(age) } + end + + it "should fail when actual returns false for :predicate?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:older_than?).with(3).and_yield(3) + delegate.should_receive(:check_older_than).with(3).and_return(false) + lambda { + actual.should be_older_than(3) { |age| delegate.check_older_than(age) } + }.should fail_with("expected older_than?(3) to return true, got false") + end + + it "should fail when actual does not respond to :predicate?" do + delegate = mock("delegate", :check_older_than => true) + lambda { + Object.new.should be_older_than(3) { |age| delegate.check_older_than(age) } + }.should raise_error(NameError) + end +end + +describe "should_not be_predicate(*args, &block)" do + it "should pass when actual returns false for :predicate?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:older_than?).with(3).and_yield(3) + delegate.should_receive(:check_older_than).with(3).and_return(false) + actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) } + end + + it "should fail when actual returns true for :predicate?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:older_than?).with(3).and_yield(3) + delegate.should_receive(:check_older_than).with(3).and_return(true) + lambda { + actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) } + }.should fail_with("expected older_than?(3) to return false, got true") + end + + it "should fail when actual does not respond to :predicate?" do + delegate = mock("delegate", :check_older_than => true) + lambda { + Object.new.should_not be_older_than(3) { |age| delegate.check_older_than(age) } + }.should raise_error(NameError) + end +end + +describe "should be_true" do + it "should pass when actual equal?(true)" do + true.should be_true + end + + it "should pass when actual is 1" do + 1.should be_true + end + + it "should fail when actual equal?(false)" do + lambda { + false.should be_true + }.should fail_with("expected false to be true") + end +end + +describe "should be_false" do + it "should pass when actual equal?(false)" do + false.should be_false + end + + it "should pass when actual equal?(nil)" do + nil.should be_false + end + + it "should fail when actual equal?(true)" do + lambda { + true.should be_false + }.should fail_with("expected true to be false") + end +end + +describe "should be_nil" do + it "should pass when actual is nil" do + nil.should be_nil + end + + it "should fail when actual is not nil" do + lambda { + :not_nil.should be_nil + }.should fail_with("expected nil, got :not_nil") + end +end + +describe "should_not be_nil" do + it "should pass when actual is not nil" do + :not_nil.should_not be_nil + end + + it "should fail when actual is nil" do + lambda { + nil.should_not be_nil + }.should fail_with("expected not nil, got nil") + end +end + +describe "should be <" do + it "should pass when < operator returns true" do + 3.should be < 4 + end + + it "should fail when < operator returns false" do + lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3") + end + + it "should describe itself" do + be.<(4).description.should == "be < 4" + end +end + +describe "should be <=" do + it "should pass when <= operator returns true" do + 3.should be <= 4 + 4.should be <= 4 + end + + it "should fail when <= operator returns false" do + lambda { 3.should be <= 2 }.should fail_with("expected <= 2, got 3") + end +end + +describe "should be >=" do + it "should pass when >= operator returns true" do + 4.should be >= 4 + 5.should be >= 4 + end + + it "should fail when >= operator returns false" do + lambda { 3.should be >= 4 }.should fail_with("expected >= 4, got 3") + end +end + +describe "should be >" do + it "should pass when > operator returns true" do + 5.should be > 4 + end + + it "should fail when > operator returns false" do + lambda { 3.should be > 4 }.should fail_with("expected > 4, got 3") + end +end + +describe "should be ==" do + it "should pass when == operator returns true" do + 5.should be == 5 + end + + it "should fail when == operator returns false" do + lambda { 3.should be == 4 }.should fail_with("expected == 4, got 3") + end +end + +describe "should be ===" do + it "should pass when === operator returns true" do + Hash.should be === Hash.new + end + + it "should fail when === operator returns false" do + lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === not a hash, got Hash]) + end +end + +describe "should_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 is a bit confusing./m) + end +end + +describe "should be" do + it "should pass if actual is truthy" do + true.should be + 1.should be + end + + it "should fail if actual is false" do + lambda {false.should be}.should fail_with("expected false to evaluate to true") + end + + it "should fail if actual is nil" do + lambda {nil.should be}.should fail_with("expected nil to evaluate to true") + end + + it "should describe itself" do + be.description.should == "be" + end +end + +describe "should_not be" do + it "should pass if actual is falsy" do + false.should_not be + nil.should_not be + end + + it "should fail on true" do + lambda {true.should_not be}.should fail_with("expected true to evaluate to false") + end +end + +describe "should be(value)" do + it "should pass if actual.equal?(value)" do + 5.should be(5) + end + + it "should fail if !actual.equal?(value)" do + lambda { 5.should be(6) }.should fail_with("expected 6, got 5") + end + + it "should describe itself" do + be(5).description.should == "be 5" + end +end + +describe "should_not be(value)" do + it "should pass if !actual.equal?(value)" do + 5.should_not be(6) + end + it "should fail if !actual.equal?(value)" do + lambda { 5.should_not be(5) }.should fail_with("expected not 5, 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 + 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 + +describe "be_a, be_an" do + it "should pass when class matches" do + "foobar".should be_a(String) + [1,2,3].should be_an(Array) + end + + it "should fail when class does not match" do + "foobar".should_not be_a(Hash) + [1,2,3].should_not be_an(Integer) + end +end + +describe "be_an_instance_of" do + it "passes when direct class matches" do + 5.should be_an_instance_of(Fixnum) + end + + it "fails when class is higher up hierarchy" do + 5.should_not be_an_instance_of(Numeric) + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/change_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/change_spec.rb new file mode 100644 index 000000000..e70daf37d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/change_spec.rb @@ -0,0 +1,349 @@ +#Based on patch from Wilson Bilkovich + +require 'spec_helper' +class SomethingExpected + attr_accessor :some_value +end + +describe "should change(actual, message)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when actual is modified by the block" do + expect {@instance.some_value = 6}.to change(@instance, :some_value) + end + + it "should fail when actual is not modified by the block" do + expect do + expect {}.to change(@instance, :some_value) + end.to fail_with("some_value should have changed, but is still 5") + end + + it "provides a #description" do + change(@instance, :some_value).description.should == "change #some_value" + end +end + +describe "should_not change(actual, message)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when actual is not modified by the block" do + expect { }.to_not change(@instance, :some_value) + end + + it "should fail when actual is not modified by the block" do + expect do + expect {@instance.some_value = 6}.to_not change(@instance, :some_value) + end.to fail_with("some_value should not have changed, but did change from 5 to 6") + end +end + +describe "should change { block }" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when actual is modified by the block" do + expect {@instance.some_value = 6}.to change { @instance.some_value } + end + + it "should fail when actual is not modified by the block" do + expect do + expect {}.to change{ @instance.some_value } + end.to fail_with("result should have changed, but is still 5") + end + + it "should warn if passed a block using do/end instead of {}" do + expect do + expect {}.to change do; end + end.to raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/) + end + + it "provides a #description" do + change { @instance.some_value }.description.should == "change #result" + end +end + +describe "should_not change { block }" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when actual is modified by the block" do + expect {}.to_not change{ @instance.some_value } + end + + it "should fail when actual is not modified by the block" do + expect do + expect {@instance.some_value = 6}.to_not change { @instance.some_value } + end.to 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 instead of {}" do + expect do + expect {}.to_not change do; end + end.to raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/) + end +end + +describe "should change(actual, message).by(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by expected amount" do + expect { @instance.some_value += 1 }.to change(@instance, :some_value).by(1) + end + + it "should fail when the attribute is changed by unexpected amount" do + expect do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by(1) + end.to fail_with("some_value should have been changed by 1, but was changed by 2") + end + + it "should fail when the attribute is changed by unexpected amount in the opposite direction" do + expect do + expect { @instance.some_value -= 1 }.to change(@instance, :some_value).by(1) + end.to fail_with("some_value should have been changed by 1, but was changed by -1") + end +end + +describe "should change{ block }.by(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by expected amount" do + expect { @instance.some_value += 1 }.to change{@instance.some_value}.by(1) + end + + it "should fail when the attribute is changed by unexpected amount" do + expect do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by(1) + end.to fail_with("result should have been changed by 1, but was changed by 2") + end + + it "should fail when the attribute is changed by unexpected amount in the opposite direction" do + expect do + expect { @instance.some_value -= 1 }.to change{@instance.some_value}.by(1) + end.to fail_with("result should have been changed by 1, but was changed by -1") + end +end + +describe "should change(actual, message).by_at_least(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by greater than the expected amount" do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_least(1) + end + + it "should pass when attribute is changed by the expected amount" do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_least(2) + end + + it "should fail when the attribute is changed by less than the expected amount" do + expect do + expect { @instance.some_value += 1 }.to change(@instance, :some_value).by_at_least(2) + end.to fail_with("some_value should have been changed by at least 2, but was changed by 1") + end + +end + +describe "should change{ block }.by_at_least(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by greater than expected amount" do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_least(1) + end + + it "should pass when attribute is changed by the expected amount" do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_least(2) + end + + it "should fail when the attribute is changed by less than the unexpected amount" do + expect do + expect { @instance.some_value += 1 }.to change{@instance.some_value}.by_at_least(2) + end.to fail_with("result should have been changed by at least 2, but was changed by 1") + end +end + + +describe "should change(actual, message).by_at_most(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by less than the expected amount" do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(3) + end + + it "should pass when attribute is changed by the expected amount" do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(2) + end + + it "should fail when the attribute is changed by greater than the expected amount" do + expect do + expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(1) + end.to fail_with("some_value should have been changed by at most 1, but was changed by 2") + end + +end + +describe "should change{ block }.by_at_most(expected)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 5 + end + + it "should pass when attribute is changed by less than expected amount" do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(3) + end + + it "should pass when attribute is changed by the expected amount" do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(2) + end + + it "should fail when the attribute is changed by greater than the unexpected amount" do + expect do + expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(1) + end.to fail_with("result should have been changed by at most 1, but was changed by 2") + end +end + +describe "should change(actual, message).from(old)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when attribute is == to expected value before executing block" do + expect { @instance.some_value = "astring" }.to change(@instance, :some_value).from("string") + end + + it "should fail when attribute is not == to expected value before executing block" do + expect do + expect { @instance.some_value = "knot" }.to change(@instance, :some_value).from("cat") + end.to fail_with("some_value should have initially been \"cat\", but was \"string\"") + end +end + +describe "should change{ block }.from(old)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when attribute is == to expected value before executing block" do + expect { @instance.some_value = "astring" }.to change{@instance.some_value}.from("string") + end + + it "should fail when attribute is not == to expected value before executing block" do + expect do + expect { @instance.some_value = "knot" }.to change{@instance.some_value}.from("cat") + end.to fail_with("result should have initially been \"cat\", but was \"string\"") + end +end + +describe "should change(actual, message).to(new)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when attribute is == to expected value after executing block" do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to("cat") + end + + it "should fail when attribute is not == to expected value after executing block" do + expect do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("dog") + end.to fail_with("some_value should have been changed to \"dog\", but is now \"cat\"") + end +end + +describe "should change{ block }.to(new)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when attribute is == to expected value after executing block" do + expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to("cat") + end + + it "should fail when attribute is not == to expected value after executing block" do + expect do + expect { @instance.some_value = "cat" }.to change{@instance.some_value}.from("string").to("dog") + end.to fail_with("result should have been changed to \"dog\", but is now \"cat\"") + end +end + +describe "should change(actual, message).from(old).to(new)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when #to comes before #from" do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to("cat").from("string") + end + + it "should pass when #from comes before #to" do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("cat") + end + + it "should show the correct messaging when #after and #to are different" do + expect do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("dog") + end.to fail_with("some_value should have been changed to \"dog\", but is now \"cat\"") + end + + it "should show the correct messaging when #before and #from are different" do + expect do + expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("not_string").to("cat") + end.to fail_with("some_value should have initially been \"not_string\", but was \"string\"") + end +end + +describe "should change{ block }.from(old).to(new)" do + before(:each) do + @instance = SomethingExpected.new + @instance.some_value = 'string' + end + + it "should pass when #to comes before #from" do + expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to("cat").from("string") + end + + it "should pass when #from comes before #to" do + expect { @instance.some_value = "cat" }.to 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 + + expect { + expect { @instance.some_value = "cat" }.to change(@instance, :some_value) + }.to_not raise_error + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/compatibility_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/compatibility_spec.rb new file mode 100644 index 000000000..3987e590f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/compatibility_spec.rb @@ -0,0 +1,28 @@ +require 'spec_helper' + +Spec::Matchers.define :have_public_instance_method do |method| + match do |klass| + klass.public_instance_methods.any? {|m| [method, method.to_sym].include?(m)} + end +end + +(Spec::Matchers.constants.sort).each do |c| + if (Class === (klass = Spec::Matchers.const_get(c))) + describe klass do + if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)} + describe "called with should" do + subject { klass } + it { should have_public_instance_method('failure_message_for_should')} + it { should have_public_instance_method('failure_message')} + end + end + if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)} + describe "called with should not" do + subject { klass } + it { should have_public_instance_method('failure_message_for_should_not')} + it { should have_public_instance_method('negative_failure_message')} + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/description_generation_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/description_generation_spec.rb new file mode 100644 index 000000000..51b483c74 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/description_generation_spec.rb @@ -0,0 +1,160 @@ +require 'spec_helper' + +describe "Matchers should be able to generate their own descriptions" do + after(:each) do + Spec::Matchers.clear_generated_description + end + + it "should == expected" do + "this".should == "this" + Spec::Matchers.generated_description.should == "should == \"this\"" + end + + it "should not == expected" do + "this".should_not == "that" + Spec::Matchers.generated_description.should == "should not == \"that\"" + end + + it "should be empty (arbitrary predicate)" do + [].should be_empty + Spec::Matchers.generated_description.should == "should be empty" + end + + it "should not be empty (arbitrary predicate)" do + [1].should_not be_empty + Spec::Matchers.generated_description.should == "should not be empty" + end + + it "should be true" do + true.should be_true + Spec::Matchers.generated_description.should == "should be true" + end + + it "should be false" do + false.should be_false + Spec::Matchers.generated_description.should == "should be false" + end + + it "should be nil" do + nil.should be_nil + Spec::Matchers.generated_description.should == "should be nil" + end + + it "should be > n" do + 5.should be > 3 + Spec::Matchers.generated_description.should == "should be > 3" + end + + it "should be predicate arg1, arg2 and arg3" do + 5.0.should be_between(0,10) + Spec::Matchers.generated_description.should == "should be between 0 and 10" + end + + it "should equal" do + expected = "expected" + expected.should equal(expected) + Spec::Matchers.generated_description.should == "should equal \"expected\"" + end + + it "should_not equal" do + 5.should_not equal(37) + Spec::Matchers.generated_description.should == "should not equal 37" + end + + it "should eql" do + "string".should eql("string") + Spec::Matchers.generated_description.should == "should eql \"string\"" + end + + it "should not eql" do + "a".should_not eql(:a) + Spec::Matchers.generated_description.should == "should not eql :a" + end + + it "should have_key" do + {:a => "a"}.should have_key(:a) + Spec::Matchers.generated_description.should == "should have key :a" + end + + it "should have n items" do + team.should have(3).players + Spec::Matchers.generated_description.should == "should have 3 players" + end + + it "should have at least n items" do + team.should have_at_least(2).players + Spec::Matchers.generated_description.should == "should have at least 2 players" + end + + it "should have at most n items" do + team.should have_at_most(4).players + Spec::Matchers.generated_description.should == "should have at most 4 players" + end + + it "should include" do + [1,2,3].should include(3) + Spec::Matchers.generated_description.should == "should include 3" + end + + it "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/) + Spec::Matchers.generated_description.should == "should match /this string/" + end + + it "should raise_error" do + lambda { raise }.should raise_error + Spec::Matchers.generated_description.should == "should raise Exception" + end + + it "should raise_error with type" do + lambda { raise }.should raise_error(RuntimeError) + Spec::Matchers.generated_description.should == "should raise RuntimeError" + end + + it "should raise_error with type and message" do + lambda { raise "there was an error" }.should raise_error(RuntimeError, "there was an error") + Spec::Matchers.generated_description.should == "should raise RuntimeError with \"there was an error\"" + end + + it "should respond_to" do + [].should respond_to(:insert) + Spec::Matchers.generated_description.should == "should respond to #insert" + end + + it "should throw symbol" do + lambda { throw :what_a_mess }.should throw_symbol + Spec::Matchers.generated_description.should == "should throw a Symbol" + end + + it "should throw symbol (with named symbol)" do + lambda { throw :what_a_mess }.should throw_symbol(:what_a_mess) + Spec::Matchers.generated_description.should == "should throw :what_a_mess" + end + + def team + Class.new do + def players + [1,2,3] + end + end.new + end +end + +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 diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/dsl_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/dsl_spec.rb new file mode 100644 index 000000000..9c280e5ae --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/dsl_spec.rb @@ -0,0 +1,34 @@ +require 'spec_helper' + +module Spec + module Matchers + module DSL + describe "#create" do + it "is deprecated" do + Spec.should_receive(:deprecate) + mod = Module.new + mod.extend Spec::Matchers::DSL + mod.create(:foo) + end + end + + describe "#define" do + it "creates a method that initializes a new matcher with the submitted name and expected arg" do + # FIXME - this expects new to be called, but we need something + # more robust - that expects new to be called with a specific + # block (lambda, proc, whatever) + mod = Module.new + mod.extend Spec::Matchers::DSL + mod.define(:foo) + + obj = Object.new + obj.extend mod + + Spec::Matchers::Matcher.should_receive(:new).with(:foo, 3) + + obj.foo(3) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/eql_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/eql_spec.rb new file mode 100644 index 000000000..5cdf541eb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/eql_spec.rb @@ -0,0 +1,33 @@ +require 'spec_helper' + +module Spec + module Matchers + describe "eql" do + it "should match when actual.eql?(expected)" do + 1.should eql(1) + end + + it "should not match when !actual.eql?(expected)" do + 1.should_not eql(2) + end + + it "should describe itself" do + 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("1") + matcher.matches?(1) + matcher.failure_message_for_should.should == "\nexpected \"1\"\n got 1\n\n(compared using eql?)\n" + end + + it "should provide message, expected and actual on #negative_failure_message" do + matcher = eql(1) + matcher.matches?(1) + matcher.failure_message_for_should_not.should == "\nexpected 1 not to equal 1\n\n(compared using eql?)\n" + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/equal_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/equal_spec.rb new file mode 100644 index 000000000..cb2fc1e51 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/equal_spec.rb @@ -0,0 +1,57 @@ +require 'spec_helper' +module Spec + module Matchers + describe "equal" do + + def inspect_object(o) + "#<#{o.class}:#{o.object_id}> => #{o.inspect}" + end + + it "should match when actual.equal?(expected)" do + 1.should equal(1) + end + + it "should not match when !actual.equal?(expected)" do + 1.should_not equal("1") + end + + it "should describe itself" do + matcher = equal(1) + matcher.matches?(1) + matcher.description.should == "equal 1" + end + + it "should provide message on #failure_message" do + expected, actual = "1", "1" + matcher = equal(expected) + matcher.matches?(actual) + + matcher.failure_message_for_should.should == <<-MESSAGE + +expected #{inspect_object(expected)} + got #{inspect_object(actual)} + +Compared using equal?, which compares object identity, +but expected and actual are not the same object. Use +'actual.should == expected' if you don't care about +object identity in this example. + +MESSAGE + end + + it "should provide message on #negative_failure_message" do + expected = actual = "1" + matcher = equal(expected) + matcher.matches?(actual) + matcher.failure_message_for_should_not.should == <<-MESSAGE + +expected not #{inspect_object(expected)} + got #{inspect_object(actual)} + +Compared using equal?, which compares object identity. + +MESSAGE + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/exist_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/exist_spec.rb new file mode 100644 index 000000000..f95c86ff8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/exist_spec.rb @@ -0,0 +1,65 @@ +require 'spec_helper' + +class Substance + def initialize exists, description + @exists = exists + @description = description + end + def exist?(arg=nil) + @exists + end + def inspect + @description + end +end + +class SubstanceTester + include Spec::Matchers + def initialize substance + @substance = substance + end + def should_exist + @substance.should exist + end +end + +describe "should exist" do + + before(:each) do + @real = Substance.new true, 'something real' + @imaginary = Substance.new false, 'something imaginary' + end + + describe "within an example group" do + + it "passes if target exists" do + @real.should exist + end + + it "passes if target exists with args" do + @real.should exist('this arg') + end + + it "fails if target does not exist" do + lambda { @imaginary.should exist }.should fail + end + + it "describes itself" do + exist.description.should == "exist" + end + + it "passes should_not exist if target doesn't exist" do + lambda { @real.should_not exist }.should fail + end + end + + describe "outside of an example group" do + + it "should pass if target exists" do + real_tester = SubstanceTester.new @real + real_tester.should_exist + end + + end + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/has_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/has_spec.rb new file mode 100644 index 000000000..f77e70274 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/has_spec.rb @@ -0,0 +1,190 @@ +require 'spec_helper' + +describe "should have_sym(*args)" do + it "should pass if #has_sym?(*args) returns true" do + {:a => "A"}.should have_key(:a) + end + + it "should fail if #has_sym?(*args) returns false" do + lambda { + {:b => "B"}.should have_key(:a) + }.should fail_with("expected #has_key?(:a) to return true, got false") + end + + it "should fail if #has_sym?(*args) returns nil" do + klass = Class.new do + def has_foo? + end + end + lambda { + klass.new.should have_foo + }.should fail_with("expected #has_foo?(nil) to return true, got false") + end + + it "should fail if target does not respond to #has_sym?" do + lambda { + Object.new.should have_key(:a) + }.should raise_error(NoMethodError) + end + + 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 + it "should pass if #has_sym?(*args) returns false" do + {:a => "A"}.should_not have_key(:b) + end + + it "should pass if #has_sym?(*args) returns nil" do + klass = Class.new do + def has_foo? + end + end + klass.new.should_not have_foo + end + + it "should fail if #has_sym?(*args) returns true" do + lambda { + {:a => "A"}.should_not have_key(:a) + }.should fail_with("expected #has_key?(:a) to return false, got true") + end + + it "should fail if target does not respond to #has_sym?" do + lambda { + Object.new.should have_key(:a) + }.should raise_error(NoMethodError) + end + + 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 "should have_sym(&block)" do + it "should pass when actual returns true for :has_sym?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).and_yield + delegate.should_receive(:check_has_foo).and_return(true) + actual.should have_foo { delegate.check_has_foo } + end + + it "should fail when actual returns false for :has_sym?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).and_yield + delegate.should_receive(:check_has_foo).and_return(false) + lambda { + actual.should have_foo { delegate.check_has_foo } + }.should fail_with("expected #has_foo?(nil) to return true, got false") + end + + it "should fail when actual does not respond to :has_sym?" do + delegate = mock("delegate", :check_has_foo => true) + lambda { + Object.new.should have_foo { delegate.check_has_foo } + }.should raise_error(NameError) + end +end + +describe "should_not have_sym(&block)" do + it "should pass when actual returns false for :has_sym?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).and_yield + delegate.should_receive(:check_has_foo).and_return(false) + actual.should_not have_foo { delegate.check_has_foo } + end + + it "should fail when actual returns true for :has_sym?(&block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).and_yield + delegate.should_receive(:check_has_foo).and_return(true) + lambda { + actual.should_not have_foo { delegate.check_has_foo } + }.should fail_with("expected #has_foo?(nil) to return false, got true") + end + + it "should fail when actual does not respond to :has_sym?" do + delegate = mock("delegate", :check_has_foo => true) + lambda { + Object.new.should_not have_foo { delegate.check_has_foo } + }.should raise_error(NameError) + end +end + +describe "should have_sym(*args, &block)" do + it "should pass when actual returns true for :has_sym?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).with(:a).and_yield(:a) + delegate.should_receive(:check_has_foo).with(:a).and_return(true) + actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) } + end + + it "should fail when actual returns false for :has_sym?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).with(:a).and_yield(:a) + delegate.should_receive(:check_has_foo).with(:a).and_return(false) + lambda { + actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) } + }.should fail_with("expected #has_foo?(:a) to return true, got false") + end + + it "should fail when actual does not respond to :has_sym?" do + delegate = mock("delegate", :check_has_foo => true) + lambda { + Object.new.should have_foo(:a) { |foo| delegate.check_has_foo(foo) } + }.should raise_error(NameError) + end +end + +describe "should_not have_sym(*args, &block)" do + it "should pass when actual returns false for :has_sym?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).with(:a).and_yield(:a) + delegate.should_receive(:check_has_foo).with(:a).and_return(false) + actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) } + end + + it "should fail when actual returns true for :has_sym?(*args, &block)" do + actual = mock("actual") + delegate = mock("delegate") + actual.should_receive(:has_foo?).with(:a).and_yield(:a) + delegate.should_receive(:check_has_foo).with(:a).and_return(true) + lambda { + actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) } + }.should fail_with("expected #has_foo?(:a) to return false, got true") + end + + it "should fail when actual does not respond to :has_sym?" do + delegate = mock("delegate", :check_has_foo => true) + lambda { + Object.new.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) } + }.should raise_error(NameError) + 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 diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/have_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/have_spec.rb new file mode 100644 index 000000000..e514acabe --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/have_spec.rb @@ -0,0 +1,381 @@ +require 'spec_helper' + +describe "have matcher" do + + def create_collection_owner_with(n) + owner = Spec::Expectations::Helper::CollectionOwner.new + (1..n).each do |number| + owner.add_to_collection_with_length_method(number) + owner.add_to_collection_with_size_method(number) + end + owner + end + + before(:each) do + if defined?(::ActiveSupport::Inflector) + @active_support_was_defined = true + else + @active_support_was_defined = false + module ::ActiveSupport + class Inflector + def self.pluralize(string) + string.to_s + 's' + end + end + end + end + end + + describe "should have(n).items" do + it "should pass if target has a collection of items with n members" do + owner = create_collection_owner_with(3) + owner.should have(3).items_in_collection_with_length_method + owner.should have(3).items_in_collection_with_size_method + end + + it "should convert :no to 0" do + owner = create_collection_owner_with(0) + owner.should have(:no).items_in_collection_with_length_method + owner.should have(:no).items_in_collection_with_size_method + end + + it "should fail if target has a collection of items with < n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have(4).items_in_collection_with_length_method + }.should fail_with("expected 4 items_in_collection_with_length_method, got 3") + lambda { + owner.should have(4).items_in_collection_with_size_method + }.should fail_with("expected 4 items_in_collection_with_size_method, got 3") + end + + it "should fail if target has a collection of items with > n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have(2).items_in_collection_with_length_method + }.should fail_with("expected 2 items_in_collection_with_length_method, got 3") + lambda { + owner.should have(2).items_in_collection_with_size_method + }.should fail_with("expected 2 items_in_collection_with_size_method, got 3") + end + end + + describe 'should have(1).item when ActiveSupport::Inflector is defined' do + it 'should pluralize the collection name' do + owner = create_collection_owner_with(1) + owner.should have(1).item + end + + after(:each) do + unless @active_support_was_defined + Object.__send__ :remove_const, :ActiveSupport + end + end + end + + describe 'should have(1).item when Inflector is defined' do + before(:each) do + if defined?(Inflector) + @inflector_was_defined = true + else + @inflector_was_defined = false + 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 + unless @inflector_was_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 + def items + Object.new + end + end.new + lambda do + owner.should have(3).items + end.should raise_error("expected items to be a collection but it does not respond to #length or #size") + end + end + + describe "should_not have(n).items" do + it "should pass if target has a collection of items with < n members" do + owner = create_collection_owner_with(3) + owner.should_not have(4).items_in_collection_with_length_method + owner.should_not have(4).items_in_collection_with_size_method + end + + it "should pass if target has a collection of items with > n members" do + owner = create_collection_owner_with(3) + owner.should_not have(2).items_in_collection_with_length_method + owner.should_not have(2).items_in_collection_with_size_method + end + + it "should fail if target has a collection of items with n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should_not have(3).items_in_collection_with_length_method + }.should fail_with("expected target not to have 3 items_in_collection_with_length_method, got 3") + lambda { + owner.should_not have(3).items_in_collection_with_size_method + }.should fail_with("expected target not to have 3 items_in_collection_with_size_method, got 3") + end + end + + describe "should have_exactly(n).items" do + it "should pass if target has a collection of items with n members" do + owner = create_collection_owner_with(3) + owner.should have_exactly(3).items_in_collection_with_length_method + owner.should have_exactly(3).items_in_collection_with_size_method + end + + it "should convert :no to 0" do + owner = create_collection_owner_with(0) + owner.should have_exactly(:no).items_in_collection_with_length_method + owner.should have_exactly(:no).items_in_collection_with_size_method + end + + it "should fail if target has a collection of items with < n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have_exactly(4).items_in_collection_with_length_method + }.should fail_with("expected 4 items_in_collection_with_length_method, got 3") + lambda { + owner.should have_exactly(4).items_in_collection_with_size_method + }.should fail_with("expected 4 items_in_collection_with_size_method, got 3") + end + + it "should fail if target has a collection of items with > n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have_exactly(2).items_in_collection_with_length_method + }.should fail_with("expected 2 items_in_collection_with_length_method, got 3") + lambda { + owner.should have_exactly(2).items_in_collection_with_size_method + }.should fail_with("expected 2 items_in_collection_with_size_method, got 3") + end + end + + describe "should have_at_least(n).items" do + it "should pass if target has a collection of items with n members" do + owner = create_collection_owner_with(3) + owner.should have_at_least(3).items_in_collection_with_length_method + owner.should have_at_least(3).items_in_collection_with_size_method + end + + it "should pass if target has a collection of items with > n members" do + owner = create_collection_owner_with(3) + owner.should have_at_least(2).items_in_collection_with_length_method + owner.should have_at_least(2).items_in_collection_with_size_method + end + + it "should fail if target has a collection of items with < n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have_at_least(4).items_in_collection_with_length_method + }.should fail_with("expected at least 4 items_in_collection_with_length_method, got 3") + lambda { + owner.should have_at_least(4).items_in_collection_with_size_method + }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3") + end + + it "should provide educational negative failure messages" do + #given + owner = create_collection_owner_with(3) + length_matcher = have_at_least(3).items_in_collection_with_length_method + size_matcher = have_at_least(3).items_in_collection_with_size_method + + #when + length_matcher.matches?(owner) + size_matcher.matches?(owner) + + #then + length_matcher.failure_message_for_should_not.should == <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_least(3).items_in_collection_with_length_method +We recommend that you use this instead: + should have_at_most(2).items_in_collection_with_length_method +EOF + + size_matcher.failure_message_for_should_not.should == <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_least(3).items_in_collection_with_size_method +We recommend that you use this instead: + should have_at_most(2).items_in_collection_with_size_method +EOF + end + end + + describe "should have_at_most(n).items" do + it "should pass if target has a collection of items with n members" do + owner = create_collection_owner_with(3) + owner.should have_at_most(3).items_in_collection_with_length_method + owner.should have_at_most(3).items_in_collection_with_size_method + end + + it "should fail if target has a collection of items with > n members" do + owner = create_collection_owner_with(3) + lambda { + owner.should have_at_most(2).items_in_collection_with_length_method + }.should fail_with("expected at most 2 items_in_collection_with_length_method, got 3") + lambda { + owner.should have_at_most(2).items_in_collection_with_size_method + }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3") + end + + it "should pass if target has a collection of items with < n members" do + owner = create_collection_owner_with(3) + owner.should have_at_most(4).items_in_collection_with_length_method + owner.should have_at_most(4).items_in_collection_with_size_method + end + + it "should provide educational negative failure messages" do + #given + owner = create_collection_owner_with(3) + length_matcher = have_at_most(3).items_in_collection_with_length_method + size_matcher = have_at_most(3).items_in_collection_with_size_method + + #when + length_matcher.matches?(owner) + size_matcher.matches?(owner) + + #then + length_matcher.failure_message_for_should_not.should == <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_most(3).items_in_collection_with_length_method +We recommend that you use this instead: + should have_at_least(4).items_in_collection_with_length_method +EOF + + size_matcher.failure_message_for_should_not.should == <<-EOF +Isn't life confusing enough? +Instead of having to figure out the meaning of this: + should_not have_at_most(3).items_in_collection_with_size_method +We recommend that you use this instead: + should have_at_least(4).items_in_collection_with_size_method +EOF + end + end + + describe "have(n).items(args, block)" do + it "should pass args to target" do + target = mock("target") + target.should_receive(:items).with("arg1","arg2").and_return([1,2,3]) + target.should have(3).items("arg1","arg2") + end + + it "should pass block to target" do + target = mock("target") + block = lambda { 5 } + target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3]) + target.should have(3).items("arg1","arg2", block) + end + end + + describe "have(n).items where target IS a collection" do + it "should reference the number of items IN the collection" do + [1,2,3].should have(3).items + end + + it "should fail when the number of items IN the collection is not as expected" do + lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3") + end + end + + describe "have(n).characters where target IS a String" do + it "should pass if the length is correct" do + "this string".should have(11).characters + end + + it "should fail if the length is incorrect" do + lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11") + end + end + + describe "have(n).things on an object which is not a collection nor contains one" do + it "should fail" do + lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/) + end + end + + describe Spec::Matchers::Have, "for a collection owner that implements #send" do + 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 + treats_method_missing_as_private :noop => false + + 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 +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/include_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/include_spec.rb new file mode 100644 index 000000000..2b959b589 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/include_spec.rb @@ -0,0 +1,88 @@ +require 'spec_helper' + +describe "should include(expected)" do + it "should pass if target includes expected" do + [1,2,3].should include(3) + "abc".should include("a") + end + + it 'should 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 { + [1,2,3].should include(4) + }.should fail_with("expected [1, 2, 3] to include 4") + lambda { + "abc".should include("d") + }.should fail_with("expected \"abc\" to include \"d\"") + lambda { + {:key => 'value'}.should include(:other) + }.should fail_with(%Q|expected {:key=>"value"} to include :other|) + end +end + +describe "should include(with, multiple, args)" do + it "should pass if target includes all items" do + [1,2,3].should include(1,2,3) + end + + it 'should 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 + it "should pass if target does not include expected" do + [1,2,3].should_not include(4) + "abc".should_not include("d") + end + + it 'should 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 { + [1,2,3].should_not include(3) + }.should fail_with("expected [1, 2, 3] not to include 3") + lambda { + "abc".should_not include("c") + }.should fail_with("expected \"abc\" not to include \"c\"") + 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 diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_array_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_array_spec.rb new file mode 100644 index 000000000..313acf46e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_array_spec.rb @@ -0,0 +1,115 @@ +require 'spec_helper' + +class UnsortableObject + def initialize(id) + @id = id + end + + def inspect + @id.to_s + end + + def ==(other) + false + end +end + +describe "array.should =~ other_array" do + it "should pass if target contains all items" do + [1,2,3].should =~ [1,2,3] + end + + it "should pass if target contains all items out of order" do + [1,3,2].should =~ [1,2,3] + end + + it "should fail if target includes extra items" do + lambda { + [1,2,3,4].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2, 3, 4] +the extra elements were: [4] +MESSAGE + end + + it "should fail if target is missing items" do + lambda { + [1,2].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2] +the missing elements were: [3] +MESSAGE + end + + it "should fail if target is missing items and has extra items" do + + lambda { + [1,2,4].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2, 4] +the missing elements were: [3] +the extra elements were: [4] +MESSAGE + end + + it "should sort items in the error message if they all respond to <=>" do + lambda { + [6,2,1,5].should =~ [4,1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3, 4] +actual collection contained: [1, 2, 5, 6] +the missing elements were: [3, 4] +the extra elements were: [5, 6] +MESSAGE + end + + it "should not sort items in the error message if they don't all respond to <=>" do + with_ruby 1.8 do + lambda { + [UnsortableObject.new(2), UnsortableObject.new(1)].should =~ [UnsortableObject.new(4), UnsortableObject.new(3)] + }.should fail_with(<<-MESSAGE) +expected collection contained: [4, 3] +actual collection contained: [2, 1] +the missing elements were: [4, 3] +the extra elements were: [2, 1] +MESSAGE + end + end + + it "should accurately report extra elements when there are duplicates" do + lambda { + [1,1,1,5].should =~ [1,5] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 5] +actual collection contained: [1, 1, 1, 5] +the extra elements were: [1, 1] +MESSAGE + end + + it "should accurately report missing elements when there are duplicates" do + lambda { + [1,5].should =~ [1,1,5] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 1, 5] +actual collection contained: [1, 5] +the missing elements were: [1] +MESSAGE + end + + it "should work with subclasses of Array" do + class SuperArray < Array; end + SuperArray.new([1,2,3]).should =~ SuperArray.new([3,2,1]) + end + +end + +describe "should_not =~ [:with, :multiple, :args]" do + it "should not be supported" do + lambda { + [1,2,3].should_not =~ [1,2,3] + }.should fail_with(/Matcher does not support should_not/) + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_spec.rb new file mode 100644 index 000000000..e5dc800a6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/match_spec.rb @@ -0,0 +1,57 @@ +require 'spec_helper' + +describe "should match(expected)" do + it "should pass when target (String) matches expected (Regexp)" do + "string".should match(/tri/) + end + + it "should pass when target (String) matches expected (String)" do + "string".should match("tri") + end + + it "should fail when target (String) does not match expected (Regexp)" do + lambda { + "string".should match(/rings/) + }.should fail + end + + it "should fail when target (String) does not match expected (String)" do + lambda { + "string".should match("rings") + }.should fail + end + + it "should provide message, expected and actual on failure" do + matcher = match(/rings/) + matcher.matches?("string") + matcher.failure_message_for_should.should == "expected \"string\" to match /rings/" + end +end + +describe "should_not match(expected)" do + it "should pass when target (String) matches does not match (Regexp)" do + "string".should_not match(/rings/) + end + + it "should pass when target (String) matches does not match (String)" do + "string".should_not match("rings") + end + + it "should fail when target (String) matches expected (Regexp)" do + lambda { + "string".should_not match(/tri/) + }.should fail + end + + it "should fail when target (String) matches expected (String)" do + lambda { + "string".should_not match("tri") + }.should fail + end + + it "should provide message, expected and actual on failure" do + matcher = match(/tri/) + matcher.matches?("string") + matcher.failure_message_for_should_not.should == "expected \"string\" not to match /tri/" + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/matcher_spec.rb new file mode 100644 index 000000000..b933cfc90 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/matcher_spec.rb @@ -0,0 +1,289 @@ +require 'spec_helper' + +class UnexpectedError < StandardError; end + +module Spec + module Matchers + describe Matcher do + context "without overrides" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple| + match do |actual| + actual % multiple == 0 + end + end + end + + it "provides a default description" do + @matcher.description.should == "be a multiple of 3" + end + + it "provides a default failure message for #should" do + @matcher.matches?(8) + @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3" + end + + it "provides a default failure message for #should_not" do + @matcher.matches?(9) + @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3" + end + end + + it "is not diffable by default" do + matcher = Spec::Matchers::Matcher.new(:name) {} + matcher.should_not be_diffable + end + + it "is diffable when told to be" do + matcher = Spec::Matchers::Matcher.new(:name) { diffable } + matcher.should be_diffable + end + + it "provides expected" do + matcher = Spec::Matchers::Matcher.new(:name, 'expected string') {} + matcher.expected.should == ['expected string'] + end + + it "provides actual" do + matcher = Spec::Matchers::Matcher.new(:name, 'expected string') do + match {|actual|} + end + + matcher.matches?('actual string') + + matcher.actual.should == 'actual string' + end + + context "wrapping another expectation (should == ...)" do + it "returns true if the wrapped expectation passes" do + matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected| + match do |actual| + actual.should == expected + end + end + matcher.matches?('value').should be_true + end + + it "returns false if the wrapped expectation fails" do + matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected| + match do |actual| + actual.should == expected + end + end + matcher.matches?('other value').should be_false + end + end + + context "with overrides" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:be_boolean, true) do |boolean| + match do |actual| + actual + end + description do + "be the boolean #{boolean}" + end + failure_message_for_should do |actual| + "expected #{actual} to be the boolean #{boolean}" + end + failure_message_for_should_not do |actual| + "expected #{actual} not to be the boolean #{boolean}" + end + end + end + + it "does not hide result of match block when true" do + @matcher.matches?(true).should be_true + end + + it "does not hide result of match block when false" do + @matcher.matches?(false).should be_false + end + + it "overrides the description" do + @matcher.description.should == "be the boolean true" + end + + it "overrides the failure message for #should" do + @matcher.matches?(false) + @matcher.failure_message_for_should.should == "expected false to be the boolean true" + end + + it "overrides the failure message for #should_not" do + @matcher.matches?(true) + @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true" + end + end + + context "#new" do + it "passes matches? arg to match block" do + matcher = Spec::Matchers::Matcher.new(:ignore) do + match do |actual| + actual == 5 + end + end + matcher.matches?(5).should be_true + end + + it "exposes arg submitted through #new to matcher block" do + matcher = Spec::Matchers::Matcher.new(:ignore, 4) do |expected| + match do |actual| + actual > expected + end + end + matcher.matches?(5).should be_true + end + end + + context "with no args" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name) do + match do |actual| + actual == 5 + end + end + end + + it "matches" do + @matcher.matches?(5).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name" + end + end + + context "with 1 arg" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1) do |expected| + match do |actual| + actual == 5 && expected == 1 + end + end + end + + it "matches" do + @matcher.matches?(5).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name 1" + end + end + + context "with multiple args" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1, 2, 3, 4) do |a,b,c,d| + match do |sum| + a + b + c + d == sum + end + end + end + + it "matches" do + @matcher.matches?(10).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name 1, 2, 3, and 4" + end + end + + it "supports helper methods" do + matcher = Spec::Matchers::Matcher.new(:be_similar_to, [1,2,3]) do |sample| + match do |actual| + similar?(sample, actual) + end + + def similar?(a, b) + a.sort == b.sort + end + end + + matcher.matches?([2,3,1]).should be_true + end + + it "supports fluent interface" do + matcher = Spec::Matchers::Matcher.new(:first_word) do + def second_word + self + end + end + + matcher.second_word.should == matcher + end + + it "treats method missing normally for undeclared methods" do + matcher = Spec::Matchers::Matcher.new(:ignore) { } + expect { matcher.non_existent_method }.to raise_error(NoMethodError) + end + + it "has access to other matchers" do + matcher = Spec::Matchers::Matcher.new(:ignore, 3) do |expected| + match do |actual| + extend Spec::Matchers + actual.should eql(5 + expected) + end + end + + matcher.matches?(8).should be_true + end + + describe "#match_unless_raises" do + context "with a passing assertion" do + let(:mod) do + Module.new do + def assert_equal(a,b) + a == b ? nil : (raise UnexpectedError.new("#{a} does not equal #{b}")) + end + end + end + let(:matcher) do + m = mod + Spec::Matchers::Matcher.new :equal, 4 do |expected| + extend m + match_unless_raises UnexpectedError do + assert_equal expected, actual + end + end + end + it "passes as you would expect" do + matcher.matches?(4).should be_true + end + it "fails as you would expect" do + matcher.matches?(5).should be_false + end + end + + context "with an unexpected error" do + let(:matcher) do + Spec::Matchers::Matcher.new :foo, :bar do |expected| + match_unless_raises SyntaxError do |actual| + raise "unexpected exception" + end + end + end + + it "raises the error" do + expect do + matcher.matches?(:bar) + end.to raise_error("unexpected exception") + end + end + + end + + it "can define chainable methods" do + matcher = Spec::Matchers::Matcher.new(:name) do + chain(:expecting) do |expected_value| + @expected_value = expected_value + end + match { |actual| actual == @expected_value } + end + + matcher.expecting('value').matches?('value').should be_true + matcher.expecting('value').matches?('other value').should be_false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/matchers_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/matchers_spec.rb new file mode 100644 index 000000000..51f5efc44 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/matchers_spec.rb @@ -0,0 +1,2 @@ +require 'spec_helper' + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/operator_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/operator_matcher_spec.rb new file mode 100644 index 000000000..86e637e0f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/operator_matcher_spec.rb @@ -0,0 +1,191 @@ +require 'spec_helper' + +require 'spec/runner/differs/default' + +describe "should ==" do + + it "should delegate message to target" do + subject = "apple" + subject.should_receive(:==).with("apple").and_return(true) + subject.should == "apple" + end + + it "should 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 + + it "should delegate message to target" do + subject = "orange" + subject.should_receive(:==).with("apple").and_return(false) + subject.should_not == "apple" + end + + it "should return true on success" do + subject = "apple" + (subject.should_not == "orange").should be_false + end + + it "should fail when target.==(actual) returns false" do + subject = "apple" + Spec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n got: "apple"], "apple", "apple") + subject.should_not == "apple" + end + +end + +describe "should ===" do + + it "should delegate message to target" do + subject = "apple" + subject.should_receive(:===).with("apple").and_return(true) + subject.should === "apple" + end + + it "should fail when target.===(actual) returns false" do + subject = "apple" + subject.should_receive(:===).with("orange").and_return(false) + Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n got: "apple" (using ===)], "orange", "apple") + subject.should === "orange" + end + +end + +describe "should_not ===" do + + it "should delegate message to target" do + subject = "orange" + subject.should_receive(:===).with("apple").and_return(false) + subject.should_not === "apple" + end + + it "should fail when target.===(actual) returns false" do + subject = "apple" + subject.should_receive(:===).with("apple").and_return(true) + Spec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple",\n got: "apple"], "apple", "apple") + subject.should_not === "apple" + end + +end + +describe "should =~" do + + it "should delegate message to target" do + subject = "foo" + subject.should_receive(:=~).with(/oo/).and_return(true) + subject.should =~ /oo/ + end + + it "should fail when target.=~(actual) returns false" do + subject = "fu" + subject.should_receive(:=~).with(/oo/).and_return(false) + Spec::Expectations.should_receive(:fail_with).with(%[expected: /oo/,\n got: "fu" (using =~)], /oo/, "fu") + subject.should =~ /oo/ + end + +end + +describe "should_not =~" do + + it "should delegate message to target" do + subject = "fu" + subject.should_receive(:=~).with(/oo/).and_return(false) + subject.should_not =~ /oo/ + end + + it "should fail when target.=~(actual) returns false" do + subject = "foo" + subject.should_receive(:=~).with(/oo/).and_return(true) + Spec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/,\n got: "foo"], /oo/, "foo") + subject.should_not =~ /oo/ + end + +end + +describe "should >" do + + it "should pass if > passes" do + 4.should > 3 + end + + it "should fail if > fails" do + Spec::Expectations.should_receive(:fail_with).with(%[expected: > 5,\n got: 4], 5, 4) + 4.should > 5 + end + +end + +describe "should >=" do + + it "should pass if >= passes" do + 4.should > 3 + 4.should >= 4 + end + + it "should fail if > fails" do + Spec::Expectations.should_receive(:fail_with).with(%[expected: >= 5,\n got: 4], 5, 4) + 4.should >= 5 + end + +end + +describe "should <" do + + it "should pass if < passes" do + 4.should < 5 + end + + it "should fail if > fails" do + Spec::Expectations.should_receive(:fail_with).with(%[expected: < 3,\n got: 4], 3, 4) + 4.should < 3 + end + +end + +describe "should <=" do + + it "should pass if <= passes" do + 4.should <= 5 + 4.should <= 4 + end + + it "should fail if > fails" do + Spec::Expectations.should_receive(:fail_with).with(%[expected: <= 3,\n got: 4], 3, 4) + 4.should <= 3 + end + +end + +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 diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/raise_exception_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/raise_exception_spec.rb new file mode 100644 index 000000000..26888926e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/raise_exception_spec.rb @@ -0,0 +1,345 @@ +require 'spec_helper' + +describe "should raise_exception" do + it "should pass if anything is raised" do + lambda {raise}.should raise_exception + end + + it "should fail if nothing is raised" do + lambda { + lambda {}.should raise_exception + }.should fail_with("expected Exception but nothing was raised") + end +end + +describe "should raise_error" do + it "should pass if anything is raised" do + lambda {raise}.should raise_error + end + + it "should fail if nothing is raised" do + lambda { + lambda {}.should raise_error + }.should fail_with("expected Exception but nothing was raised") + end +end + +describe "should raise_exception {|e| ... }" do + it "passes if there is an exception" do + ran = false + lambda { non_existent_method }.should raise_exception {|e| + ran = true + } + ran.should be_true + end + + it "passes the exception to the block" do + exception = nil + lambda { non_existent_method }.should raise_exception {|e| + exception = e + } + exception.should be_kind_of(NameError) + end +end + +describe "should_not raise_exception" do + it "should pass if nothing is raised" do + lambda {}.should_not raise_exception + end + + it "should fail if anything is raised" do + lambda { + lambda {raise}.should_not raise_exception + }.should fail_with("expected no Exception, got RuntimeError") + end +end + +describe "should raise_exception(message)" do + it "should pass if RuntimeError is raised with the right message" do + lambda {raise 'blah'}.should raise_exception('blah') + end + it "should pass if RuntimeError is raised with a matching message" do + lambda {raise 'blah'}.should raise_exception(/blah/) + end + it "should pass if any other exception is raised with the right message" do + lambda {raise NameError.new('blah')}.should raise_exception('blah') + end + it "should fail if RuntimeError exception is raised with the wrong message" do + lambda do + lambda {raise 'blarg'}.should raise_exception('blah') + end.should fail_with("expected Exception with \"blah\", got #<RuntimeError: blarg>") + end + it "should fail if any other exception is raised with the wrong message" do + lambda do + lambda {raise NameError.new('blarg')}.should raise_exception('blah') + end.should fail_with("expected Exception with \"blah\", got #<NameError: blarg>") + end +end + +describe "should_not raise_exception(message)" do + it "should pass if RuntimeError exception is raised with the different message" do + lambda {raise 'blarg'}.should_not raise_exception('blah') + end + it "should pass if any other exception is raised with the wrong message" do + lambda {raise NameError.new('blarg')}.should_not raise_exception('blah') + end + it "should fail if RuntimeError is raised with message" do + lambda do + lambda {raise 'blah'}.should_not raise_exception('blah') + end.should fail_with(%Q|expected no Exception with "blah", got #<RuntimeError: blah>|) + end + it "should fail if any other exception is raised with message" do + lambda do + lambda {raise NameError.new('blah')}.should_not raise_exception('blah') + end.should fail_with(%Q|expected no Exception with "blah", got #<NameError: blah>|) + end +end + +describe "should raise_exception(NamedError)" do + it "should pass if named exception is raised" do + lambda { non_existent_method }.should raise_exception(NameError) + end + + it "should fail if nothing is raised" do + lambda { + lambda { }.should raise_exception(NameError) + }.should fail_with("expected NameError but nothing was raised") + end + + it "should fail if another exception is raised (NameError)" do + lambda { + lambda { raise }.should raise_exception(NameError) + }.should fail_with("expected NameError, got RuntimeError") + end + + it "should fail if another exception is raised (NameError)" do + lambda { + lambda { load "non/existent/file" }.should raise_exception(NameError) + }.should fail_with(/expected NameError, got #<LoadError/) + end +end + +describe "should_not raise_exception(NamedError)" do + it "should pass if nothing is raised" do + lambda { }.should_not raise_exception(NameError) + end + + it "should pass if another exception is raised" do + lambda { raise }.should_not raise_exception(NameError) + end + + it "should fail if named exception is raised" do + lambda { + lambda { 1 + 'b' }.should_not raise_exception(TypeError) + }.should fail_with(/expected no TypeError, got #<TypeError: String can't be/) + end +end + +describe "should raise_exception(NamedError, exception_message) with String" do + it "should pass if named exception is raised with same message" do + lambda { raise "example message" }.should raise_exception(RuntimeError, "example message") + end + + it "should fail if nothing is raised" do + lambda { + lambda {}.should raise_exception(RuntimeError, "example message") + }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised") + end + + it "should fail if incorrect exception is raised" do + lambda { + lambda { raise }.should raise_exception(NameError, "example message") + }.should fail_with("expected NameError with \"example message\", got RuntimeError") + end + + it "should fail if correct exception is raised with incorrect message" do + lambda { + lambda { raise RuntimeError.new("not the example message") }.should raise_exception(RuntimeError, "example message") + }.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/) + end +end + +describe "should raise_exception(NamedError, exception_message) { |err| ... }" do + it "should yield exception if named exception is raised with same message" do + ran = false + + lambda { + raise "example message" + }.should raise_exception(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_exception(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 exception was thrown" do + ran = false + + lambda { + lambda {}.should raise_exception(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 exception class is not matched" do + ran = false + + lambda { + lambda { + raise "example message" + }.should raise_exception(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 exception message is not matched" do + ran = false + + lambda { + lambda { + raise "example message" + }.should raise_exception(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_exception(NamedError, exception_message) { |err| ... }" do + it "should pass if nothing is raised" do + ran = false + + lambda {}.should_not raise_exception(RuntimeError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should pass if a different exception is raised" do + ran = false + + lambda { raise }.should_not raise_exception(NameError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should pass if same exception is raised with different message" do + ran = false + + lambda { + raise RuntimeError.new("not the example message") + }.should_not raise_exception(RuntimeError, "example message") { |err| + ran = true + } + + ran.should == false + end + + it "should fail if named exception is raised with same message" do + ran = false + + lambda { + lambda { + raise "example message" + }.should_not raise_exception(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_exception(NamedError, exception_message) with String" do + it "should pass if nothing is raised" do + lambda {}.should_not raise_exception(RuntimeError, "example message") + end + + it "should pass if a different exception is raised" do + lambda { raise }.should_not raise_exception(NameError, "example message") + end + + it "should pass if same exception is raised with different message" do + lambda { raise RuntimeError.new("not the example message") }.should_not raise_exception(RuntimeError, "example message") + end + + it "should fail if named exception is raised with same message" do + lambda { + lambda { raise "example message" }.should_not raise_exception(RuntimeError, "example message") + }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>") + end +end + +describe "should raise_exception(NamedError, exception_message) with Regexp" do + it "should pass if named exception is raised with matching message" do + lambda { raise "example message" }.should raise_exception(RuntimeError, /ample mess/) + end + + it "should fail if nothing is raised" do + lambda { + lambda {}.should raise_exception(RuntimeError, /ample mess/) + }.should fail_with("expected RuntimeError with message matching /ample mess/ but nothing was raised") + end + + it "should fail if incorrect exception is raised" do + lambda { + lambda { raise }.should raise_exception(NameError, /ample mess/) + }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError") + end + + it "should fail if correct exception is raised with incorrect message" do + lambda { + lambda { raise RuntimeError.new("not the example message") }.should raise_exception(RuntimeError, /less than ample mess/) + }.should fail_with("expected RuntimeError with message matching /less than ample mess/, got #<RuntimeError: not the example message>") + end +end + +describe "should_not raise_exception(NamedError, exception_message) with Regexp" do + it "should pass if nothing is raised" do + lambda {}.should_not raise_exception(RuntimeError, /ample mess/) + end + + it "should pass if a different exception is raised" do + lambda { raise }.should_not raise_exception(NameError, /ample mess/) + end + + it "should pass if same exception is raised with non-matching message" do + lambda { raise RuntimeError.new("non matching message") }.should_not raise_exception(RuntimeError, /ample mess/) + end + + it "should fail if named exception is raised with matching message" do + lambda { + lambda { raise "example message" }.should_not raise_exception(RuntimeError, /ample mess/) + }.should fail_with("expected no RuntimeError with message matching /ample mess/, got #<RuntimeError: example message>") + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/respond_to_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/respond_to_spec.rb new file mode 100644 index 000000000..8d8f3c1ac --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/respond_to_spec.rb @@ -0,0 +1,116 @@ +require 'spec_helper' + +describe "should respond_to(:sym)" do + + it "passes if target responds to :sym" do + Object.new.should respond_to(:methods) + end + + it "fails if target does not respond to :sym" do + lambda { + "this string".should respond_to(:some_method) + }.should fail_with(%q|expected "this string" to respond to :some_method|) + end + +end + +describe "should respond_to(:sym).with(1).argument" do + it "passes if target responds to :sym with 1 arg" do + obj = Object.new + def obj.foo(arg); end + obj.should respond_to(:foo).with(1).argument + end + + it "fails if target does not respond to :sym" do + obj = Object.new + lambda { + obj.should respond_to(:some_method).with(1).argument + }.should fail_with(/expected .* to respond to :some_method/) + end + + it "fails if :sym expects 0 args" do + obj = Object.new + def obj.foo; end + lambda { + obj.should respond_to(:foo).with(1).argument + }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/) + end + + it "fails if :sym expects 2 args" do + obj = Object.new + def obj.foo(arg, arg2); end + lambda { + obj.should respond_to(:foo).with(1).argument + }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/) + end +end + +describe "should respond_to(message1, message2)" do + + it "passes if target responds to both messages" do + Object.new.should respond_to('methods', 'inspect') + end + + it "fails if target does not respond to first message" do + lambda { + Object.new.should respond_to('method_one', 'inspect') + }.should fail_with(/expected #<Object:.*> to respond to "method_one"/) + end + + it "fails if target does not respond to second message" do + lambda { + Object.new.should respond_to('inspect', 'method_one') + }.should fail_with(/expected #<Object:.*> to respond to "method_one"/) + end + + it "fails if target does not respond to either message" do + lambda { + Object.new.should respond_to('method_one', 'method_two') + }.should fail_with(/expected #<Object:.*> to respond to "method_one", "method_two"/) + end +end + +describe "should respond_to(:sym).with(2).arguments" do + it "passes if target responds to :sym with 2 args" do + obj = Object.new + def obj.foo(a1, a2); end + obj.should respond_to(:foo).with(2).arguments + end + + it "fails if target does not respond to :sym" do + obj = Object.new + lambda { + obj.should respond_to(:some_method).with(2).arguments + }.should fail_with(/expected .* to respond to :some_method/) + end + + it "fails if :sym expects 0 args" do + obj = Object.new + def obj.foo; end + lambda { + obj.should respond_to(:foo).with(2).arguments + }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/) + end + + it "fails if :sym expects 2 args" do + obj = Object.new + def obj.foo(arg); end + lambda { + obj.should respond_to(:foo).with(2).arguments + }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/) + end +end + +describe "should_not respond_to(:sym)" do + + it "passes if target does not respond to :sym" do + Object.new.should_not respond_to(:some_method) + end + + it "fails if target responds to :sym" do + lambda { + Object.new.should_not respond_to(:methods) + }.should fail_with(/expected #<Object:.*> not to respond to :methods/) + end + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/satisfy_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/satisfy_spec.rb new file mode 100644 index 000000000..e50c395a6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/satisfy_spec.rb @@ -0,0 +1,36 @@ +require 'spec_helper' + +describe "should satisfy { block }" do + it "should pass if block returns true" do + true.should satisfy { |val| val } + true.should satisfy do |val| + val + end + end + + it "should fail if block returns false" do + lambda { + false.should satisfy { |val| val } + }.should fail_with("expected false to satisfy block") + lambda do + false.should satisfy do |val| + val + end + end.should fail_with("expected false to satisfy block") + end +end + +describe "should_not satisfy { block }" do + it "should pass if block returns false" do + false.should_not satisfy { |val| val } + false.should_not satisfy do |val| + val + end + end + + it "should fail if block returns true" do + lambda { + true.should_not satisfy { |val| val } + }.should fail_with("expected true not to satisfy block") + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/simple_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/simple_matcher_spec.rb new file mode 100644 index 000000000..7d38862b2 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/simple_matcher_spec.rb @@ -0,0 +1,100 @@ +require 'spec_helper' + +module Spec + module Matchers + describe SimpleMatcher do + before { Spec.stub(:deprecate) } + + it "is deprecated" do + Spec.should_receive(:deprecate) + simple_matcher("foo") {} + end + + it "should pass match arg to block" do + actual = nil + matcher = simple_matcher("message") do |given| actual = given end + matcher.matches?("foo") + actual.should == "foo" + end + + it "should provide a stock failure message" do + matcher = simple_matcher("thing") do end + matcher.matches?("other") + matcher.failure_message.should =~ /expected \"thing\" but got \"other\"/ + end + + it "should provide a stock negative failure message" do + matcher = simple_matcher("thing") do end + matcher.matches?("other") + matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/ + end + + it "should provide 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 + + 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 +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/matchers/throw_symbol_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/matchers/throw_symbol_spec.rb new file mode 100644 index 000000000..e6aa008e0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/matchers/throw_symbol_spec.rb @@ -0,0 +1,121 @@ +require 'spec_helper' + +module Spec + module Matchers + describe ThrowSymbol do + describe "with no args" do + let(:matcher) { throw_symbol } + + it "matches if any Symbol is thrown" do + matcher.matches?(lambda{ throw :sym }).should be_true + end + + it "matches if any Symbol is thrown with an arg" do + matcher.matches?(lambda{ throw :sym, "argument" }).should be_true + end + + it "does not match if no Symbol is thrown" do + matcher.matches?(lambda{ }).should be_false + end + + it "provides a failure message" do + matcher.matches?(lambda{}) + matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown" + end + + it "provides a negative failure message" do + matcher.matches?(lambda{ throw :sym}) + matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym" + end + end + + describe "with a symbol" do + let(:matcher) { throw_symbol(:sym) } + + it "matches if correct Symbol is thrown" do + matcher.matches?(lambda{ throw :sym }).should be_true + end + + it "matches if correct Symbol is thrown with an arg" do + matcher.matches?(lambda{ throw :sym, "argument" }).should be_true + end + + it "does not match if no Symbol is thrown" do + matcher.matches?(lambda{ }).should be_false + end + + it "does not match if correct Symbol is thrown" do + matcher.matches?(lambda{ throw :other_sym }).should be_false + end + + it "provides a failure message when no Symbol is thrown" do + matcher.matches?(lambda{}) + matcher.failure_message_for_should.should == "expected :sym but nothing was thrown" + end + + it "provides a failure message when wrong Symbol is thrown" do + matcher.matches?(lambda{ throw :other_sym }) + matcher.failure_message_for_should.should == "expected :sym, got :other_sym" + end + + it "provides a negative failure message" do + matcher.matches?(lambda{ throw :sym }) + matcher.failure_message_for_should_not.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 + + it "bubbles up errors other than NameError" do + lambda do + matcher.matches?(lambda{ raise 'foo' }) + end.should raise_error('foo') + end + end + + describe "with a symbol and an arg" do + let(:matcher) { throw_symbol(:sym, "a") } + + it "matches if correct Symbol and args are thrown" do + matcher.matches?(lambda{ throw :sym, "a" }).should be_true + end + + it "does not match if nothing is thrown" do + matcher.matches?(lambda{ }).should be_false + end + + it "does not match if other Symbol is thrown" do + matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false + end + + it "does not match if no arg is thrown" do + matcher.matches?(lambda{ throw :sym }).should be_false + end + + it "does not match if wrong arg is thrown" do + matcher.matches?(lambda{ throw :sym, "b" }).should be_false + end + + it "provides a failure message when no Symbol is thrown" do + matcher.matches?(lambda{}) + matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown] + end + + it "provides a failure message when wrong Symbol is thrown" do + matcher.matches?(lambda{ throw :other_sym }) + matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym] + end + + it "provides a negative failure message" do + matcher.matches?(lambda{ throw :sym }) + matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown] + end + + it "only matches NameErrors raised by uncaught throws" do + matcher.matches?(lambda{ :sym }).should be_false + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/and_yield_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/and_yield_spec.rb new file mode 100644 index 000000000..39a07a212 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/and_yield_spec.rb @@ -0,0 +1,117 @@ +require 'spec_helper' + +module Spec + module Mocks + describe Mock do + describe "#and_yield" do + + context "with eval context as block argument" do + let(:obj) { double } + + it "evaluates the supplied block as it is read" do + evaluated = false + obj.stub(:method_that_accepts_a_block).and_yield do |eval_context| + evaluated = true + end + evaluated.should be_true + end + + it "passes an eval context object to the supplied block" do + obj.stub(:method_that_accepts_a_block).and_yield do |eval_context| + eval_context.should_not be_nil + end + end + + it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do + expected_eval_context = nil + actual_eval_context = nil + + obj.stub(:method_that_accepts_a_block).and_yield do |eval_context| + expected_eval_context = eval_context + end + + obj.method_that_accepts_a_block do + actual_eval_context = self + end + + actual_eval_context.should equal(expected_eval_context) + end + + context "and no yielded arguments" do + + it "passes when expectations set on the eval context are met" do + configured_eval_context = nil + obj.stub(:method_that_accepts_a_block).and_yield do |eval_context| + configured_eval_context = eval_context + configured_eval_context.should_receive(:foo) + end + + obj.method_that_accepts_a_block do + foo + end + + configured_eval_context.rspec_verify + end + + it "fails when expectations set on the eval context are not met" do + configured_eval_context = nil + obj.stub(:method_that_accepts_a_block).and_yield do |eval_context| + configured_eval_context = eval_context + configured_eval_context.should_receive(:foo) + end + + obj.method_that_accepts_a_block do + # foo is not called here + end + + lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError) + end + + end + + context "and yielded arguments" do + + it "passes when expectations set on the eval context and yielded arguments are met" do + configured_eval_context = nil + yielded_arg = Object.new + obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context| + configured_eval_context = eval_context + configured_eval_context.should_receive(:foo) + yielded_arg.should_receive(:bar) + end + + obj.method_that_accepts_a_block do |obj| + obj.bar + foo + end + + configured_eval_context.rspec_verify + yielded_arg.rspec_verify + end + + it "fails when expectations set on the eval context and yielded arguments are not met" do + configured_eval_context = nil + yielded_arg = Object.new + obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context| + configured_eval_context = eval_context + configured_eval_context.should_receive(:foo) + yielded_arg.should_receive(:bar) + end + + obj.method_that_accepts_a_block do |obj| + # obj.bar is not called here + # foo is not called here + end + + lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError) + lambda {yielded_arg.rspec_verify}.should raise_error(MockExpectationError) + end + + end + + end + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/any_number_of_times_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/any_number_of_times_spec.rb new file mode 100644 index 000000000..9a3f6edaf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/any_number_of_times_spec.rb @@ -0,0 +1,36 @@ +require 'spec_helper' + +module Spec + module Mocks + + describe "AnyNumberOfTimes" do + before(:each) do + @mock = Mock.new("test mock") + end + + it "should pass if any number of times method is called many times" do + @mock.should_receive(:random_call).any_number_of_times + (1..10).each do + @mock.random_call + end + end + + it "should pass if any number of times method is called once" do + @mock.should_receive(:random_call).any_number_of_times + @mock.random_call + end + + it "should pass if any number of times method is not called" do + @mock.should_receive(:random_call).any_number_of_times + end + + 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 +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_expectation_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_expectation_spec.rb new file mode 100644 index 000000000..496f7507c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_expectation_spec.rb @@ -0,0 +1,23 @@ +require 'spec_helper' + +module Spec + module Mocks + describe ArgumentExpectation do + it "should consider an object that responds to #matches? and #description to be a matcher" do + argument_expecatation = Spec::Mocks::ArgumentExpectation.new([]) + obj = mock("matcher") + obj.should_receive(:respond_to?).with(:matches?).and_return(true) + obj.should_receive(:respond_to?).with(:description).and_return(true) + argument_expecatation.is_matcher?(obj).should be_true + end + + it "should NOT consider an object that only responds to #matches? to be a matcher" do + argument_expecatation = Spec::Mocks::ArgumentExpectation.new([]) + obj = mock("matcher") + obj.should_receive(:respond_to?).with(:matches?).and_return(true) + obj.should_receive(:respond_to?).with(:description).and_return(false) + argument_expecatation.is_matcher?(obj).should be_false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_matchers_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_matchers_spec.rb new file mode 100644 index 000000000..fc8165583 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/argument_matchers_spec.rb @@ -0,0 +1,19 @@ +require 'spec_helper' + +module Spec + module Mocks + module ArgumentMatchers + describe AnyArgsMatcher do + it "represents itself nicely for failure messages" do + AnyArgsMatcher.new.description.should == "any args" + end + end + + describe AnyArgMatcher do + it "represents itself nicely for failure messages" do + AnyArgMatcher.new(nil).description.should == "anything" + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_least_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_least_spec.rb new file mode 100644 index 000000000..0b76d3213 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_least_spec.rb @@ -0,0 +1,97 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "at_least" do + before(:each) do + @mock = Mock.new("test mock") + end + + it "should fail if method is never called" do + @mock.should_receive(:random_call).at_least(4).times + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when called less than n times" do + @mock.should_receive(:random_call).at_least(4).times + @mock.random_call + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when at least once method is never called" do + @mock.should_receive(:random_call).at_least(:once) + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when at least twice method is called once" do + @mock.should_receive(:random_call).at_least(:twice) + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when at least twice method is never called" do + @mock.should_receive(:random_call).at_least(:twice) + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should pass when at least n times method is called exactly n times" do + @mock.should_receive(:random_call).at_least(4).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at least n times method is called n plus 1 times" do + @mock.should_receive(:random_call).at_least(4).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at least once method is called once" do + @mock.should_receive(:random_call).at_least(:once) + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at least once method is called twice" do + @mock.should_receive(:random_call).at_least(:once) + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at least twice method is called three times" do + @mock.should_receive(:random_call).at_least(:twice) + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at least twice method is called twice" do + @mock.should_receive(:random_call).at_least(:twice) + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_most_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_most_spec.rb new file mode 100644 index 000000000..744c9ff1b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/at_most_spec.rb @@ -0,0 +1,93 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "at_most" do + before(:each) do + @mock = Mock.new("test mock") + end + + it "should fail when at most n times method is called n plus 1 times" do + @mock.should_receive(:random_call).at_most(4).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when at most once method is called twice" do + @mock.should_receive(:random_call).at_most(:once) + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when at most twice method is called three times" do + @mock.should_receive(:random_call).at_most(:twice) + @mock.random_call + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should pass when at most n times method is called exactly n times" do + @mock.should_receive(:random_call).at_most(4).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at most n times method is called less than n times" do + @mock.should_receive(:random_call).at_most(4).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at most n times method is never called" do + @mock.should_receive(:random_call).at_most(4).times + @mock.rspec_verify + end + + it "should pass when at most once method is called once" do + @mock.should_receive(:random_call).at_most(:once) + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at most once method is never called" do + @mock.should_receive(:random_call).at_most(:once) + @mock.rspec_verify + end + + it "should pass when at most twice method is called once" do + @mock.should_receive(:random_call).at_most(:twice) + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at most twice method is called twice" do + @mock.should_receive(:random_call).at_most(:twice) + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass when at most twice method is never called" do + @mock.should_receive(:random_call).at_most(:twice) + @mock.rspec_verify + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10260_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10260_spec.rb new file mode 100644 index 000000000..783782f64 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10260_spec.rb @@ -0,0 +1,8 @@ +require 'spec_helper' + +describe "An RSpec Mock" do + it "should hide internals in its inspect representation" do + m = mock('cup') + m.inspect.should =~ /#<Spec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/ + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10263_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10263_spec.rb new file mode 100644 index 000000000..8a0bc505f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_10263_spec.rb @@ -0,0 +1,27 @@ +describe "Mock" do + before do + @mock = mock("test mock") + end + + specify "when one example has an expectation (non-mock) inside the block passed to the mock" do + @mock.should_receive(:msg) do |b| + b.should be_true #this call exposes the problem + end + begin + @mock.msg(false) + rescue Exception + end + end + + specify "then the next example should behave as expected instead of saying" do + @mock.should_receive(:foobar) + @mock.foobar + @mock.rspec_verify + begin + @mock.foobar + rescue Exception => e + e.message.should == "Mock \"test mock\" received unexpected message :foobar with (no args)" + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_11545_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_11545_spec.rb new file mode 100644 index 000000000..7eb7c6e45 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_11545_spec.rb @@ -0,0 +1,32 @@ +require 'spec_helper' + +class LiarLiarPantsOnFire + def respond_to?(sym, incl_private=false) + true + end + + def self.respond_to?(sym, incl_private=false) + true + end +end + +describe 'should_receive' do + before(:each) do + @liar = LiarLiarPantsOnFire.new + end + + it "should work when object lies about responding to a method" do + @liar.should_receive(:something) + @liar.something + end + + it 'should work when class lies about responding to a method' do + LiarLiarPantsOnFire.should_receive(:something) + LiarLiarPantsOnFire.something + end + + it 'should cleanup after itself' do + (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something") + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_15719_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_15719_spec.rb new file mode 100644 index 000000000..efd7a7824 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_15719_spec.rb @@ -0,0 +1,30 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "mock failure" do + + it "should tell you when it receives the right message with the wrong args" do + m = mock("foo") + m.should_receive(:bar).with("message") + lambda { + m.bar("different message") + }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock "foo" received :bar with unexpected arguments\n expected: ("message")\n got: ("different message")}) + m.bar("message") # allows the spec to pass + end + + it "should tell you when it receives the right message with the wrong args if you stub the method" do + pending("fix bug 15719") + # NOTE - for whatever reason, if you use a the block style of pending here, + # rcov gets unhappy. Don't know why yet. + m = mock("foo") + m.stub!(:bar) + m.should_receive(:bar).with("message") + lambda { + m.bar("different message") + }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock "foo" received :bar with unexpected arguments\n expected: ("message")\n got: ("different message")}) + m.bar("message") # allows the spec to pass + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_496_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_496_spec.rb new file mode 100644 index 000000000..d9edd7994 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_496_spec.rb @@ -0,0 +1,17 @@ +require 'spec_helper' + +module BugReport496 + class BaseClass + end + + class SubClass < BaseClass + end + + describe "a message expectation on a base class object" do + it "should correctly pick up message sent to it subclass" do + BaseClass.should_receive(:new).once + SubClass.new + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_600_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_600_spec.rb new file mode 100644 index 000000000..c5c50d5a4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_600_spec.rb @@ -0,0 +1,22 @@ +require 'spec_helper' + +module BugReport600 + class ExampleClass + def self.method_that_uses_define_method + define_method "defined_method" do |attributes| + load_address(address, attributes) + end + end + end + + describe "stubbing a class method" do + it "should work" do + ExampleClass.should_receive(:define_method).with("defined_method") + ExampleClass.method_that_uses_define_method + end + + it "should restore the original method" do + ExampleClass.method_that_uses_define_method + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7611_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7611_spec.rb new file mode 100644 index 000000000..ff1ef8795 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7611_spec.rb @@ -0,0 +1,19 @@ +require 'spec_helper' + +module Bug7611 + class Foo + end + + class Bar < Foo + end + + describe "A Partial Mock" do + it "should respect subclasses" do + Foo.stub!(:new).and_return(Object.new) + end + + it "should" do + Bar.new.class.should == Bar + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7805_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7805_spec.rb new file mode 100644 index 000000000..9a3d493d9 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_7805_spec.rb @@ -0,0 +1,22 @@ +require 'spec_helper' + +module Bug7805 + #This is really a duplicate of 8302 + + describe "Stubs should correctly restore module methods" do + it "1 - stub the open method" do + File.stub!(:open).and_return("something") + File.open.should == "something" + end + it "2 - use File.open to create example.txt" do + filename = "#{File.dirname(__FILE__)}/example-#{Time.new.to_i}.txt" + File.exist?(filename).should be_false + file = File.open(filename,'w') + file.close + File.exist?(filename).should be_true + File.delete(filename) + File.exist?(filename).should be_false + end + end + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8165_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8165_spec.rb new file mode 100644 index 000000000..8d8d01772 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8165_spec.rb @@ -0,0 +1,31 @@ +require 'spec_helper' + +describe "An object where respond_to? is true and does not have method" do + # When should_receive(:sym) is sent to any object, the Proxy sends + # respond_to?(:sym) to that object to see if the method should be proxied. + # + # If respond_to? itself is proxied, then when the Proxy sends respond_to? + # to the object, the proxy is invoked and responds yes (if so set in the spec). + # When the object does NOT actually respond to :sym, an exception is thrown + # when trying to proxy it. + # + # The fix was to keep track of whether :respond_to? had been proxied and, if + # so, call the munged copy of :respond_to? on the object. + + it "should not raise an exception for Object" do + obj = Object.new + obj.should_receive(:respond_to?).with(:foobar).and_return(true) + obj.should_receive(:foobar).and_return(:baz) + obj.respond_to?(:foobar).should be_true + obj.foobar.should == :baz + end + + it "should not raise an exception for mock" do + obj = mock("obj") + obj.should_receive(:respond_to?).with(:foobar).and_return(true) + obj.should_receive(:foobar).and_return(:baz) + obj.respond_to?(:foobar).should be_true + obj.foobar.should == :baz + end + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8302_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8302_spec.rb new file mode 100644 index 000000000..55d8d3acd --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_8302_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Bug8302 + class Foo + def Foo.class_method(arg) + end + + def instance_bar(arg) + end + end + + describe "Bug report 8302:" do + it "class method is not restored correctly when proxied" do + Foo.should_not_receive(:class_method).with(Array.new) + Foo.rspec_verify + Foo.class_method(Array.new) + end + + it "instance method is not restored correctly when proxied" do + foo = Foo.new + foo.should_not_receive(:instance_bar).with(Array.new) + foo.rspec_verify + foo.instance_bar(Array.new) + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_830_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_830_spec.rb new file mode 100644 index 000000000..ed16f419a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/bug_report_830_spec.rb @@ -0,0 +1,21 @@ +require 'spec_helper' + +module Spec + module Mocks + describe 'Calling a method that catches StandardError' do + class Foo + def self.foo + bar + rescue StandardError + end + end + + it 'still reports mock failures' do + Foo.should_not_receive :bar + lambda do + Foo.foo + end.should raise_error(MockExpectationError) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/double_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/double_spec.rb new file mode 100644 index 000000000..0d6ee982d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/double_spec.rb @@ -0,0 +1,12 @@ +require 'spec_helper' + +describe "double" do + it "is an alias for stub and mock" do + double().should be_a(Spec::Mocks::Mock) + end + + it "uses 'Double' in failure messages" do + double = double('name') + expect {double.foo}.to raise_error(/Double "name" received/) + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/failing_argument_matchers_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/failing_argument_matchers_spec.rb new file mode 100644 index 000000000..30742157d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/failing_argument_matchers_spec.rb @@ -0,0 +1,95 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "failing MockArgumentMatchers" do + before(:each) do + @mock = mock("test mock") + @reporter = Mock.new("reporter", :null_object => true) + end + + after(:each) do + @mock.rspec_reset + end + + it "should reject non boolean" do + @mock.should_receive(:random_call).with(boolean()) + lambda do + @mock.random_call("false") + end.should raise_error(MockExpectationError) + end + + it "should reject non numeric" do + @mock.should_receive(:random_call).with(an_instance_of(Numeric)) + lambda do + @mock.random_call("1") + end.should raise_error(MockExpectationError) + end + + it "should reject non string" do + @mock.should_receive(:random_call).with(an_instance_of(String)) + lambda do + @mock.random_call(123) + end.should raise_error(MockExpectationError) + end + + it "should reject goose when expecting a duck" do + @mock.should_receive(:random_call).with(duck_type(:abs, :div)) + lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError) + end + + it "should fail if regexp does not match submitted string" do + @mock.should_receive(:random_call).with(/bcd/) + lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError) + end + + it "should fail if regexp does not match submitted regexp" do + @mock.should_receive(:random_call).with(/bcd/) + lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError) + end + + it "should fail for a hash w/ wrong values" do + @mock.should_receive(:random_call).with(:a => "b", :c => "d") + lambda do + @mock.random_call(:a => "b", :c => "e") + end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/) + end + + it "should fail for a hash w/ wrong keys" do + @mock.should_receive(:random_call).with(:a => "b", :c => "d") + lambda do + @mock.random_call("a" => "b", "c" => "d") + end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/) + end + + it "should match against a Matcher" do + lambda do + @mock.should_receive(:msg).with(equal(3)) + @mock.msg(37) + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n expected: (equal 3)\n got: (37)") + end + + it "should fail no_args with one arg" do + lambda do + @mock.should_receive(:msg).with(no_args) + @mock.msg(37) + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n expected: (no args)\n got: (37)") + end + + 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\" received :msg with unexpected arguments\n expected: (hash_including(:a=>1))\n got: ({})") + end + + it "should fail with block matchers" do + lambda do + @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 + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_including_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_including_matcher_spec.rb new file mode 100644 index 000000000..d757f619a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_including_matcher_spec.rb @@ -0,0 +1,90 @@ +require 'spec_helper' + +module Spec + module Mocks + module ArgumentMatchers + describe HashIncludingMatcher do + + it "should describe itself properly" do + HashIncludingMatcher.new(:a => 1).description.should == "hash_including(:a=>1)" + end + + describe "passing" do + it "should match the same hash" do + hash_including(:a => 1).should == {:a => 1} + end + + it "should match a hash with extra stuff" do + hash_including(:a => 1).should == {:a => 1, :b => 2} + end + + describe "when matching against other matchers" do + it "should match an int against anything()" do + hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2} + end + + it "should match a string against anything()" do + hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2} + end + end + + describe "when passed only keys or keys mixed with key/value pairs" do + it "should match if the key is present" do + hash_including(:a).should == {:a => 1, :b => 2} + end + + it "should match if more keys are present" do + hash_including(:a, :b).should == {:a => 1, :b => 2, :c => 3} + end + + it "should match a string against a given key" do + hash_including(:a).should == {:a => "1", :b => 2} + end + + it "should match if passed one key and one key/value pair" do + hash_including(:a, :b => 2).should == {:a => 1, :b => 2} + end + + it "should match if passed many keys and one key/value pair" do + hash_including(:a, :b, :c => 3).should == {:a => 1, :b => 2, :c => 3, :d => 4} + end + + it "should match if passed many keys and many key/value pairs" do + hash_including(:a, :b, :c => 3, :e => 5).should == {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5} + end + end + end + + describe "failing" do + it "should not match a non-hash" do + hash_including(:a => 1).should_not == 1 + end + + it "should not match a hash with a missing key" do + hash_including(:a => 1).should_not == {:b => 2} + end + + it "should not match a hash with a missing key" do + hash_including(:a).should_not == {:b => 2} + end + + it "should not match an empty hash with a given key" do + hash_including(:a).should_not == {} + end + + it "should not match a hash with a missing key when one pair is matching" do + hash_including(:a, :b => 2).should_not == {:b => 2} + end + + it "should not match a hash with an incorrect value" do + hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3} + end + + it "should not match when values are nil but keys are different" do + hash_including(:a => nil).should_not == {:b => nil} + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_not_including_matcher_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_not_including_matcher_spec.rb new file mode 100644 index 000000000..9df69fe6c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/hash_not_including_matcher_spec.rb @@ -0,0 +1,67 @@ +require 'spec_helper' + +module Spec + module Mocks + module ArgumentMatchers + describe HashNotIncludingMatcher do + + it "should describe itself properly" do + HashNotIncludingMatcher.new(:a => 5).description.should == "hash_not_including(:a=>5)" + end + + describe "passing" do + it "should match a hash without the specified key" do + hash_not_including(:c).should == {:a => 1, :b => 2} + end + + it "should match a hash with the specified key, but different value" do + hash_not_including(:b => 3).should == {:a => 1, :b => 2} + end + + it "should match a hash without the specified key, given as anything()" do + hash_not_including(:c => anything).should == {:a => 1, :b => 2} + end + + it "should match an empty hash" do + hash_not_including(:a).should == {} + end + + it "should match a hash without any of the specified keys" do + hash_not_including(:a, :b, :c).should == { :d => 7} + end + + end + + describe "failing" do + it "should not match a non-hash" do + hash_not_including(:a => 1).should_not == 1 + end + + it "should not match a hash with a specified key" do + hash_not_including(:b).should_not == {:b => 2} + end + + it "should not match a hash with the specified key/value pair" do + hash_not_including(:b => 2).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with the specified key" do + hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with one of the specified keys" do + hash_not_including(:a, :b).should_not == {:b => 2} + end + + it "should not match a hash with some of the specified keys" do + hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with one key/value pair included" do + hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7} + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_ordering_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_ordering_spec.rb new file mode 100644 index 000000000..4bd15478f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_ordering_spec.rb @@ -0,0 +1,94 @@ +require 'spec_helper' + +module Spec + module Mocks + + describe "Mock ordering" do + + before do + @mock = mock("test mock") + end + + after do + @mock.rspec_reset + end + + it "should pass two calls in order" do + @mock.should_receive(:one).ordered + @mock.should_receive(:two).ordered + @mock.one + @mock.two + @mock.rspec_verify + end + + it "should pass three calls in order" do + @mock.should_receive(:one).ordered + @mock.should_receive(:two).ordered + @mock.should_receive(:three).ordered + @mock.one + @mock.two + @mock.three + @mock.rspec_verify + end + + it "should fail if second call comes first" do + @mock.should_receive(:one).ordered + @mock.should_receive(:two).ordered + lambda do + @mock.two + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :two out of order") + end + + it "should fail if third call comes first" do + @mock.should_receive(:one).ordered + @mock.should_receive(:two).ordered + @mock.should_receive(:three).ordered + @mock.one + lambda do + @mock.three + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order") + end + + it "should fail if third call comes second" do + @mock.should_receive(:one).ordered + @mock.should_receive(:two).ordered + @mock.should_receive(:three).ordered + @mock.one + lambda do + @mock.three + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order") + end + + it "should ignore order of non ordered calls" do + @mock.should_receive(:ignored_0) + @mock.should_receive(:ordered_1).ordered + @mock.should_receive(:ignored_1) + @mock.should_receive(:ordered_2).ordered + @mock.should_receive(:ignored_2) + @mock.should_receive(:ignored_3) + @mock.should_receive(:ordered_3).ordered + @mock.should_receive(:ignored_4) + @mock.ignored_3 + @mock.ordered_1 + @mock.ignored_0 + @mock.ordered_2 + @mock.ignored_4 + @mock.ignored_2 + @mock.ordered_3 + @mock.ignored_1 + @mock.rspec_verify + end + + it "should pass when duplicates exist" do + @mock.should_receive(:a).ordered + @mock.should_receive(:b).ordered + @mock.should_receive(:a).ordered + + @mock.a + @mock.b + @mock.a + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_space_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_space_spec.rb new file mode 100644 index 000000000..878239307 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_space_spec.rb @@ -0,0 +1,54 @@ +require 'spec_helper' +require 'spec/mocks' + +module Spec + module Mocks + describe Space do + before :each do + @space = Space.new + klazz = Class.new do + def rspec_verify + @verified = true + end + def verified? + @verified + end + def rspec_reset + @reset = true + end + def reset? + @reset + end + end + @m1 = klazz.new + @m2 = klazz.new + end + it "should verify all mocks within" do + @space.add(@m1) + @space.add(@m2) + @space.verify_all + @m1.should be_verified + @m2.should be_verified + end + it "should reset all mocks within" do + @space.add(m1 = mock("mock1")) + @space.add(m2 = mock("mock2")) + m1.should_receive(:rspec_reset) + m2.should_receive(:rspec_reset) + @space.reset_all + end + it "should clear internal mocks on reset_all" do + @space.add(m = mock("mock")) + @space.reset_all + @space.instance_eval { mocks.empty? }.should be_true + end + it "should only add an instance once" do + @space.add(m1 = mock("mock1")) + @space.add(m1) + m1.should_receive(:rspec_verify) + @space.verify_all + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_spec.rb new file mode 100644 index 000000000..d86b75458 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/mock_spec.rb @@ -0,0 +1,594 @@ +require 'spec_helper' + +module Spec + module Mocks + describe Mock do + treats_method_missing_as_private :subject => Mock.new, :noop => false + + before(:each) do + @mock = mock("test mock") + end + + after(:each) do + @mock.rspec_reset + end + + describe "deprecated #stub_everything method" do + before(:each) do + Kernel.stub!(:warn) + end + + it "creates a mock that behaves as a null object" do + stub_everything.should be_null_object + end + + it "provides deprecation warning" do + Kernel.should_receive(:warn).with(/DEPRECATION: stub_everything.* is deprecated./) + stub_everything + end + end + + it "should report line number of expectation of unreceived message" do + expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3) + begin + @mock.rspec_verify + violated + rescue MockExpectationError => e + # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line + e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/) + end + end + + it "should report line number of expectation of unreceived message after #should_receive after similar stub" do + @mock.stub!(:wont_happen) + expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3) + begin + @mock.rspec_verify + violated + rescue MockExpectationError => e + # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line + e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/) + end + end + + it "should pass when not receiving message specified as not to be received" do + @mock.should_not_receive(:not_expected) + @mock.rspec_verify + end + + it "should pass when receiving message specified as not to be received with different args" do + @mock.should_not_receive(:message).with("unwanted text") + @mock.should_receive(:message).with("other text") + @mock.message "other text" + @mock.rspec_verify + end + + it "should fail when receiving message specified as not to be received" do + @mock.should_not_receive(:not_expected) + lambda { + @mock.not_expected + violated + }.should raise_error(MockExpectationError, "Mock \"test mock\" expected :not_expected with (no args) 0 times, but received it once") + end + + it "should fail when receiving message specified as not to be received with args" do + @mock.should_not_receive(:not_expected).with("unexpected text") + lambda { + @mock.not_expected("unexpected text") + violated + }.should raise_error(MockExpectationError, "Mock \"test mock\" expected :not_expected with (\"unexpected text\") 0 times, but received it once") + end + + it "should pass when receiving message specified as not to be received with wrong args" do + @mock.should_not_receive(:not_expected).with("unexpected text") + @mock.not_expected "really unexpected text" + @mock.rspec_verify + end + + it "should allow block to calculate return values" do + @mock.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a } + @mock.something("a","b","c").should == "cba" + @mock.rspec_verify + end + + it "should allow parameter as return value" do + @mock.should_receive(:something).with("a","b","c").and_return("booh") + @mock.something("a","b","c").should == "booh" + @mock.rspec_verify + end + + it "should return nil if no return value set" do + @mock.should_receive(:something).with("a","b","c") + @mock.something("a","b","c").should be_nil + @mock.rspec_verify + end + + it "should raise exception if args don't match when method called" do + @mock.should_receive(:something).with("a","b","c").and_return("booh") + lambda { + @mock.something("a","d","c") + violated + }.should raise_error(MockExpectationError, "Mock \"test mock\" received :something with unexpected arguments\n expected: (\"a\", \"b\", \"c\")\n got: (\"a\", \"d\", \"c\")") + end + + it "should raise exception if args don't match when method called even when the method is stubbed" do + @mock.stub!(:something) + @mock.should_receive(:something).with("a","b","c") + lambda { + @mock.something("a","d","c") + @mock.rspec_verify + }.should raise_error(MockExpectationError, "Mock \"test mock\" received :something with unexpected arguments\n expected: (\"a\", \"b\", \"c\")\n got: ([\"a\", \"d\", \"c\"])") + end + + it "should raise exception if args don't match when method called even when using null_object" do + @mock = mock("test mock", :null_object => true) + @mock.should_receive(:something).with("a","b","c") + lambda { + @mock.something("a","d","c") + @mock.rspec_verify + }.should raise_error(MockExpectationError, "Mock \"test mock\" received :something with unexpected arguments\n expected: (\"a\", \"b\", \"c\")\n got: ([\"a\", \"d\", \"c\"])") + end + + it "should fail if unexpected method called" do + lambda { + @mock.something("a","b","c") + violated + }.should raise_error(MockExpectationError, "Mock \"test mock\" received unexpected message :something with (\"a\", \"b\", \"c\")") + end + + it "should use block for expectation if provided" do + @mock.should_receive(:something) do | a, b | + a.should == "a" + b.should == "b" + "booh" + end + @mock.something("a", "b").should == "booh" + @mock.rspec_verify + end + + it "should fail if expectation block fails" do + @mock.should_receive(:something) {| bool | bool.should be_true} + lambda { + @mock.something false + }.should raise_error(MockExpectationError, /Mock "test mock" received :something but passed block failed with: expected false to be true/) + end + + it "should fail right away when method defined as never is received" do + @mock.should_receive(:not_expected).never + lambda { + @mock.not_expected + }.should raise_error(MockExpectationError, "Mock \"test mock\" expected :not_expected with (no args) 0 times, but received it once") + end + + it "should eventually fail when method defined as never is received" do + @mock.should_receive(:not_expected).never + lambda { + @mock.not_expected + }.should raise_error(MockExpectationError, "Mock \"test mock\" expected :not_expected with (no args) 0 times, but received it once") + end + + it "should raise when told to" do + @mock.should_receive(:something).and_raise(RuntimeError) + lambda do + @mock.something + end.should raise_error(RuntimeError) + end + + it "should raise passed an Exception instance" do + error = RuntimeError.new("error message") + @mock.should_receive(:something).and_raise(error) + lambda { + @mock.something + }.should raise_error(RuntimeError, "error message") + end + + it "should raise RuntimeError with passed message" do + @mock.should_receive(:something).and_raise("error message") + lambda { + @mock.something + }.should raise_error(RuntimeError, "error message") + end + + it "should not raise when told to if args dont match" do + @mock.should_receive(:something).with(2).and_raise(RuntimeError) + lambda { + @mock.something 1 + }.should raise_error(MockExpectationError) + end + + it "should throw when told to" do + @mock.should_receive(:something).and_throw(:blech) + lambda { + @mock.something + }.should throw_symbol(:blech) + end + + it "should raise when explicit return and block constrained" do + lambda { + @mock.should_receive(:fruit) do |colour| + :strawberry + end.and_return :apple + }.should raise_error(AmbiguousReturnError) + end + + it "should ignore args on any args" do + @mock.should_receive(:something).at_least(:once).with(any_args) + @mock.something + @mock.something 1 + @mock.something "a", 2 + @mock.something [], {}, "joe", 7 + @mock.rspec_verify + end + + it "should fail on no args if any args received" do + @mock.should_receive(:something).with(no_args()) + lambda { + @mock.something 1 + }.should raise_error(MockExpectationError, "Mock \"test mock\" received :something with unexpected arguments\n expected: (no args)\n got: (1)") + end + + it "should fail when args are expected but none are received" do + @mock.should_receive(:something).with(1) + lambda { + @mock.something + }.should raise_error(MockExpectationError, "Mock \"test mock\" received :something with unexpected arguments\n expected: (1)\n got: (no args)") + end + + it "should return value from block by default" do + @mock.stub!(:method_that_yields).and_yield + @mock.method_that_yields { :returned_obj }.should == :returned_obj + @mock.rspec_verify + end + + it "should yield 0 args to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield + a = nil + @mock.yield_back {|*x| a = x} + a.should == [] + @mock.rspec_verify + end + + it "should yield 0 args multiple times to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield. + and_yield + a = nil + b = [] + @mock.yield_back {|*a| b << a} + b.should == [ [], [] ] + @mock.rspec_verify + end + + it "should yield one arg to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99) + a = nil + @mock.yield_back {|*x| a = x} + a.should == [99] + @mock.rspec_verify + end + + it "should yield one arg 3 times consecutively to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99). + and_yield(43). + and_yield("something fruity") + a = nil + b = [] + @mock.yield_back {|*a| b << a} + b.should == [[99], [43], ["something fruity"]] + @mock.rspec_verify + end + + it "should yield many args to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go") + a = nil + @mock.yield_back {|*x| a = x} + a.should == [99, 27, "go"] + @mock.rspec_verify + end + + it "should yield many args 3 times consecutively to blocks that take a variable number of arguments" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go"). + and_yield("wait", :amber). + and_yield("stop", 12, :red) + a = nil + b = [] + @mock.yield_back {|*a| b << a} + b.should == [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]] + @mock.rspec_verify + end + + it "should yield single value" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99) + a = nil + @mock.yield_back {|x| a = x} + a.should == 99 + @mock.rspec_verify + end + + it "should yield single value 3 times consecutively" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99). + and_yield(43). + and_yield("something fruity") + a = nil + b = [] + @mock.yield_back {|a| b << a} + b.should == [99, 43, "something fruity"] + @mock.rspec_verify + end + + it "should yield two values" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup') + a, b = nil + @mock.yield_back {|x,y| a=x; b=y} + a.should == 'wha' + b.should == 'zup' + @mock.rspec_verify + end + + it "should yield two values 3 times consecutively" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup'). + and_yield('not', 'down'). + and_yield(14, 65) + a, b = nil + c = [] + @mock.yield_back {|a,b| c << [a, b]} + c.should == [['wha', 'zup'], ['not', 'down'], [14, 65]] + @mock.rspec_verify + end + + it "should fail when calling yielding method with wrong arity" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup') + lambda { + @mock.yield_back {|a|} + }.should raise_error(MockExpectationError, "Mock \"test mock\" yielded |\"wha\", \"zup\"| to block with arity of 1") + end + + it "should fail when calling yielding method consecutively with wrong arity" do + @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup'). + and_yield('down'). + and_yield(14, 65) + lambda { + a, b = nil + c = [] + @mock.yield_back {|a,b| c << [a, b]} + }.should raise_error(MockExpectationError, "Mock \"test mock\" yielded |\"down\"| to block with arity of 2") + end + + it "should fail when calling yielding method without block" do + @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup') + lambda { + @mock.yield_back + }.should raise_error(MockExpectationError, "Mock \"test mock\" asked to yield |[\"wha\", \"zup\"]| but no block was passed") + end + + it "should be able to mock send" do + @mock.should_receive(:send).with(any_args) + @mock.send 'hi' + @mock.rspec_verify + end + + it "should be able to raise from method calling yielding mock" do + @mock.should_receive(:yield_me).and_yield 44 + + lambda { + @mock.yield_me do |x| + raise "Bang" + end + }.should raise_error(StandardError, "Bang") + + @mock.rspec_verify + end + + it "should clear expectations after verify" do + @mock.should_receive(:foobar) + @mock.foobar + @mock.rspec_verify + lambda { + @mock.foobar + }.should raise_error(MockExpectationError, "Mock \"test mock\" received unexpected message :foobar with (no args)") + end + + it "should restore objects to their original state on rspec_reset" do + mock = mock("this is a mock") + mock.should_receive(:blah) + mock.rspec_reset + mock.rspec_verify #should throw if reset didn't work + end + + it "should work even after method_missing starts raising NameErrors instead of NoMethodErrors" do + # Object#method_missing throws either NameErrors or NoMethodErrors. + # + # On a fresh ruby program Object#method_missing: + # * raises a NoMethodError when called directly + # * raises a NameError when called indirectly + # + # Once Object#method_missing has been called at least once (on any object) + # it starts behaving differently: + # * raises a NameError when called directly + # * raises a NameError when called indirectly + # + # There was a bug in Mock#method_missing that relied on the fact + # that calling Object#method_missing directly raises a NoMethodError. + # This example tests that the bug doesn't exist anymore. + + + # Ensures that method_missing always raises NameErrors. + a_method_that_doesnt_exist rescue + + + @mock.should_receive(:foobar) + @mock.foobar + @mock.rspec_verify + + lambda { @mock.foobar }.should_not raise_error(NameError) + lambda { @mock.foobar }.should raise_error(MockExpectationError) + end + + it "should temporarily replace a method stub on a mock" do + @mock.stub!(:msg).and_return(:stub_value) + @mock.should_receive(:msg).with(:arg).and_return(:mock_value) + @mock.msg(:arg).should equal(:mock_value) + @mock.msg.should equal(:stub_value) + @mock.msg.should equal(:stub_value) + @mock.rspec_verify + end + + it "should not require a different signature to replace a method stub" do + @mock.stub!(:msg).and_return(:stub_value) + @mock.should_receive(:msg).and_return(:mock_value) + @mock.msg(:arg).should equal(:mock_value) + @mock.msg.should equal(:stub_value) + @mock.msg.should equal(:stub_value) + @mock.rspec_verify + end + + it "should raise an error when a previously stubbed method has a negative expectation" do + @mock.stub!(:msg).and_return(:stub_value) + @mock.should_not_receive(:msg).and_return(:mock_value) + lambda {@mock.msg(:arg)}.should raise_error(MockExpectationError) + end + + it "should temporarily replace a method stub on a non-mock" do + non_mock = Object.new + non_mock.stub!(:msg).and_return(:stub_value) + non_mock.should_receive(:msg).with(:arg).and_return(:mock_value) + non_mock.msg(:arg).should equal(:mock_value) + non_mock.msg.should equal(:stub_value) + non_mock.msg.should equal(:stub_value) + non_mock.rspec_verify + end + + it "should return the stubbed value when no new value specified" do + @mock.stub!(:msg).and_return(:stub_value) + @mock.should_receive(:msg) + @mock.msg.should equal(:stub_value) + @mock.rspec_verify + end + + it "should not mess with the stub's yielded values when also mocked" do + @mock.stub!(:yield_back).and_yield(:stub_value) + @mock.should_receive(:yield_back).and_yield(:mock_value) + @mock.yield_back{|v| v.should == :mock_value } + @mock.yield_back{|v| v.should == :stub_value } + @mock.rspec_verify + end + + it "should yield multiple values after a similar stub" do + File.stub!(:open).and_yield(:stub_value) + File.should_receive(:open).and_yield(:first_call).and_yield(:second_call) + yielded_args = [] + File.open {|v| yielded_args << v } + yielded_args.should == [:first_call, :second_call] + File.open {|v| v.should == :stub_value } + File.rspec_verify + end + + it "should assign stub return values" do + mock = Mock.new('name', :message => :response) + mock.message.should == :response + end + + end + + describe "a mock message receiving a block" do + before(:each) do + @mock = mock("mock") + @calls = 0 + end + + def add_call + @calls = @calls + 1 + end + + it "should call the block after #should_receive" do + @mock.should_receive(:foo) { add_call } + + @mock.foo + + @calls.should == 1 + end + + it "should call the block after #should_receive after a similar stub" do + @mock.stub!(:foo).and_return(:bar) + @mock.should_receive(:foo) { add_call } + + @mock.foo + + @calls.should == 1 + end + + it "should call the block after #once" do + @mock.should_receive(:foo).once { add_call } + + @mock.foo + + @calls.should == 1 + end + + it "should call the block after #twice" do + @mock.should_receive(:foo).twice { add_call } + + @mock.foo + @mock.foo + + @calls.should == 2 + end + + it "should call the block after #times" do + @mock.should_receive(:foo).exactly(10).times { add_call } + + (1..10).each { @mock.foo } + + @calls.should == 10 + end + + it "should call the block after #any_number_of_times" do + @mock.should_receive(:foo).any_number_of_times { add_call } + + (1..7).each { @mock.foo } + + @calls.should == 7 + end + + it "should call the block after #ordered" do + @mock.should_receive(:foo).ordered { add_call } + @mock.should_receive(:bar).ordered { add_call } + + @mock.foo + @mock.bar + + @calls.should == 2 + end + end + + describe 'string representation generated by #to_s' do + it 'should not contain < because that might lead to invalid HTML in some situations' do + mock = mock("Dog") + valid_html_str = "#{mock}" + valid_html_str.should_not include('<') + end + end + + describe "mock created with no name" do + it "should not use a name in a failure message" do + mock = mock() + expect {mock.foo}.to raise_error(/Mock received/) + end + + it "should respond to initially stubbed methods" do + mock = mock(:foo => "woo", :bar => "car") + mock.foo.should == "woo" + mock.bar.should == "car" + end + end + + describe "==" do + it "sends '== self' to the comparison object" do + first = mock('first') + second = mock('second') + + first.should_receive(:==).with(second) + second == first + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/multiple_return_value_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/multiple_return_value_spec.rb new file mode 100644 index 000000000..08a6b066c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/multiple_return_value_spec.rb @@ -0,0 +1,113 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "a Mock expectation with multiple return values and no specified count" do + before(:each) do + @mock = Mock.new("mock") + @return_values = ["1",2,Object.new] + @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2]) + end + + it "should return values in order to consecutive calls" do + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + @mock.message.should == @return_values[2] + @mock.rspec_verify + end + + it "should complain when there are too few calls" do + third = Object.new + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice") + end + + it "should complain when there are too many calls" do + third = Object.new + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + @mock.message.should == @return_values[2] + @mock.message.should == @return_values[2] + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times") + end + end + + describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do + before(:each) do + @mock = Mock.new("mock") + @return_values = ["1",2,Object.new] + @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2]) + end + + it "should return values in order to consecutive calls" do + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + @mock.message.should == @return_values[2] + @mock.rspec_verify + end + + it "should complain when there are too few calls" do + third = Object.new + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice") + end + + it "should complain when there are too many calls" do + third = Object.new + @mock.message.should == @return_values[0] + @mock.message.should == @return_values[1] + @mock.message.should == @return_values[2] + @mock.message.should == @return_values[2] + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times") + end + end + + describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do + before(:each) do + @mock = Mock.new("mock") + @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22) + end + + it "should use last return value for subsequent calls" do + @mock.message.should equal(11) + @mock.message.should equal(22) + @mock.message.should equal(22) + @mock.rspec_verify + end + + it "should fail when called less than the specified number" do + @mock.message.should equal(11) + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (no args) twice, but received it once") + end + end + describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do + before(:each) do + @mock = Mock.new("mock") + @mock.should_receive(:message).exactly(3).times.and_return(11, 22) + end + + it "should use last return value for subsequent calls" do + @mock.message.should equal(11) + @mock.message.should equal(22) + @mock.message.should equal(22) + @mock.rspec_verify + end + + it "should fail when called less than the specified number" do + @mock.message.should equal(11) + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it once") + end + + it "should fail when called greater than the specified number" do + @mock.message.should equal(11) + @mock.message.should equal(22) + @mock.message.should equal(22) + @mock.message.should equal(22) + lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times") + end + end + end +end + diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/nil_expectation_warning_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/nil_expectation_warning_spec.rb new file mode 100644 index 000000000..f8f72baff --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/nil_expectation_warning_spec.rb @@ -0,0 +1,53 @@ +require 'spec_helper' + +module Spec + module Mocks + + describe "an expectation set on nil" do + + it "should issue a warning with file and line number information" do + expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.% + Kernel.should_receive(:warn).with(expected_warning) + + nil.should_receive(:foo) + nil.foo + end + + it "should issue a warning when the expectation is negative" do + Kernel.should_receive(:warn) + + nil.should_not_receive(:foo) + end + + it "should not issue a warning when expectations are set to be allowed" do + allow_message_expectations_on_nil + Kernel.should_not_receive(:warn) + + nil.should_receive(:foo) + nil.should_not_receive(:bar) + nil.foo + end + + end + + describe "#allow_message_expectations_on_nil" do + + it "should not effect subsequent examples" do + example_group = Class.new(::Spec::Example::ExampleGroupDouble) + example_group.it("when called in one example that doesn't end up setting an expectation on nil") do + allow_message_expectations_on_nil + end + example_group.it("should not effect the next exapmle ran") do + Kernel.should_receive(:warn) + nil.should_receive(:foo) + nil.foo + end + + example_group.run(Spec::Runner.options).should be_true + + end + + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/null_object_mock_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/null_object_mock_spec.rb new file mode 100644 index 000000000..8af6b49d7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/null_object_mock_spec.rb @@ -0,0 +1,54 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "a mock acting as a NullObject" do + before(:each) do + @mock = Mock.new("null_object", :null_object => true) + end + + it "should allow explicit expectation" do + @mock.should_receive(:something) + @mock.something + end + + it "should fail verification when explicit exception not met" do + lambda do + @mock.should_receive(:something) + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should ignore unexpected methods" do + @mock.random_call("a", "d", "c") + @mock.rspec_verify + end + + it "should expected message with different args first" do + @mock.should_receive(:message).with(:expected_arg) + @mock.message(:unexpected_arg) + @mock.message(:expected_arg) + end + + it "should expected message with different args second" do + @mock.should_receive(:message).with(:expected_arg) + @mock.message(:expected_arg) + @mock.message(:unexpected_arg) + end + end + + describe "#null_object?" do + it "should default to false" do + obj = mock('anything') + obj.should_not be_null_object + end + end + + describe "#as_null_object" do + it "should set the object to null_object" do + obj = mock('anything').as_null_object + obj.should be_null_object + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/once_counts_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/once_counts_spec.rb new file mode 100644 index 000000000..951298321 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/once_counts_spec.rb @@ -0,0 +1,53 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "OnceCounts" do + before(:each) do + @mock = mock("test mock") + end + + it "once should fail when called once with wrong args" do + @mock.should_receive(:random_call).once.with("a", "b", "c") + lambda do + @mock.random_call("d", "e", "f") + end.should raise_error(MockExpectationError) + @mock.rspec_reset + end + + it "once should fail when called twice" do + @mock.should_receive(:random_call).once + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "once should fail when not called" do + @mock.should_receive(:random_call).once + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "once should pass when called once" do + @mock.should_receive(:random_call).once + @mock.random_call + @mock.rspec_verify + end + + it "once should pass when called once with specified args" do + @mock.should_receive(:random_call).once.with("a", "b", "c") + @mock.random_call("a", "b", "c") + @mock.rspec_verify + end + + it "once should pass when called once with unspecified args" do + @mock.should_receive(:random_call).once + @mock.random_call("a", "b", "c") + @mock.rspec_verify + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/options_hash_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/options_hash_spec.rb new file mode 100644 index 000000000..f82757827 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/options_hash_spec.rb @@ -0,0 +1,35 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "calling :should_receive with an options hash" do + it "should report the file and line submitted with :expected_from" do + begin + mock = Spec::Mocks::Mock.new("a mock") + mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37") + mock.rspec_verify + rescue Exception => e + ensure + e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m + end + end + + it "should use the message supplied with :message" do + lambda { + m = Spec::Mocks::Mock.new("a mock") + m.should_receive(:message, :message => "recebi nada") + m.rspec_verify + }.should raise_error("recebi nada") + end + + it "should use the message supplied with :message after a similar stub" do + lambda { + m = Spec::Mocks::Mock.new("a mock") + m.stub!(:message) + m.should_receive(:message, :message => "from mock") + m.rspec_verify + }.should raise_error("from mock") + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_spec.rb new file mode 100644 index 000000000..c19ecd304 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_spec.rb @@ -0,0 +1,164 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "using a Partial Mock," do + before(:each) do + @object = Object.new + end + + it "should name the class in the failure message" do + @object.should_receive(:foo) + lambda do + @object.rspec_verify + end.should raise_error(Spec::Mocks::MockExpectationError, /<Object:.*> expected/) + end + + it "should name the class in the failure message when expectation is on class" do + Object.should_receive(:foo) + lambda do + Object.rspec_verify + end.should raise_error(Spec::Mocks::MockExpectationError, /<Object \(class\)>/) + end + + it "should not conflict with @options in the object" do + @object.instance_eval { @options = Object.new } + @object.should_receive(:blah) + @object.blah + end + + it "should_not_receive should mock out the method" do + @object.should_not_receive(:fuhbar) + lambda do + @object.fuhbar + end.should raise_error(MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/) + end + + it "should_not_receive should return a negative message expectation" do + @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation) + end + + it "should_receive should mock out the method" do + @object.should_receive(:foobar).with(:test_param).and_return(1) + @object.foobar(:test_param).should equal(1) + end + + it "should_receive should handle a hash" do + @object.should_receive(:foobar).with(:key => "value").and_return(1) + @object.foobar(:key => "value").should equal(1) + end + + it "should_receive should handle an inner hash" do + hash = {:a => {:key => "value"}} + @object.should_receive(:foobar).with(:key => "value").and_return(1) + @object.foobar(hash[:a]).should equal(1) + end + + it "should_receive should return a message expectation" do + @object.should_receive(:foobar).should be_kind_of(MessageExpectation) + @object.foobar + end + + it "should_receive should verify method was called" do + @object.should_receive(:foobar).with(:test_param).and_return(1) + lambda do + @object.rspec_verify + end.should raise_error(Spec::Mocks::MockExpectationError) + end + + it "should_receive should also take a String argument" do + @object.should_receive('foobar') + @object.foobar + end + + it "should_not_receive should also take a String argument" do + @object.should_not_receive('foobar') + lambda do + @object.foobar + end.should raise_error(Spec::Mocks::MockExpectationError) + end + + it "should use report nil in the error message" do + allow_message_expectations_on_nil + + @this_will_resolve_to_nil.should_receive(:foobar) + lambda do + @this_will_resolve_to_nil.rspec_verify + end.should raise_error(Spec::Mocks::MockExpectationError, /nil expected :foobar with/) + end + end + + describe "Partially mocking an object that defines ==, after another mock has been defined" do + before(:each) do + stub("existing mock", :foo => :foo) + end + + class PartiallyMockedEquals + attr_reader :val + def initialize(val) + @val = val + end + + def ==(other) + @val == other.val + end + end + + it "should not raise an error when stubbing the object" do + o = PartiallyMockedEquals.new :foo + lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError) + end + end + + describe "Method visibility when using partial mocks" do + class MockableClass + def public_method + private_method + protected_method + end + protected + def protected_method; end + private + def private_method; end + end + + before(:each) do + @object = MockableClass.new + end + + it 'should keep public methods public' do + @object.should_receive(:public_method) + with_ruby('1.9') do + @object.public_methods.should include(:public_method) + end + with_ruby('1.8') do + @object.public_methods.should include('public_method') + end + @object.public_method + end + + it 'should keep private methods private' do + @object.should_receive(:private_method) + with_ruby('1.9') do + @object.private_methods.should include(:private_method) + end + with_ruby('1.8') do + @object.private_methods.should include('private_method') + end + @object.public_method + end + + it 'should keep protected methods protected' do + @object.should_receive(:protected_method) + with_ruby('1.9') do + @object.protected_methods.should include(:protected_method) + end + with_ruby('1.8') do + @object.protected_methods.should include('protected_method') + end + @object.public_method + end + + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb new file mode 100644 index 000000000..a69aa6ac0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb @@ -0,0 +1,66 @@ +require 'spec_helper' + +module Spec +module Mocks +describe "PartialMockUsingMocksDirectly" do + before(:each) do + + klass=Class.new + klass.class_eval do + def existing_method + :original_value + end + end + @obj = klass.new + + end + + # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149 + # specify "should clear expectations on verify" do + # @obj.should_receive(:msg) + # @obj.msg + # @obj.rspec_verify + # lambda do + # @obj.msg + # end.should raise_error(NoMethodError) + # + # end + it "should fail when expected message is not received" do + @obj.should_receive(:msg) + lambda do + @obj.rspec_verify + end.should raise_error(MockExpectationError) + + end + it "should fail when message is received with incorrect args" do + @obj.should_receive(:msg).with(:correct_arg) + lambda do + @obj.msg(:incorrect_arg) + end.should raise_error(MockExpectationError) + @obj.msg(:correct_arg) + + end + it "should pass when expected message is received" do + @obj.should_receive(:msg) + @obj.msg + @obj.rspec_verify + + end + it "should pass when message is received with correct args" do + @obj.should_receive(:msg).with(:correct_arg) + @obj.msg(:correct_arg) + @obj.rspec_verify + + end + it "should revert to original method if existed" do + @obj.existing_method.should equal(:original_value) + @obj.should_receive(:existing_method).and_return(:mock_value) + @obj.existing_method.should equal(:mock_value) + @obj.rspec_verify + @obj.existing_method.should equal(:original_value) + + end + +end +end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/passing_argument_matchers_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/passing_argument_matchers_spec.rb new file mode 100644 index 000000000..a364df0ae --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/passing_argument_matchers_spec.rb @@ -0,0 +1,145 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "mock argument matchers", :shared => true do + before(:each) do + @mock = Mock.new("test mock") + Kernel.stub!(:warn) + end + + after(:each) do + @mock.rspec_verify + end + end + + describe Methods, "handling argument matchers" do + it_should_behave_like "mock argument matchers" + + it "should accept true as boolean()" do + @mock.should_receive(:random_call).with(boolean()) + @mock.random_call(true) + end + + it "should accept false as boolean()" do + @mock.should_receive(:random_call).with(boolean()) + @mock.random_call(false) + end + + it "should accept fixnum as kind_of(Numeric)" do + @mock.should_receive(:random_call).with(kind_of(Numeric)) + @mock.random_call(1) + end + + it "should accept float as an_instance_of(Numeric)" do + @mock.should_receive(:random_call).with(kind_of(Numeric)) + @mock.random_call(1.5) + end + + it "accepts fixnum as instance_of(Fixnum)" do + @mock.should_receive(:random_call).with(instance_of(Fixnum)) + @mock.random_call(1) + end + + it "should NOT accept fixnum as instance_of(Numeric)" do + @mock.should_not_receive(:random_call).with(instance_of(Numeric)) + @mock.random_call(1) + end + + it "should NOT accept float as instance_of(Numeric)" do + @mock.should_not_receive(:random_call).with(instance_of(Numeric)) + @mock.random_call(1.5) + end + + it "should accept string as anything()" do + @mock.should_receive(:random_call).with("a", anything(), "c") + @mock.random_call("a", "whatever", "c") + end + + it "should match duck type with one method" do + @mock.should_receive(:random_call).with(duck_type(:length)) + @mock.random_call([]) + end + + it "should match duck type with two methods" do + @mock.should_receive(:random_call).with(duck_type(:abs, :div)) + @mock.random_call(1) + end + + it "should match no args against any_args()" do + @mock.should_receive(:random_call).with(any_args) + @mock.random_call() + end + + it "should match one arg against any_args()" do + @mock.should_receive(:random_call).with(any_args) + @mock.random_call("a string") + end + + it "should match no args against no_args()" do + @mock.should_receive(:random_call).with(no_args) + @mock.random_call() + end + + it "should match hash with hash_including same hash" do + @mock.should_receive(:random_call).with(hash_including(:a => 1)) + @mock.random_call(:a => 1) + end + + end + + describe Methods, "handling block matchers" do + it_should_behave_like "mock argument matchers" + + it "should match arguments against RSpec expectations" do + @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest| + arg1.should == 5 + arg2.should have_at_least(3).characters + arg2.should have_at_most(10).characters + arr.map {|i| i * 2}.should == [2,4,6] + rest.should == [:fee, "fi", 4] + } + @mock.random_call 5, "hello", [1,2,3], :fee, "fi", 4 + end + end + + describe Methods, "handling non-matcher arguments" do + + before(:each) do + @mock = Mock.new("test mock") + end + + it "should match non special symbol (can be removed when deprecated symbols are removed)" do + @mock.should_receive(:random_call).with(:some_symbol) + @mock.random_call(:some_symbol) + end + + it "should match string against regexp" do + @mock.should_receive(:random_call).with(/bcd/) + @mock.random_call("abcde") + end + + it "should match regexp against regexp" do + @mock.should_receive(:random_call).with(/bcd/) + @mock.random_call(/bcd/) + end + + it "should match against a hash submitted and received by value" do + @mock.should_receive(:random_call).with(:a => "a", :b => "b") + @mock.random_call(:a => "a", :b => "b") + end + + it "should match against a hash submitted by reference and received by value" do + opts = {:a => "a", :b => "b"} + @mock.should_receive(:random_call).with(opts) + @mock.random_call(:a => "a", :b => "b") + end + + it "should match against a hash submitted by value and received by reference" do + opts = {:a => "a", :b => "b"} + @mock.should_receive(:random_call).with(:a => "a", :b => "b") + @mock.random_call(opts) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/precise_counts_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/precise_counts_spec.rb new file mode 100644 index 000000000..5b64ef281 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/precise_counts_spec.rb @@ -0,0 +1,52 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "PreciseCounts" do + before(:each) do + @mock = mock("test mock") + end + + it "should fail when exactly n times method is called less than n times" do + @mock.should_receive(:random_call).exactly(3).times + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should fail when exactly n times method is never called" do + @mock.should_receive(:random_call).exactly(3).times + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "should pass if exactly n times method is called exactly n times" do + @mock.should_receive(:random_call).exactly(3).times + @mock.random_call + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "should pass multiple calls with different args and counts" do + @mock.should_receive(:random_call).twice.with(1) + @mock.should_receive(:random_call).once.with(2) + @mock.random_call(1) + @mock.random_call(2) + @mock.random_call(1) + @mock.rspec_verify + end + + it "should pass mutiple calls with different args" do + @mock.should_receive(:random_call).once.with(1) + @mock.should_receive(:random_call).once.with(2) + @mock.random_call(1) + @mock.random_call(2) + @mock.rspec_verify + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/record_messages_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/record_messages_spec.rb new file mode 100644 index 000000000..bed2fbff6 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/record_messages_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "a mock" do + before(:each) do + @mock = mock("mock", :null_object => true) + end + it "should answer false for received_message? when no messages received" do + @mock.received_message?(:message).should be_false + end + it "should answer true for received_message? when message received" do + @mock.message + @mock.received_message?(:message).should be_true + end + it "should answer true for received_message? when message received with correct args" do + @mock.message 1,2,3 + @mock.received_message?(:message, 1,2,3).should be_true + end + it "should answer false for received_message? when message received with incorrect args" do + @mock.message 1,2,3 + @mock.received_message?(:message, 1,2).should be_false + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_chain_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_chain_spec.rb new file mode 100644 index 000000000..3536e1761 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_chain_spec.rb @@ -0,0 +1,42 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "A chained method stub" do + before(:each) do + @subject = Object.new + end + + it "returns expected value from chaining only one method call" do + @subject.stub_chain(:msg1).and_return(:return_value) + @subject.msg1.should equal(:return_value) + end + + it "returns expected value from chaining two method calls" do + @subject.stub_chain(:msg1, :msg2).and_return(:return_value) + @subject.msg1.msg2.should equal(:return_value) + end + + it "returns expected value from chaining four method calls" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value) + @subject.msg1.msg2.msg3.msg4.should equal(:return_value) + end + + it "returns expected value from two chains with shared messages at the end" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first) + @subject.stub_chain(:msg5, :msg2, :msg3, :msg4).and_return(:second) + + @subject.msg1.msg2.msg3.msg4.should equal(:first) + @subject.msg5.msg2.msg3.msg4.should equal(:second) + end + + it "returns expected value from two chains with shared messages at the beginning" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first) + @subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second) + + @subject.msg1.msg2.msg3.msg4.should equal(:first) + @subject.msg1.msg2.msg3.msg5.should equal(:second) + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_implementation_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_implementation_spec.rb new file mode 100644 index 000000000..1487277fc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_implementation_spec.rb @@ -0,0 +1,31 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "stub implementation" do + context "with no args" do + it "execs the block when called" do + obj = stub() + obj.stub(:foo) { :bar } + obj.foo.should == :bar + end + end + + context "with one arg" do + it "execs the block with that arg when called" do + obj = stub() + obj.stub(:foo) {|given| given} + obj.foo(:bar).should == :bar + end + end + + context "with variable args" do + it "execs the block when called" do + obj = stub() + obj.stub(:foo) {|*given| given.first} + obj.foo(:bar).should == :bar + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_spec.rb new file mode 100644 index 000000000..e0b7b2640 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stub_spec.rb @@ -0,0 +1,203 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "A method stub" do + before(:each) do + @class = Class.new do + def self.existing_class_method + :original_value + end + + def existing_instance_method + :original_value + end + end + @instance = @class.new + @stub = Object.new + end + + [:stub!, :stub].each do |method| + context "using #{method}" do + it "should return expected value when expected message is received" do + @instance.send(method, :msg).and_return(:return_value) + @instance.msg.should equal(:return_value) + @instance.rspec_verify + end + end + end + + it "should ignore when expected message is received" do + @instance.stub!(:msg) + @instance.msg + lambda do + @instance.rspec_verify + end.should_not raise_error + end + + it "should ignore when message is received with args" do + @instance.stub!(:msg) + @instance.msg(:an_arg) + lambda do + @instance.rspec_verify + end.should_not raise_error + end + + it "should ignore when expected message is not received" do + @instance.stub!(:msg) + lambda do + @instance.rspec_verify + end.should_not raise_error + end + + it "should handle multiple stubbed methods" do + @instance.stub!(:msg1 => 1, :msg2 => 2) + @instance.msg1.should == 1 + @instance.msg2.should == 2 + end + + it "should clear itself when verified" do + @instance.stub!(:this_should_go).and_return(:blah) + @instance.this_should_go.should == :blah + @instance.rspec_verify + lambda do + @instance.this_should_go + end.should raise_error(NameError) + end + + it "should return values in order to consecutive calls" do + return_values = ["1",2,Object.new] + @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2]) + @instance.msg.should == return_values[0] + @instance.msg.should == return_values[1] + @instance.msg.should == return_values[2] + end + + it "should keep returning last value in consecutive calls" do + return_values = ["1",2,Object.new] + @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2]) + @instance.msg.should == return_values[0] + @instance.msg.should == return_values[1] + @instance.msg.should == return_values[2] + @instance.msg.should == return_values[2] + @instance.msg.should == return_values[2] + end + + it "should revert to original instance method if there is one" do + @instance.existing_instance_method.should equal(:original_value) + @instance.stub!(:existing_instance_method).and_return(:mock_value) + @instance.existing_instance_method.should equal(:mock_value) + @instance.rspec_verify + @instance.existing_instance_method.should equal(:original_value) + end + + it "should revert to original class method if there is one" do + @class.existing_class_method.should equal(:original_value) + @class.stub!(:existing_class_method).and_return(:mock_value) + @class.existing_class_method.should equal(:mock_value) + @class.rspec_verify + @class.existing_class_method.should equal(:original_value) + end + + it "should yield a specified object" do + @instance.stub!(:method_that_yields).and_yield(:yielded_obj) + current_value = :value_before + @instance.method_that_yields {|val| current_value = val} + current_value.should == :yielded_obj + @instance.rspec_verify + end + + it "should yield multiple times with multiple calls to and_yield" do + @instance.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value). + and_yield(:another_value) + current_value = [] + @instance.method_that_yields_multiple_times {|val| current_value << val} + current_value.should == [:yielded_value, :another_value] + @instance.rspec_verify + end + + it "should yield a specified object and return another specified object" do + yielded_obj = mock("my mock") + yielded_obj.should_receive(:foo).with(:bar) + @instance.stub!(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz) + @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz + end + + it "should throw when told to" do + @mock.stub!(:something).and_throw(:up) + lambda do + @mock.something + end.should throw_symbol(:up) + end + + it "should override a pre-existing stub" do + @stub.stub!(:existing_instance_method).and_return(:updated_stub_value) + @stub.existing_instance_method.should == :updated_stub_value + end + + it "should limit " do + @stub.stub!(:foo).with("bar") + @stub.should_receive(:foo).with("baz") + @stub.foo("bar") + @stub.foo("baz") + end + + it "calculates return value by executing block passed to #and_return" do + @mock.stub!(:something).with("a","b","c").and_return { |a,b,c| c+b+a } + @mock.something("a","b","c").should == "cba" + @mock.rspec_verify + end + end + + describe "A method stub with args" do + before(:each) do + @stub = Object.new + @stub.stub!(:foo).with("bar") + end + + it "should not complain if not called" do + end + + it "should not complain if called with arg" do + @stub.foo("bar") + end + + it "should complain if called with no arg" do + lambda do + @stub.foo + end.should raise_error + end + + it "should complain if called with other arg" do + lambda do + @stub.foo("other") + end.should raise_error + end + + it "should not complain if also mocked w/ different args" do + @stub.should_receive(:foo).with("baz") + @stub.foo("bar") + @stub.foo("baz") + end + + it "should complain if also mocked w/ different args AND called w/ a 3rd set of args" do + @stub.should_receive(:foo).with("baz") + @stub.foo("bar") + @stub.foo("baz") + lambda do + @stub.foo("other") + end.should raise_error + end + + it "should support options" do + @stub.stub!(:foo, :expected_from => "bar") + end + + it "should use 'Stub' in the failure message" do + stub = stub('name') + expect {stub.foo}.to raise_error(/Stub "name" received/) + end + end + + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/stubbed_message_expectations_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stubbed_message_expectations_spec.rb new file mode 100644 index 000000000..03c8fecdc --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/stubbed_message_expectations_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "Example with stubbed and then called message" do + it "fails if the message is expected and then subsequently not called again" do + mock_obj = mock("mock", :msg => nil) + mock_obj.msg + mock_obj.should_receive(:msg) + lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError) + end + + it "outputs arguments of all similar calls" do + m = mock('mock', :foo => true) + m.should_receive(:foo).with('first') + m.foo('second') + m.foo('third') + lambda do + m.rspec_verify + end.should raise_error(%Q|Mock "mock" received :foo with unexpected arguments\n expected: ("first")\n got: (["second"], ["third"])|) + m.rspec_reset + end + end + + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/twice_counts_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/twice_counts_spec.rb new file mode 100644 index 000000000..4538eb8f9 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/twice_counts_spec.rb @@ -0,0 +1,67 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "TwiceCounts" do + before(:each) do + @mock = mock("test mock") + end + + it "twice should fail when call count is higher than expected" do + @mock.should_receive(:random_call).twice + @mock.random_call + @mock.random_call + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "twice should fail when call count is lower than expected" do + @mock.should_receive(:random_call).twice + @mock.random_call + lambda do + @mock.rspec_verify + end.should raise_error(MockExpectationError) + end + + it "twice should fail when called twice with wrong args on the first call" do + @mock.should_receive(:random_call).twice.with("1", 1) + lambda do + @mock.random_call(1, "1") + end.should raise_error(MockExpectationError) + @mock.rspec_reset + end + + it "twice should fail when called twice with wrong args on the second call" do + @mock.should_receive(:random_call).twice.with("1", 1) + @mock.random_call("1", 1) + lambda do + @mock.random_call(1, "1") + end.should raise_error(MockExpectationError) + @mock.rspec_reset + end + + it "twice should pass when called twice" do + @mock.should_receive(:random_call).twice + @mock.random_call + @mock.random_call + @mock.rspec_verify + end + + it "twice should pass when called twice with specified args" do + @mock.should_receive(:random_call).twice.with("1", 1) + @mock.random_call("1", 1) + @mock.random_call("1", 1) + @mock.rspec_verify + end + + it "twice should pass when called twice with unspecified args" do + @mock.should_receive(:random_call).twice + @mock.random_call("1") + @mock.random_call(1) + @mock.rspec_verify + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/mocks/unstub_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/mocks/unstub_spec.rb new file mode 100644 index 000000000..89e5ac381 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/mocks/unstub_spec.rb @@ -0,0 +1,127 @@ +require 'spec_helper' + +module Spec + module Mocks + describe Mock do + context "unstubbing a mock object with a stub" do + it "should remove the stub" do + a_mock = mock 'an object', :foo => :bar + + a_mock.unstub! :foo + a_mock.should_not respond_to(:foo) + end + end + + context "unstubbing a real object with a stub" do + before do + @obj = Object.new + end + + it "should raise a NoMethodError if the message is called after unstubbing" do + @obj.stub!(:foo).and_return :bar + @obj.unstub!(:foo) + + lambda { + @obj.foo + }.should raise_error(NoMethodError) + end + + it "should only clear the stub specified" do + @obj.stub!(:foo).and_return :bar + @obj.stub!(:other).and_return :baz + + @obj.unstub!(:foo) + + @obj.other.should == :baz + end + + it "should no longer respond_to? the method" do + @obj.stub!(:foo).and_return :bar + @obj.unstub!(:foo) + + @obj.should_not respond_to(:foo) + end + + it "should unstub using a string (should convert the string to a symbol)" do + @obj.stub!(:foo) + + @obj.unstub!("foo") + + @obj.should_not respond_to(:foo) + end + + it "should restore a previous method definition" do + def @obj.foo + :a_result + end + + @obj.stub!(:foo).and_return :stubbed_result + @obj.unstub!(:foo) + + @obj.foo.should == :a_result + end + + it "should have unstub as an alias of unstub!" do + @obj.stub!(:foo).and_return :bar + + @obj.unstub(:foo) + + lambda { + @obj.foo + }.should raise_error(NoMethodError) + end + + it "should raise a MockExpectationError if it is not stubbed" do + lambda { + @obj.unstub!(:foo) + }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed") + end + + it "should raise a MockExpectationError if it was already unstubbed" do + @obj.stub!(:foo) + @obj.unstub!(:foo) + + lambda { + @obj.unstub!(:foo) + }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed") + end + + it "should use the correct message name in the error" do + @obj.stub!(:bar) + @obj.unstub!(:bar) + + lambda { + @obj.unstub!(:bar) + }.should raise_error(MockExpectationError, "The method `bar` was not stubbed or was already unstubbed") + end + + it "should raise a MockExpectationError if the method is defined, but not stubbed" do + def @obj.meth; end + + lambda { + @obj.unstub!(:meth) + }.should raise_error(MockExpectationError) + end + + it "should be able to restub a after unstubbing" do + @obj.stub!(:foo).and_return :bar + + @obj.unstub!(:foo) + + @obj.stub!(:foo).and_return :baz + + @obj.foo.should == :baz + end + + it "should remove only the first stub if multiple stubs have been defined" do + @obj.stub!(:foo).and_return :first + @obj.stub!(:foo).and_return :second + + @obj.unstub!(:foo) + + @obj.foo.should == :first + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/package/bin_spec_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/package/bin_spec_spec.rb new file mode 100644 index 000000000..6628fad72 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/package/bin_spec_spec.rb @@ -0,0 +1,16 @@ +require 'spec_helper' +require 'ruby_forker' + +describe "The bin/spec script" do + include RubyForker + + it "should have no warnings" do + output = ruby "-w -Ilib bin/spec --help" + output.should_not =~ /warning/n + end + + it "should show the help w/ no args" do + output = ruby "-w -Ilib bin/spec" + output.should =~ /^Usage: spec/ + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/rake/spectask_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/rake/spectask_spec.rb new file mode 100644 index 000000000..ea834bad4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/rake/spectask_spec.rb @@ -0,0 +1,150 @@ +require 'spec_helper' +require 'spec/rake/spectask' + +module Spec + module Rake + + class MockTask + class << self + attr_accessor :last_instance, :last_cmd + end + + def self.tasks + @tasks ||= {} + end + + def self.reset_tasks + @tasks = {} + end + + def self.task(name) + tasks[name] + end + + def self.register_task(name, block) + tasks[name] = block + end + + def initialize(name, &block) + MockTask.register_task(name, block) + MockTask.last_instance = block + end + + def self.create_task(name, &block) + new(name, &block) + end + end + + class SpecTask + def task(name, &block) + MockTask.create_task(name, &block) + end + + def system(cmd) + MockTask.last_cmd = cmd + true + end + + def default_ruby_path + RUBY + end + end + + describe SpecTask do + + before(:each) do + MockTask.reset_tasks + end + + it "should execute rake's ruby path by default" do + task = SpecTask.new + MockTask.last_instance.call + MockTask.last_cmd.should match(/^#{task.default_ruby_path} /) + end + + it "should execute the command with system if ruby_cmd is specified" do + task = SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"} + task.should_receive(:system).and_return(true) + MockTask.last_instance.call + end + + it "should execute the ruby_cmd path if specified" do + SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"} + MockTask.last_instance.call + MockTask.last_cmd.should match(/^path_to_multiruby /) + end + + it "should produce a deprecation warning if the out option is used" do + SpecTask.new {|t| t.out = "somewhere_over_the_rainbow"} + STDERR.should_receive(:puts).with("The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead.") + MockTask.last_instance.call + end + + it "should produce an error if failure_message is set and the command fails" do + task = SpecTask.new {|t| t.failure_message = "oops"; t.fail_on_error = false} + STDERR.should_receive(:puts).with("oops") + task.stub(:system).and_return(false) + MockTask.last_instance.call + end + + it "should raise if fail_on_error is set and the command fails" do + task = SpecTask.new + task.stub(:system).and_return(false) + lambda {MockTask.last_instance.call}.should raise_error + end + + it "should not raise if fail_on_error is not set and the command fails" do + task = SpecTask.new {|t| t.fail_on_error = false} + task.stub(:system).and_return(false) + lambda {MockTask.last_instance.call}.should_not raise_error + end + + context "with ENV['SPEC'] set" do + before(:each) do + @orig_env_spec = ENV['SPEC'] + ENV['SPEC'] = 'foo.rb' + end + after(:each) do + ENV['SPEC'] = @orig_env_spec + end + it "should use the provided file list" do + task = SpecTask.new + task.spec_file_list.should == ["foo.rb"] + end + end + + context "with the rcov option" do + + it "should create a clobber_rcov task" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:clobber_rcov) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "should setup the clobber_rcov task to remove the rcov directory" do + task = SpecTask.new(:rcov) {|t| t.rcov = true; t.rcov_dir = "path_to_rcov_directory"} + task.should_receive(:rm_r).with("path_to_rcov_directory") + MockTask.task(:clobber_rcov).call + end + + it "should make the clobber task depend on clobber_rcov" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:clobber => [:clobber_rcov]) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "should make the rcov task depend on clobber_rcov" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:rcov => :clobber_rcov) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "creates an rcov options list" do + MockTask.stub!(:create_task) + task = SpecTask.new(:rcov) {|t| t.rcov = true, t.rcov_opts = ['a','b']} + task.rcov_option_list.should == "a b" + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/class_and_argument_parser_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/class_and_argument_parser_spec.rb new file mode 100644 index 000000000..1168818f0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/class_and_argument_parser_spec.rb @@ -0,0 +1,23 @@ +require 'spec_helper' + +module Spec + module Runner + describe ClassAndArgumentsParser, ".parse" do + + it "should use a single : to separate class names from arguments" do + ClassAndArgumentsParser.parse('Foo').should == ['Foo', nil] + ClassAndArgumentsParser.parse('Foo:arg').should == ['Foo', 'arg'] + ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg').should == ['Foo::Bar::Zap', 'arg'] + ClassAndArgumentsParser.parse('Foo:arg1,arg2').should == ['Foo', 'arg1,arg2'] + ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg1,arg2').should == ['Foo::Bar::Zap', 'arg1,arg2'] + ClassAndArgumentsParser.parse('Foo::Bar::Zap:drb://foo,drb://bar').should == ['Foo::Bar::Zap', 'drb://foo,drb://bar'] + end + + it "should raise an error when passed an empty string" do + lambda do + ClassAndArgumentsParser.parse('') + end.should raise_error("Couldn't parse \"\"") + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/command_line_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/command_line_spec.rb new file mode 100644 index 000000000..bc64e5aef --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/command_line_spec.rb @@ -0,0 +1,162 @@ +require 'spec_helper' + +module Spec + module Runner + describe CommandLine, ".run" do + with_sandboxed_options do + attr_reader :err, :out + before do + @err = options.error_stream + @out = options.output_stream + end + + it "should run directory" do + file = File.dirname(__FILE__) + '/../../../examples/passing' + run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out)) + + @out.rewind + @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n + end + + it "should run file" do + file = File.dirname(__FILE__) + '/../../../examples/failing/predicate_example.rb' + run_with(OptionParser.parse([file], @err, @out)) + + @out.rewind + @out.read.should =~ /3 examples, 2 failures/n + end + + it "should raise when file does not exist" do + file = File.dirname(__FILE__) + '/doesntexist' + + lambda { + Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out)) + }.should raise_error + end + + it "should return true when in --generate-options mode" do + # NOTE - this used to say /dev/null but jruby hangs on that for some reason + Spec::Runner::CommandLine.run( + OptionParser.parse(['--generate-options', '/tmp/foo'], @err, @out) + ).should be_true + end + + it "should exit if Interrupt exception occurrs during the spec" do + example_group = Class.new(::Spec::Example::ExampleGroup) do + describe("example_group") + it "no error" do + end + + it "should interrupt" do + raise Interrupt, "I'm interrupting" + end + end + + options = ::Spec::Runner::Options.new(@err, @out) + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + options.add_example_group(example_group) + + expect { + Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out)) + }.to raise_error(SystemExit) + end + + it "should exit if Interrupt exception occurrs during an after(:each)" do + example_group = Class.new(::Spec::Example::ExampleGroup) do + describe("example_group") + it "no error" do + end + + after do + raise Interrupt, "I'm interrupting" + end + end + + options = ::Spec::Runner::Options.new(@err, @out) + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + options.add_example_group(example_group) + + expect { + Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out)) + }.to raise_error(SystemExit) + end + + it "should heckle when options have heckle_runner" do + example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do + it "no error" do + end + end + options = ::Spec::Runner::Options.new(@err, @out) + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + options.add_example_group example_group + + heckle_runner = mock("heckle_runner") + heckle_runner.should_receive(:heckle_with) + $rspec_mocks.__send__(:mocks).delete(heckle_runner) + + options.heckle_runner = heckle_runner + options.add_example_group(example_group) + + Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out)) + heckle_runner.rspec_verify + end + + it "should run examples backwards if options.reverse is true" do + options = ::Spec::Runner::Options.new(@err, @out) + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + options.reverse = true + + b1 = Class.new(Spec::Example::ExampleGroup) + b2 = Class.new(Spec::Example::ExampleGroup) + + b2.should_receive(:run).ordered + b1.should_receive(:run).ordered + + options.add_example_group(b1) + options.add_example_group(b2) + + Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out)) + end + + it "should pass its ExampleGroup to the reporter" do + example_group = describe("example_group") do + it "should" do + end + end + options = ::Spec::Runner::Options.new(@err, @out) + options.add_example_group(example_group) + + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group)) + + Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out)) + end + + it "runs only selected Examples when options.examples is set" do + options = ::Spec::Runner::Options.new(@err, @out) + ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options) + + options.examples << "example group expected example" + expected_example_was_run = false + unexpected_example_was_run = false + example_group = describe("example group") do + it "expected example" do + expected_example_was_run = true + end + it "unexpected example" do + unexpected_example_was_run = true + end + end + + options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group)) + + options.add_example_group example_group + run_with(options) + + expected_example_was_run.should be_true + unexpected_example_was_run.should be_false + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/configuration_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/configuration_spec.rb new file mode 100644 index 000000000..ea545d641 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/configuration_spec.rb @@ -0,0 +1,320 @@ +require 'spec_helper' + +module Spec + module Runner + describe Configuration do + with_sandboxed_options do + with_sandboxed_config do + + describe "#mock_with" do + it "should default mock framework to rspec" do + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/ + end + + it "should set rspec mocking explicitly" do + config.mock_with(:rspec) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/ + end + + it "should set mocha" do + config.mock_with(:mocha) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/mocha$/ + end + + it "should set flexmock" do + config.mock_with(:flexmock) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/flexmock$/ + end + + it "should set rr" do + config.mock_with(:rr) + config.mock_framework.should =~ /^spec\/adapters\/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 + + describe "#include" do + + before(:each) do + @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {} + Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class) + 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 not include modules in a type they are not intended for" do + mod = Module.new + @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + config.include mod, :type => :foobar + + Class.new(@other_example_group_class).included_modules.should_not include(mod) + end + + it "accepts an Array of types" do + mod = Module.new + @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + config.include mod, :type => [:foobar, :baz] + + Class.new(@example_group_class).included_modules.should include(mod) + Class.new(@other_example_group_class).included_modules.should include(mod) + end + + end + + describe "#extend" do + + before(:each) do + @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {} + Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class) + 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(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + mod = Module.new + @other_example_group_class.should_not_receive(:extend) + + Spec::Runner.configuration.extend mod, :type => :foobar + end + + end + end + + describe "ordering methods: " do + + before(:each) do + @special_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("special_example_group") + @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group") + @nonspecial_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("nonspecial_example_group") + Spec::Example::ExampleGroupFactory.register(:special, @special_example_group) + Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group) + Spec::Example::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 + + @example_group.run(options) + order.should == [ + :prepend__before_all, + :special_prepend__before_all, + :special_child_prepend__before_all, + :prepend__before_each, + :special_prepend__before_each, + :special_child_prepend__before_each + ] + end + end + + describe "#append_before" do + + it "calls append_before on the type" do + order = [] + config.append_before(:all) do + order << :append_before_all + end + config.append_before(:all, :type => :special) do + order << :special_append_before_all + end + config.append_before(:all, :type => :special_child) do + order << :special_child_append_before_all + end + config.append_before do # default is :each + 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(options) + order.should == [ + :append_before_all, + :special_append_before_all, + :special_child_append_before_all, + :append_before_each, + :special_append_before_each, + :special_child_append_before_each + ] + end + end + + describe "#prepend_after" do + + it "prepends the after block on all instances of the passed in type" do + order = [] + config.prepend_after(:all) do + order << :prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_child_prepend__after_all + end + config.prepend_after(:each) do + order << :prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_child_prepend__after_each + end + config.prepend_after(:all, :type => :non_special) do + order << :special_prepend__after_all + end + config.prepend_after(:each, :type => :non_special) do + order << :special_prepend__after_each + end + @example_group.it "calls prepend_after" do + end + + @example_group.run(options) + order.should == [ + :special_child_prepend__after_each, + :special_prepend__after_each, + :prepend__after_each, + :special_child_prepend__after_all, + :special_prepend__after_all, + :prepend__after_all + ] + end + end + + describe "#append_after" do + + it "calls append_after on the type" do + order = [] + config.append_after(:all) do + order << :append__after_all + end + config.append_after(:all, :type => :special) do + order << :special_append__after_all + end + config.append_after(:all, :type => :special_child) do + order << :special_child_append__after_all + end + config.append_after(:each) do + order << :append__after_each + end + config.append_after(:each, :type => :special) do + order << :special_append__after_each + end + config.append_after(:each, :type => :special_child) do + order << :special_child_append__after_each + end + config.append_after(:all, :type => :non_special) do + order << :non_special_append_after_all + end + config.append_after(:each, :type => :non_special) do + order << :non_special_append_after_each + end + @example_group.it "calls append_after" do + end + + @example_group.run(options) + 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 + + describe "#ignore_backtrace_patterns" do + it "adds patterns to ignore in backtrace" do + config.ignore_backtrace_patterns /custom_pattern/, /shoulda/, /spork/ + config.ignored_backtrace_patterns.should include(/custom_pattern/) + config.ignored_backtrace_patterns.should include(/shoulda/) + config.ignored_backtrace_patterns.should include(/spork/) + end + end + + describe "#predicate_matchers (DEPRECATED)" do + it "is deprecated" do + Spec.should_receive(:deprecate) + config.predicate_matchers[:foo] = :bar? + end + end + + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/drb_command_line_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/drb_command_line_spec.rb new file mode 100644 index 000000000..4071956ab --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/drb_command_line_spec.rb @@ -0,0 +1,146 @@ +require 'spec_helper' + +module Spec + module Runner + unless jruby? + describe DrbCommandLine do + + context "without server running" do + it "prints error" do + err = out = StringIO.new + DrbCommandLine.run(OptionParser.parse(['--version'], err, out)) + + err.rewind + err.read.should =~ /No server is running/ + end + + it "returns nil" do + err = out = StringIO.new + result = DrbCommandLine.run(OptionParser.parse(['--version'], err, out)) + result.should be_false + end + end + + context "with server running" do + class ::CommandLineForDrbSpec + def self.run(argv, stderr, stdout) + orig_options = Spec::Runner.options + tmp_options = Spec::Runner::OptionParser.parse(argv, stderr, stdout) + Spec::Runner.use tmp_options + Spec::Runner::CommandLine.run(tmp_options) + ensure + Spec::Runner.use orig_options + end + end + + before(:all) do + DRb.start_service("druby://127.0.0.1:8989", ::CommandLineForDrbSpec) + @@drb_example_file_counter = 0 + end + + before(:each) do + create_dummy_spec_file + @@drb_example_file_counter = @@drb_example_file_counter + 1 + end + + after(:each) do + File.delete(@dummy_spec_filename) + end + + after(:all) do + DRb.stop_service + end + + it "returns true" do + err = out = StringIO.new + result = DrbCommandLine.run(OptionParser.parse(['--version'], err, out)) + result.should be_true + end + + it "should run against local server" do + out = run_spec_via_druby(['--version']) + out.should =~ /rspec \d+\.\d+\.\d+.*/n + end + + it "should output green colorized text when running with --colour option" do + out = run_spec_via_druby(["--colour", @dummy_spec_filename]) + out.should =~ /\e\[32m/n + end + + it "should output red colorized text when running with -c option" do + out = run_spec_via_druby(["-c", @dummy_spec_filename]) + out.should =~ /\e\[31m/n + end + + def create_dummy_spec_file + @dummy_spec_filename = File.expand_path(File.dirname(__FILE__)) + "/_dummy_spec#{@@drb_example_file_counter}.rb" + File.open(@dummy_spec_filename, 'w') do |f| + f.write %{ + describe "DUMMY CONTEXT for 'DrbCommandLine with -c option'" do + it "should be output with green bar" do + true.should be_true + end + + it "should be output with red bar" do + violated("I want to see a red bar!") + end + end + } + end + end + + def run_spec_via_druby(argv) + err, out = StringIO.new, StringIO.new + out.instance_eval do + def tty?; true end + end + options = ::Spec::Runner::Options.new(err, out) + options.argv = argv + Spec::Runner::DrbCommandLine.run(options) + out.rewind; out.read + end + end + + context "#port" do + before do + @options = stub("options", :drb_port => nil) + end + + context "with no additional configuration" do + it "defaults to 8989" do + Spec::Runner::DrbCommandLine.port(@options).should == 8989 + end + end + + context "with RSPEC_DRB environment variable set" do + def with_RSPEC_DRB_set_to(val) + original = ENV['RSPEC_DRB'] + begin + ENV['RSPEC_DRB'] = val + yield + ensure + ENV['RSPEC_DRB'] = original + end + end + + it "uses RSPEC_DRB value" do + with_RSPEC_DRB_set_to('9000') do + Spec::Runner::DrbCommandLine.port(@options).should == 9000 + end + end + + context "and config variable set" do + it "uses configured value" do + @options.stub(:drb_port => '5000') + with_RSPEC_DRB_set_to('9000') do + Spec::Runner::DrbCommandLine.port(@options).should == 5000 + end + end + end + + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/empty_file.txt b/vendor/gems/rspec-1.3.1/spec/spec/runner/empty_file.txt new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/empty_file.txt diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/example_group_runner_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/example_group_runner_spec.rb new file mode 100644 index 000000000..2b1601aca --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/example_group_runner_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Spec + module Runner + describe ExampleGroupRunner do + before(:each) do + err = StringIO.new('') + out = StringIO.new('') + @options = Options.new(err, out) + @runner = Spec::Runner::ExampleGroupRunner.new(@options) + end + + after(:each) do + Spec::Expectations.differ = nil + end + + describe "#load_files" do + it "should load UTF-8 encoded files" do + file = File.expand_path(File.dirname(__FILE__) + "/resources/utf8_encoded.rb") + @options.files << file + @runner.load_files(@options.files_to_load).should == @options.files_to_load + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/examples.txt b/vendor/gems/rspec-1.3.1/spec/spec/runner/examples.txt new file mode 100644 index 000000000..2fcbd355d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/examples.txt @@ -0,0 +1,2 @@ +Sir, if you were my husband, I would poison your drink. +Madam, if you were my wife, I would drink it.
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/failed.txt b/vendor/gems/rspec-1.3.1/spec/spec/runner/failed.txt new file mode 100644 index 000000000..07c5442cf --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/failed.txt @@ -0,0 +1,3 @@ +heckler_spec.rb +command_line_spec.rb +reporter_spec.rb
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_formatter_spec.rb new file mode 100644 index 000000000..a904bf380 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_formatter_spec.rb @@ -0,0 +1,30 @@ +require 'spec_helper' + +module Spec + module Runner + module Formatter + describe BaseFormatter do + subject { BaseFormatter.new(nil,nil) } + it {should respond_to(:start ).with(1).argument } + it {should respond_to(:example_group_started).with(1).argument } + it {should respond_to(:example_started ).with(1).argument } + # -3 indicates that one of the arguments is optional, with a default + # value assigned. This is due to deprecated_pending_location. Once + # that is removed, this should be changed to 2. + it {should respond_to(:example_pending ).with(-3).arguments} + it {should respond_to(:example_passed ).with(1).argument } + it {should respond_to(:example_failed ).with(3).arguments} + it {should respond_to(:start_dump ).with(0).arguments} + it {should respond_to(:dump_failure ).with(2).arguments} + it {should respond_to(:dump_summary ).with(4).arguments} + it {should respond_to(:dump_pending ).with(0).arguments} + it {should respond_to(:close ).with(0).arguments} + + it "deprecates add_example_group" do + Spec.should_receive(:deprecate) + subject.add_example_group(stub('example group')) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_text_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_text_formatter_spec.rb new file mode 100644 index 000000000..e3677ad47 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/base_text_formatter_spec.rb @@ -0,0 +1,113 @@ +require 'spec_helper' +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + describe BaseTextFormatter do + + before :all do + @sandbox = "spec/sandbox" + end + + it "should create the directory contained in WHERE if it does not exist" do + FileUtils.should_receive(:mkdir_p).with(@sandbox) + File.stub!(:open) + BaseTextFormatter.new({},"#{@sandbox}/temp.rb") + end + + context "(deprecations)" do + before(:each) do + Kernel.stub!(:warn) + @io = StringIO.new + @options = mock('options') + @options.stub!(:dry_run).and_return(false) + @options.stub!(:colour).and_return(false) + @options.stub!(:autospec).and_return(false) + @formatter = Class.new(BaseTextFormatter) do + def method_that_class_magenta(message) + magenta(message) + end + def method_that_class_colourise(message, failure) + colourise(message, failure) + end + end.new(@options, @io) + @failure = stub('failure', :pending_fixed? => false) + end + + context "#colourise" do + it "warns when subclasses call colourise" do + Spec.should_receive(:deprecate) + @formatter.method_that_class_colourise('this message', @failure) + end + + it "delegates to colorize_failure" do + @formatter.should_receive(:colorize_failure).with('this message', @failure) + @formatter.colourise('this message', @failure) + end + end + + context "#magenta" do + it "warns when subclasses call magenta" do + Spec.should_receive(:deprecate).with(/#magenta/) + @formatter.method_that_class_magenta('this message') + end + + it "delegates to red" do + @formatter.should_receive(:red).with('this message') + @formatter.method_that_class_magenta('this message') + end + end + + end + + describe "#colour (protected)" do + before(:each) do + @original_RSPEC_COLOR = ENV['RSPEC_COLOR'] + end + + it "does not colorize when output_to_file? returns true" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(true) + formatter.stub!(:output_to_file?).and_return(true) + formatter.__send__(:colour, 'foo', "\e[32m").should == "foo" + end + + it "colorizes when colour? and output_to_tty? return true" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(true) + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + it "colorizes when ENV['RSPEC_COLOR'] is set even if colour? and output_to_tty? return false" do + out = StringIO.new + options = stub('options', :colour => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(false) + + ENV['RSPEC_COLOR'] = 'true' + + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + it "colorizes when autospec? is true even if colour? and output_to_tty? return false" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => true) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(false) + + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + after(:each) do + ENV['RSPEC_COLOR'] = @original_RSPEC_COLOR + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb new file mode 100644 index 000000000..b390131ad --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb @@ -0,0 +1,45 @@ +require 'spec_helper' +require 'spec/runner/formatter/failing_example_groups_formatter' + +module Spec + module Runner + module Formatter + describe FailingExampleGroupsFormatter do + attr_reader :example_group, :formatter, :io + + before(:each) do + @io = StringIO.new + options = mock('options') + @formatter = FailingExampleGroupsFormatter.new(options, io) + @example_group = Class.new(::Spec::Example::ExampleGroup) + end + + it "should add example name for each failure" do + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(Class.new(::Spec::Example::ExampleGroupDouble).describe("b 1"))) + formatter.example_failed("e 1", nil, Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(Class.new(::Spec::Example::ExampleGroupDouble).describe("b 2"))) + formatter.example_failed("e 2", nil, Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + formatter.example_failed("e 3", nil, Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + io.string.should include("b 1") + io.string.should include("b 2") + end + + it "should delimit ExampleGroup superclass descriptions with :" do + parent_example_group = Class.new(example_group).describe("Parent") + child_example_group = Class.new(parent_example_group).describe("#child_method") + grand_child_example_group = Class.new(child_example_group).describe("GrandChild") + + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group)) + formatter.example_failed("failure", nil, ::Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + io.string.should == "Parent#child_method GrandChild\n" + end + + it "should remove druby url, which is used by Spec::Distributed" do + @formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(Class.new(::Spec::Example::ExampleGroupDouble).describe("something something (druby://99.99.99.99:99)"))) + @formatter.example_failed("e 1", nil, ::Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + io.string.should == "something something\n" + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_examples_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_examples_formatter_spec.rb new file mode 100644 index 000000000..76d03fa39 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/failing_examples_formatter_spec.rb @@ -0,0 +1,33 @@ +require 'spec_helper' +require 'spec/runner/formatter/failing_examples_formatter' + +module Spec + module Runner + module Formatter + describe FailingExamplesFormatter do + before(:each) do + @io = StringIO.new + options = mock('options') + @formatter = FailingExamplesFormatter.new(options, @io) + end + + it "should add example name for each failure" do + example_group_1 = Class.new(::Spec::Example::ExampleGroupDouble).describe("A") + example_group_2 = Class.new(example_group_1).describe("B") + + @formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group_1)) + @formatter.example_failed(example_group_1.it("a1"){}, nil, ::Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + @formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group_2)) + @formatter.example_failed(example_group_2.it("b2"){}, nil, ::Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + @formatter.example_failed(example_group_2.it("b3"){}, nil, ::Spec::Runner::Reporter::Failure.new("g", nil, RuntimeError.new)) + @io.string.should eql(<<-EOF +A a1 +A B b2 +A B b3 +EOF +) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html new file mode 100644 index 000000000..029cee62e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>examples/failing/mocking_example.rb:11: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>examples/failing/mocking_example.rb:20: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>examples/failing/mocking_example.rb:27: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>examples/failing/mocking_example.rb:31: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>examples/failing/diffing_spec.rb:13: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>examples/failing/diffing_spec.rb:34: +spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6.html new file mode 100644 index 000000000..1461d03e4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.6.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:11: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:20: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:27: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:31: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:13: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:34: +./spec/spec_helper.rb:44:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.7.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.7.html new file mode 100644 index 000000000..5e489bba5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.8.7.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:11: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:20: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:27: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:31: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:13: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:34: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.9.1.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.9.1.html new file mode 100644 index 000000000..5d0be3bfe --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatted-1.9.1.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:11:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:20:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:27:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:31:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:13:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:34:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatter_spec.rb new file mode 100644 index 000000000..bbff1ef42 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/html_formatter_spec.rb @@ -0,0 +1,118 @@ +# require 'spec_helper' + +begin # See rescue all the way at the bottom + +require 'nokogiri' # Needed to compare generated with wanted HTML +require 'spec/runner/formatter/html_formatter' + +module Spec + module Runner + module Formatter + describe HtmlFormatter do + + treats_method_missing_as_private + + attr_reader :root, :expected_file, :expected_html + + before do + @root = File.expand_path("#{File.dirname(__FILE__)}/../../../..") + suffix = jruby? ? '-jruby' : '' + @expected_file = "#{File.dirname(__FILE__)}/html_formatted-#{::RUBY_VERSION}#{suffix}.html" + raise "There is no HTML file with expected content for this platform: #{expected_file}" unless File.file?(expected_file) + @expected_html = File.read(expected_file) + end + + # Uncomment this line temporarily in order to overwrite the expected with actual. + # Use with care!!! + # describe "file generator" do + # it "generates a new comparison file" do + # Dir.chdir(root) do + # args = [ + # 'examples/failing/mocking_example.rb', + # 'examples/failing/diffing_spec.rb', + # 'examples/passing/stubbing_example.rb', + # 'examples/passing/pending_example.rb', + # '--format', + # 'html', + # "--diff" + # ] + # err = StringIO.new + # out = StringIO.new + # run_with ::Spec::Runner::OptionParser.parse(args, err, out) + # + # seconds = /\d+\.\d+ seconds/ + # html = out.string.gsub seconds, 'x seconds' + # + # File.open(expected_file, 'w') {|io| io.write(html)} + # end + # end + # end + + it "should produce HTML identical to the one we designed manually with --diff" do + Dir.chdir(root) do + args = [ + 'examples/failing/mocking_example.rb', + 'examples/failing/diffing_spec.rb', + 'examples/passing/stubbing_example.rb', + 'examples/passing/pending_example.rb', + '--format', + 'html', + "--diff" + ] + err = StringIO.new + out = StringIO.new + run_with ::Spec::Runner::OptionParser.parse(args, err, out) + + seconds = /\d+\.\d+ seconds/ + html = out.string.gsub seconds, 'x seconds' + expected_html.gsub! seconds, 'x seconds' + + doc = Nokogiri::HTML(html) + backtraces = doc.search("div.backtrace").collect {|e| e.at("pre").inner_html} + doc.css("div.backtrace").remove + + expected_doc = Nokogiri::HTML(expected_html) + expected_backtraces = expected_doc.search("div.backtrace").collect {|e| e.at("pre").inner_html} + expected_doc.search("div.backtrace").remove + + doc.inner_html.should == expected_doc.inner_html + + expected_backtraces.each_with_index do |expected_line, i| + expected_path, expected_line_number, expected_suffix = expected_line.split(':') + actual_path, actual_line_number, actual_suffix = backtraces[i].split(':') + File.expand_path(actual_path).should == File.expand_path(expected_path) + actual_line_number.should == expected_line_number + end + end + end + + it "should produce HTML identical to the one we designed manually with --dry-run" do + Dir.chdir(root) do + args = [ + 'examples/failing/mocking_example.rb', + 'examples/failing/diffing_spec.rb', + 'examples/passing/stubbing_example.rb', + 'examples/passing/pending_example.rb', + '--format', + 'html', + "--dry-run" + ] + err = StringIO.new + out = StringIO.new + run_with ::Spec::Runner::OptionParser.parse(args, err, out) + + seconds = /\d+\.\d+ seconds/ + html = out.string.gsub seconds, 'x seconds' + expected_html.gsub! seconds, 'x seconds' + + html.should =~ /This was a dry-run/m + end + end + end + end + end +end + +rescue LoadError + warn "nokogiri not loaded -- skipping HtmlFormatter specs" +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/nested_text_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/nested_text_formatter_spec.rb new file mode 100644 index 000000000..e64d3f615 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/nested_text_formatter_spec.rb @@ -0,0 +1,329 @@ +require 'spec_helper' +require 'spec/runner/formatter/nested_text_formatter' + +module Spec + module Runner + module Formatter + describe NestedTextFormatter do + with_sandboxed_options do + attr_reader :io, :options, :formatter, :example_group + before(:each) do + @io = StringIO.new + @formatter = NestedTextFormatter.new(options, io) + @example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("ExampleGroup") + @example_group.example("example") {} + end + + describe "where ExampleGroup has no superclass with a description" do + def example_group_started + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + end + + before(:each) do + example_group_started + end + + describe "#dump_summary" do + it "produces standard summary without pending when pending has a 0 count" do + formatter.dump_summary(3, 2, 1, 0) + io.string.should == <<-OUT +ExampleGroup + +Finished in 3 seconds + +2 examples, 1 failure +OUT + end + + it "produces standard summary" do + formatter.dump_summary(3, 2, 1, 4) + io.string.should == <<-OUT +ExampleGroup + +Finished in 3 seconds + +2 examples, 1 failure, 4 pending +OUT + end + end + + describe "#example_group_started" do + + describe "when ExampleGroup has a nested description" do + + describe "when ExampleGroup has no parents with nested description" do + it "pushes ExampleGroup name" do + io.string.should eql("ExampleGroup\n") + end + end + + describe "when ExampleGroup has one parent with nested description" do + attr_reader :child_example_group + def example_group_started + @child_example_group = Class.new(example_group).describe("Child ExampleGroup") + end + + describe "and parent ExampleGroups have not been printed" do + before do + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + end + + it "pushes ExampleGroup name with two spaces of indentation" do + io.string.should == <<-OUT +ExampleGroup + Child ExampleGroup +OUT + end + end + + describe "and parent ExampleGroups have been printed" do + before do + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + io.string = "" + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + end + + it "should print only the indented ExampleGroup" do + io.string.should == <<-OUT + Child ExampleGroup +OUT + end + end + end + + describe "when ExampleGroup has two parents with nested description" do + attr_reader :child_example_group, :grand_child_example_group + def example_group_started + @child_example_group = Class.new(example_group).describe("Child ExampleGroup") + @grand_child_example_group = Class.new(child_example_group).describe("GrandChild ExampleGroup") + end + + describe "and parent ExampleGroups have not been printed" do + before do + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group)) + end + + it "prints the entire nested ExampleGroup heirarchy" do + io.string.should == <<-OUT +ExampleGroup + Child ExampleGroup + GrandChild ExampleGroup +OUT + end + end + + describe "and parent ExampleGroups have been printed" do + before do + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + io.string = "" + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group)) + end + + it "should print only the indented ExampleGroup" do + io.string.should == <<-OUT + GrandChild ExampleGroup +OUT + end + end + end + end + + describe "when ExampleGroup nested description is blank" do + attr_reader :child_example_group + + describe "and parent ExampleGroups have not been printed" do + def example_group_started + @child_example_group = Class.new(example_group) + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + end + + it "should render only the parent ExampleGroup" do + io.string.should == <<-OUT +ExampleGroup +OUT + end + end + + describe "and parent ExampleGroups have been printed" do + def example_group_started + @child_example_group = Class.new(example_group) + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + io.string = "" + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + end + + it "should not render anything" do + io.string.should == "" + end + end + end + + describe "when ExampleGroup nested description is blank" do + def example_group_started + example_group.set_description + super + end + + it "should not render anything" do + io.string.should == "" + end + end + + describe "with parallel groups" do + def make_group(name, parent=::Spec::Example::ExampleGroupDouble) + Class.new(parent).describe(name) + end + + it "excludes duplicated group" do + parent_1 = make_group("ExampleGroup") + child_1 = make_group("Child ExampleGroup", parent_1) + grandchild_1 = make_group("GrandChild ExampleGroup", child_1) + + parent_2 = make_group("ExampleGroup") + child_2 = make_group("Child ExampleGroup 2", parent_2) + grandchild_2 = make_group("GrandChild ExampleGroup", child_2) + + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grandchild_1)) + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grandchild_2)) + io.string.should == <<-OUTPUT +ExampleGroup + Child ExampleGroup + GrandChild ExampleGroup + Child ExampleGroup 2 + GrandChild ExampleGroup +OUTPUT + end + end + end + + describe "#example_failed" do + describe "where ExampleGroup has no superclasss with a description" do + describe "when having an error" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + ::Spec::Runner::Reporter::Failure.new("g", "c s", RuntimeError.new) + ) + io.string.should == <<-OUT +ExampleGroup + spec (FAILED - 98) +OUT + end + end + + describe "when having an expectation failure" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + ::Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Expectations::ExpectationNotMetError.new) + ) + io.string.should == <<-OUT +ExampleGroup + spec (FAILED - 98) +OUT + end + end + end + + describe "where ExampleGroup has two superclasses with a description" do + attr_reader :child_example_group, :grand_child_example_group + + def example_group_started + @child_example_group = Class.new(example_group).describe("Child ExampleGroup") + @grand_child_example_group = Class.new(child_example_group).describe("GrandChild ExampleGroup") + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group)) + end + + describe "when having an error" do + it "should push failing spec name and failure number" do + formatter.example_failed( + grand_child_example_group.it("spec"), + 98, + ::Spec::Runner::Reporter::Failure.new("g", "c s", RuntimeError.new) + ) + io.string.should == <<-OUT +ExampleGroup + Child ExampleGroup + GrandChild ExampleGroup + spec (FAILED - 98) +OUT + end + end + + describe "when having an expectation" do + it "should push failing spec name and failure number" do + formatter.example_failed( + grand_child_example_group.it("spec"), + 98, + ::Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Expectations::ExpectationNotMetError.new) + ) + io.string.should == <<-OUT +ExampleGroup + Child ExampleGroup + GrandChild ExampleGroup + spec (FAILED - 98) +OUT + end + end + end + end + + describe "#start" do + it "should push nothing on start" do + formatter.start(5) + io.string.should == <<-OUT +ExampleGroup +OUT + end + end + + describe "#start_dump" do + it "should push nothing on start dump" do + formatter.start_dump + io.string.should == <<-OUT +ExampleGroup +OUT + end + end + + describe "#example_passed" do + it "should push passing spec name" do + formatter.example_passed(example_group.it("spec")) + io.string.should == <<-OUT +ExampleGroup + spec +OUT + end + end + + describe "#example_pending" do + it "should push pending example name and message" do + formatter.example_pending(example_group.examples.first, 'reason', "#{__FILE__}:#{__LINE__}") + io.string.should == <<-OUT +ExampleGroup + example (PENDING: reason) +OUT + end + + it "should dump pending" do + formatter.example_pending(example_group.examples.first, 'reason', "#{__FILE__}:#{__LINE__}") + io.rewind + formatter.dump_pending + io.string.should =~ /Pending\:\n\nExampleGroup example \(reason\)\n/ + end + end + + def have_single_level_example_group_output(expected_output) + expected = "ExampleGroup\n #{expected_output}" + ::Spec::Matchers::SimpleMatcher.new(expected) do |actual| + actual == expected + end + end + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/profile_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/profile_formatter_spec.rb new file mode 100644 index 000000000..338df7089 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/profile_formatter_spec.rb @@ -0,0 +1,70 @@ +require 'spec_helper' +require 'spec/runner/formatter/profile_formatter' + +module Spec + module Runner + module Formatter + describe ProfileFormatter do + + treats_method_missing_as_private + + attr_reader :io, :formatter + before(:each) do + @io = StringIO.new + options = mock('options') + options.stub!(:colour).and_return(true) + options.stub!(:autospec).and_return(true) + @formatter = ProfileFormatter.new(options, io) + end + + it "should print a heading" do + formatter.start(0) + io.string.should eql("Profiling enabled.\n") + end + + it "should record the current time when starting a new example" do + now = Time.now + Time.stub!(:now).and_return(now) + formatter.example_started('should foo') + formatter.instance_variable_get("@time").should == now + end + + it "should correctly record a passed example" do + now = Time.now + Time.stub!(:now).and_return(now) + parent_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe('Parent') + child_example_group = Class.new(parent_example_group).describe('Child') + + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group)) + + formatter.example_started('when foo') + Time.stub!(:now).and_return(now+1) + formatter.example_passed(stub('foo', :description => 'i like ice cream')) + + formatter.start_dump + io.string.should include('Parent Child') + end + + it "should sort the results in descending order" do + formatter.instance_variable_set("@example_times", [['a', 'a', 0.1], ['b', 'b', 0.3], ['c', 'c', 0.2]]) + formatter.start_dump + formatter.instance_variable_get("@example_times").should == [ ['b', 'b', 0.3], ['c', 'c', 0.2], ['a', 'a', 0.1]] + end + + it "should print the top 10 results" do + example_group = Class.new(::Spec::Example::ExampleGroup).describe("ExampleGroup") + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + formatter.instance_variable_set("@time", Time.now) + + 15.times do + formatter.example_passed(stub('foo', :description => 'i like ice cream')) + end + + io.should_receive(:print).exactly(10) + formatter.start_dump + end + + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/progress_bar_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/progress_bar_formatter_spec.rb new file mode 100644 index 000000000..ea96ca6c4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/progress_bar_formatter_spec.rb @@ -0,0 +1,149 @@ +require 'spec_helper' +require 'spec/runner/formatter/progress_bar_formatter' + +module Spec + module Runner + module Formatter + describe ProgressBarFormatter do + + treats_method_missing_as_private + + before(:each) do + @io = StringIO.new + @options = mock('options') + @options.stub!(:dry_run).and_return(false) + @options.stub!(:colour).and_return(false) + @options.stub!(:autospec).and_return(false) + @formatter = ProgressBarFormatter.new(@options, @io) + end + + it "should produce line break on start dump" do + @formatter.start_dump + @io.string.should eql("\n") + end + + it "should produce standard summary without pending when pending has a 0 count" do + @formatter.dump_summary(3, 2, 1, 0) + @io.string.should eql("\nFinished in 3 seconds\n\n2 examples, 1 failure\n") + end + + it "should produce standard summary" do + example_group = ExampleGroup.describe("example_group") do + specify "example" do + end + end + example = example_group.examples.first + @formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + @formatter.example_pending(example, "message", "#{__FILE__}:#{__LINE__}") + @io.rewind + @formatter.dump_summary(3, 2, 1, 1) + @io.string.should eql(%Q| +Finished in 3 seconds + +2 examples, 1 failure, 1 pending +|) + end + + it "should push green dot for passing spec" do + @formatter.stub(:output_to_file?) {false} + @io.stub(:tty?) {true} + @options.stub(:colour) {true} + @formatter.example_passed("spec") + @io.string.should == "\e[32m.\e[0m" + end + + it "should push red F for failure spec" do + @formatter.stub(:output_to_file?) {false} + @io.stub(:tty?) {true} + @options.stub(:colour) {true} + @formatter.example_failed("spec", 98, Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Expectations::ExpectationNotMetError.new)) + @io.string.should eql("\e[31mF\e[0m") + end + + it "should push red F for error spec" do + @formatter.stub(:output_to_file?) {false} + @io.stub(:tty?) {true} + @options.stub(:colour) {true} + @formatter.example_failed("spec", 98, Spec::Runner::Reporter::Failure.new("g", "c s", RuntimeError.new)) + @io.string.should eql("\e[31mF\e[0m") + end + + it "should push blue F for fixed pending spec" do + @formatter.stub(:output_to_file?) {false} + @io.stub(:tty?) {true} + @options.stub(:colour) {true} + @formatter.example_failed("spec", 98, Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Example::PendingExampleFixedError.new)) + @io.string.should eql("\e[34mF\e[0m") + end + + it "should push nothing on start" do + @formatter.start(4) + @io.string.should eql("") + end + + it "should ensure two ':' in the first backtrace" do + backtrace = ["/tmp/x.rb:1", "/tmp/x.rb:2", "/tmp/x.rb:3"] + @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip) +/tmp/x.rb:1: +/tmp/x.rb:2: +/tmp/x.rb:3: +EOE + + backtrace = ["/tmp/x.rb:1: message", "/tmp/x.rb:2", "/tmp/x.rb:3"] + @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip) +/tmp/x.rb:1: message +/tmp/x.rb:2: +/tmp/x.rb:3: +EOE + end + + it "should dump pending with file and line number" do + example_group = ExampleGroup.describe("example_group") do + specify "example" do + end + end + example = example_group.examples.first + file = __FILE__ + line = __LINE__ - 5 + @formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + @formatter.example_pending(example, "message", "#{__FILE__}:#{__LINE__}") + @formatter.dump_pending + @io.string.should =~ /Pending:\n\nexample_group example \(message\)\n#{file}:#{line}/m + end + end + + describe "ProgressBarFormatter outputting to custom out" do + before(:each) do + @out = mock("out") + @options = mock('options') + @out.stub!(:puts) + @formatter = ProgressBarFormatter.new(@options, @out) + @formatter.class.__send__ :public, :output_to_tty? + end + + after(:each) do + @formatter.class.__send__ :protected, :output_to_tty? + end + + it "should not throw NoMethodError on output_to_tty?" do + @out.should_receive(:tty?).and_raise(NoMethodError) + @formatter.output_to_tty?.should be_false + end + end + + describe ProgressBarFormatter, "dry run" do + before(:each) do + @io = StringIO.new + options = mock('options') + options.stub!(:dry_run).and_return(true) + @formatter = ProgressBarFormatter.new(options, @io) + end + + it "should not produce summary on dry run" do + @formatter.dump_summary(3, 2, 1, 0) + @io.string.should eql("") + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/snippet_extractor_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/snippet_extractor_spec.rb new file mode 100644 index 000000000..c683c39a8 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/snippet_extractor_spec.rb @@ -0,0 +1,18 @@ +require 'spec_helper' +require 'spec/runner/formatter/snippet_extractor' + +module Spec + module Runner + module Formatter + describe SnippetExtractor do + it "should fall back on a default message when it doesn't understand a line" do + SnippetExtractor.new.snippet_for("blech").should == ["# Couldn't get snippet for blech", 1] + end + + it "should fall back on a default message when it doesn't find the file" do + SnippetExtractor.new.lines_around("blech", 8).should == "# Couldn't get snippet for blech" + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/specdoc_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/specdoc_formatter_spec.rb new file mode 100644 index 000000000..ac4e0eeea --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/specdoc_formatter_spec.rb @@ -0,0 +1,159 @@ +require 'spec_helper' +require 'spec/runner/formatter/specdoc_formatter' + +module Spec + module Runner + module Formatter + describe SpecdocFormatter do + with_sandboxed_options do + attr_reader :io, :formatter, :example_group + before(:each) do + @io = StringIO.new + options.stub!(:dry_run).and_return(false) + options.stub!(:colour).and_return(false) + @formatter = SpecdocFormatter.new(options, io) + @example_group = ::Spec::Example::ExampleGroup.describe("ExampleGroup") do + specify "example" do + end + end + end + + describe "where ExampleGroup has no superclasss with a description" do + before do + example_group_started + end + + def example_group_started + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group)) + end + + describe "#dump_summary" do + it "should produce standard summary without pending when pending has a 0 count" do + formatter.dump_summary(3, 2, 1, 0) + io.string.should have_example_group_output("\nFinished in 3 seconds\n\n2 examples, 1 failure\n") + end + + it "should produce standard summary" do + formatter.dump_summary(3, 2, 1, 4) + io.string.should have_example_group_output("\nFinished in 3 seconds\n\n2 examples, 1 failure, 4 pending\n") + end + end + + describe "#example_group_started" do + it "should push ExampleGroup name" do + io.string.should eql("\nExampleGroup\n") + end + end + + describe "#example_failed" do + describe "where ExampleGroup has no superclasss with a description" do + describe "when having an error" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + Spec::Runner::Reporter::Failure.new("g", "c s", RuntimeError.new) + ) + io.string.should have_example_group_output("- spec (FAILED - 98)\n") + end + end + + describe "when having an expectation failure" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Expectations::ExpectationNotMetError.new) + ) + io.string.should have_example_group_output("- spec (FAILED - 98)\n") + end + end + end + + describe "where ExampleGroup has two superclasses with a description" do + attr_reader :child_example_group, :grand_child_example_group + + def example_group_started + @child_example_group = Class.new(example_group).describe("Child ExampleGroup") + @grand_child_example_group = Class.new(child_example_group).describe("GrandChild ExampleGroup") + formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group)) + end + + describe "when having an error" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + Spec::Runner::Reporter::Failure.new("g", "c s", RuntimeError.new) + ) + io.string.should have_nested_example_group_output("- spec (FAILED - 98)\n") + end + end + + describe "when having an expectation" do + it "should push failing spec name and failure number" do + formatter.example_failed( + example_group.it("spec"), + 98, + Spec::Runner::Reporter::Failure.new("g", "c s", Spec::Expectations::ExpectationNotMetError.new) + ) + io.string.should have_nested_example_group_output("- spec (FAILED - 98)\n") + end + end + + def have_nested_example_group_output(expected_output) + expected_full_output = "\nExampleGroup Child ExampleGroup GrandChild ExampleGroup\n#{expected_output}" + ::Spec::Matchers::SimpleMatcher.new(expected_full_output) do |actual| + actual == expected_full_output + end + end + end + end + + describe "#start" do + it "should push nothing on start" do + formatter.start(5) + io.string.should have_example_group_output("") + end + end + + describe "#start_dump" do + it "should push nothing on start dump" do + formatter.start_dump + io.string.should have_example_group_output("") + end + end + + describe "#example_passed" do + it "should push passing spec name" do + formatter.example_passed(example_group.it("spec")) + io.string.should have_example_group_output("- spec\n") + end + end + + describe "#example_pending" do + it "should push pending example name and message" do + formatter.example_pending(example_group.examples.first, 'reason', "#{__FILE__}:#{__LINE__}") + io.string.should have_example_group_output("- example (PENDING: reason)\n") + end + + it "should dump pending" do + formatter.example_pending(example_group.examples.first, 'reason', "#{__FILE__}:#{__LINE__}") + io.rewind + formatter.dump_pending + io.string.should =~ /Pending\:\n\nExampleGroup example \(reason\)\n/ + end + end + + def have_example_group_output(expected_output) + expected = "\nExampleGroup\n#{expected_output}" + ::Spec::Matchers::SimpleMatcher.new(expected) do |actual| + actual == expected + end + end + end + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html new file mode 100644 index 000000000..bbef5eb8b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">examples/failing/mocking_example.rb:11</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">examples/failing/mocking_example.rb:20</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">examples/failing/mocking_example.rb:27</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">examples/failing/mocking_example.rb:31</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">examples/failing/diffing_spec.rb:13</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">examples/failing/diffing_spec.rb:34</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6.html new file mode 100644 index 000000000..54d761901 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.6.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">./examples/failing/mocking_example.rb:11</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">./examples/failing/mocking_example.rb:20</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">./examples/failing/mocking_example.rb:27</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">./examples/failing/mocking_example.rb:31</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">./examples/failing/diffing_spec.rb:13</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">./examples/failing/diffing_spec.rb:34</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html new file mode 100644 index 000000000..54d761901 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">./examples/failing/mocking_example.rb:11</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">./examples/failing/mocking_example.rb:20</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">./examples/failing/mocking_example.rb:27</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">./examples/failing/mocking_example.rb:31</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">./examples/failing/diffing_spec.rb:13</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">./examples/failing/diffing_spec.rb:34</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html new file mode 100644 index 000000000..24c98046b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">./examples/failing/mocking_example.rb:11</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">./examples/failing/mocking_example.rb:20</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">./examples/failing/mocking_example.rb:27</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">./examples/failing/mocking_example.rb:31</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">./examples/failing/diffing_spec.rb:13</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">./examples/failing/diffing_spec.rb:34</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatter_spec.rb new file mode 100644 index 000000000..a35ad89f5 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/formatter/text_mate_formatter_spec.rb @@ -0,0 +1,106 @@ +require 'spec_helper' + +begin # See rescue all the way at the bottom + +require 'nokogiri' # Needed to compare generated with wanted HTML +require 'spec/runner/formatter/text_mate_formatter' + +module Spec + module Runner + module Formatter + describe TextMateFormatter do + attr_reader :root, :suffix, :expected_file + before do + @root = File.expand_path(File.dirname(__FILE__) + '/../../../..') + @suffix = jruby? ? '-jruby' : '' + @expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::RUBY_VERSION}#{suffix}.html" + end + + def produces_html_identical_to_manually_designed_document(opt) + root = File.expand_path(File.dirname(__FILE__) + '/../../../..') + + Dir.chdir(root) do + args = [ + 'examples/failing/mocking_example.rb', + 'examples/failing/diffing_spec.rb', + 'examples/passing/stubbing_example.rb', + 'examples/passing/pending_example.rb', + '--format', + 'textmate', + opt + ] + err = StringIO.new + out = StringIO.new + + run_with ::Spec::Runner::OptionParser.parse(args, err, out) + + yield(out.string) + end + end + + # Uncomment this spec temporarily in order to overwrite the expected with actual. + # Use with care!!! + # describe "functional spec file generator" do + # it "generates a new comparison file" do + # Dir.chdir(root) do + # args = ['examples/failing/mocking_example.rb', 'examples/failing/diffing_spec.rb', 'examples/passing/stubbing_example.rb', 'examples/passing/pending_example.rb', '--format', 'textmate', '--diff'] + # err = StringIO.new + # out = StringIO.new + # Spec::Runner::CommandLine.run( + # ::Spec::Runner::OptionParser.parse(args, err, out) + # ) + # + # seconds = /\d+\.\d+ seconds/ + # html = out.string.gsub seconds, 'x seconds' + # + # File.open(expected_file, 'w') {|io| io.write(html)} + # end + # end + # end + + describe "functional spec using --diff" do + it "should produce HTML identical to the one we designed manually with --diff" do + produces_html_identical_to_manually_designed_document("--diff") do |html| + suffix = jruby? ? '-jruby' : '' + expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::RUBY_VERSION}#{suffix}.html" + unless File.file?(expected_file) + raise "There is no HTML file with expected content for this platform: #{expected_file}" + end + expected_html = File.read(expected_file) + + seconds = /\d+\.\d+ seconds/ + html.gsub! seconds, 'x seconds' + expected_html.gsub! seconds, 'x seconds' + + doc = Nokogiri::HTML(html) + backtraces = doc.search("div.backtrace a") + doc.search("div.backtrace").remove + + expected_doc = Nokogiri::HTML(expected_html) + expected_doc.search("div.backtrace").remove + + doc.inner_html.should == expected_doc.inner_html + + backtraces.each do |backtrace_link| + backtrace_link['href'].should include("txmt://open?url=") + end + end + end + + end + + describe "functional spec using --dry-run" do + it "should produce HTML identical to the one we designed manually with --dry-run" do + produces_html_identical_to_manually_designed_document("--dry-run") do |html, expected_html| + html.should =~ /This was a dry-run/m + end + end + end + end + end + end +end + +rescue LoadError + warn "nokogiri not loaded -- skipping TextMateFormatter specs" +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/heckle_runner_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/heckle_runner_spec.rb new file mode 100644 index 000000000..287ff856a --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/heckle_runner_spec.rb @@ -0,0 +1,78 @@ +require 'spec_helper' +unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} || Spec::Ruby.version.to_f == 1.9 + require 'spec/runner/heckle_runner' + + module Foo + class Bar + def one; end + def two; end + end + + class Zap + def three; end + def four; end + end + end + + describe "HeckleRunner" do + before(:each) do + @heckle = mock("heckle", :null_object => true) + @heckle_class = mock("heckle_class") + end + + it "should heckle all methods in all classes in a module" do + @heckle_class.should_receive(:new).with("Foo::Bar", "one", Spec::Runner.options).and_return(@heckle) + @heckle_class.should_receive(:new).with("Foo::Bar", "two", Spec::Runner.options).and_return(@heckle) + @heckle_class.should_receive(:new).with("Foo::Zap", "three", Spec::Runner.options).and_return(@heckle) + @heckle_class.should_receive(:new).with("Foo::Zap", "four", Spec::Runner.options).and_return(@heckle) + + heckle_runner = Spec::Runner::HeckleRunner.new("Foo", @heckle_class) + heckle_runner.heckle_with + end + + it "should heckle all methods in a class" do + @heckle_class.should_receive(:new).with("Foo::Bar", "one", Spec::Runner.options).and_return(@heckle) + @heckle_class.should_receive(:new).with("Foo::Bar", "two", Spec::Runner.options).and_return(@heckle) + + heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar", @heckle_class) + heckle_runner.heckle_with + end + + it "should fail heckling when the class is not found" do + lambda do + heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bob", @heckle_class) + heckle_runner.heckle_with + end.should raise_error(StandardError, "Heckling failed - \"Foo::Bob\" is not a known class or module") + end + + it "should heckle specific method in a class (with #)" do + @heckle_class.should_receive(:new).with("Foo::Bar", "two", Spec::Runner.options).and_return(@heckle) + + heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar#two", @heckle_class) + heckle_runner.heckle_with + end + + it "should heckle specific method in a class (with .)" do + @heckle_class.should_receive(:new).with("Foo::Bar", "two", Spec::Runner.options).and_return(@heckle) + + heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar.two", @heckle_class) + heckle_runner.heckle_with + end + end + + describe "Heckler" do + it "should say yes to tests_pass? if specs pass" do + options = mock("options", :null_object => true) + options.should_receive(:run_examples).and_return(true) + heckler = Spec::Runner::Heckler.new("Foo", nil, options) + heckler.tests_pass?.should be_true + end + + it "should say no to tests_pass? if specs fail" do + options = mock("options", :null_object => true) + options.should_receive(:run_examples).and_return(false) + heckler = Spec::Runner::Heckler.new("Foo", nil, options) + heckler.tests_pass?.should be_false + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/heckler_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/heckler_spec.rb new file mode 100644 index 000000000..00869df6e --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/heckler_spec.rb @@ -0,0 +1,20 @@ +if Spec::Ruby.version.to_f < 1.9 + require 'spec_helper' + unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} + require 'spec/runner/heckle_runner' + + describe "Heckler" do + it "should run examples on tests_pass?" do + sub = Class.new(Spec::Runner::Heckler) do + def initialize(klass_name, method_name, rspec_options) + @rspec_options = rspec_options + end + end + opts = mock('options') + opts.should_receive(:run_examples).and_return(true) + heckler = sub.new('klass','method',opts) + heckler.tests_pass? + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query/line_number_query_fixture.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query/line_number_query_fixture.rb new file mode 100644 index 000000000..82a257d3b --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query/line_number_query_fixture.rb @@ -0,0 +1,70 @@ +require 'spec_helper' + +describe "c" do + + it "1" do + end + + it "2" do + end + +end + +describe "d" do + + it "3" do + end + + it "4" do + end + +end + +class LineNumberQuerySubject +end + +describe LineNumberQuerySubject do + + it "5" do + end + +end + +describe LineNumberQuerySubject, "described" do + + it "6" do + end + +end + +describe LineNumberQuerySubject, "described", :something => :something_else do + + it "7" do + end + +end + +describe "described", :something => :something_else do + + it "8" do + end + +end + +describe "e" do + + it "9" do + end + + it "10" do + end + + describe "f" do + it "11" do + end + + it "12" do + end + end + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query_spec.rb new file mode 100644 index 000000000..e4e11050d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/line_number_query_spec.rb @@ -0,0 +1,129 @@ +require 'spec_helper' + +describe "LineNumberQuery" do + with_sandboxed_options do + attr_reader :parser, :file + + before do + @parser = Spec::Runner::LineNumberQuery.new(options) + @file = "#{File.dirname(__FILE__)}/line_number_query/line_number_query_fixture.rb" + load file + end + + it "should find spec name for 'specify' at same line" do + parser.spec_name_for(file, 5).should == "c 1" + end + + it "should find spec name for 'specify' at end of spec line" do + parser.spec_name_for(file, 6).should == "c 1" + end + + it "should find context for 'context' above all specs" do + parser.spec_name_for(file, 4).should == "c" + end + + it "should find spec name for 'it' at same line" do + parser.spec_name_for(file, 15).should == "d 3" + end + + it "should find spec name for 'it' at end of spec line" do + parser.spec_name_for(file, 16).should == "d 3" + end + + it "should find context for 'describe' above all specs" do + parser.spec_name_for(file, 14).should == "d" + end + + it "should find nearest example name between examples" do + parser.spec_name_for(file, 7).should == "c 1" + end + + it "should find nothing outside a context" do + parser.spec_name_for(file, 2).should be_nil + end + + it "should find context name for type" do + parser.spec_name_for(file, 26).should == "LineNumberQuerySubject" + end + + it "should find context and spec name for type" do + parser.spec_name_for(file, 28).should == "LineNumberQuerySubject 5" + end + + it "should find context and description for type" do + parser.spec_name_for(file, 33).should == "LineNumberQuerySubject described" + end + + it "should find context and description and example for type" do + parser.spec_name_for(file, 36).should == "LineNumberQuerySubject described 6" + end + + it "should find context and description for type with modifications" do + parser.spec_name_for(file, 40).should == "LineNumberQuerySubject described" + end + + it "should find context and described and example for type with modifications" do + parser.spec_name_for(file, 43).should == "LineNumberQuerySubject described 7" + end + + it "should find example group" do + parser.spec_name_for(file, 47).should == "described" + end + + it "should find example" do + parser.spec_name_for(file, 50).should == "described 8" + end + + it "should find nested example" do + parser.spec_name_for(file, 63).should == "e f 11" + end + + it "should handle paths which contain colons" do + fixture = + { "c:/somepath/somefile.rb:999:in 'method'" => "c:/somepath/somefile.rb", + "./somepath/somefile:999" => "./somepath/somefile" } + fixture.each_pair do |input, expected| + parser.send(:parse_location, input ).should == [expected, 999] + end + end + + it "should handle paths which contain colons and backslashes" do + fixture = + { "c:\\somepath\\somefile.rb:999:in 'method'" => "c:\\somepath\\somefile.rb", + ".\\somepath\\somefile:999" => ".\\somepath\\somefile" } + fixture.each_pair do |input, expected| + parser.send(:parse_location, input ).should == [expected, 999] + end + end + + it "ignores example group base classes which have no location" do + options = stub('options', :example_groups => [ + stub('example_group', :location => nil) + ]) + parser = Spec::Runner::LineNumberQuery.new(options) + parser.spec_name_for('foo',37).should == nil + end + + describe "#example_line_for" do + it "should find example declared on same line" do + parser.example_line_for(file, 5).should == 5 + end + + it "should find example declared on the line above, while still inside the example" do + parser.example_line_for(file, 6).should == 5 + end + + it "should find example declared from empty line below the example" do + parser.example_line_for(file, 7).should == 5 + end + + it "should find the group declared on the same line" do + parser.example_line_for(file, 3).should == 3 + end + + it "should find the group declared above the first example" do + parser.example_line_for(file, 4).should == 3 + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/noisy_backtrace_tweaker_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/noisy_backtrace_tweaker_spec.rb new file mode 100644 index 000000000..13b79432c --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/noisy_backtrace_tweaker_spec.rb @@ -0,0 +1,51 @@ +require 'spec_helper' + +module Spec + module Runner + describe NoisyBacktraceTweaker do + before(:each) do + @error = RuntimeError.new + @tweaker = NoisyBacktraceTweaker.new + end + + it "gracefully handles nil backtrace" do + lambda do + @tweaker.tweak_backtrace(@error) + end.should_not raise_error + end + + it "cleans up double slashes" do + @error.set_backtrace(["/a//b/c//d.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should include("/a/b/c/d.rb") + end + + it "preserves lines in lib/spec" do + ["expectations", "mocks", "runner", "stubs"].each do |child| + @error.set_backtrace(["/lib/spec/#{child}/anything.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should_not be_empty + end + end + + it "preserves lines in spec/" do + @error.set_backtrace(["/lib/spec/expectations/anything.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should_not be_empty + end + + it "preserves lines in bin/spec" do + @error.set_backtrace(["bin/spec:"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should_not be_empty + end + + it "ignores custom patterns" do + @tweaker.ignore_patterns(/custom_pattern/) + @error.set_backtrace(["custom_pattern"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should_not be_empty + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/option_parser_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/option_parser_spec.rb new file mode 100644 index 000000000..3b31f35c1 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/option_parser_spec.rb @@ -0,0 +1,551 @@ +require 'spec_helper' +require 'spec/runner/resources/custom_example_group_runner' +require 'fakefs/spec_helpers' + +describe "OptionParser" do + before(:each) do + @out = StringIO.new + @err = StringIO.new + @parser = Spec::Runner::OptionParser.new(@err, @out) + end + + def parse(args) + @parser.parse(args) + @parser.options + end + + describe "with fakefs" do + include FakeFS::SpecHelpers + + it "should not use colour by default" do + options = parse([]) + options.colour.should == false + end + + it "should use progress bar formatter by default" do + options = parse([]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::ProgressBarFormatter) + end + end + + it "should leave the submitted argv alone" do + args = ["--pattern", "foo"] + @parser.order!(args) + args.should == ["--pattern", "foo"] + end + + it "should accept files to include" do + options = parse(["--pattern", "foo"]) + options.filename_pattern.should == "foo" + end + + it "should accept debugger option" do + options = parse(["--debugger"]) + options.debug.should be_true + end + + it "should accept -u form of debugger option" do + options = parse(["-u"]) + options.debug.should be_true + end + + it "should turn off the debugger option if drb is specified later" do + @parser.stub!(:parse_drb).with(no_args).and_return(true) + options = parse(["-u", "--drb"]) + options.debug.should be_false + end + + it "should turn off the debugger option if drb is specified first" do + @parser.stub!(:parse_drb).with(no_args).and_return(true) + options = parse(["--drb", "-u"]) + options.debug.should be_false + end + + it "should accept port option" do + options = parse(["--port", "9000"]) + options.drb_port.should == 9000 + end + + it 'should require argument to port option' do + lambda { parse(["--port"]) }.should raise_error(OptionParser::MissingArgument) + end + + it "should accept dry run option" do + options = parse(["--dry-run"]) + options.dry_run.should be_true + end + + it "should eval and use custom formatter when none of the builtins" do + options = parse(["--format", "Custom::Formatter"]) + options.formatters[0].class.should be(Custom::Formatter) + end + + it "should support formatters with relative and absolute paths, even on windows" do + options = parse([ + "--format", "Custom::Formatter:C:\\foo\\bar", + "--format", "Custom::Formatter:foo/bar", + "--format", "Custom::Formatter:foo\\bar", + "--format", "Custom::Formatter:/foo/bar" + ]) + options.formatters[0].where.should eql("C:\\foo\\bar") + options.formatters[1].where.should eql("foo/bar") + options.formatters[2].where.should eql("foo\\bar") + options.formatters[3].where.should eql("/foo/bar") + end + + it "should not be verbose by default" do + options = parse([]) + options.verbose.should be_nil + end + + it "should print help to stdout if no args and spec_comand?" do + Spec::Runner::OptionParser.stub!(:spec_command?).and_return(true) + options = parse([]) + @out.rewind + @out.read.should match(/Usage: spec \(FILE\(:LINE\)\?\|DIRECTORY\|GLOB\)\+ \[options\]/m) + end + + it "should not print help to stdout if no args and NOT spec_command?" do + Spec::Runner::OptionParser.stub!(:spec_command?).and_return(false) + options = parse([]) + @out.rewind + @out.read.should == "" + end + + it "should print help to stdout" do + options = parse(["--help"]) + @out.rewind + @out.read.should match(/Usage: spec \(FILE\(:LINE\)\?\|DIRECTORY\|GLOB\)\+ \[options\]/m) + end + + it "should print instructions about how to require missing formatter" do + lambda do + options = parse(["--format", "Custom::MissingFormatter"]) + options.formatters + end.should raise_error(NameError) + @err.string.should match(/Couldn't find formatter class Custom::MissingFormatter/n) + end + + it "should print version to stdout" do + options = parse(["--version"]) + @out.rewind + @out.read.should match(/rspec \d+\.\d+\.\d+/n) + end + + it "should require file when require specified" do + lambda do + parse(["--require", "whatever"]) + end.should raise_error(LoadError) + end + + it "should support c option" do + options = parse(["-c"]) + options.colour.should be_true + end + + it "should support queens colour option" do + options = parse(["--colour"]) + options.colour.should be_true + end + + it "should support us color option" do + options = parse(["--color"]) + options.colour.should be_true + end + + it "should support single example with -e option" do + options = parse(["-e", "something or other"]) + options.examples.should eql(["something or other"]) + end + + it "should support single example with -s option (will be removed when autotest supports -e)" do + options = parse(["-s", "something or other"]) + options.examples.should eql(["something or other"]) + end + + it "should support single example with --example option" do + options = parse(["--example", "something or other"]) + options.examples.should eql(["something or other"]) + end + + it "should read several example names from file if --example is given an existing file name" do + options = parse(["--example", File.dirname(__FILE__) + '/examples.txt']) + options.examples.should eql([ + "Sir, if you were my husband, I would poison your drink.", + "Madam, if you were my wife, I would drink it."]) + end + + it "should read no examples if given an empty file" do + options = parse(["--example", File.dirname(__FILE__) + '/empty_file.txt']) + options.examples.should eql([]) + end + + it "should use html formatter when format is h" do + options = parse(["--format", "h"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter) + end + + it "should use html formatter when format is html" do + options = parse(["--format", "html"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter) + end + + it "should use silent formatter when format is s" do + options = parse(["--format", "l"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::SilentFormatter) + end + + it "should use silent formatter when format is silent" do + options = parse(["--format", "silent"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::SilentFormatter) + end + + it "should use html formatter with explicit output when format is html:test.html" do + FileUtils.rm 'test.html' if File.exist?('test.html') + options = parse(["--format", "html:test.html"]) + options.formatters # creates the file + File.should exist('test.html') + options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter) + options.formatters[0].close + FileUtils.rm 'test.html' + end + + it "should use noisy backtrace tweaker with b option" do + options = parse(["-b"]) + options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker) + end + + it "should use noisy backtrace tweaker with backtrace option" do + options = parse(["--backtrace"]) + options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker) + end + + it "should use quiet backtrace tweaker by default" do + options = parse([]) + options.backtrace_tweaker.should be_instance_of(Spec::Runner::QuietBacktraceTweaker) + end + + it "should use specdoc formatter when format is s" do + options = parse(["--format", "s"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter) + end + + it "should use specdoc formatter when format is specdoc" do + options = parse(["--format", "specdoc"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter) + end + + it "should use nested text formatter when format is s" do + options = parse(["--format", "n"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::NestedTextFormatter) + end + + it "should use nested text formatter when format is nested" do + options = parse(["--format", "nested"]) + options.formatters[0].class.should equal(Spec::Runner::Formatter::NestedTextFormatter) + end + + it "should support diff option when format is not specified" do + options = parse(["--diff"]) + options.diff_format.should == :unified + end + + it "should use unified diff format option when format is unified" do + options = parse(["--diff", "unified"]) + options.diff_format.should == :unified + options.differ_class.should equal(Spec::Expectations::Differs::Default) + end + + it "should use context diff format option when format is context" do + options = parse(["--diff", "context"]) + options.diff_format.should == :context + options.differ_class.should == Spec::Expectations::Differs::Default + end + + it "should use custom diff format option when format is a custom format" do + Spec::Expectations.differ.should_not be_instance_of(Custom::Differ) + + options = parse(["--diff", "Custom::Differ"]) + options.parse_diff "Custom::Differ" + options.diff_format.should == :custom + options.differ_class.should == Custom::Differ + Spec::Expectations.differ.should be_instance_of(Custom::Differ) + end + + it "should print instructions about how to fix missing differ" do + lambda { parse(["--diff", "Custom::MissingFormatter"]) }.should raise_error(NameError) + @err.string.should match(/Couldn't find differ class Custom::MissingFormatter/n) + end + + describe "when attempting a focussed spec" do + attr_reader :file, :dir + before(:each) do + @original_rspec_options = Spec::Runner.options + @file = "#{File.dirname(__FILE__)}/line_number_query/line_number_query_fixture.rb" + @dir = File.dirname(file) + end + + after(:each) do + Spec::Runner.use @original_rspec_options + end + + def parse(args) + options = super + Spec::Runner.use options + options.filename_pattern = "*_fixture.rb" + options + end + + describe 'with the --line flag' do + it "should correctly identify the spec" do + options = parse([file, "--line", "13"]) + options.line_number.should == 13 + options.examples.should be_empty + options.run_examples + options.examples.should eql(["d"]) + end + + it "should fail with error message if specified file is a dir" do + options = parse([dir, "--line", "169"]) + options.line_number.should == 169 + options.run_examples + @err.string.should match(/You must specify one file, not a directory when providing a line number/n) + end + + + it "should fail with error message if file does not exist" do + options = parse(["some file", "--line", "169"]) + proc do + options.run_examples + end.should raise_error + end + + it "should fail with error message if more than one files are specified" do + options = parse([file, file, "--line", "169"]) + options.run_examples + @err.string.should match(/Only one file can be specified when providing a line number/n) + end + + it "should fail with error message if using simultaneously with --example" do + options = parse([file, "--example", "some example", "--line", "169"]) + options.run_examples + @err.string.should match(/You cannot use --example and specify a line number/n) + end + end + + describe 'with the colon syntax (filename:LINE_NUMBER)' do + + it "should strip the line number from the file name" do + options = parse(["#{file}:13"]) + options.files.should include(file) + end + + it "should correctly identify the spec" do + options = parse(["#{file}:13"]) + options.line_number.should == 13 + options.examples.should be_empty + options.run_examples + options.examples.should eql(["d"]) + end + + it "should fail with error message if specified file is a dir" do + options = parse(["#{dir}:169"]) + options.line_number.should == 169 + options.run_examples + @err.string.should match(/You must specify one file, not a directory when providing a line number/n) + end + + + it "should fail with error message if file does not exist" do + options = parse(["some file:169"]) + proc do + options.run_examples + end.should raise_error + end + + it "should fail with error message if more than one files are specified" do + options = parse([file, "#{file}:169"]) + options.run_examples + @err.string.should match(/Only one file can be specified when providing a line number/n) + end + + it "should fail with error message if using simultaneously with --example" do + options = parse(["#{file}:169", "--example", "some example"]) + options.run_examples + @err.string.should match(/You cannot use --example and specify a line number/n) + end + end + + end + + if [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} + it "should barf when --heckle is specified (and platform is windows)" do + lambda do + options = parse(["--heckle", "Spec"]) + end.should raise_error(StandardError, /Heckle is not supported/) + end + elsif Spec::Ruby.version.to_f == 1.9 + it "should barf when --heckle is specified (and platform is Ruby 1.9)" do + lambda do + options = parse(["--heckle", "Spec"]) + end.should raise_error(StandardError, /Heckle is not supported/) + end + else + it "should heckle when --heckle is specified (and platform is not windows)" do + options = parse(["--heckle", "Spec"]) + options.heckle_runner.should be_instance_of(Spec::Runner::HeckleRunner) + end + end + + it "should read options from file when --options is specified" do + options = parse(["--options", File.dirname(__FILE__) + "/spec.opts"]) + options.diff_format.should_not be_nil + options.colour.should be_true + end + + it "should default the formatter to ProgressBarFormatter when using options file" do + options = parse(["--options", File.dirname(__FILE__) + "/spec.opts"]) + options.formatters.first.should be_instance_of(::Spec::Runner::Formatter::ProgressBarFormatter) + end + + it "should run parse drb after parsing options" do + @parser.should_receive(:parse_drb).with(no_args).and_return(true) + options = parse(["--options", File.dirname(__FILE__) + "/spec_drb.opts"]) + end + + it "should send all the arguments other than --drb back to the parser after parsing options" do + Spec::Runner::DrbCommandLine.should_receive(:run).and_return do |options| + options.argv.should == ["example_file.rb", "--colour"] + end + options = parse(["example_file.rb", "--options", File.dirname(__FILE__) + "/spec_drb.opts"]) + end + + it "runs specs locally if no drb is running when --drb is specified" do + Spec::Runner::DrbCommandLine.should_receive(:run).and_return(false) + options = parse(["example_file.rb", "--options", File.dirname(__FILE__) + "/spec_drb.opts"]) + options.__send__(:examples_should_be_run?).should be_true + end + + it "says its running specs locally if no drb is running when --drb is specified" do + Spec::Runner::DrbCommandLine.should_receive(:run).and_return(false) + options = parse(["example_file.rb", "--options", File.dirname(__FILE__) + "/spec_drb.opts"]) + options.error_stream.rewind + options.error_stream.string.should =~ /Running specs locally/ + end + + it "does not run specs locally if drb is running when --drb is specified" do + Spec::Runner::DrbCommandLine.should_receive(:run).and_return(true) + options = parse(["example_file.rb", "--options", File.dirname(__FILE__) + "/spec_drb.opts"]) + options.__send__(:examples_should_be_run?).should be_false + end + + it "should read spaced and multi-line options from file when --options is specified" do + options = parse(["--options", File.dirname(__FILE__) + "/spec_spaced.opts"]) + options.diff_format.should_not be_nil + options.colour.should be_true + options.formatters.first.should be_instance_of(::Spec::Runner::Formatter::SpecdocFormatter) + end + + it "should save config to file when --generate-options is specified" do + FileUtils.rm 'test.spec.opts' if File.exist?('test.spec.opts') + options = parse(["--colour", "--generate-options", "test.spec.opts", "--diff"]) + IO.read('test.spec.opts').should == "--colour\n--diff\n" + FileUtils.rm 'test.spec.opts' + end + + it "should save config to file when -G is specified" do + FileUtils.rm 'test.spec.opts' if File.exist?('test.spec.opts') + options = parse(["--colour", "-G", "test.spec.opts", "--diff"]) + IO.read('test.spec.opts').should == "--colour\n--diff\n" + FileUtils.rm 'test.spec.opts' + end + + it "when --drb is specified, calls DrbCommandLine all of the other ARGV arguments" do + options = Spec::Runner::OptionParser.parse([ + "some/spec.rb", "--diff", "--colour" + ], @err, @out) + Spec::Runner::DrbCommandLine.should_receive(:run).and_return do |options| + options.argv.should == ["some/spec.rb", "--diff", "--colour"] + end + parse(["some/spec.rb", "--diff", "--drb", "--colour"]) + end + + it "should reverse spec order when --reverse is specified" do + options = parse(["some/spec.rb", "--reverse"]) + end + + it "should set an mtime comparator when --loadby mtime" do + options = parse(["--loadby", 'mtime']) + runner = Spec::Runner::ExampleGroupRunner.new(options) + Spec::Runner::ExampleGroupRunner.should_receive(:new). + with(options). + and_return(runner) + runner.should_receive(:load_files).with(["most_recent_spec.rb", "command_line_spec.rb"]) + + Dir.chdir(File.dirname(__FILE__)) do + options.files << 'command_line_spec.rb' + options.files << 'most_recent_spec.rb' + FileUtils.touch "most_recent_spec.rb" + options.run_examples + FileUtils.rm "most_recent_spec.rb" + end + end + + it "should use the standard runner by default" do + runner = ::Spec::Runner::ExampleGroupRunner.new(@parser.options) + ::Spec::Runner::ExampleGroupRunner.should_receive(:new). + with(@parser.options). + and_return(runner) + options = parse([]) + options.run_examples + end + + it "should use a custom runner when given" do + runner = Custom::ExampleGroupRunner.new(@parser.options, nil) + Custom::ExampleGroupRunner.should_receive(:new). + with(@parser.options, nil). + and_return(runner) + options = parse(["--runner", "Custom::ExampleGroupRunner"]) + options.run_examples + end + + it "should use a custom runner with extra options" do + runner = Custom::ExampleGroupRunner.new(@parser.options, 'something') + Custom::ExampleGroupRunner.should_receive(:new). + with(@parser.options, 'something'). + and_return(runner) + options = parse(["--runner", "Custom::ExampleGroupRunner:something"]) + options.run_examples + end + + it "sets options.autospec to true with --autospec" do + options = parse(["--autospec"]) + options.autospec.should be(true) + end + + describe "implicitly loading spec/spec.opts" do + include FakeFS::SpecHelpers + + it "uses spec/spec.opts if present" do + File.open('spec/spec.opts', 'w') { |f| f.write "--colour" } + options = parse(['ignore.rb']) + options.colour.should be(true) + end + + it "does not try to load spec/spec.opts if not present" do + FileUtils.rm 'spec/spec.opts' + options = parse(['ignore.rb']) + options.colour.should be(false) + end + + it "uses specified opts if supplied" do + options = nil + File.open("spec/spec.opts",'w') { |f| f.write "" } + File.open("spec/alternate.opts",'w') { |f| f.write "--colour" } + options = parse(['-O','spec/alternate.opts']) + options.colour.should be(true) + end + end + + +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/options_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/options_spec.rb new file mode 100644 index 000000000..63f9fa43d --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/options_spec.rb @@ -0,0 +1,554 @@ +require 'spec_helper' +require 'spec/runner/resources/custom_example_group_runner' + +module Spec + module Runner + describe Options do + before(:each) do + @err = StringIO.new('') + @out = StringIO.new('') + @options = Options.new(@err, @out) + + before_suite_parts = [] + after_suite_parts = [] + @options.stub!(:before_suite_parts).and_return(before_suite_parts) + @options.stub!(:after_suite_parts).and_return(after_suite_parts) + end + + after(:each) do + Spec::Expectations.differ = nil + end + + describe "#require_ruby_debug" do + it "should require ruby-debug" do + @options.stub!(:require) + @options.should_receive(:require).with("ruby-debug") + @options.require_ruby_debug + end + end + + describe "#examples" do + it "should default to empty array" do + @options.examples.should == [] + end + end + + describe "#include_pattern" do + it "should default to '**/*_spec.rb'" do + @options.filename_pattern.should == "**/*_spec.rb" + end + end + + describe "#files_to_load" do + + it "should load files not following pattern if named explicitly" do + file = File.expand_path(File.dirname(__FILE__) + "/resources/a_bar.rb") + @options.files << file + @options.files_to_load.should include(file) + end + + describe "with default --pattern" do + it "should load files named _spec.rb" do + dir = File.expand_path(File.dirname(__FILE__) + "/resources/") + @options.files << dir + @options.files_to_load.should == ["#{dir}/a_spec.rb"] + end + end + + describe "with explicit pattern (single)" do + before(:each) do + @options.filename_pattern = "**/*_foo.rb" + end + + it "should load files following pattern" do + file = File.expand_path(File.dirname(__FILE__) + "/resources/a_foo.rb") + @options.files << file + @options.files_to_load.should include(file) + end + + it "should load files in directories following pattern" do + dir = File.expand_path(File.dirname(__FILE__) + "/resources") + @options.files << dir + @options.files_to_load.should include("#{dir}/a_foo.rb") + end + + it "should not load files in directories not following pattern" do + dir = File.expand_path(File.dirname(__FILE__) + "/resources") + @options.files << dir + @options.files_to_load.should_not include("#{dir}/a_bar.rb") + end + end + + describe "with explicit pattern (comma,separated,values)" do + + before(:each) do + @options.filename_pattern = "**/*_foo.rb,**/*_bar.rb" + end + + it "should support comma separated values" do + dir = File.expand_path(File.dirname(__FILE__) + "/resources") + @options.files << dir + @options.files_to_load.should include("#{dir}/a_foo.rb") + @options.files_to_load.should include("#{dir}/a_bar.rb") + end + + it "should support comma separated values with spaces" do + dir = File.expand_path(File.dirname(__FILE__) + "/resources") + @options.files << dir + @options.files_to_load.should include("#{dir}/a_foo.rb") + @options.files_to_load.should include("#{dir}/a_bar.rb") + end + + end + + end + + describe "#backtrace_tweaker" do + it "should default to QuietBacktraceTweaker" do + @options.backtrace_tweaker.class.should == QuietBacktraceTweaker + end + + it "adds custom ignored backtrace patterns" do + Spec::Runner.configuration.stub!(:ignored_backtrace_patterns).and_return([/custom_pattern/]) + @options.run_examples + @options.backtrace_tweaker.ignored_patterns.should include(/custom_pattern/) + end + end + + describe "#dry_run" do + it "should default to false" do + @options.dry_run.should == false + end + end + + describe "#debug" do + it "should default to false" do + @options.debug.should == false + end + end + + describe "#context_lines" do + it "should default to 3" do + @options.context_lines.should == 3 + end + end + + describe "#parse_diff with nil" do + before(:each) do + @options.parse_diff nil + end + + it "should make diff_format unified" do + @options.diff_format.should == :unified + end + + it "should set Spec::Expectations.differ to be a default differ" do + Spec::Expectations.differ.class.should == + ::Spec::Expectations::Differs::Default + end + end + + describe "#parse_diff with 'unified'" do + before(:each) do + @options.parse_diff 'unified' + end + + it "should make diff_format unified and uses default differ_class" do + @options.diff_format.should == :unified + @options.differ_class.should equal(Spec::Expectations::Differs::Default) + end + + it "should set Spec::Expectations.differ to be a default differ" do + Spec::Expectations.differ.class.should == + ::Spec::Expectations::Differs::Default + end + end + + describe "#parse_diff with 'context'" do + before(:each) do + @options.parse_diff 'context' + end + + it "should make diff_format context and uses default differ_class" do + @options.diff_format.should == :context + @options.differ_class.should == Spec::Expectations::Differs::Default + end + + it "should set Spec::Expectations.differ to be a default differ" do + Spec::Expectations.differ.class.should == + ::Spec::Expectations::Differs::Default + end + end + + describe "#parse_diff with Custom::Differ" do + before(:each) do + @options.parse_diff 'Custom::Differ' + end + + it "should use custom differ_class" do + @options.diff_format.should == :custom + @options.differ_class.should == Custom::Differ + Spec::Expectations.differ.should be_instance_of(Custom::Differ) + end + + it "should set Spec::Expectations.differ to be a default differ" do + Spec::Expectations.differ.class.should == + ::Custom::Differ + end + end + + describe "#parse_diff with missing class name" do + it "should raise error" do + lambda { @options.parse_diff "Custom::MissingDiffer" }.should raise_error(NameError) + @err.string.should match(/Couldn't find differ class Custom::MissingDiffer/n) + end + end + + describe "#parse_example" do + it "with argument thats not a file path, sets argument as the example" do + example = "something or other" + File.file?(example).should == false + @options.parse_example example + @options.examples.should eql(["something or other"]) + end + + it "with argument that is a file path, sets examples to contents of the file" do + example = "#{File.dirname(__FILE__)}/examples.txt" + File.should_receive(:file?).with(example).and_return(true) + file = StringIO.new("Sir, if you were my husband, I would poison your drink.\nMadam, if you were my wife, I would drink it.") + File.should_receive(:open).with(example).and_return(file) + + @options.parse_example example + @options.examples.should eql([ + "Sir, if you were my husband, I would poison your drink.", + "Madam, if you were my wife, I would drink it." + ]) + end + end + + describe "#examples_should_not_be_run" do + it "should cause #run_examples to return true and do nothing" do + @options.examples_should_not_be_run + ExampleGroupRunner.should_not_receive(:new) + + @options.run_examples.should be_true + end + end + + describe "debug option specified" do + it "should cause ruby_debug to be required and do nothing" do + @options.debug = true + @options.should_receive(:require_ruby_debug) + @options.run_examples.should be_true + end + end + + describe "debug option not specified" do + it "should not cause ruby_debug to be required" do + @options.debug = false + @options.should_not_receive(:require_ruby_debug) + @options.run_examples.should be_true + end + end + + describe "#load_class" do + it "should raise error when not class name" do + lambda do + @options.__send__(:load_class, 'foo', 'fruit', '--food') + end.should raise_error('"foo" is not a valid class name') + end + end + + describe "#reporter" do + it "returns a Reporter" do + @options.reporter.should be_instance_of(Reporter) + @options.reporter.options.should === @options + end + end + + describe "#drb_port" do + it "returns a number" do + @options.drb_port = "400" + @options.drb_port.should == 400 + end + end + + describe "#number_of_examples" do + context "when --example is parsed" do + it "provides the number of examples parsed instead of the total number of examples collected" do + @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do + it "uses this example_group 1" do; end + it "uses this example_group 2" do; end + it "uses this example_group 3" do; end + end + @options.add_example_group @example_group + @options.parse_example("an example") + @options.number_of_examples.should == 1 + end + end + end + + describe "#add_example_group affecting passed in example_group" do + it "runs all examples when options.examples is empty" do + example_1_has_run = false + example_2_has_run = false + @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do + it "runs 1" do + example_1_has_run = true + end + it "runs 2" do + example_2_has_run = true + end + end + + @options.examples.clear + + @options.add_example_group @example_group + @options.run_examples + example_1_has_run.should be_true + example_2_has_run.should be_true + end + + it "keeps all example_definitions when options.examples is empty" do + example_1_has_run = false + example_2_has_run = false + @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do + it "runs 1" do + example_1_has_run = true + end + it "runs 2" do + example_2_has_run = true + end + end + + @options.add_example_group @example_group + @options.run_examples + example_1_has_run.should be_true + example_2_has_run.should be_true + end + end + + describe "#add_example_group affecting example_group" do + it "adds example_group when example_group has example_definitions and is not shared" do + @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do + it "uses this example_group" do + end + end + + @options.number_of_examples.should == 0 + @options.add_example_group @example_group + @options.number_of_examples.should == 1 + @options.example_groups.length.should == 1 + end + end + + describe "#remove_example_group" do + it "should remove the ExampleGroup from the list of ExampleGroups" do + @example_group = Class.new(::Spec::Example::ExampleGroup).describe("Some Examples") do + end + @options.add_example_group @example_group + @options.example_groups.should include(@example_group) + + @options.remove_example_group @example_group + @options.example_groups.should_not include(@example_group) + end + end + + describe "#run_examples" do + describe "with global predicate matchers" do + it "defines global predicate matcher methods on ExampleMethods" do + Spec::Runner.configuration.stub!(:predicate_matchers).and_return({:this => :that?}) + group = Class.new(::Spec::Example::ExampleGroupDouble).describe("Some Examples") + example = group.new(::Spec::Example::ExampleProxy.new) + + @options.run_examples + example.this + end + + after(:each) do + Spec::Example::ExampleMethods.class_eval "undef :this" + end + end + + describe "with a mock framework defined as a Symbol" do + it "includes Spec::Adapters::MockFramework" do + Spec::Runner.configuration.stub!(:mock_framework).and_return('spec/adapters/mock_frameworks/rspec') + + Spec::Example::ExampleMethods.should_receive(:include).with(Spec::Adapters::MockFramework) + + @options.run_examples + end + end + + describe "with a mock framework defined as a Module" do + it "includes the module in ExampleMethods" do + mod = Module.new + Spec::Runner.configuration.stub!(:mock_framework).and_return(mod) + Spec::Example::ExampleMethods.should_receive(:include).with(mod) + @options.run_examples + end + end + + describe "when not given a custom runner" do + it "should use the standard" do + runner = ::Spec::Runner::ExampleGroupRunner.new(@options) + ::Spec::Runner::ExampleGroupRunner.should_receive(:new). + with(@options). + and_return(runner) + @options.user_input_for_runner = nil + + @options.run_examples + end + end + + describe "when given a custom runner" do + it "should use the custom runner" do + runner = Custom::ExampleGroupRunner.new(@options, nil) + Custom::ExampleGroupRunner.should_receive(:new). + with(@options, nil). + and_return(runner) + @options.user_input_for_runner = "Custom::ExampleGroupRunner" + + @options.run_examples + end + + it "should use the custom runner with extra options" do + runner = Custom::ExampleGroupRunner.new(@options, 'something') + Custom::ExampleGroupRunner.should_receive(:new). + with(@options, 'something'). + and_return(runner) + @options.user_input_for_runner = "Custom::ExampleGroupRunner:something" + + @options.run_examples + end + end + + describe "when there are examples" do + before(:each) do + @example_group = Class.new(::Spec::Example::ExampleGroup) + @options.add_example_group @example_group + @options.formatters << Formatter::BaseTextFormatter.new(@options, @out) + end + + it "runs the Examples and outputs the result" do + @options.run_examples + @out.string.should include("0 examples, 0 failures") + end + + it "sets #examples_run? to true" do + @options.examples_run?.should be_false + @options.run_examples + @options.examples_run?.should be_true + end + + describe "and the suite passes" do + before do + @example_group.should_receive(:run).and_return(true) + end + + it "invokes after_suite_parts with true" do + success_result = nil + @options.after_suite_parts << lambda do |success| + success_result = success + end + + @options.run_examples + success_result.should be_true + end + end + + describe "and the suite fails" do + before(:each) do + @example_group.should_receive(:run).and_return(false) + end + + it "invokes after_suite_parts with false" do + success_result = nil + @options.after_suite_parts << lambda do |success| + success_result = success + end + + @options.run_examples + success_result.should be_false + end + end + + describe "when using heckle runner" do + before(:each) do + @heckle_runner_mock = mock("HeckleRunner") + @options.heckle_runner = @heckle_runner_mock + end + + it "should heckle" do + @heckle_runner_mock.should_receive(:heckle_with) + @options.run_examples + end + + it "shouldn't heckle recursively" do + heckled = false + @heckle_runner_mock.should_receive(:heckle_with) { + heckled.should == false + heckled = true + @options.run_examples + } + @options.run_examples + end + + it "shouldn't load spec files twice" do + example_runner = mock("ExampleGroupRunner") + example_runner_inside_heckle = mock("ExampleGroupRunner inside Heckle") + + ExampleGroupRunner.should_receive(:new).twice.and_return( + example_runner, example_runner_inside_heckle + ) + + example_runner.stub!(:run) + example_runner.should_receive(:load_files) + @heckle_runner_mock.stub!(:heckle_with).and_return { @options.run_examples } + example_runner_inside_heckle.stub!(:run) + example_runner_inside_heckle.should_not_receive(:load_files) + + @options.run_examples + end + end + end + + describe "when there are no examples" do + before(:each) do + @options.formatters << Formatter::BaseTextFormatter.new(@options, @out) + end + + it "does not run Examples and does not output a result" do + @options.run_examples + @out.string.should_not include("examples") + @out.string.should_not include("failures") + end + + it "sets #examples_run? to false" do + @options.examples_run?.should be_false + @options.run_examples + @options.examples_run?.should be_false + end + + it "invokes after_suite_parts with true" do + success_result = nil + @options.after_suite_parts << lambda do |success| + success_result = success + end + + @options.run_examples + success_result.should be_true + end + end + end + + describe "#add_dir_from_project_root_to_load_path" do + it "handles nil gracefully" do + load_path = double().as_null_object + @options.stub(:project_root).and_return(nil) + @options.add_dir_from_project_root_to_load_path(nil,load_path) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture.rb new file mode 100644 index 000000000..8a3a9fc72 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture.rb @@ -0,0 +1,7 @@ +require 'spec_helper' + +describe "Running an Example" do + it "should not output twice" do + true.should be_true + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture_runner.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture_runner.rb new file mode 100644 index 000000000..b6b3761e4 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_fixture_runner.rb @@ -0,0 +1,7 @@ +require "spec_helper" + +triggering_double_output = Spec::Runner.options +options = Spec::Runner::OptionParser.parse( + [File.dirname(__FILE__) + "/output_one_time_fixture.rb"], $stderr, $stdout +) +Spec::Runner::CommandLine.run(options) diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_spec.rb new file mode 100644 index 000000000..c91bb0ffb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/output_one_time_spec.rb @@ -0,0 +1,15 @@ +require 'spec_helper' +require 'ruby_forker' + +module Spec + module Runner + describe CommandLine do + include RubyForker + it "should not output twice" do + output = ruby "-Ilib bin/spec spec/spec/runner/output_one_time_fixture_runner.rb" + output.should include("1 example, 0 failures") + output.should_not include("0 examples, 0 failures") + end + end + end +end
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/quiet_backtrace_tweaker_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/quiet_backtrace_tweaker_spec.rb new file mode 100644 index 000000000..725434775 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/quiet_backtrace_tweaker_spec.rb @@ -0,0 +1,123 @@ +require 'spec_helper' + +module Spec + module Runner + describe QuietBacktraceTweaker do + before(:each) do + @error = RuntimeError.new + @tweaker = QuietBacktraceTweaker.new + end + + it "gracefully handles nil backtrace" do + expect do + @tweaker.tweak_backtrace(@error) + end.to_not raise_error + end + + it "gracefully handles backtraces with newlines" do + @error.set_backtrace(["we like\nbin/spec:\nnewlines"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should include("we like\nnewlines") + end + + it "cleans up double slashes" do + @error.set_backtrace(["/a//b/c//d.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should include("/a/b/c/d.rb") + end + + it "preserves lines from textmate ruby bundle" do + @error.set_backtrace(["/Applications/TextMate.app/Contents/SharedSupport/Bundles/Ruby.tmbundle/Support/tmruby.rb:147"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty + end + + it "removes lines in lib/spec" do + ["expectations", "mocks", "runner"].each do |child| + element="/lib/spec/#{child}/anything.rb" + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + end + + it "removes lines in bin/spec" do + @error.set_backtrace(["bin/spec:"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty + end + + it "preserves lines in spec" do + @error.set_backtrace(["spec/foo/bar_spec.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should == ["spec/foo/bar_spec.rb"] + end + + it "preserves lines in ./spec" do + @error.set_backtrace(["./spec/foo/bar_spec.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should == ["./spec/foo/bar_spec.rb"] + end + + it "preserves lines in /path/to/project/spec" do + @error.set_backtrace(["/path/to/project/spec/foo/bar_spec.rb"]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should == ["/path/to/project/spec/foo/bar_spec.rb"] + end + + it "removes lines in mock_frameworks/rspec" do + element = "mock_frameworks/rspec" + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + + it "removes custom patterns in regexp form" do + element = "/vendor/lib/custom_pattern/" + @tweaker.ignore_patterns /custom_pattern/ + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + + it "removes custom patterns in string form" do + element = "/vendor/lib/custom_pattern/" + @tweaker.ignore_patterns "custom_pattern" + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + + it "removes lines in mock_frameworks/rspec" do + element = "mock_frameworks/rspec" + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + + it "removes lines in rspec gem" do + ["/rspec-1.2.3/lib/spec.rb","/rspec-1.2.3/lib/spec/anything.rb","bin/spec:123"].each do |element| + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + end + + it "removes lines in pre-release rspec gems" do + ["/rspec-1.2.3.a1.gem/lib/spec.rb","/rspec-1.2.3.b1.gem/lib/spec.rb","/rspec-1.2.3.rc1.gem/lib/spec.rb"].each do |element| + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + end + + it "removes lines in spork gem" do + ["/spork-1.2.3/lib/spec.rb","/spork-1.2.3/lib/spec/anything.rb","bin/spork:123"].each do |element| + @error.set_backtrace([element]) + @tweaker.tweak_backtrace(@error) + @error.backtrace.should be_empty, "Should have removed line with '#{element}'" + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/reporter_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/reporter_spec.rb new file mode 100644 index 000000000..556387dc7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/reporter_spec.rb @@ -0,0 +1,244 @@ +require 'spec_helper' + +module Spec + module Runner + describe Reporter do + attr_reader :formatter_output, :options, :backtrace_tweaker, :formatter, :reporter, :example_group, :example_group_proxy, :example_proxy + before(:each) do + @formatter_output = StringIO.new + @options = Options.new(StringIO.new, StringIO.new) + @backtrace_tweaker = stub("backtrace tweaker", :tweak_backtrace => nil) + options.backtrace_tweaker = backtrace_tweaker + @formatter = ::Spec::Runner::Formatter::BaseTextFormatter.new(options, formatter_output) + options.formatters << formatter + @reporter = Reporter.new(options) + @example_group = create_example_group("example_group") + @example_group_proxy = Spec::Example::ExampleGroupProxy.new(@example_group) + @example_proxy = Spec::Example::ExampleProxy.new + example_group.notify(reporter) + end + + def failure + Mocks::ArgumentMatchers::DuckTypeMatcher.new(:header, :exception) + end + + def create_example_group(text) + example_group = Spec::Example::ExampleGroup.describe(text) do + it "should do something" do + end + end + example_group + end + + it "should assign itself as the reporter to options" do + options.reporter.should equal(@reporter) + end + + it "should tell formatter when example_group is added" do + formatter.should_receive(:example_group_started).with(example_group_proxy) + example_group.notify(reporter) + end + + it "should handle multiple example_groups with same name" do + formatter.should_receive(:example_group_started).exactly(3).times + formatter.should_receive(:example_started).exactly(3).times + formatter.should_receive(:example_passed).exactly(3).times + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:close).with(no_args) + formatter.should_receive(:dump_summary).with(anything(), 3, 0, 0) + create_example_group("example_group").notify(reporter) + reporter.example_started(description_of("spec 1")) + reporter.example_finished(description_of("spec 1")) + create_example_group("example_group").notify(reporter) + reporter.example_started(description_of("spec 2")) + reporter.example_finished(description_of("spec 2")) + create_example_group("example_group").notify(reporter) + reporter.example_started(description_of("spec 3")) + reporter.example_finished(description_of("spec 3")) + reporter.dump + end + + def description_of(example) + ::Spec::Example::ExampleProxy.new(String === example ? example : example.description) + end + + it "should handle multiple examples with the same name" do + error=RuntimeError.new + passing = ::Spec::Example::ExampleGroupDouble.new(example_proxy) + failing = ::Spec::Example::ExampleGroupDouble.new(example_proxy) + + formatter.should_receive(:example_group_started).exactly(2).times + formatter.should_receive(:example_passed).with(description_of(passing)).exactly(2).times + formatter.should_receive(:example_failed).with(description_of(failing), 1, failure) + formatter.should_receive(:example_failed).with(description_of(failing), 2, failure) + formatter.should_receive(:dump_failure).exactly(2).times + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:close).with(no_args) + formatter.should_receive(:dump_summary).with(anything(), 4, 2, 0) + backtrace_tweaker.should_receive(:tweak_backtrace).twice + + create_example_group("example_group").notify(reporter) + reporter.example_finished(description_of(passing)) + reporter.example_finished(description_of(failing), error) + + create_example_group("example_group").notify(reporter) + reporter.example_finished(description_of(passing)) + reporter.example_finished(description_of(failing), error) + reporter.dump + end + + it "should push stats to formatter even with no data" do + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:dump_summary).with(anything(), 0, 0, 0) + formatter.should_receive(:close).with(no_args) + reporter.dump + end + + it "should push time to formatter" do + formatter.should_receive(:start).with(5) + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:close).with(no_args) + formatter.should_receive(:dump_summary) do |time, a, b| + time.to_s.should match(/[0-9].[0-9|e|-]+/) + end + reporter.start(5) + reporter.end + reporter.dump + end + + describe "reporting one passing example" do + it "should tell formatter example passed" do + formatter.should_receive(:example_passed) + reporter.example_finished(description_of("example")) + end + + it "should not delegate to backtrace tweaker" do + formatter.should_receive(:example_passed) + backtrace_tweaker.should_not_receive(:tweak_backtrace) + reporter.example_finished(description_of("example")) + end + + it "should account for passing example in stats" do + formatter.should_receive(:example_passed) + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:dump_summary).with(anything(), 1, 0, 0) + formatter.should_receive(:close).with(no_args) + reporter.example_finished(description_of("example")) + reporter.dump + end + end + + describe "reporting one failing example" do + it "should tell formatter that example failed" do + example = example_group.it("should do something") {} + formatter.should_receive(:example_failed) + reporter.example_finished(description_of(example), RuntimeError.new) + end + + it "should delegate to backtrace tweaker" do + formatter.should_receive(:example_failed) + backtrace_tweaker.should_receive(:tweak_backtrace) + reporter.example_finished(example_proxy, RuntimeError.new) + end + + it "should account for failing example in stats" do + example = ::Spec::Example::ExampleGroupDouble.new(example_proxy) + formatter.should_receive(:example_failed).with(description_of(example), 1, failure) + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:dump_failure).with(1, anything()) + formatter.should_receive(:dump_summary).with(anything(), 1, 1, 0) + formatter.should_receive(:close).with(no_args) + reporter.example_finished(description_of(example), RuntimeError.new) + reporter.dump + end + + end + + describe "reporting one pending example (ExamplePendingError)" do + before :each do + @pending_error = Spec::Example::ExamplePendingError.new("reason") + end + + it "should tell formatter example is pending" do + example = ExampleGroup.new(example_proxy) + formatter.should_receive(:example_pending).with(description_of(example), "reason") + formatter.should_receive(:example_group_started).with(example_group_proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example), @pending_error) + end + + it "should account for pending example in stats" do + example = ExampleGroup.new(example_proxy) + formatter.should_receive(:example_pending).with(description_of(example), "reason") + formatter.should_receive(:start_dump) + formatter.should_receive(:dump_pending) + formatter.should_receive(:dump_summary).with(anything(), 1, 0, 1) + formatter.should_receive(:close).with(no_args) + formatter.should_receive(:example_group_started).with(example_group_proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example), @pending_error) + reporter.dump + end + + describe "to formatters which have example_pending's arity of 3 (which is now deprecated)" do + before :each do + Spec.stub!(:warn) + + @deprecated_formatter = Class.new(@formatter.class) do + attr_reader :example_passed_to_method, :message_passed_to_method + + def example_pending(example_passed_to_method, message_passed_to_method, deprecated_pending_location) + @example_passed_to_method = example_passed_to_method + @message_passed_to_method = message_passed_to_method + end + end.new(options, formatter_output) + + options.formatters << @deprecated_formatter + end + + it "should pass the correct example description to the formatter" do + proxy = Spec::Example::ExampleProxy.new("name") + example = ExampleGroup.new(proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example), @pending_error) + + @deprecated_formatter.example_passed_to_method.should == proxy + end + + it "should pass the correct pending error message to the formatter" do + example = ExampleGroup.new(example_proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example), @pending_error) + + @deprecated_formatter.message_passed_to_method.should == @pending_error.message + end + + it "should raise a deprecation warning" do + Spec.should_receive(:warn) + + example = ExampleGroup.new(example_proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example), @pending_error) + end + end + end + + describe "reporting one pending example (PendingExampleFixedError)" do + it "should tell formatter pending example is fixed" do + formatter.should_receive(:example_failed) do |name, counter, failure| + failure.header.should == "'example_group should do something' FIXED" + end + formatter.should_receive(:example_group_started).with(example_group_proxy) + example_group.notify(reporter) + reporter.example_finished(description_of(example_group.examples.first), Spec::Example::PendingExampleFixedError.new("reason")) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_bar.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_bar.rb new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_bar.rb diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_foo.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_foo.rb new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_foo.rb diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_spec.rb new file mode 100644 index 000000000..d9b67cc76 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/a_spec.rb @@ -0,0 +1 @@ +# Empty - used by ../options_spec.rb
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/custom_example_group_runner.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/custom_example_group_runner.rb new file mode 100644 index 000000000..edcf54e96 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/custom_example_group_runner.rb @@ -0,0 +1,14 @@ +module Custom + class ExampleGroupRunner + attr_reader :options, :arg + def initialize(options, arg) + @options, @arg = options, arg + end + + def load_files(files) + end + + def run + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/utf8_encoded.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/utf8_encoded.rb new file mode 100644 index 000000000..7cbdd6908 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/resources/utf8_encoded.rb @@ -0,0 +1,8 @@ +# encoding: utf-8 +module Custom + class ExampleUTF8ClassNameVarietà + def self.è + così = :però + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/spec.opts b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec.opts new file mode 100644 index 000000000..fd816a424 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec.opts @@ -0,0 +1,2 @@ +--diff +--colour
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_drb.opts b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_drb.opts new file mode 100644 index 000000000..61f260b71 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_drb.opts @@ -0,0 +1,2 @@ +--colour +--drb diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_spaced.opts b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_spaced.opts new file mode 100644 index 000000000..6b3efd20f --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner/spec_spaced.opts @@ -0,0 +1,2 @@ +--diff --colour +--format s
\ No newline at end of file diff --git a/vendor/gems/rspec-1.3.1/spec/spec/runner_spec.rb b/vendor/gems/rspec-1.3.1/spec/spec/runner_spec.rb new file mode 100644 index 000000000..3b55be7a7 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec/runner_spec.rb @@ -0,0 +1,13 @@ +require 'spec_helper' + +module Spec + describe Runner do + describe ".configure" do + it "should yield global configuration" do + Spec::Runner.configure do |config| + config.should equal(Spec::Runner.configuration) + end + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/spec_helper.rb b/vendor/gems/rspec-1.3.1/spec/spec_helper.rb new file mode 100644 index 000000000..d746d0871 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/spec_helper.rb @@ -0,0 +1,113 @@ +$: << '.' # for ruby 1.9 +require 'stringio' + +$_spec_spec = true # Prevents Kernel.exit in various places + +require 'spec' +require 'spec/mocks' +require 'spec/runner/differs/default' +require 'spec/autorun' + +require 'support/spec_classes' +require 'support/macros' + +def jruby? + ::RUBY_PLATFORM == 'java' +end + +module Spec + module Example + class NonStandardError < Exception; end + end + + module Matchers + def fail + raise_error(Spec::Expectations::ExpectationNotMetError) + end + + def fail_with(message) + raise_error(Spec::Expectations::ExpectationNotMetError, message) + end + + def exception_from(&block) + exception = nil + begin + yield + rescue StandardError => e + exception = e + end + exception + end + + def run_with(options) + ::Spec::Runner::CommandLine.run(options) + end + + def with_ruby(version) + yield if RUBY_VERSION =~ Regexp.compile("^#{version.to_s}") + end + end +end + +def with_sandboxed_options + attr_reader :options + + before(:each) do + @original_rspec_options = ::Spec::Runner.options + ::Spec::Runner.use(@options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)) + end + + after(:each) do + ::Spec::Runner.use(@original_rspec_options) + end + + yield +end + +def with_sandboxed_config + attr_reader :config + + before(:each) do + @config = ::Spec::Runner::Configuration.new + @original_configuration = ::Spec::Runner.configuration + spec_configuration = @config + ::Spec::Runner.instance_eval {@configuration = spec_configuration} + end + + after(:each) do + original_configuration = @original_configuration + ::Spec::Runner.instance_eval {@configuration = original_configuration} + ::Spec::Example::ExampleGroupFactory.reset + end + + yield +end + +module Spec + module Example + module Resettable + def reset # :nodoc: + @before_all_parts = nil + @after_all_parts = nil + @before_each_parts = nil + @after_each_parts = nil + end + end + class ExampleGroup + extend Resettable + end + class ExampleGroupDouble < ExampleGroup + ::Spec::Runner.options.remove_example_group self + def register_example_group(klass) + #ignore + end + def initialize(proxy=nil, &block) + super(proxy || ExampleProxy.new, &block) + end + end + end +end + +Spec::Runner.configure do |config| + config.extend(Macros) +end diff --git a/vendor/gems/rspec-1.3.1/spec/support/macros.rb b/vendor/gems/rspec-1.3.1/spec/support/macros.rb new file mode 100644 index 000000000..6322060b0 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/support/macros.rb @@ -0,0 +1,29 @@ +module Macros + def treats_method_missing_as_private(options = {:noop => true, :subject => nil}) + it "should have method_missing as private" do + with_ruby 1.8 do + described_class.private_instance_methods.should include("method_missing") + end + with_ruby 1.9 do + described_class.private_instance_methods.should include(:method_missing) + end + end + + it "should not respond_to? method_missing (because it's private)" do + formatter = options[:subject] || described_class.new({ }, StringIO.new) + formatter.should_not respond_to(:method_missing) + end + + if options[:noop] + it "should respond_to? all messages" do + formatter = described_class.new({ }, StringIO.new) + formatter.should respond_to(:just_about_anything) + end + + it "should respond_to? anything, when given the private flag" do + formatter = described_class.new({ }, StringIO.new) + formatter.respond_to?(:method_missing, true).should be_true + end + end + end +end diff --git a/vendor/gems/rspec-1.3.1/spec/support/spec_classes.rb b/vendor/gems/rspec-1.3.1/spec/support/spec_classes.rb new file mode 100644 index 000000000..c8900a789 --- /dev/null +++ b/vendor/gems/rspec-1.3.1/spec/support/spec_classes.rb @@ -0,0 +1,133 @@ +# This file contains various classes used by the specs. +module Spec + module Expectations + class Person + attr_reader :name + def initialize name + @name = name + end + def == other + return @name == other.name + end + end + + class ClassWithMultiWordPredicate + def multi_word_predicate? + true + end + end + + module Helper + class CollectionWithSizeMethod + def initialize; @list = []; end + def size; @list.size; end + def push(item); @list.push(item); end + end + + class CollectionWithLengthMethod + def initialize; @list = []; end + def length; @list.size; end + def push(item); @list.push(item); end + end + + class CollectionOwner + attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method + + def initialize + @items_in_collection_with_size_method = CollectionWithSizeMethod.new + @items_in_collection_with_length_method = CollectionWithLengthMethod.new + end + + def add_to_collection_with_size_method(item) + @items_in_collection_with_size_method.push(item) + end + + def add_to_collection_with_length_method(item) + @items_in_collection_with_length_method.push(item) + end + + def items_for(arg) + return [1, 2, 3] if arg == 'a' + [1] + end + + def items + @items_in_collection_with_size_method + end + end + + class HandCodedMock + include Spec::Matchers + def initialize(return_val) + @return_val = return_val + @funny_called = false + end + + def funny? + @funny_called = true + @return_val + end + + def hungry?(a, b, c) + a.should equal(1) + b.should equal(2) + c.should equal(3) + @funny_called = true + @return_val + end + + def exists? + @return_val + end + + def multi_word_predicate? + @return_val + end + + def rspec_verify + @funny_called.should be_true + end + end + class ClassWithUnqueriedPredicate + attr_accessor :foo + def initialize(foo) + @foo = foo + end + end + end + end +end + +module Custom + require 'spec/runner/formatter/base_text_formatter' + class Formatter < Spec::Runner::Formatter::BaseTextFormatter + attr_reader :options, :where + + def initialize(options, where) + @options = options + @where = where + end + end + + class BadFormatter < Spec::Runner::Formatter::BaseTextFormatter + attr_reader :where + + def initialize(options, where) + bad_method + end + end + + class Differ + attr_reader :options + def initialize(options) + @options = options + end + + def diff_as_object(target, expected) + "" + end + end +end + +class FakeReporter < Spec::Runner::Reporter +end |