mspec/spec/runner/context_spec.rb

   1 require File.dirname(__FILE__) + '/../spec_helper'
   2 require 'mspec/expectations/expectations'
   3 require 'mspec/matchers/base'
   4 require 'mspec/runner/mspec'
   5 require 'mspec/mocks/mock'
   6 require 'mspec/runner/context'
   7
   8 describe ContextState, "#describe" do
   9   before :each do
  10     @state = ContextState.new "C#m"
  11     @proc = lambda { ScratchPad.record :a }
  12     ScratchPad.clear
  13   end
  14
  15   it "evaluates the passed block" do
  16     @state.describe(&@proc)
  17     ScratchPad.recorded.should == :a
  18   end
  19
  20   it "evaluates the passed block via #protect" do
  21     @state.should_receive(:protect).with("C#m", @proc, false)
  22     @state.describe(&@proc)
  23   end
  24
  25   it "registers #parent as the current MSpec ContextState" do
  26     parent = ContextState.new ""
  27     @state.parent = parent
  28     MSpec.should_receive(:register_current).with(parent)
  29     @state.describe { }
  30   end
  31
  32   it "registers self with MSpec when #shared? is true" do
  33     state = ContextState.new "something shared", :shared => true
  34     MSpec.should_receive(:register_shared).with(state)
  35     state.describe { }
  36   end
  37 end
  38
  39 describe ContextState, "#shared?" do
  40   it "returns false when the ContextState is not shared" do
  41     ContextState.new("").shared?.should be_false
  42   end
  43
  44   it "returns true when the ContextState is shared" do
  45     ContextState.new("", {:shared => true}).shared?.should be_true
  46   end
  47 end
  48
  49 describe ContextState, "#to_s" do
  50   it "returns a description string for self when passed a Module" do
  51     ContextState.new(Object).to_s.should == "Object"
  52   end
  53
  54   it "returns a description string for self when passed a String" do
  55     ContextState.new("SomeClass").to_s.should == "SomeClass"
  56   end
  57
  58   it "returns a description string for self when passed a Module, String" do
  59     ContextState.new(Object, "when empty").to_s.should == "Object when empty"
  60   end
  61
  62   it "returns a description string for self when passed a Module and String beginning with '#'" do
  63     ContextState.new(Object, "#to_s").to_s.should == "Object#to_s"
  64   end
  65
  66   it "returns a description string for self when passed a Module and String beginning with '.'" do
  67     ContextState.new(Object, ".to_s").to_s.should == "Object.to_s"
  68   end
  69
  70   it "returns a description string for self when passed a Module and String beginning with '::'" do
  71     ContextState.new(Object, "::to_s").to_s.should == "Object::to_s"
  72   end
  73 end
  74
  75 describe ContextState, "#description" do
  76   before :each do
  77     @state = ContextState.new "when empty"
  78     @parent = ContextState.new "Toplevel"
  79   end
  80
  81   it "returns a composite description string from self and all parents" do
  82     @parent.description.should == "Toplevel"
  83     @state.description.should == "when empty"
  84     @state.parent = @parent
  85     @state.description.should == "Toplevel when empty"
  86   end
  87 end
  88
  89 describe ContextState, "#it" do
  90   before :each do
  91     @state = ContextState.new ""
  92     @proc = lambda { }
  93   end
  94
  95   it "creates an ExampleState instance for the block" do
  96     ex = ExampleState.new("", "", &@proc)
  97     ExampleState.should_receive(:new).with(@state, "it", @proc).and_return(ex)
  98     @state.describe(&@proc)
  99     @state.it("it", &@proc)
 100   end
 101 end
 102
 103 describe ContextState, "#examples" do
 104   before :each do
 105     @state = ContextState.new ""
 106   end
 107
 108   it "returns a list of all examples in this ContextState" do
 109     @state.it("first") { }
 110     @state.it("second") { }
 111     @state.examples.size.should == 2
 112   end
 113 end
 114
 115 describe ContextState, "#before" do
 116   before :each do
 117     @state = ContextState.new ""
 118     @proc = lambda { }
 119   end
 120
 121   it "records the block for :each" do
 122     @state.before(:each, &@proc)
 123     @state.before(:each).should == [@proc]
 124   end
 125
 126   it "records the block for :all" do
 127     @state.before(:all, &@proc)
 128     @state.before(:all).should == [@proc]
 129   end
 130 end
 131
 132 describe ContextState, "#after" do
 133   before :each do
 134     @state = ContextState.new ""
 135     @proc = lambda { }
 136   end
 137
 138   it "records the block for :each" do
 139     @state.after(:each, &@proc)
 140     @state.after(:each).should == [@proc]
 141   end
 142
 143   it "records the block for :all" do
 144     @state.after(:all, &@proc)
 145     @state.after(:all).should == [@proc]
 146   end
 147 end
 148
 149 describe ContextState, "#pre" do
 150   before :each do
 151     @a = lambda { }
 152     @b = lambda { }
 153     @c = lambda { }
 154
 155     parent = ContextState.new ""
 156     parent.before(:each, &@c)
 157     parent.before(:all, &@c)
 158
 159     @state = ContextState.new ""
 160     @state.parent = parent
 161   end
 162
 163   it "returns before(:each) actions in the order they were defined" do
 164     @state.before(:each, &@a)
 165     @state.before(:each, &@b)
 166     @state.pre(:each).should == [@c, @a, @b]
 167   end
 168
 169   it "returns before(:all) actions in the order they were defined" do
 170     @state.before(:all, &@a)
 171     @state.before(:all, &@b)
 172     @state.pre(:all).should == [@c, @a, @b]
 173   end
 174 end
 175
 176 describe ContextState, "#post" do
 177   before :each do
 178     @a = lambda { }
 179     @b = lambda { }
 180     @c = lambda { }
 181
 182     parent = ContextState.new ""
 183     parent.after(:each, &@c)
 184     parent.after(:all, &@c)
 185
 186     @state = ContextState.new ""
 187     @state.parent = parent
 188   end
 189
 190   it "returns after(:each) actions in the reverse order they were defined" do
 191     @state.after(:each, &@a)
 192     @state.after(:each, &@b)
 193     @state.post(:each).should == [@b, @a, @c]
 194   end
 195
 196   it "returns after(:all) actions in the reverse order they were defined" do
 197     @state.after(:all, &@a)
 198     @state.after(:all, &@b)
 199     @state.post(:all).should == [@b, @a, @c]
 200   end
 201 end
 202
 203 describe ContextState, "#protect" do
 204   before :each do
 205     ScratchPad.record []
 206     @a = lambda { ScratchPad << :a }
 207     @b = lambda { ScratchPad << :b }
 208     @c = lambda { raise Exception, "Fail!" }
 209   end
 210
 211   it "returns true and does execute any blocks if check is true and MSpec.pretend_mode? is true" do
 212     MSpec.stub!(:pretend_mode?).and_return(true)
 213     ContextState.new("").protect("message", [@a, @b]).should be_true
 214     ScratchPad.recorded.should == []
 215   end
 216
 217   it "executes the blocks if MSpec.pretend_mode? is false" do
 218     MSpec.stub!(:pretend_mode?).and_return(false)
 219     ContextState.new("").protect("message", [@a, @b])
 220     ScratchPad.recorded.should == [:a, :b]
 221   end
 222
 223   it "executes the blocks if check is false" do
 224     ContextState.new("").protect("message", [@a, @b], false)
 225     ScratchPad.recorded.should == [:a, :b]
 226   end
 227
 228   it "returns true if none of the blocks raise an exception" do
 229     ContextState.new("").protect("message", [@a, @b]).should be_true
 230   end
 231
 232   it "returns false if any of the blocks raise an exception" do
 233     ContextState.new("").protect("message", [@a, @c, @b]).should be_false
 234   end
 235 end
 236
 237 describe ContextState, "#parent=" do
 238   before :each do
 239     @state = ContextState.new ""
 240     @parent = mock("describe")
 241     @parent.stub!(:parent).and_return(nil)
 242     @parent.stub!(:child)
 243   end
 244
 245   it "does not set self as a child of parent if shared" do
 246     @parent.should_not_receive(:child)
 247     state = ContextState.new "", :shared => true
 248     state.parent = @parent
 249   end
 250
 251   it "sets self as a child of parent" do
 252     @parent.should_receive(:child).with(@state)
 253     @state.parent = @parent
 254   end
 255
 256   it "creates the list of parents" do
 257     @state.parent = @parent
 258     @state.parents.should == [@parent, @state]
 259   end
 260 end
 261
 262 describe ContextState, "#parent" do
 263   before :each do
 264     @state = ContextState.new ""
 265     @parent = mock("describe")
 266     @parent.stub!(:parent).and_return(nil)
 267     @parent.stub!(:child)
 268   end
 269
 270   it "returns nil if parent has not been set" do
 271     @state.parent.should be_nil
 272   end
 273
 274   it "returns the parent" do
 275     @state.parent = @parent
 276     @state.parent.should == @parent
 277   end
 278 end
 279
 280 describe ContextState, "#parents" do
 281   before :each do
 282     @first = ContextState.new ""
 283     @second = ContextState.new ""
 284     @parent = mock("describe")
 285     @parent.stub!(:parent).and_return(nil)
 286     @parent.stub!(:child)
 287   end
 288
 289   it "returns a list of all enclosing ContextState instances" do
 290     @first.parent = @parent
 291     @second.parent = @first
 292     @second.parents.should == [@parent, @first, @second]
 293   end
 294 end
 295
 296 describe ContextState, "#child" do
 297   before :each do
 298     @first = ContextState.new ""
 299     @second = ContextState.new ""
 300     @parent = mock("describe")
 301     @parent.stub!(:parent).and_return(nil)
 302     @parent.stub!(:child)
 303   end
 304
 305   it "adds the ContextState to the list of contained ContextStates" do
 306     @first.child @second
 307     @first.children.should == [@second]
 308   end
 309 end
 310
 311 describe ContextState, "#children" do
 312   before :each do
 313     @parent = ContextState.new ""
 314     @first = ContextState.new ""
 315     @second = ContextState.new ""
 316   end
 317
 318   it "returns the list of directly contained ContextStates" do
 319     @first.parent = @parent
 320     @second.parent = @first
 321     @parent.children.should == [@first]
 322     @first.children.should == [@second]
 323   end
 324 end
 325
 326 describe ContextState, "#state" do
 327   before :each do
 328     MSpec.store :before, []
 329     MSpec.store :after, []
 330
 331     @state = ContextState.new ""
 332   end
 333
 334   it "returns nil if no spec is being executed" do
 335     @state.state.should == nil
 336   end
 337
 338   it "returns a ExampleState instance if an example is being executed" do
 339     ScratchPad.record @state
 340     @state.describe { }
 341     @state.it("") { ScratchPad.record ScratchPad.recorded.state }
 342     @state.process
 343     @state.state.should == nil
 344     ScratchPad.recorded.should be_kind_of(ExampleState)
 345   end
 346 end
 347
 348 describe ContextState, "#process" do
 349   before :each do
 350     MSpec.store :before, []
 351     MSpec.store :after, []
 352     MSpec.stub!(:register_current)
 353
 354     @state = ContextState.new ""
 355     @state.describe { }
 356
 357     @a = lambda { ScratchPad << :a }
 358     @b = lambda { ScratchPad << :b }
 359     ScratchPad.record []
 360   end
 361
 362   it "calls each before(:all) block" do
 363     @state.before(:all, &@a)
 364     @state.before(:all, &@b)
 365     @state.it("") { }
 366     @state.process
 367     ScratchPad.recorded.should == [:a, :b]
 368   end
 369
 370   it "calls each after(:all) block" do
 371     @state.after(:all, &@a)
 372     @state.after(:all, &@b)
 373     @state.it("") { }
 374     @state.process
 375     ScratchPad.recorded.should == [:b, :a]
 376   end
 377
 378   it "calls each it block" do
 379     @state.it("one", &@a)
 380     @state.it("two", &@b)
 381     @state.process
 382     ScratchPad.recorded.should == [:a, :b]
 383   end
 384
 385   it "does not call the #it block if #filtered? returns true" do
 386     @state.it("one", &@a)
 387     @state.it("two", &@b)
 388     @state.examples.first.stub!(:filtered?).and_return(true)
 389     @state.process
 390     ScratchPad.recorded.should == [:b]
 391   end
 392
 393   it "calls each before(:each) block" do
 394     @state.before(:each, &@a)
 395     @state.before(:each, &@b)
 396     @state.it("") { }
 397     @state.process
 398     ScratchPad.recorded.should == [:a, :b]
 399   end
 400
 401   it "calls each after(:each) block" do
 402     @state.after(:each, &@a)
 403     @state.after(:each, &@b)
 404     @state.it("") { }
 405     @state.process
 406     ScratchPad.recorded.should == [:b, :a]
 407   end
 408
 409   it "calls Mock.cleanup for each it block" do
 410     @state.it("") { }
 411     @state.it("") { }
 412     Mock.should_receive(:cleanup).twice
 413     @state.process
 414   end
 415
 416   it "calls Mock.verify_count for each it block" do
 417     @state.it("") { }
 418     @state.it("") { }
 419     Mock.should_receive(:verify_count).twice
 420     @state.process
 421   end
 422
 423   it "calls the describe block" do
 424     ScratchPad.record []
 425     @state.describe { ScratchPad << :a }
 426     @state.process
 427     ScratchPad.recorded.should == [:a]
 428   end
 429
 430   it "creates a new ExampleState instance for each example" do
 431     ScratchPad.record @state
 432     @state.describe { }
 433     @state.it("it") { ScratchPad.record ScratchPad.recorded.state }
 434     @state.process
 435     ScratchPad.recorded.should be_kind_of(ExampleState)
 436   end
 437
 438   it "clears the expectations flag before evaluating the #it block" do
 439     MSpec.clear_expectations
 440     MSpec.should_receive(:clear_expectations)
 441     @state.it("it") { ScratchPad.record MSpec.expectation? }
 442     @state.process
 443     ScratchPad.recorded.should be_false
 444   end
 445
 446   it "shuffles the spec list if MSpec.randomize? is true" do
 447     MSpec.randomize
 448     MSpec.should_receive(:shuffle)
 449     @state.it("") { }
 450     @state.process
 451     MSpec.randomize false
 452   end
 453
 454   it "sets the current MSpec ContextState" do
 455     MSpec.should_receive(:register_current).with(@state)
 456     @state.process
 457   end
 458
 459   it "resets the current MSpec ContextState to nil when there are examples" do
 460     MSpec.should_receive(:register_current).with(nil)
 461     @state.it("") { }
 462     @state.process
 463   end
 464
 465   it "resets the current MSpec ContextState to nil when there are no examples" do
 466     MSpec.should_receive(:register_current).with(nil)
 467     @state.process
 468   end
 469
 470   it "call #process on children when there are examples" do
 471     child = ContextState.new ""
 472     child.should_receive(:process)
 473     @state.child child
 474     @state.it("") { }
 475     @state.process
 476   end
 477
 478   it "call #process on children when there are no examples" do
 479     child = ContextState.new ""
 480     child.should_receive(:process)
 481     @state.child child
 482     @state.process
 483   end
 484 end
 485
 486 describe ContextState, "#process" do
 487   before :each do
 488     MSpec.store :exception, []
 489
 490     @state = ContextState.new ""
 491     @state.describe { }
 492
 493     action = mock("action")
 494     def action.exception(exc)
 495       ScratchPad.record :exception if exc.exception.is_a? ExpectationNotFoundError
 496     end
 497     MSpec.register :exception, action
 498
 499     MSpec.clear_expectations
 500     ScratchPad.clear
 501   end
 502
 503   after :each do
 504     MSpec.store :exception, nil
 505   end
 506
 507   it "raises an ExpectationNotFoundError if an #it block does not contain an expectation" do
 508     @state.it("it") { }
 509     @state.process
 510     ScratchPad.recorded.should == :exception
 511   end
 512
 513   it "does not raise an ExpectationNotFoundError if an #it block does contain an expectation" do
 514     @state.it("it") { MSpec.expectation }
 515     @state.process
 516     ScratchPad.recorded.should be_nil
 517   end
 518
 519   it "does not raise an ExpectationNotFoundError if the #it block causes a failure" do
 520     @state.it("it") { raise Exception, "Failed!" }
 521     @state.process
 522     ScratchPad.recorded.should be_nil
 523   end
 524 end
 525
 526 describe ContextState, "#process" do
 527   before :each do
 528     MSpec.store :example, []
 529
 530     @state = ContextState.new ""
 531     @state.describe { }
 532
 533     example = mock("example")
 534     def example.example(state, spec)
 535       ScratchPad << state << spec
 536     end
 537     MSpec.register :example, example
 538
 539     ScratchPad.record []
 540   end
 541
 542   after :each do
 543     MSpec.store :example, nil
 544   end
 545
 546   it "calls registered example actions with the current ExampleState and block" do
 547     @state.it("") { MSpec.expectation }
 548     @state.process
 549
 550     ScratchPad.recorded.first.should be_kind_of(ExampleState)
 551     ScratchPad.recorded.last.should be_kind_of(Proc)
 552   end
 553
 554   it "does not call registered example actions if the example has no block" do
 555     @state.it("empty example")
 556     @state.process
 557     ScratchPad.recorded.should == []
 558   end
 559 end
 560
 561 describe ContextState, "#process" do
 562   before :each do
 563     MSpec.store :before, []
 564     MSpec.store :after, []
 565
 566     @state = ContextState.new ""
 567     @state.describe { }
 568     @state.it("") { MSpec.expectation }
 569   end
 570
 571   after :each do
 572     MSpec.store :before, nil
 573     MSpec.store :after, nil
 574   end
 575
 576   it "calls registered before actions with the current ExampleState instance" do
 577     before = mock("before")
 578     before.should_receive(:before).and_return {
 579       ScratchPad.record :before
 580       @spec_state = @state.state
 581     }
 582     MSpec.register :before, before
 583     @state.process
 584     ScratchPad.recorded.should == :before
 585     @spec_state.should be_kind_of(ExampleState)
 586   end
 587
 588   it "calls registered after actions with the current ExampleState instance" do
 589     after = mock("after")
 590     after.should_receive(:after).and_return {
 591       ScratchPad.record :after
 592       @spec_state = @state.state
 593     }
 594     MSpec.register :after, after
 595     @state.process
 596     ScratchPad.recorded.should == :after
 597     @spec_state.should be_kind_of(ExampleState)
 598   end
 599 end
 600
 601 describe ContextState, "#process" do
 602   before :each do
 603     MSpec.store :enter, []
 604     MSpec.store :leave, []
 605
 606     @state = ContextState.new "C#m"
 607     @state.describe { }
 608     @state.it("") { MSpec.expectation }
 609   end
 610
 611   after :each do
 612     MSpec.store :enter, nil
 613     MSpec.store :leave, nil
 614   end
 615
 616   it "calls registered enter actions with the current #describe string" do
 617     enter = mock("enter")
 618     enter.should_receive(:enter).with("C#m").and_return { ScratchPad.record :enter }
 619     MSpec.register :enter, enter
 620     @state.process
 621     ScratchPad.recorded.should == :enter
 622   end
 623
 624   it "calls registered leave actions" do
 625     leave = mock("leave")
 626     leave.should_receive(:leave).and_return { ScratchPad.record :leave }
 627     MSpec.register :leave, leave
 628     @state.process
 629     ScratchPad.recorded.should == :leave
 630   end
 631 end
 632
 633 describe ContextState, "#process when an exception is raised in before(:all)" do
 634   before :each do
 635     MSpec.store :before, []
 636     MSpec.store :after, []
 637
 638     @state = ContextState.new ""
 639     @state.describe { }
 640
 641     @a = lambda { ScratchPad << :a }
 642     @b = lambda { ScratchPad << :b }
 643     ScratchPad.record []
 644
 645     @state.before(:all) { raise Exception, "Fail!" }
 646   end
 647
 648   after :each do
 649     MSpec.store :before, nil
 650     MSpec.store :after, nil
 651   end
 652
 653   it "does not call before(:each)" do
 654     @state.before(:each, &@a)
 655     @state.it("") { }
 656     @state.process
 657     ScratchPad.recorded.should == []
 658   end
 659
 660   it "does not call the it block" do
 661     @state.it("one", &@a)
 662     @state.process
 663     ScratchPad.recorded.should == []
 664   end
 665
 666   it "does not call after(:each)" do
 667     @state.after(:each, &@a)
 668     @state.it("") { }
 669     @state.process
 670     ScratchPad.recorded.should == []
 671   end
 672
 673   it "does not call after(:each)" do
 674     @state.after(:all, &@a)
 675     @state.it("") { }
 676     @state.process
 677     ScratchPad.recorded.should == []
 678   end
 679
 680   it "does not call Mock.verify_count" do
 681     @state.it("") { }
 682     Mock.should_not_receive(:verify_count)
 683     @state.process
 684   end
 685
 686   it "calls Mock.cleanup" do
 687     @state.it("") { }
 688     Mock.should_receive(:cleanup)
 689     @state.process
 690   end
 691 end
 692
 693 describe ContextState, "#process when an exception is raised in before(:each)" do
 694   before :each do
 695     MSpec.store :before, []
 696     MSpec.store :after, []
 697
 698     @state = ContextState.new ""
 699     @state.describe { }
 700
 701     @a = lambda { ScratchPad << :a }
 702     @b = lambda { ScratchPad << :b }
 703     ScratchPad.record []
 704
 705     @state.before(:each) { raise Exception, "Fail!" }
 706   end
 707
 708   after :each do
 709     MSpec.store :before, nil
 710     MSpec.store :after, nil
 711   end
 712
 713   it "does not call the it block" do
 714     @state.it("one", &@a)
 715     @state.process
 716     ScratchPad.recorded.should == []
 717   end
 718
 719   it "does not call after(:each)" do
 720     @state.after(:each, &@a)
 721     @state.it("") { }
 722     @state.process
 723     ScratchPad.recorded.should == []
 724   end
 725
 726   it "does not call Mock.verify_count" do
 727     @state.it("") { }
 728     Mock.should_not_receive(:verify_count)
 729     @state.process
 730   end
 731 end
 732
 733 describe ContextState, "#process in pretend mode" do
 734   before :all do
 735     MSpec.register_mode :pretend
 736   end
 737
 738   after :all do
 739     MSpec.register_mode nil
 740   end
 741
 742   before :each do
 743     ScratchPad.clear
 744     MSpec.store :before, []
 745     MSpec.store :after, []
 746
 747     @state = ContextState.new ""
 748     @state.describe { }
 749     @state.it("") { }
 750   end
 751
 752   after :each do
 753     MSpec.store :before, nil
 754     MSpec.store :after, nil
 755   end
 756
 757   it "calls registered before actions with the current ExampleState instance" do
 758     before = mock("before")
 759     before.should_receive(:before).and_return {
 760       ScratchPad.record :before
 761       @spec_state = @state.state
 762     }
 763     MSpec.register :before, before
 764     @state.process
 765     ScratchPad.recorded.should == :before
 766     @spec_state.should be_kind_of(ExampleState)
 767   end
 768
 769   it "calls registered after actions with the current ExampleState instance" do
 770     after = mock("after")
 771     after.should_receive(:after).and_return {
 772       ScratchPad.record :after
 773       @spec_state = @state.state
 774     }
 775     MSpec.register :after, after
 776     @state.process
 777     ScratchPad.recorded.should == :after
 778     @spec_state.should be_kind_of(ExampleState)
 779   end
 780 end
 781
 782 describe ContextState, "#process in pretend mode" do
 783   before :all do
 784     MSpec.register_mode :pretend
 785   end
 786
 787   after :all do
 788     MSpec.register_mode nil
 789   end
 790
 791   before :each do
 792     MSpec.store :before, []
 793     MSpec.store :after, []
 794
 795     @state = ContextState.new ""
 796     @state.describe { }
 797
 798     @a = lambda { ScratchPad << :a }
 799     @b = lambda { ScratchPad << :b }
 800     ScratchPad.record []
 801   end
 802
 803   it "calls the describe block" do
 804     ScratchPad.record []
 805     @state.describe { ScratchPad << :a }
 806     @state.process
 807     ScratchPad.recorded.should == [:a]
 808   end
 809
 810   it "does not call any before(:all) block" do
 811     @state.before(:all, &@a)
 812     @state.before(:all, &@b)
 813     @state.it("") { }
 814     @state.process
 815     ScratchPad.recorded.should == []
 816   end
 817
 818   it "does not call any after(:all) block" do
 819     @state.after(:all, &@a)
 820     @state.after(:all, &@b)
 821     @state.it("") { }
 822     @state.process
 823     ScratchPad.recorded.should == []
 824   end
 825
 826   it "does not call any it block" do
 827     @state.it("one", &@a)
 828     @state.it("two", &@b)
 829     @state.process
 830     ScratchPad.recorded.should == []
 831   end
 832
 833   it "does not call any before(:each) block" do
 834     @state.before(:each, &@a)
 835     @state.before(:each, &@b)
 836     @state.it("") { }
 837     @state.process
 838     ScratchPad.recorded.should == []
 839   end
 840
 841   it "does not call any after(:each) block" do
 842     @state.after(:each, &@a)
 843     @state.after(:each, &@b)
 844     @state.it("") { }
 845     @state.process
 846     ScratchPad.recorded.should == []
 847   end
 848
 849   it "does not call Mock.cleanup" do
 850     @state.it("") { }
 851     @state.it("") { }
 852     Mock.should_not_receive(:cleanup)
 853     @state.process
 854   end
 855 end
 856
 857 describe ContextState, "#process in pretend mode" do
 858   before :all do
 859     MSpec.register_mode :pretend
 860   end
 861
 862   after :all do
 863     MSpec.register_mode nil
 864   end
 865
 866   before :each do
 867     MSpec.store :enter, []
 868     MSpec.store :leave, []
 869
 870     @state = ContextState.new ""
 871     @state.describe { }
 872     @state.it("") { }
 873   end
 874
 875   after :each do
 876     MSpec.store :enter, nil
 877     MSpec.store :leave, nil
 878   end
 879
 880   it "calls registered enter actions with the current #describe string" do
 881     enter = mock("enter")
 882     enter.should_receive(:enter).and_return { ScratchPad.record :enter }
 883     MSpec.register :enter, enter
 884     @state.process
 885     ScratchPad.recorded.should == :enter
 886   end
 887
 888   it "calls registered leave actions" do
 889     leave = mock("leave")
 890     leave.should_receive(:leave).and_return { ScratchPad.record :leave }
 891     MSpec.register :leave, leave
 892     @state.process
 893     ScratchPad.recorded.should == :leave
 894   end
 895 end
 896
 897 describe ContextState, "#it_should_behave_like" do
 898   before :each do
 899     @shared = ContextState.new("", :shared => true)
 900     MSpec.stub!(:retrieve_shared).and_return(@shared)
 901
 902     @state = ContextState.new ""
 903     @a = lambda { }
 904     @b = lambda { }
 905   end
 906
 907   it "raises an Exception if unable to find the shared ContextState" do
 908     MSpec.should_receive(:retrieve_shared).and_return(nil)
 909     lambda { @state.it_should_behave_like "this" }.should raise_error(Exception)
 910   end
 911
 912   it "adds examples from the shared ContextState" do
 913     @shared.it "some", &@a
 914     @shared.it "thing", &@b
 915     @state.it_should_behave_like ""
 916     @state.examples.should include(*@shared.examples)
 917   end
 918
 919   it "sets the containing ContextState for the examples" do
 920     @shared.it "some", &@a
 921     @shared.it "thing", &@b
 922     @shared.examples.each { |ex| ex.should_receive(:context=).with(@state) }
 923     @state.it_should_behave_like ""
 924   end
 925
 926   it "adds before(:all) blocks from the shared ContextState" do
 927     @shared.before :all, &@a
 928     @shared.before :all, &@b
 929     @state.it_should_behave_like ""
 930     @state.before(:all).should include(*@shared.before(:all))
 931   end
 932
 933   it "adds before(:each) blocks from the shared ContextState" do
 934     @shared.before :each, &@a
 935     @shared.before :each, &@b
 936     @state.it_should_behave_like ""
 937     @state.before(:each).should include(*@shared.before(:each))
 938   end
 939
 940   it "adds after(:each) blocks from the shared ContextState" do
 941     @shared.after :each, &@a
 942     @shared.after :each, &@b
 943     @state.it_should_behave_like ""
 944     @state.after(:each).should include(*@shared.after(:each))
 945   end
 946
 947   it "adds after(:all) blocks from the shared ContextState" do
 948     @shared.after :all, &@a
 949     @shared.after :all, &@b
 950     @state.it_should_behave_like ""
 951     @state.after(:all).should include(*@shared.after(:all))
 952   end
 953 end
 954
 955 describe ContextState, "#filter_examples" do
 956   before :each do
 957     @state = ContextState.new ""
 958     @state.it("one") { }
 959     @state.it("two") { }
 960   end
 961
 962   it "removes examples that are filtered" do
 963     @state.examples.first.stub!(:filtered?).and_return(true)
 964     @state.examples.size.should == 2
 965     @state.filter_examples
 966     @state.examples.size.should == 1
 967   end
 968
 969   it "returns true if there are remaining examples to evaluate" do
 970     @state.examples.first.stub!(:filtered?).and_return(true)
 971     @state.filter_examples.should be_true
 972   end
 973
 974   it "returns false if there are no remaining examples to evaluate" do
 975     @state.examples.first.stub!(:filtered?).and_return(true)
 976     @state.examples.last.stub!(:filtered?).and_return(true)
 977     @state.filter_examples.should be_false
 978   end
 979 end