You are viewing a plain text version of this content. The canonical link for it is here.
Posted to olio-commits@incubator.apache.org by ws...@apache.org on 2008/12/11 01:34:30 UTC
svn commit: r725524 [11/14] - in /incubator/olio/webapp/rails/trunk:
app/controllers/ app/models/ app/views/events/ config/ config/environments/
spec/controllers/ spec/models/ vendor/plugins/attachment_fu/
vendor/plugins/attachment_fu/lib/ vendor/plugi...
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_group_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_group_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_group_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_group_spec.rb Wed Dec 10 17:34:18 2008
@@ -65,584 +65,584 @@
end
describe ExampleGroup, "#run" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :example_group, :formatter, :reporter
- before :each do
- @formatter = mock("formatter", :null_object => true)
- options.formatters << formatter
- options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
- @reporter = FakeReporter.new(options)
- options.reporter = reporter
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it "does nothing" do
- end
- end
- class << example_group
- public :include
- end
- end
-
- after :each do
- ExampleGroup.reset
- end
-
- it "should not run when there are no examples" do
- example_group = Class.new(ExampleGroup) do
- describe("Foobar")
- end
- example_group.examples.should be_empty
-
- reporter = mock("Reporter")
- reporter.should_not_receive(:add_example_group)
- example_group.run
- end
-
- describe "when before_each fails" do
- before(:each) do
- $example_ran = $after_each_ran = false
- @example_group = describe("Foobar") do
- before(:each) {raise}
- it "should not be run" do
- $example_ran = true
- end
- after(:each) do
- $after_each_ran = true
+ with_sandboxed_options do
+ attr_reader :example_group, :formatter, :reporter
+ before :each do
+ method_with_three_args = lambda { |arg1, arg2, arg3| }
+ @formatter = mock("formatter", :null_object => true, :example_pending => method_with_three_args)
+ options.formatters << formatter
+ options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
+ @reporter = FakeReporter.new(options)
+ options.reporter = reporter
+ @example_group = Class.new(ExampleGroup) do
+ describe("example")
+ it "does nothing" do
end
end
- end
-
- it "should not run example block" do
- example_group.run
- $example_ran.should be_false
- end
-
- it "should run after_each" do
- example_group.run
- $after_each_ran.should be_true
- end
-
- it "should report failure location when in before_each" do
- reporter.should_receive(:example_finished) do |example_group, error|
- error.message.should eql("in before_each")
+ class << example_group
+ public :include
end
- example_group.run
end
- end
- describe ExampleGroup, "#run on dry run" do
- before do
- @options.dry_run = true
+ after :each do
+ ExampleGroup.reset
end
- it "should not run before(:all) or after(:all)" do
- before_all_ran = false
- after_all_ran = false
- ExampleGroup.before(:all) { before_all_ran = true }
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.it("should") {}
- example_group.run
- before_all_ran.should be_false
- after_all_ran.should be_false
- end
+ it "should not run when there are no examples" do
+ example_group = Class.new(ExampleGroup) do
+ describe("Foobar")
+ end
+ example_group.examples.should be_empty
- it "should not run example" do
- example_ran = false
- example_group.it("should") {example_ran = true}
+ reporter = mock("Reporter")
+ reporter.should_not_receive(:add_example_group)
example_group.run
- example_ran.should be_false
- end
- end
-
- describe ExampleGroup, "#run with specified examples" do
- attr_reader :examples_that_were_run
- before do
- @examples_that_were_run = []
end
-
- describe "when specified_examples matches entire ExampleGroup" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("the ExampleGroup")
- it("should be run") do
- examples_that_were_run << 'should be run'
+
+ 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
-
- it("should also be run") do
- examples_that_were_run << 'should also be run'
+ after(:each) do
+ $after_each_ran = true
end
end
- options.examples = ["the ExampleGroup"]
end
- it "should not run the Examples in the ExampleGroup" do
+ it "should not run example block" do
example_group.run
- examples_that_were_run.should == ['should be run', 'should also be run']
+ $example_ran.should be_false
end
- end
-
- describe ExampleGroup, "#run when specified_examples matches only Example description" do
- before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be run") do
- examples_that_were_run << 'should be run'
- end
- end
- options.examples = ["should be run"]
+
+ it "should run after_each" do
+ example_group.run
+ $after_each_ran.should be_true
end
- it "should not run the example" do
+ 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
- examples_that_were_run.should == ['should be run']
end
end
- describe ExampleGroup, "#run when specified_examples does not match an Example description" do
+ describe ExampleGroup, "#run on dry run" do
before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be something else") do
- examples_that_were_run << 'should be something else'
- end
- end
- options.examples = ["does not match anything"]
+ @options.dry_run = true
end
- it "should not run the example" do
+ 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
- examples_that_were_run.should == []
+ before_all_ran.should be_false
+ after_all_ran.should be_false
+ end
+
+ it "should not run example" do
+ example_ran = false
+ example_group.it("should") {example_ran = true}
+ example_group.run
+ example_ran.should be_false
end
end
- describe ExampleGroup, "#run when specified_examples matches an Example description" do
+ describe ExampleGroup, "#run with specified examples" do
+ attr_reader :examples_that_were_run
before do
- examples_that_were_run = @examples_that_were_run
- @example_group = Class.new(ExampleGroup) do
- describe("example")
- it("should be run") do
- examples_that_were_run << 'should be run'
- end
- it("should not be run") do
- examples_that_were_run << 'should not be run'
+ @examples_that_were_run = []
+ end
+
+ describe "when specified_examples matches entire ExampleGroup" do
+ before do
+ examples_that_were_run = @examples_that_were_run
+ @example_group = Class.new(ExampleGroup) do
+ describe("the ExampleGroup")
+ it("should be run") do
+ examples_that_were_run << 'should be run'
+ end
+
+ it("should also be run") do
+ examples_that_were_run << 'should also be run'
+ end
end
+ options.examples = ["the ExampleGroup"]
end
- options.examples = ["should be run"]
- end
- it "should run only the example, when there in only one" do
- example_group.run
- examples_that_were_run.should == ["should be run"]
+ it "should not run the Examples in the ExampleGroup" do
+ example_group.run
+ examples_that_were_run.should == ['should be run', 'should also be run']
+ end
end
- it "should run only the one example" do
- example_group.run
- examples_that_were_run.should == ["should be run"] end
- end
- end
+ describe ExampleGroup, "#run when specified_examples matches only Example description" do
+ before do
+ examples_that_were_run = @examples_that_were_run
+ @example_group = Class.new(ExampleGroup) do
+ describe("example")
+ it("should be run") do
+ examples_that_were_run << 'should be run'
+ end
+ end
+ options.examples = ["should be run"]
+ end
- describe ExampleGroup, "#run with success" do
- before do
- @special_example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:special, @special_example_group)
- @not_special_example_group = Class.new(ExampleGroup)
- ExampleGroupFactory.register(:not_special, @not_special_example_group)
- end
+ it "should not run the example" do
+ example_group.run
+ examples_that_were_run.should == ['should be run']
+ end
+ end
- after do
- ExampleGroupFactory.reset
- end
+ describe ExampleGroup, "#run when specified_examples does not match an Example description" do
+ before do
+ examples_that_were_run = @examples_that_were_run
+ @example_group = Class.new(ExampleGroup) do
+ describe("example")
+ it("should be something else") do
+ examples_that_were_run << 'should be something else'
+ end
+ end
+ options.examples = ["does not match anything"]
+ end
- it "should send reporter add_example_group" do
- example_group.run
- reporter.example_groups.should == [example_group]
- end
+ it "should not run the example" do
+ example_group.run
+ examples_that_were_run.should == []
+ end
+ end
- it "should run example on run" do
- example_ran = false
- example_group.it("should") {example_ran = true}
- example_group.run
- example_ran.should be_true
- end
+ describe ExampleGroup, "#run when specified_examples matches an Example description" do
+ before do
+ examples_that_were_run = @examples_that_were_run
+ @example_group = Class.new(ExampleGroup) do
+ describe("example")
+ it("should be run") do
+ examples_that_were_run << 'should be run'
+ end
+ it("should not be run") do
+ examples_that_were_run << 'should not be run'
+ end
+ end
+ options.examples = ["should be run"]
+ end
- it "should run before(:all) block only once" do
- before_all_run_count_run_count = 0
- example_group.before(:all) {before_all_run_count_run_count += 1}
- example_group.it("test") {true}
- example_group.it("test2") {true}
- example_group.run
- before_all_run_count_run_count.should == 1
- end
+ it "should run only the example, when there is only one" do
+ example_group.run
+ examples_that_were_run.should == ["should be run"]
+ end
- it "should run after(:all) block only once" do
- after_all_run_count = 0
- example_group.after(:all) {after_all_run_count += 1}
- example_group.it("test") {true}
- example_group.it("test2") {true}
- example_group.run
- after_all_run_count.should == 1
- @reporter.rspec_verify
+ it "should run only the one example" do
+ example_group.run
+ examples_that_were_run.should == ["should be run"] end
+ end
end
- it "after(:all) should have access to all instance variables defined in before(:all)" do
- context_instance_value_in = "Hello there"
- context_instance_value_out = ""
- example_group.before(:all) { @instance_var = context_instance_value_in }
- example_group.after(:all) { context_instance_value_out = @instance_var }
- example_group.it("test") {true}
- example_group.run
- context_instance_value_in.should == context_instance_value_out
- end
+ describe ExampleGroup, "#run with success" do
+ before do
+ @special_example_group = Class.new(ExampleGroup)
+ ExampleGroupFactory.register(:special, @special_example_group)
+ @not_special_example_group = Class.new(ExampleGroup)
+ ExampleGroupFactory.register(:not_special, @not_special_example_group)
+ end
- it "should copy instance variables from before(:all)'s execution context into spec's execution context" do
- context_instance_value_in = "Hello there"
- context_instance_value_out = ""
- example_group.before(:all) { @instance_var = context_instance_value_in }
- example_group.it("test") {context_instance_value_out = @instance_var}
- example_group.run
- context_instance_value_in.should == context_instance_value_out
- end
+ after do
+ ExampleGroupFactory.reset
+ end
- it "should not add global before callbacks for untargetted example_group" do
- fiddle = []
+ it "should send reporter add_example_group" do
+ example_group.run
+ reporter.example_groups.should == [example_group]
+ end
- 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)" }
+ it "should run example on run" do
+ example_ran = false
+ example_group.it("should") {example_ran = true}
+ example_group.run
+ example_ran.should be_true
+ end
- example_group = Class.new(ExampleGroup) do
- describe("I'm not special", :type => :not_special)
- it "does nothing"
+ it "should run before(:all) block only once" do
+ before_all_run_count_run_count = 0
+ example_group.before(:all) {before_all_run_count_run_count += 1}
+ example_group.it("test") {true}
+ example_group.it("test2") {true}
+ example_group.run
+ before_all_run_count_run_count.should == 1
end
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- ]
- end
-
- it "should add global before callbacks for targetted example_groups" do
- fiddle = []
-
- ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
- ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
- @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" }
- @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" }
- @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" }
- @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" }
- @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" }
- example_group = Class.new(@special_example_group).describe("I'm a special example_group") {}
- example_group.it("test") {true}
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- 'special.prepend_before(:all, :type => :special)',
- 'special.before(:all, :type => :special)',
- 'special.prepend_before(:each, :type => :special)',
- 'special.before(:each, :type => :special)',
- 'special.append_before(:each, :type => :special)',
- ]
- end
-
- it "should order before callbacks from global to local" do
- fiddle = []
- ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
- ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
- example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" }
- example_group.before(:all) { fiddle << "before(:all)" }
- example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" }
- example_group.before(:each) { fiddle << "before(:each)" }
- example_group.run
- fiddle.should == [
- 'Example.prepend_before(:all)',
- 'Example.before(:all)',
- 'prepend_before(:all)',
- 'before(:all)',
- 'prepend_before(:each)',
- 'before(:each)'
- ]
- end
-
- it "should order after callbacks from local to global" do
- fiddle = []
- example_group.after(:each) { fiddle << "after(:each)" }
- example_group.append_after(:each) { fiddle << "append_after(:each)" }
- example_group.after(:all) { fiddle << "after(:all)" }
- example_group.append_after(:all) { fiddle << "append_after(:all)" }
- ExampleGroup.after(:all) { fiddle << "Example.after(:all)" }
- ExampleGroup.append_after(:all) { fiddle << "Example.append_after(:all)" }
- example_group.run
- fiddle.should == [
- 'after(:each)',
- 'append_after(:each)',
- 'after(:all)',
- 'append_after(:all)',
- 'Example.after(:all)',
- 'Example.append_after(:all)'
- ]
- end
+ it "should run after(:all) block only once" do
+ after_all_run_count = 0
+ example_group.after(:all) {after_all_run_count += 1}
+ example_group.it("test") {true}
+ example_group.it("test2") {true}
+ example_group.run
+ after_all_run_count.should == 1
+ @reporter.rspec_verify
+ end
- it "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
+ it "after(:all) should have access to all instance variables defined in before(:all)" do
+ context_instance_value_in = "Hello there"
+ context_instance_value_out = ""
+ example_group.before(:all) { @instance_var = context_instance_value_in }
+ example_group.after(:all) { context_instance_value_out = @instance_var }
+ example_group.it("test") {true}
+ example_group.run
+ context_instance_value_in.should == context_instance_value_out
end
- mod2_method_called = false
- mod2 = Module.new do
- define_method :mod2_method do
- mod2_method_called = true
- end
+ it "should copy instance variables from before(:all)'s execution context into spec's execution context" do
+ context_instance_value_in = "Hello there"
+ context_instance_value_out = ""
+ example_group.before(:all) { @instance_var = context_instance_value_in }
+ example_group.it("test") {context_instance_value_out = @instance_var}
+ example_group.run
+ context_instance_value_in.should == context_instance_value_out
end
- example_group.include mod1, mod2
+ it "should not add global before callbacks for untargetted example_group" do
+ fiddle = []
- example_group.it("test") do
- mod1_method
- mod2_method
- end
- example_group.run
- mod1_method_called.should be_true
- mod2_method_called.should be_true
- end
+ 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)" }
- 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(ExampleGroup) do
+ describe("I'm not special", :type => :not_special)
+ it "does nothing"
+ end
+ example_group.run
+ fiddle.should == [
+ 'Example.prepend_before(:all)',
+ 'Example.before(:all)',
+ ]
+ end
+
+ it "should add global before callbacks for targetted example_groups" do
+ fiddle = []
+
+ ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
+ ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
+ @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" }
+ @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" }
+ @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" }
+ @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" }
+ @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" }
- example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do
- it "does nothing"
+ example_group = Class.new(@special_example_group).describe("I'm a special example_group") {}
+ example_group.it("test") {true}
+ example_group.run
+ fiddle.should == [
+ 'Example.prepend_before(:all)',
+ 'Example.before(:all)',
+ 'special.prepend_before(:all, :type => :special)',
+ 'special.before(:all, :type => :special)',
+ 'special.prepend_before(:each, :type => :special)',
+ 'special.before(:each, :type => :special)',
+ 'special.append_before(:each, :type => :special)',
+ ]
+ end
+
+ it "should order before callbacks from global to local" do
+ fiddle = []
+ ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
+ ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
+ example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" }
+ example_group.before(:all) { fiddle << "before(:all)" }
+ example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" }
+ example_group.before(:each) { fiddle << "before(:each)" }
+ example_group.run
+ fiddle.should == [
+ 'Example.prepend_before(:all)',
+ 'Example.before(:all)',
+ 'prepend_before(:all)',
+ 'before(:all)',
+ 'prepend_before(:each)',
+ 'before(:each)'
+ ]
+ end
+
+ it "should order after callbacks from local to global" do
+ fiddle = []
+ example_group.after(:each) { fiddle << "after(:each)" }
+ example_group.append_after(:each) { fiddle << "append_after(:each)" }
+ example_group.after(:all) { fiddle << "after(:all)" }
+ example_group.append_after(:all) { fiddle << "append_after(:all)" }
+ ExampleGroup.after(:all) { fiddle << "Example.after(:all)" }
+ ExampleGroup.append_after(:all) { fiddle << "Example.append_after(:all)" }
+ example_group.run
+ fiddle.should == [
+ 'after(:each)',
+ 'append_after(:each)',
+ 'after(:all)',
+ 'append_after(:all)',
+ 'Example.after(:all)',
+ 'Example.append_after(:all)'
+ ]
end
- example_group.run
- example_group.included_modules.should include(mod1)
- example_group.included_modules.should include(mod2)
- example_group.included_modules.should_not include(mod3)
- end
-
- it "should include any predicate_matchers included using configuration" do
- $included_predicate_matcher_found = false
- Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something?
- example_group = Class.new(ExampleGroup) do
- describe('example')
- it "should respond to do_something" do
- $included_predicate_matcher_found = respond_to?(:do_something)
+ 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
- end
- example_group.run
- $included_predicate_matcher_found.should be(true)
- end
- it "should use a mock framework set up in config" do
- mod = Module.new do
- class << self
- def included(mod)
- $included_module = mod
+ mod2_method_called = false
+ mod2 = Module.new do
+ define_method :mod2_method do
+ mod2_method_called = true
end
end
- def teardown_mocks_for_rspec
- $torn_down = true
+ example_group.include mod1, mod2
+
+ example_group.it("test") do
+ mod1_method
+ mod2_method
end
+ example_group.run
+ mod1_method_called.should be_true
+ mod2_method_called.should be_true
end
- begin
- $included_module = nil
- $torn_down = true
- Spec::Runner.configuration.mock_with mod
+ 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(ExampleGroup) do
- describe('example')
+ example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do
it "does nothing"
end
example_group.run
- $included_module.should_not be_nil
- $torn_down.should == true
- ensure
- Spec::Runner.configuration.mock_with :rspec
+ example_group.included_modules.should include(mod1)
+ example_group.included_modules.should include(mod2)
+ example_group.included_modules.should_not include(mod3)
end
- end
- end
- describe ExampleGroup, "#run with pending example that has a failing assertion" do
- before do
- example_group.it("should be pending") do
- pending("Example fails") {false.should be_true}
+ it "should include any predicate_matchers included using configuration" do
+ $included_predicate_matcher_found = false
+ Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something?
+ example_group = Class.new(ExampleGroup) do
+ describe('example')
+ it "should respond to do_something" do
+ $included_predicate_matcher_found = respond_to?(:do_something)
+ end
+ end
+ example_group.run
+ $included_predicate_matcher_found.should be(true)
end
- end
- it "should send example_pending to formatter" do
- @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails")
- example_group.run
- end
- end
+ it "should use a mock framework set up in config" do
+ mod = Module.new do
+ def self.included(mod)
+ $included_module = mod
+ 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"
+ def teardown_mocks_for_rspec
+ $torn_down = true
+ end
+ end
+
+ begin
+ $included_module = nil
+ $torn_down = true
+ Spec::Runner.configuration.mock_with mod
- before do
- example_group.it("should be pending") do
- pending("Example passes") {true.should be_true}
+ example_group = Class.new(ExampleGroup) do
+ describe('example')
+ it "does nothing"
+ end
+ example_group.run
+
+ $included_module.should_not be_nil
+ $torn_down.should == true
+ ensure
+ Spec::Runner.configuration.mock_with :rspec
+ end
end
end
- it "should send example_pending to formatter" do
- @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes")
- example_group.run
+ describe ExampleGroup, "#run with pending example that has a failing assertion" do
+ before do
+ example_group.it("should be pending") do
+ pending("Example fails") {false.should be_true}
+ end
+ end
+
+ it "should send example_pending to formatter" do
+ @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails")
+ example_group.run
+ end
end
- end
- describe ExampleGroup, "#run when before(:all) fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+ 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
- ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" }
- end
+ before do
+ example_group.it("should be pending") do
+ pending("Example passes") {true.should be_true}
+ end
+ end
- it "should not run any example" do
- spec_ran = false
- example_group.it("test") {spec_ran = true}
- example_group.run
- spec_ran.should be_false
+ it "should send example_pending to formatter" do
+ @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes")
+ example_group.run
+ end
end
- it "should run ExampleGroup after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
+ describe ExampleGroup, "#run when before(:all) fails" do
+ it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
- it "should run example_group after(:all)" do
- after_all_ran = false
- example_group.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
- end
+ before do
+ ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" }
+ end
- it "should supply before(:all) as description" do
- @reporter.should_receive(:failure) do |example, error|
- example.description.should eql("before(:all)")
- error.message.should eql("before(:all) failure")
+ it "should not run any example" do
+ spec_ran = false
+ example_group.it("test") {spec_ran = true}
+ example_group.run
+ spec_ran.should be_false
end
- example_group.it("test") {true}
- example_group.run
- end
- end
+ it "should run ExampleGroup after(:all)" do
+ after_all_ran = false
+ ExampleGroup.after(:all) { after_all_ran = true }
+ example_group.run
+ after_all_ran.should be_true
+ end
- describe ExampleGroup, "#run when before(:each) fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+ it "should run example_group after(:all)" do
+ after_all_ran = false
+ example_group.after(:all) { after_all_ran = true }
+ example_group.run
+ after_all_ran.should be_true
+ end
- before do
- ExampleGroup.before(:each) { raise NonStandardError }
- end
+ it "should supply before(:all) as description" do
+ @reporter.should_receive(:failure) do |example, error|
+ example.description.should eql("before(:all)")
+ error.message.should eql("before(:all) failure")
+ end
- it "should run after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
+ example_group.it("test") {true}
+ example_group.run
+ end
end
- end
- describe ExampleGroup, "#run when any example fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+ describe ExampleGroup, "#run when before(:each) fails" do
+ it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
- before do
- example_group.it("should") { raise NonStandardError }
- end
+ before do
+ ExampleGroup.before(:each) { raise NonStandardError }
+ end
- it "should run after(:all)" do
- after_all_ran = false
- ExampleGroup.after(:all) { after_all_ran = true }
- example_group.run
- after_all_ran.should be_true
+ it "should run after(:all)" do
+ after_all_ran = false
+ ExampleGroup.after(:all) { after_all_ran = true }
+ example_group.run
+ after_all_ran.should be_true
+ end
end
- end
- describe ExampleGroup, "#run when first after(:each) block fails" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+ describe ExampleGroup, "#run when any example 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
+ before do
+ example_group.it("should") { raise NonStandardError }
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"
+ it "should run after(:all)" do
+ after_all_ran = false
+ ExampleGroup.after(:all) { after_all_ran = true }
+ example_group.run
+ after_all_ran.should be_true
end
end
- it "should run second after(:each) block" do
- reporter.should_receive(:example_finished) do |example, error|
- example.should equal(example)
- error.message.should eql("first")
- end
- example_group.run
- example_group.first_after_ran.should be_true
- example_group.second_after_ran.should be_true
- end
- end
+ describe ExampleGroup, "#run when first after(:each) block fails" do
+ it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
- 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_after_ran, :second_after_ran
+ end
+ example_group.first_after_ran = false
+ example_group.second_after_ran = false
- before do
- class << example_group
- attr_accessor :first_before_ran, :second_before_ran
+ 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
- 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
+ it "should run second after(:each) block" do
+ reporter.should_receive(:example_finished) do |example, error|
+ example.should equal(example)
+ error.message.should eql("first")
+ end
+ example_group.run
+ example_group.first_after_ran.should be_true
+ example_group.second_after_ran.should be_true
end
end
- it "should not run second before(:each)" do
- reporter.should_receive(:example_finished) do |name, error|
- error.message.should eql("first")
+ describe ExampleGroup, "#run when first before(:each) block fails" do
+ it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+
+ before do
+ class << example_group
+ attr_accessor :first_before_ran, :second_before_ran
+ end
+ example_group.first_before_ran = false
+ example_group.second_before_ran = false
+
+ example_group.before(:each) do
+ self.class.first_before_ran = true
+ raise "first"
+ end
+ example_group.before(:each) do
+ self.class.second_before_ran = true
+ end
+ end
+
+ it "should not run second before(:each)" do
+ reporter.should_receive(:example_finished) do |name, error|
+ error.message.should eql("first")
+ end
+ example_group.run
+ example_group.first_before_ran.should be_true
+ example_group.second_before_ran.should be_false
end
- example_group.run
- example_group.first_before_ran.should be_true
- example_group.second_before_ran.should be_false
end
- end
- describe ExampleGroup, "#run when failure in after(:all)" do
- it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
+ 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
+ before do
+ ExampleGroup.after(:all) { raise NonStandardError, "in after(:all)" }
+ end
- it "should return false" do
- example_group.run.should be_false
+ it "should return false" do
+ example_group.run.should be_false
+ end
end
end
end
@@ -659,7 +659,7 @@
example_group = Class.new(ExampleSubclass) do
describe(Array)
end
- example_group.send(:described_type).should == Array
+ example_group.__send__(:described_type).should == Array
end
it "should concat descriptions when nested" do
@@ -671,53 +671,5 @@
$nested_group.description.to_s.should == "Array when empty"
end
end
-
- describe Enumerable do
- before(:each) do
- Kernel.stub!(:warn)
- end
-
- def each(&block)
- ["4", "2", "1"].each(&block)
- end
-
- it "should be included in examples because it is a module" do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
-
- describe "An", Enumerable, "as a second argument" do
- before(:each) do
- Kernel.stub!(:warn)
- end
-
- def each(&block)
- ["4", "2", "1"].each(&block)
- end
-
- it "should be included in examples because it is a module" do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
-
- describe Enumerable do
- describe "as the parent of nested example groups" do
- before(:each) do
- Kernel.stub!(:warn)
- end
-
- it "should be included in examples because it is a module" do
- pending("need to make sure nested groups know the described type") do
- map{|e| e.to_i}.should == [4,2,1]
- end
- end
- end
- end
-
- describe String do
- it "should not be included in examples because it is not a module" do
- lambda{self.map}.should raise_error(NoMethodError, /undefined method `map' for/)
- end
- end
end
end
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_matcher_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_matcher_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_matcher_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_matcher_spec.rb Wed Dec 10 17:34:18 2008
@@ -2,31 +2,14 @@
module Spec
module Example
- module ExampleMatcherSpecHelper
- class MatchDescription
- def initialize(description)
- @description = description
- end
-
- def matches?(matcher)
- matcher.matches?(@description)
- end
-
- def failure_message
- "expected matcher.matches?(#{@description.inspect}) to return true, got false"
- end
-
- def negative_failure_message
- "expected matcher.matches?(#{@description.inspect}) to return false, got true"
- end
- end
+ describe ExampleMatcher, "#matches?" do
def match_description(description)
- MatchDescription.new(description)
+ simple_matcher do |actual, matcher|
+ matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false"
+ matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true"
+ actual.matches?(description)
+ end
end
- end
-
- describe ExampleMatcher, "#matches?" do
- include ExampleMatcherSpecHelper
it "should match correct example_group and example" do
matcher = ExampleMatcher.new("example_group", "example")
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_methods_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_methods_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_methods_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/example_methods_spec.rb Wed Dec 10 17:34:18 2008
@@ -22,105 +22,300 @@
end
describe "lifecycle" do
- before do
- @original_rspec_options = $rspec_options
- @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
- $rspec_options = @options
- @options.formatters << mock("formatter", :null_object => true)
- @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
- @reporter = FakeReporter.new(@options)
- @options.reporter = @reporter
+ with_sandboxed_options do
+ before do
+ @options.formatters << mock("formatter", :null_object => true)
+ @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
+ @reporter = FakeReporter.new(@options)
+ @options.reporter = @reporter
+
+ ExampleGroup.before_all_parts.should == []
+ ExampleGroup.before_each_parts.should == []
+ ExampleGroup.after_each_parts.should == []
+ ExampleGroup.after_all_parts.should == []
+ def ExampleGroup.count
+ @count ||= 0
+ @count = @count + 1
+ @count
+ end
+ end
- ExampleMethods.before_all_parts.should == []
- ExampleMethods.before_each_parts.should == []
- ExampleMethods.after_each_parts.should == []
- ExampleMethods.after_all_parts.should == []
- def ExampleMethods.count
- @count ||= 0
- @count = @count + 1
- @count
+ after do
+ ExampleGroup.instance_variable_set("@before_all_parts", [])
+ ExampleGroup.instance_variable_set("@before_each_parts", [])
+ ExampleGroup.instance_variable_set("@after_each_parts", [])
+ ExampleGroup.instance_variable_set("@after_all_parts", [])
end
- end
- after do
- $rspec_options = @original_rspec_options
- ExampleMethods.instance_variable_set("@before_all_parts", [])
- ExampleMethods.instance_variable_set("@before_each_parts", [])
- ExampleMethods.instance_variable_set("@after_each_parts", [])
- ExampleMethods.instance_variable_set("@after_all_parts", [])
- end
+ it "should pass before and after callbacks to all ExampleGroup subclasses" do
+ ExampleGroup.before(:suite) do
+ ExampleGroup.count.should == 1
+ end
- it "should pass before and after callbacks to all ExampleGroup subclasses" do
- ExampleMethods.before(:suite) do
- ExampleMethods.count.should == 1
- end
+ ExampleGroup.before(:all) do
+ ExampleGroup.count.should == 2
+ end
- ExampleMethods.before(:all) do
- ExampleMethods.count.should == 2
- end
+ ExampleGroup.before(:each) do
+ ExampleGroup.count.should == 3
+ end
- ExampleMethods.before(:each) do
- ExampleMethods.count.should == 3
- end
+ ExampleGroup.after(:each) do
+ ExampleGroup.count.should == 4
+ end
- ExampleMethods.after(:each) do
- ExampleMethods.count.should == 4
- end
+ ExampleGroup.after(:all) do
+ ExampleGroup.count.should == 5
+ end
- ExampleMethods.after(:all) do
- ExampleMethods.count.should == 5
- end
+ ExampleGroup.after(:suite) do
+ ExampleGroup.count.should == 6
+ end
- ExampleMethods.after(:suite) do
- ExampleMethods.count.should == 6
+ Class.new(ExampleGroup) do
+ it "should use ExampleMethods callbacks" do end
+ end
+ @options.run_examples
+ ExampleGroup.count.should == 7
end
- @example_group = Class.new(ExampleGroup) do
- it "should use ExampleMethods callbacks" do
+ describe "eval_block" do
+ before(:each) do
+ @example_group = Class.new(ExampleGroup)
+ end
+
+ describe "with a given description" do
+ it "should provide the given description" do
+ @example = @example_group.it("given description") { 2.should == 2 }
+ @example.eval_block
+ @example.description.should == "given description"
+ end
+ end
+
+ describe "with no given description" do
+ it "should provide the generated description" do
+ @example = @example_group.it { 2.should == 2 }
+ @example.eval_block
+ @example.description.should == "should == 2"
+ end
+ end
+
+ describe "with no implementation" do
+ it "should raise an NotYetImplementedError" do
+ lambda {
+ @example = @example_group.it
+ @example.eval_block
+ }.should raise_error(Spec::Example::NotYetImplementedError, "Not Yet Implemented")
+ end
+
+ def extract_error(&blk)
+ begin
+ blk.call
+ rescue Exception => e
+ return e
+ end
+
+ nil
+ end
+
+ it "should use the proper file and line number for the NotYetImplementedError" do
+ file = __FILE__
+ line_number = __LINE__ + 3
+
+ error = extract_error do
+ @example = @example_group.it
+ @example.eval_block
+ end
+
+ error.pending_caller.should == "#{file}:#{line_number}"
+ end
end
end
- @options.run_examples
- ExampleMethods.count.should == 7
end
+ end
- describe "run_with_description_capturing" do
+ describe "#backtrace" do
+ with_sandboxed_options do
+ it "returns the backtrace from where the example was defined" do
+ example_group = Class.new(ExampleGroup) do
+ example "of something" do; end
+ end
+
+ example = example_group.examples.first
+ example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
+ end
+ end
+ end
+
+ describe "#implementation_backtrace (deprecated)" do
+ with_sandboxed_options do
before(:each) do
- @example_group = Class.new(ExampleGroup) do end
- @example = @example_group.new("foo", &(lambda { 2.should == 2 }))
- @example.run_with_description_capturing
+ Kernel.stub!(:warn)
end
- it "should provide the generated description" do
- @example.instance_eval { @_matcher_description }.should == "should == 2"
+ it "sends a deprecation warning" do
+ example_group = Class.new(ExampleGroup) {}
+ example = example_group.example("") {}
+ Kernel.should_receive(:warn).with(/#implementation_backtrace.*deprecated.*#backtrace instead/m)
+ example.implementation_backtrace
+ end
+
+ it "returns the backtrace from where the example was defined" do
+ example_group = Class.new(ExampleGroup) do
+ example "of something" do; end
+ end
+
+ example = example_group.examples.first
+ example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
end
+ end
+ end
- it "should clear the global generated_description" do
- Spec::Matchers.generated_description.should == nil
+ describe "#full_description" do
+ it "should return the full description of the ExampleGroup and Example" do
+ example_group = Class.new(ExampleGroup).describe("An ExampleGroup") do
+ it "should do something" do
+ end
+ end
+ example = example_group.examples.first
+ example.full_description.should == "An ExampleGroup should do something"
+ end
+ end
+
+ describe "#subject" do
+ with_sandboxed_options do
+ it "should return an instance variable named after the described type" do
+ example_group = Class.new(ExampleGroup).describe(Array) do
+ example {}
+ end
+ example = example_group.examples.first
+ example.subject.should == []
+ end
+
+ it "should not barf on a module (as opposed to a class)" do
+ example_group = Class.new(ExampleGroup).describe(ObjectSpace) do
+ example {}
+ end
+ example_group.examples.first.subject.should be_nil
+ end
+
+ it "should not barf on a string" do
+ example_group = Class.new(ExampleGroup).describe('foo') do
+ example {}
+ end
+ example_group.examples.first.subject.should be_nil
+ end
+
+ it "should interact with the same scope as the before block" do
+ example_group = Class.new(ExampleGroup) do
+ subject { @foo = 'foo'}
+ example { should == @foo}
+ it { should == 'foo'}
+ end
+ example_group.run.should be_true
end
end
end
- describe "#implementation_backtrace" do
- it "returns the backtrace of where the implementation was defined" do
- example_group = Class.new(ExampleGroup) do
- it "should use ExampleMethods callbacks" do
+ describe "#should" do
+ with_sandboxed_options do
+ class Thing
+ def ==(other)
+ true
end
end
- example = example_group.examples.first
- example.implementation_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
+
+ describe "in an ExampleGroup with the ivar defined in before" do
+ attr_reader :example, :success
+
+ before(:each) do
+ example_group = describe(Thing, "1") do
+ before(:each) { @spec_example_thing = 'expected' }
+ it { should eql('expected') }
+ end
+ @example = example_group.examples.first
+ @success = example_group.run
+ end
+
+ it "should create an example using the description from the matcher" do
+ example.description.should == 'should eql "expected"'
+ end
+
+ it "should test the matcher returned from the block" do
+ success.should be_true
+ end
+ end
+
+ describe "in an ExampleGroup with the subject defined using #subject" do
+ it "should create an example using the description from the matcher" do
+ example_group = describe(Thing, "2") do
+ subject {'this is the subject'}
+ it { should eql('this is the subject') }
+ end
+ example = example_group.examples.first
+ example_group.run
+ example.description.should =~ /should eql "this is the subject"/
+ end
+ end
+
+ describe "in an ExampleGroup using an implicit ivar" do
+ it "should create an example using the description from the matcher" do
+ example_group = describe(Thing, "3") do
+ it { should == Thing.new }
+ end
+ example = example_group.examples.first
+ success = example_group.run
+ example.description.should =~ /should == #<Spec::Example::Thing/
+ success.should be_true
+ end
+ end
+
+ after(:each) do
+ ExampleGroup.reset
+ end
+
end
end
- describe "#__full_description" do
- it "should return the full description of the ExampleGroup and Example" do
- example_group = Class.new(ExampleGroup).describe("An ExampleGroup") do
- it "should do something" do
+ describe "#should_not" do
+ with_sandboxed_options do
+
+ attr_reader :example_group, :example, :success
+
+ before do
+ @example_group = Class.new(ExampleGroup) do
+ def subject; @actual; end
+ before(:each) { @actual = 'expected' }
+ it { should_not eql('unexpected') }
end
+ @example = @example_group.examples.first
+
+ @success = example_group.run
end
- example = example_group.examples.first
- example.__full_description.should == "An ExampleGroup should do something"
+
+ it "should create an example using the description from the matcher" do
+ example.description.should == 'should not eql "unexpected"'
+ end
+
+ it "should test the matcher returned from the block" do
+ success.should be_true
+ end
+
+ after do
+ ExampleGroup.reset
+ end
+
end
end
end
+
+ describe "#options" do
+ it "should expose the options hash" do
+ example_group = Class.new(ExampleGroup)
+ example = example_group.example "name", :this => 'that' do; end
+ example.options[:this].should == 'that'
+ end
+ end
+
end
-end
\ No newline at end of file
+end
Added: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb?rev=725524&view=auto
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb (added)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb Wed Dec 10 17:34:18 2008
@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../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
+
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/pending_module_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/pending_module_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/pending_module_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/pending_module_spec.rb Wed Dec 10 17:34:18 2008
@@ -4,28 +4,136 @@
it 'should raise an ExamplePendingError if no block is supplied' do
lambda {
- include Pending
pending "TODO"
}.should raise_error(ExamplePendingError, /TODO/)
end
it 'should raise an ExamplePendingError if a supplied block fails as expected' do
lambda {
- include Pending
pending "TODO" do
raise "oops"
end
}.should raise_error(ExamplePendingError, /TODO/)
end
+ it 'should raise an ExamplePendingError if a supplied block fails as expected with a mock' do
+ lambda {
+ pending "TODO" do
+ m = mock('thing')
+ m.should_receive(:foo)
+ m.rspec_verify
+ end
+ }.should raise_error(ExamplePendingError, /TODO/)
+ end
+
it 'should raise a PendingExampleFixedError if a supplied block starts working' do
lambda {
- include Pending
pending "TODO" do
# success!
end
}.should raise_error(PendingExampleFixedError, /TODO/)
end
+
+ it "should have the correct file and line number for pending given with a block which fails" do
+ file = __FILE__
+ line_number = __LINE__ + 2
+ begin
+ pending do
+ raise
+ end
+ rescue => error
+ error.pending_caller.should == "#{file}:#{line_number}"
+ end
+ end
+
+ it "should have the correct file and line number for pending given with no block" do
+ file = __FILE__
+ line_number = __LINE__ + 2
+ begin
+ pending("TODO")
+ rescue => error
+ error.pending_caller.should == "#{file}:#{line_number}"
+ end
+ end
+ end
+
+ describe ExamplePendingError do
+ it "should have the caller (from two calls from initialization)" do
+ two_calls_ago = caller[0]
+ ExamplePendingError.new("a message").pending_caller.should == two_calls_ago
+ end
+
+ it "should keep the trace information from initialization" do
+ two_calls_ago = caller[0]
+ obj = ExamplePendingError.new("a message")
+ obj.pending_caller
+ def another_caller(obj)
+ obj.pending_caller
+ end
+
+ another_caller(obj).should == two_calls_ago
+ end
+
+ it "should have the message provided" do
+ ExamplePendingError.new("a message").message.should == "a message"
+ end
+
+ it "should use a 'ExamplePendingError' as it's default message" do
+ ExamplePendingError.new.message.should == "Spec::Example::ExamplePendingError"
+ end
+ end
+
+ describe NotYetImplementedError do
+ def rspec_root
+ File.expand_path(__FILE__.gsub("/spec/spec/example/pending_module_spec.rb", "/lib"))
+ end
+
+ it "should have the root rspec path" do
+ NotYetImplementedError::RSPEC_ROOT_LIB.should == rspec_root
+ end
+
+ it "should always have the error 'Not Yet Implemented'" do
+ NotYetImplementedError.new([]).message.should == "Not Yet Implemented"
+ end
+
+ describe "pending_caller" do
+ it "should select an element out of the backtrace" do
+ error = NotYetImplementedError.new(["foo/bar.rb:18"])
+
+ error.pending_caller.should == "foo/bar.rb:18"
+ end
+
+ it "should actually report the element from the backtrace" do
+ error = NotYetImplementedError.new(["bar.rb:18"])
+
+ error.pending_caller.should == "bar.rb:18"
+ end
+
+ it "should not use an element with the rspec root path" do
+ error = NotYetImplementedError.new(["#{rspec_root}:8"])
+
+ error.pending_caller.should be_nil
+ end
+
+ it "should select the first line in the backtrace which isn't in the rspec root" do
+ error = NotYetImplementedError.new([
+ "#{rspec_root}/foo.rb:2",
+ "#{rspec_root}/foo/bar.rb:18",
+ "path1.rb:22",
+ "path2.rb:33"
+ ])
+
+ error.pending_caller.should == "path1.rb:22"
+ end
+
+ it "should cache the caller" do
+ backtrace = mock('backtrace')
+ backtrace.should_receive(:detect).once
+
+ error = NotYetImplementedError.new(backtrace)
+ error.pending_caller.should == error.pending_caller
+ end
+ end
end
end
end
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb Wed Dec 10 17:34:18 2008
@@ -3,262 +3,254 @@
module Spec
module Example
describe ExampleGroup, "with :shared => true" do
- it_should_behave_like "sandboxed rspec_options"
- attr_reader :formatter, :example_group
- before(:each) do
- @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
- options.formatters << formatter
- @example_group = Class.new(ExampleGroup).describe("example_group")
- class << example_group
- public :include
+ with_sandboxed_options do
+ attr_reader :formatter, :example_group
+ before(:each) do
+ @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
+ options.formatters << formatter
+ @example_group = Class.new(ExampleGroup).describe("example_group")
+ class << example_group
+ public :include
+ end
end
- end
-
- after(:each) do
- @formatter.rspec_verify
- @example_group = nil
- $shared_example_groups.clear unless $shared_example_groups.nil?
- end
-
- def make_shared_example_group(name, opts=nil, &block)
- example_group = SharedExampleGroup.new(name, :shared => true, &block)
- SharedExampleGroup.add_shared_example_group(example_group)
- example_group
- end
-
- def non_shared_example_group()
- @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
- end
-
- it "should accept an optional options hash" do
- lambda { Class.new(ExampleGroup).describe("context") }.should_not raise_error(Exception)
- lambda { Class.new(ExampleGroup).describe("context", :shared => true) }.should_not raise_error(Exception)
- end
- it "should return all shared example_groups" do
- b1 = make_shared_example_group("b1", :shared => true) {}
- b2 = make_shared_example_group("b2", :shared => true) {}
-
- b1.should_not be(nil)
- b2.should_not be(nil)
-
- SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
- SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
- end
-
- it "should register as shared example_group" do
- example_group = make_shared_example_group("example_group") {}
- SharedExampleGroup.shared_example_groups.should include(example_group)
- end
-
- it "should not be shared when not configured as shared" do
- example_group = non_shared_example_group
- SharedExampleGroup.shared_example_groups.should_not include(example_group)
- end
+ 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 {}
+ 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 "should complain when adding a second shared example_group with the same description" do
- describe "shared example_group", :shared => true do
+ 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
- lambda do
+
+ it "complains when adding a second shared example_group with the same description" do
describe "shared example_group", :shared => true do
end
- end.should raise_error(ArgumentError)
- end
-
- it "should NOT complain when adding the same shared example_group instance again" do
- shared_example_group = Class.new(ExampleGroup).describe("shared example_group", :shared => true)
- SharedExampleGroup.add_shared_example_group(shared_example_group)
- SharedExampleGroup.add_shared_example_group(shared_example_group)
- end
+ 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 "should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
- lambda do
- 2.times do
- describe "shared example_group which gets loaded twice", :shared => true do
+ 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,
+ :spec_path => "/my/spec/a/../shared.rb"
+ )
+ SharedExampleGroup.register(
+ "shared example_group",
+ :shared => true,
+ :spec_path => "/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,
+ :spec_path => "/my/spec/a/shared.rb"
+ )
+ lambda do
+ SharedExampleGroup.register(
+ "shared example_group",
+ :shared => true,
+ :spec_path => "/my/spec/b/shared.rb"
+ )
+ end.should raise_error(ArgumentError, /already exists/)
+ end
+
+ 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
- end.should_not raise_error(ArgumentError)
- end
- it "should NOT complain when adding the same shared example_group in same file with different absolute path" do
- shared_example_group_1 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/a/../shared.rb"
- )
- shared_example_group_2 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/b/../shared.rb"
- )
+ 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
- SharedExampleGroup.add_shared_example_group(shared_example_group_1)
- SharedExampleGroup.add_shared_example_group(shared_example_group_2)
- 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
- it "should complain when adding a different shared example_group with the same name in a different file with the same basename" do
- shared_example_group_1 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/a/shared.rb"
- )
- shared_example_group_2 = Class.new(ExampleGroup).describe(
- "shared example_group",
- :shared => true,
- :spec_path => "/my/spec/b/shared.rb"
- )
-
- SharedExampleGroup.add_shared_example_group(shared_example_group_1)
- lambda do
- SharedExampleGroup.add_shared_example_group(shared_example_group_2)
- end.should raise_error(ArgumentError, /already exists/)
- end
+ shared_example_group_1 = SharedExampleGroup.register("shared example_group 2") do
+ it("shared example 2") {}
+ end
- it "should add examples to current example_group using it_should_behave_like" do
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") {}
- it("shared example 2") {}
+ 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
- example_group.it("example") {}
- example_group.number_of_examples.should == 1
- example_group.it_should_behave_like("shared example_group")
- example_group.number_of_examples.should == 3
- end
-
- it "should add examples to current example_group using include" do
- shared_example_group = describe "all things", :shared => true do
- it "should do stuff" do end
- end
+ 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 = describe "one thing" do
+ include shared_example_group
+ end
- example_group.number_of_examples.should == 1
- end
-
- it "should add examples to current example_group using it_should_behave_like with a module" do
- AllThings = describe "all things", :shared => true do
- it "should do stuff" do end
+ 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 = describe "one thing" do
+ it_should_behave_like AllThings
+ end
- example_group.number_of_examples.should == 1
- end
-
- it "should run shared examples" do
- shared_example_ran = false
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") { shared_example_ran = true }
+ example_group.number_of_examples.should == 1
end
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_example_ran.should be_true
- end
+ it "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
- it "should run setup and teardown from shared example_group" do
- shared_setup_ran = false
- shared_teardown_ran = false
- shared_example_group = make_shared_example_group("shared example_group") do
- before { shared_setup_ran = true }
- after { shared_teardown_ran = true }
- it("shared example") { shared_example_ran = true }
- end
-
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_setup_ran.should be_true
- shared_teardown_ran.should be_true
- end
+ example_ran = false
- it "should run before(:all) and after(:all) only once from shared example_group" do
- shared_before_all_run_count = 0
- shared_after_all_run_count = 0
- shared_example_group = make_shared_example_group("shared example_group") do
- before(:all) { shared_before_all_run_count += 1}
- after(:all) { shared_after_all_run_count += 1}
- it("shared example") { shared_example_ran = true }
- end
-
- example_ran = false
-
- example_group.it_should_behave_like("shared example_group")
- example_group.it("example") {example_ran = true}
- example_group.run
- example_ran.should be_true
- shared_before_all_run_count.should == 1
- shared_after_all_run_count.should == 1
- end
+ example_group.it_should_behave_like("shared example_group")
+ example_group.it("example") {example_ran = true}
+ example_group.run
+ example_ran.should be_true
+ shared_example_ran.should be_true
+ end
+
+ it "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
- it "should include modules, included into shared example_group, into current example_group" do
- @formatter.should_receive(:add_example_group).with(any_args)
+ example_group.it_should_behave_like("shared example_group")
+ example_group.it("example") {example_ran = true}
+ example_group.run
+ example_ran.should be_true
+ shared_setup_ran.should be_true
+ shared_teardown_ran.should be_true
+ end
+
+ it "should run before(:all) and after(:all) only once from shared example_group" do
+ shared_before_all_run_count = 0
+ shared_after_all_run_count = 0
+ shared_example_group = 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
- shared_example_group = make_shared_example_group("shared example_group") do
- it("shared example") { shared_example_ran = true }
+ example_ran = false
+
+ example_group.it_should_behave_like("shared example_group")
+ example_group.it("example") {example_ran = true}
+ example_group.run
+ example_ran.should be_true
+ shared_before_all_run_count.should == 1
+ shared_after_all_run_count.should == 1
end
- mod1_method_called = false
- mod1 = Module.new do
- define_method :mod1_method do
- mod1_method_called = true
+ it "should include modules, included into shared example_group, into current example_group" do
+ @formatter.should_receive(:add_example_group).with(any_args)
+
+ shared_example_group = SharedExampleGroup.register("shared example_group") do
+ it("shared example") { shared_example_ran = true }
end
- end
- mod2_method_called = false
- mod2 = Module.new do
- define_method :mod2_method do
- mod2_method_called = true
+ 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
- end
- shared_example_group.include mod2
+ shared_example_group.__send__ :include, mod2
- example_group.it_should_behave_like("shared example_group")
- example_group.include mod1
+ example_group.it_should_behave_like("shared example_group")
+ example_group.include mod1
- example_group.it("test") do
- mod1_method
- mod2_method
+ example_group.it("test") do
+ mod1_method
+ mod2_method
+ end
+ example_group.run
+ mod1_method_called.should be_true
+ mod2_method_called.should be_true
end
- example_group.run
- mod1_method_called.should be_true
- mod2_method_called.should be_true
- end
- it "should make methods defined in the shared example_group available in consuming example_group" do
- shared_example_group = make_shared_example_group("shared example_group xyz") do
- def a_shared_helper_method
- "this got defined in a shared example_group"
+ it "should make methods defined in the shared example_group available in consuming example_group" do
+ shared_example_group = SharedExampleGroup.register("shared example_group xyz") do
+ def a_shared_helper_method
+ "this got defined in a shared example_group"
+ end
end
+ example_group.it_should_behave_like("shared example_group xyz")
+ success = false
+ example_group.it("should access a_shared_helper_method") do
+ a_shared_helper_method
+ success = true
+ end
+ example_group.run
+ success.should be_true
end
- example_group.it_should_behave_like("shared example_group xyz")
- success = false
- example_group.it("should access a_shared_helper_method") do
- a_shared_helper_method
- success = true
- end
- example_group.run
- success.should be_true
- end
- it "should raise when named shared example_group can not be found" do
- lambda {
- example_group.it_should_behave_like("non-existent shared example group")
- violated
- }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
+ 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
Modified: incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb
URL: http://svn.apache.org/viewvc/incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb?rev=725524&r1=725523&r2=725524&view=diff
==============================================================================
--- incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb (original)
+++ incubator/olio/webapp/rails/trunk/vendor/plugins/rspec/spec/spec/expectations/extensions/object_spec.rb Wed Dec 10 17:34:18 2008
@@ -39,12 +39,6 @@
}.should raise_error(Spec::Expectations::InvalidMatcherError)
end
- it "should raise error if it receives nil" do
- lambda {
- @target.should nil
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
it "should raise error if it receives no argument and it is not used as a left side of an operator" do
pending "Is it even possible to catch this?"
lambda {
@@ -92,12 +86,6 @@
}.should raise_error(Spec::Expectations::InvalidMatcherError)
end
- it "should raise error if it receives nil" do
- lambda {
- @target.should_not nil
- }.should raise_error(Spec::Expectations::InvalidMatcherError)
- end
-
it "should raise error if it receives no argument and it is not used as a left side of an operator" do
pending "Is it even possible to catch this?"
lambda {