vendor/gems/rspec-1.1.2/spec/spec/example/example_group_spec.rb

   1 require File.dirname(__FILE__) + '/../../spec_helper'
   2
   3 module Spec
   4   module Example
   5     class ExampleModuleScopingSpec < ExampleGroup
   6       describe ExampleGroup, "via a class definition"
   7
   8       module Foo
   9         module Bar
  10           def self.loaded?
  11             true
  12           end
  13         end
  14       end
  15       include Foo
  16
  17       it "should understand module scoping" do
  18         Bar.should be_loaded
  19       end
  20
  21       @@foo = 1
  22
  23       it "should allow class variables to be defined" do
  24         @@foo.should == 1
  25       end
  26     end
  27
  28     class ExampleClassVariablePollutionSpec < ExampleGroup
  29       describe ExampleGroup, "via a class definition without a class variable"
  30
  31       it "should not retain class variables from other Example classes" do
  32         proc do
  33           @@foo
  34         end.should raise_error
  35       end
  36     end
  37
  38     describe ExampleGroup, "#pending" do
  39       it "should raise a Pending error when its block fails" do
  40         block_ran = false
  41         lambda {
  42           pending("something") do
  43             block_ran = true
  44             raise "something wrong with my example"
  45           end
  46         }.should raise_error(Spec::Example::ExamplePendingError, "something")
  47         block_ran.should == true
  48       end
  49
  50       it "should raise Spec::Example::PendingExampleFixedError when its block does not fail" do
  51         block_ran = false
  52         lambda {
  53           pending("something") do
  54             block_ran = true
  55           end
  56         }.should raise_error(Spec::Example::PendingExampleFixedError, "Expected pending 'something' to fail. No Error was raised.")
  57         block_ran.should == true
  58       end
  59     end
  60
  61     describe ExampleGroup, "#run with failure in example", :shared => true do
  62       it "should add an example failure to the TestResult" do
  63         example_group.run.should be_false
  64       end
  65     end
  66
  67     describe ExampleGroup, "#run" do
  68       it_should_behave_like "sandboxed rspec_options"
  69       attr_reader :example_group, :formatter, :reporter
  70       before :each do
  71         @formatter = mock("formatter", :null_object => true)
  72         options.formatters << formatter
  73         options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
  74         @reporter = FakeReporter.new(options)
  75         options.reporter = reporter
  76         @example_group = Class.new(ExampleGroup) do
  77           describe("example")
  78           it "does nothing" do
  79           end
  80         end
  81         class << example_group
  82           public :include
  83         end
  84       end
  85
  86       after :each do
  87         ExampleGroup.reset
  88       end
  89
  90       it "should not run when there are no examples" do
  91         example_group = Class.new(ExampleGroup) do
  92           describe("Foobar")
  93         end
  94         example_group.examples.should be_empty
  95
  96         reporter = mock("Reporter")
  97         reporter.should_not_receive(:add_example_group)
  98         example_group.run
  99       end
 100
 101       describe "when before_each fails" do
 102         before(:each) do
 103           $example_ran = $after_each_ran = false
 104           @example_group = describe("Foobar") do
 105             before(:each) {raise}
 106             it "should not be run" do
 107               $example_ran = true
 108             end
 109             after(:each) do
 110               $after_each_ran = true
 111             end
 112           end
 113         end
 114
 115         it "should not run example block" do
 116           example_group.run
 117           $example_ran.should be_false
 118         end
 119
 120         it "should run after_each" do
 121           example_group.run
 122           $after_each_ran.should be_true
 123         end
 124
 125         it "should report failure location when in before_each" do
 126           reporter.should_receive(:example_finished) do |example_group, error|
 127             error.message.should eql("in before_each")
 128           end
 129           example_group.run
 130         end
 131       end
 132
 133       describe ExampleGroup, "#run on dry run" do
 134         before do
 135           @options.dry_run = true
 136         end
 137
 138         it "should not run before(:all) or after(:all)" do
 139           before_all_ran = false
 140           after_all_ran = false
 141           ExampleGroup.before(:all) { before_all_ran = true }
 142           ExampleGroup.after(:all) { after_all_ran = true }
 143           example_group.it("should") {}
 144           example_group.run
 145           before_all_ran.should be_false
 146           after_all_ran.should be_false
 147         end
 148
 149         it "should not run example" do
 150           example_ran = false
 151           example_group.it("should") {example_ran = true}
 152           example_group.run
 153           example_ran.should be_false
 154         end
 155       end
 156
 157       describe ExampleGroup, "#run with specified examples" do
 158         attr_reader :examples_that_were_run
 159         before do
 160           @examples_that_were_run = []
 161         end
 162
 163         describe "when specified_examples matches entire ExampleGroup" do
 164           before do
 165             examples_that_were_run = @examples_that_were_run
 166             @example_group = Class.new(ExampleGroup) do
 167               describe("the ExampleGroup")
 168               it("should be run") do
 169                 examples_that_were_run << 'should be run'
 170               end
 171
 172               it("should also be run") do
 173                 examples_that_were_run << 'should also be run'
 174               end
 175             end
 176             options.examples = ["the ExampleGroup"]
 177           end
 178
 179           it "should not run the Examples in the ExampleGroup" do
 180             example_group.run
 181             examples_that_were_run.should == ['should be run', 'should also be run']
 182           end
 183         end
 184
 185         describe ExampleGroup, "#run when specified_examples matches only Example description" do
 186           before do
 187             examples_that_were_run = @examples_that_were_run
 188             @example_group = Class.new(ExampleGroup) do
 189               describe("example")
 190               it("should be run") do
 191                 examples_that_were_run << 'should be run'
 192               end
 193             end
 194             options.examples = ["should be run"]
 195           end
 196
 197           it "should not run the example" do
 198             example_group.run
 199             examples_that_were_run.should == ['should be run']
 200           end
 201         end
 202
 203         describe ExampleGroup, "#run when specified_examples does not match an Example description" do
 204           before do
 205             examples_that_were_run = @examples_that_were_run
 206             @example_group = Class.new(ExampleGroup) do
 207               describe("example")
 208               it("should be something else") do
 209                 examples_that_were_run << 'should be something else'
 210               end
 211             end
 212             options.examples = ["does not match anything"]
 213           end
 214
 215           it "should not run the example" do
 216             example_group.run
 217             examples_that_were_run.should == []
 218           end
 219         end
 220
 221         describe ExampleGroup, "#run when specified_examples matches an Example description" do
 222           before do
 223             examples_that_were_run = @examples_that_were_run
 224             @example_group = Class.new(ExampleGroup) do
 225               describe("example")
 226               it("should be run") do
 227                 examples_that_were_run << 'should be run'
 228               end
 229               it("should not be run") do
 230                 examples_that_were_run << 'should not be run'
 231               end
 232             end
 233             options.examples = ["should be run"]
 234           end
 235
 236           it "should run only the example, when there in only one" do
 237             example_group.run
 238             examples_that_were_run.should == ["should be run"]
 239           end
 240
 241           it "should run only the one example" do
 242             example_group.run
 243             examples_that_were_run.should == ["should be run"]          end
 244         end
 245       end
 246
 247       describe ExampleGroup, "#run with success" do
 248         before do
 249           @special_example_group = Class.new(ExampleGroup)
 250           ExampleGroupFactory.register(:special, @special_example_group)
 251           @not_special_example_group = Class.new(ExampleGroup)
 252           ExampleGroupFactory.register(:not_special, @not_special_example_group)
 253         end
 254
 255         after do
 256           ExampleGroupFactory.reset
 257         end
 258
 259         it "should send reporter add_example_group" do
 260           example_group.run
 261           reporter.example_groups.should == [example_group]
 262         end
 263
 264         it "should run example on run" do
 265           example_ran = false
 266           example_group.it("should") {example_ran = true}
 267           example_group.run
 268           example_ran.should be_true
 269         end
 270
 271         it "should run before(:all) block only once" do
 272           before_all_run_count_run_count = 0
 273           example_group.before(:all) {before_all_run_count_run_count += 1}
 274           example_group.it("test") {true}
 275           example_group.it("test2") {true}
 276           example_group.run
 277           before_all_run_count_run_count.should == 1
 278         end
 279
 280         it "should run after(:all) block only once" do
 281           after_all_run_count = 0
 282           example_group.after(:all) {after_all_run_count += 1}
 283           example_group.it("test") {true}
 284           example_group.it("test2") {true}
 285           example_group.run
 286           after_all_run_count.should == 1
 287           @reporter.rspec_verify
 288         end
 289
 290         it "after(:all) should have access to all instance variables defined in before(:all)" do
 291           context_instance_value_in = "Hello there"
 292           context_instance_value_out = ""
 293           example_group.before(:all) { @instance_var = context_instance_value_in }
 294           example_group.after(:all) { context_instance_value_out = @instance_var }
 295           example_group.it("test") {true}
 296           example_group.run
 297           context_instance_value_in.should == context_instance_value_out
 298         end
 299
 300         it "should copy instance variables from before(:all)'s execution context into spec's execution context" do
 301           context_instance_value_in = "Hello there"
 302           context_instance_value_out = ""
 303           example_group.before(:all) { @instance_var = context_instance_value_in }
 304           example_group.it("test") {context_instance_value_out = @instance_var}
 305           example_group.run
 306           context_instance_value_in.should == context_instance_value_out
 307         end
 308
 309         it "should not add global before callbacks for untargetted example_group" do
 310           fiddle = []
 311
 312           ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
 313           ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
 314           @special_example_group.before(:each) { fiddle << "Example.before(:each, :type => :special)" }
 315           @special_example_group.prepend_before(:each) { fiddle << "Example.prepend_before(:each, :type => :special)" }
 316           @special_example_group.before(:all) { fiddle << "Example.before(:all, :type => :special)" }
 317           @special_example_group.prepend_before(:all) { fiddle << "Example.prepend_before(:all, :type => :special)" }
 318
 319           example_group = Class.new(ExampleGroup) do
 320             describe("I'm not special", :type => :not_special)
 321             it "does nothing"
 322           end
 323           example_group.run
 324           fiddle.should == [
 325             'Example.prepend_before(:all)',
 326             'Example.before(:all)',
 327           ]
 328         end
 329
 330         it "should add global before callbacks for targetted example_groups" do
 331           fiddle = []
 332
 333           ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
 334           ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
 335           @special_example_group.before(:each) { fiddle << "special.before(:each, :type => :special)" }
 336           @special_example_group.prepend_before(:each) { fiddle << "special.prepend_before(:each, :type => :special)" }
 337           @special_example_group.before(:all) { fiddle << "special.before(:all, :type => :special)" }
 338           @special_example_group.prepend_before(:all) { fiddle << "special.prepend_before(:all, :type => :special)" }
 339           @special_example_group.append_before(:each) { fiddle << "special.append_before(:each, :type => :special)" }
 340
 341           example_group = Class.new(@special_example_group).describe("I'm a special example_group") {}
 342           example_group.it("test") {true}
 343           example_group.run
 344           fiddle.should == [
 345             'Example.prepend_before(:all)',
 346             'Example.before(:all)',
 347             'special.prepend_before(:all, :type => :special)',
 348             'special.before(:all, :type => :special)',
 349             'special.prepend_before(:each, :type => :special)',
 350             'special.before(:each, :type => :special)',
 351             'special.append_before(:each, :type => :special)',
 352           ]
 353         end
 354
 355         it "should order before callbacks from global to local" do
 356           fiddle = []
 357           ExampleGroup.prepend_before(:all) { fiddle << "Example.prepend_before(:all)" }
 358           ExampleGroup.before(:all) { fiddle << "Example.before(:all)" }
 359           example_group.prepend_before(:all) { fiddle << "prepend_before(:all)" }
 360           example_group.before(:all) { fiddle << "before(:all)" }
 361           example_group.prepend_before(:each) { fiddle << "prepend_before(:each)" }
 362           example_group.before(:each) { fiddle << "before(:each)" }
 363           example_group.run
 364           fiddle.should == [
 365             'Example.prepend_before(:all)',
 366             'Example.before(:all)',
 367             'prepend_before(:all)',
 368             'before(:all)',
 369             'prepend_before(:each)',
 370             'before(:each)'
 371           ]
 372         end
 373
 374         it "should order after callbacks from local to global" do
 375           fiddle = []
 376           example_group.after(:each) { fiddle << "after(:each)" }
 377           example_group.append_after(:each) { fiddle << "append_after(:each)" }
 378           example_group.after(:all) { fiddle << "after(:all)" }
 379           example_group.append_after(:all) { fiddle << "append_after(:all)" }
 380           ExampleGroup.after(:all) { fiddle << "Example.after(:all)" }
 381           ExampleGroup.append_after(:all) { fiddle << "Example.append_after(:all)" }
 382           example_group.run
 383           fiddle.should == [
 384             'after(:each)',
 385             'append_after(:each)',
 386             'after(:all)',
 387             'append_after(:all)',
 388             'Example.after(:all)',
 389             'Example.append_after(:all)'
 390           ]
 391         end
 392
 393         it "should have accessible instance methods from included module" do
 394           mod1_method_called = false
 395           mod1 = Module.new do
 396             define_method :mod1_method do
 397               mod1_method_called = true
 398             end
 399           end
 400
 401           mod2_method_called = false
 402           mod2 = Module.new do
 403             define_method :mod2_method do
 404               mod2_method_called = true
 405             end
 406           end
 407
 408           example_group.include mod1, mod2
 409
 410           example_group.it("test") do
 411             mod1_method
 412             mod2_method
 413           end
 414           example_group.run
 415           mod1_method_called.should be_true
 416           mod2_method_called.should be_true
 417         end
 418
 419         it "should include targetted modules included using configuration" do
 420           mod1 = Module.new
 421           mod2 = Module.new
 422           mod3 = Module.new
 423           Spec::Runner.configuration.include(mod1, mod2)
 424           Spec::Runner.configuration.include(mod3, :type => :not_special)
 425
 426           example_group = Class.new(@special_example_group).describe("I'm special", :type => :special) do
 427             it "does nothing"
 428           end
 429           example_group.run
 430
 431           example_group.included_modules.should include(mod1)
 432           example_group.included_modules.should include(mod2)
 433           example_group.included_modules.should_not include(mod3)
 434         end
 435
 436         it "should include any predicate_matchers included using configuration" do
 437           $included_predicate_matcher_found = false
 438           Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something?
 439           example_group = Class.new(ExampleGroup) do
 440             describe('example')
 441             it "should respond to do_something" do
 442               $included_predicate_matcher_found = respond_to?(:do_something)
 443             end
 444           end
 445           example_group.run
 446           $included_predicate_matcher_found.should be(true)
 447         end
 448
 449         it "should use a mock framework set up in config" do
 450           mod = Module.new do
 451             class << self
 452               def included(mod)
 453                 $included_module = mod
 454               end
 455             end
 456
 457             def teardown_mocks_for_rspec
 458               $torn_down = true
 459             end
 460           end
 461
 462           begin
 463             $included_module = nil
 464             $torn_down = true
 465             Spec::Runner.configuration.mock_with mod
 466
 467             example_group = Class.new(ExampleGroup) do
 468               describe('example')
 469               it "does nothing"
 470             end
 471             example_group.run
 472
 473             $included_module.should_not be_nil
 474             $torn_down.should == true
 475           ensure
 476             Spec::Runner.configuration.mock_with :rspec
 477           end
 478         end
 479       end
 480
 481       describe ExampleGroup, "#run with pending example that has a failing assertion" do
 482         before do
 483           example_group.it("should be pending") do
 484             pending("Example fails") {false.should be_true}
 485           end
 486         end
 487
 488         it "should send example_pending to formatter" do
 489           @formatter.should_receive(:example_pending).with("example", "should be pending", "Example fails")
 490           example_group.run
 491         end
 492       end
 493
 494       describe ExampleGroup, "#run with pending example that does not have a failing assertion" do
 495         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 496
 497         before do
 498           example_group.it("should be pending") do
 499             pending("Example passes") {true.should be_true}
 500           end
 501         end
 502
 503         it "should send example_pending to formatter" do
 504           @formatter.should_receive(:example_pending).with("example", "should be pending", "Example passes")
 505           example_group.run
 506         end
 507       end
 508
 509       describe ExampleGroup, "#run when before(:all) fails" do
 510         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 511
 512         before do
 513           ExampleGroup.before(:all) { raise NonStandardError, "before(:all) failure" }
 514         end
 515
 516         it "should not run any example" do
 517           spec_ran = false
 518           example_group.it("test") {spec_ran = true}
 519           example_group.run
 520           spec_ran.should be_false
 521         end
 522
 523         it "should run ExampleGroup after(:all)" do
 524           after_all_ran = false
 525           ExampleGroup.after(:all) { after_all_ran = true }
 526           example_group.run
 527           after_all_ran.should be_true
 528         end
 529
 530         it "should run example_group after(:all)" do
 531           after_all_ran = false
 532           example_group.after(:all) { after_all_ran = true }
 533           example_group.run
 534           after_all_ran.should be_true
 535         end
 536
 537         it "should supply before(:all) as description" do
 538           @reporter.should_receive(:failure) do |example, error|
 539             example.description.should eql("before(:all)")
 540             error.message.should eql("before(:all) failure")
 541           end
 542
 543           example_group.it("test") {true}
 544           example_group.run
 545         end
 546       end
 547
 548       describe ExampleGroup, "#run when before(:each) fails" do
 549         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 550
 551         before do
 552           ExampleGroup.before(:each) { raise NonStandardError }
 553         end
 554
 555         it "should run after(:all)" do
 556           after_all_ran = false
 557           ExampleGroup.after(:all) { after_all_ran = true }
 558           example_group.run
 559           after_all_ran.should be_true
 560         end
 561       end
 562
 563       describe ExampleGroup, "#run when any example fails" do
 564         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 565
 566         before do
 567           example_group.it("should") { raise NonStandardError }
 568         end
 569
 570         it "should run after(:all)" do
 571           after_all_ran = false
 572           ExampleGroup.after(:all) { after_all_ran = true }
 573           example_group.run
 574           after_all_ran.should be_true
 575         end
 576       end
 577
 578       describe ExampleGroup, "#run when first after(:each) block fails" do
 579         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 580
 581         before do
 582           class << example_group
 583             attr_accessor :first_after_ran, :second_after_ran
 584           end
 585           example_group.first_after_ran = false
 586           example_group.second_after_ran = false
 587
 588           example_group.after(:each) do
 589             self.class.second_after_ran = true
 590           end
 591           example_group.after(:each) do
 592             self.class.first_after_ran = true
 593             raise "first"
 594           end
 595         end
 596
 597         it "should run second after(:each) block" do
 598           reporter.should_receive(:example_finished) do |example, error|
 599             example.should equal(example)
 600             error.message.should eql("first")
 601           end
 602           example_group.run
 603           example_group.first_after_ran.should be_true
 604           example_group.second_after_ran.should be_true
 605         end
 606       end
 607
 608       describe ExampleGroup, "#run when first before(:each) block fails" do
 609         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 610
 611         before do
 612           class << example_group
 613             attr_accessor :first_before_ran, :second_before_ran
 614           end
 615           example_group.first_before_ran = false
 616           example_group.second_before_ran = false
 617
 618           example_group.before(:each) do
 619             self.class.first_before_ran = true
 620             raise "first"
 621           end
 622           example_group.before(:each) do
 623             self.class.second_before_ran = true
 624           end
 625         end
 626
 627         it "should not run second before(:each)" do
 628           reporter.should_receive(:example_finished) do |name, error|
 629             error.message.should eql("first")
 630           end
 631           example_group.run
 632           example_group.first_before_ran.should be_true
 633           example_group.second_before_ran.should be_false
 634         end
 635       end
 636
 637       describe ExampleGroup, "#run when failure in after(:all)" do
 638         it_should_behave_like "Spec::Example::ExampleGroup#run with failure in example"
 639
 640         before do
 641           ExampleGroup.after(:all) { raise NonStandardError, "in after(:all)" }
 642         end
 643
 644         it "should return false" do
 645           example_group.run.should be_false
 646         end
 647       end
 648     end
 649
 650     class ExampleSubclass < ExampleGroup
 651     end
 652
 653     describe ExampleGroup, "subclasses" do
 654       after do
 655         ExampleGroupFactory.reset
 656       end
 657
 658       it "should have access to the described_type" do
 659         example_group = Class.new(ExampleSubclass) do
 660           describe(Array)
 661         end
 662         example_group.send(:described_type).should == Array
 663       end
 664
 665       it "should concat descriptions when nested" do
 666         example_group = Class.new(ExampleSubclass) do
 667           describe(Array)
 668           $nested_group = describe("when empty") do
 669           end
 670         end
 671         $nested_group.description.to_s.should == "Array when empty"
 672       end
 673     end
 674
 675     describe Enumerable do
 676       def each(&block)
 677         ["4", "2", "1"].each(&block)
 678       end
 679
 680       it "should be included in examples because it is a module" do
 681         map{|e| e.to_i}.should == [4,2,1]
 682       end
 683     end
 684
 685     describe "An", Enumerable, "as a second argument" do
 686       def each(&block)
 687         ["4", "2", "1"].each(&block)
 688       end
 689
 690       it "should be included in examples because it is a module" do
 691         map{|e| e.to_i}.should == [4,2,1]
 692       end
 693     end
 694
 695     describe Enumerable do
 696       describe "as the parent of nested example groups" do
 697         it "should be included in examples because it is a module" do
 698           pending("need to make sure nested groups know the described type") do
 699             map{|e| e.to_i}.should == [4,2,1]
 700           end
 701         end
 702       end
 703     end
 704
 705     describe String do
 706       it"should not be included in examples because it is not a module" do
 707         lambda{self.map}.should raise_error(NoMethodError, /undefined method `map' for/)
 708       end
 709     end
 710   end
 711 end