mspec 1.0.0

data/spec/runner/mspec_spec.rb

@@ -0,0 +1,393 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/helpers/tmp'
+require 'mspec/matchers/base'
+require 'mspec/runner/mspec'
+
+describe MSpec, ".register_files" do
+  it "records which spec files to run" do
+    MSpec.register_files [:one, :two, :three]
+    MSpec.retrieve(:files).should == [:one, :two, :three]
+  end
+end
+
+describe MSpec, ".register_mode" do
+  it "sets execution mode flags" do
+    MSpec.register_mode :verify
+    MSpec.retrieve(:mode).should == :verify
+  end
+end
+
+describe MSpec, ".register_tags_path" do
+  it "records the path to tag files" do
+    MSpec.register_tags_path "path/to/tags"
+    MSpec.retrieve(:tags_path).should == "path/to/tags"
+  end
+end
+
+describe MSpec, ".register_exit" do
+  before :each do
+    MSpec.store :exit, 0
+  end
+
+  it "records the exit code" do
+    MSpec.exit_code.should == 0
+    MSpec.register_exit 1
+    MSpec.exit_code.should == 1
+  end
+end
+
+describe MSpec, ".exit_code" do
+  it "retrieves the code set with .register_exit" do
+    MSpec.register_exit 99
+    MSpec.exit_code.should == 99
+  end
+end
+
+describe MSpec, ".store" do
+  it "records data for MSpec settings" do
+    MSpec.store :anything, :value
+    MSpec.retrieve(:anything).should == :value
+  end
+end
+
+describe MSpec, ".retrieve" do
+  it "accesses .store'd data" do
+    MSpec.register :action, :first
+    MSpec.retrieve(:action).should == [:first]
+  end
+end
+
+describe MSpec, ".randomize" do
+  it "sets the flag to randomize spec execution order" do
+    MSpec.randomize?.should == false
+    MSpec.randomize
+    MSpec.randomize?.should == true
+    MSpec.randomize false
+    MSpec.randomize?.should == false
+  end
+end
+
+describe MSpec, ".register" do
+  it "is the gateway behind the register(symbol, action) facility" do
+    MSpec.register :bonus, :first
+    MSpec.register :bonus, :second
+    MSpec.register :bonus, :second
+    MSpec.retrieve(:bonus).should == [:first, :second]
+  end
+end
+
+describe MSpec, ".unregister" do
+  it "is the gateway behind the unregister(symbol, actions) facility" do
+    MSpec.register :unregister, :first
+    MSpec.register :unregister, :second
+    MSpec.unregister :unregister, :second
+    MSpec.retrieve(:unregister).should == [:first]
+  end
+end
+
+describe MSpec, ".protect" do
+  before :each do
+    @ss = mock('SpecState')
+    @ss.stub!(:exceptions).and_return([])
+    @rs = mock('RunState')
+    @rs.stub!(:state).and_return(@ss)
+    @exception = Exception.new("Sharp!")
+    ScratchPad.record @exception
+  end
+
+  it "rescues any exceptions raised when executing the block argument" do
+    MSpec.stack.push @rs
+    lambda {
+      MSpec.protect("") { raise Exception, "Now you see me..." }
+    }.should_not raise_error
+  end
+
+  it "records the exception in the current.state object's exceptions" do
+    MSpec.stack.push @rs
+    MSpec.protect("testing") { raise ScratchPad.recorded }
+    @ss.exceptions.should == [["testing", ScratchPad.recorded]]
+  end
+
+  it "writes a message to STDERR if current is nil" do
+    STDERR.stub!(:write)
+    STDERR.should_receive(:write).with("\nAn exception occurred in testing:\nException: \"Sharp!\"\n")
+    MSpec.stack.clear
+    MSpec.protect("testing") { raise ScratchPad.recorded }
+  end
+
+  it "writes a message to STDERR if current.state is nil" do
+    STDERR.stub!(:write)
+    STDERR.should_receive(:write).with("\nAn exception occurred in testing:\nException: \"Sharp!\"\n")
+    @rs.stub!(:state).and_return(nil)
+    MSpec.stack.push @rs
+    MSpec.protect("testing") { raise ScratchPad.recorded }
+  end
+end
+
+describe MSpec, ".stack" do
+  it "returns an array" do
+    MSpec.stack.should be_kind_of(Array)
+  end
+end
+
+describe MSpec, ".current" do
+  it "returns the top of the execution stack" do
+    MSpec.stack.clear
+    MSpec.stack.push :a
+    MSpec.stack.push :b
+    MSpec.current.should == :b
+  end
+end
+
+describe MSpec, ".actions" do
+  before :each do
+    MSpec.store :start, []
+    ScratchPad.record []
+    start_one = mock("one")
+    start_one.stub!(:start).and_return { ScratchPad << :one }
+    start_two = mock("two")
+    start_two.stub!(:start).and_return { ScratchPad << :two }
+    MSpec.register :start, start_one
+    MSpec.register :start, start_two
+  end
+
+  it "does not attempt to run any actions if none have been registered" do
+    MSpec.store :finish, nil
+    lambda { MSpec.actions :finish }.should_not raise_error
+  end
+
+  it "runs each action registered as a start action" do
+    MSpec.actions :start
+    ScratchPad.recorded.should == [:one, :two]
+  end
+end
+
+describe MSpec, ".verify_mode?" do
+  before :each do
+    MSpec.store :mode, nil
+  end
+
+  it "returns true if register_mode(:verify) is called" do
+    MSpec.verify_mode?.should == false
+    MSpec.register_mode :verify
+    MSpec.verify_mode?.should == true
+  end
+end
+
+describe MSpec, ".report_mode?" do
+  before :each do
+    MSpec.store :mode, nil
+  end
+
+  it "returns true if register_mode(:report) is called" do
+    MSpec.report_mode?.should == false
+    MSpec.register_mode :report
+    MSpec.report_mode?.should == true
+  end
+end
+
+describe MSpec, ".describe" do
+  before :each do
+    MSpec.stack.clear
+  end
+
+  it "accepts one argument" do
+    MSpec.describe(Object) { ScratchPad.record MSpec.current }
+    ScratchPad.recorded.should be_kind_of(RunState)
+  end
+
+  it "pushes a new RunState instance on the stack" do
+    MSpec.describe(Object, "msg") { ScratchPad.record MSpec.current }
+    ScratchPad.recorded.should be_kind_of(RunState)
+  end
+
+  it "pops the RunState instance off the stack when finished" do
+    MSpec.describe(Object, "msg") { ScratchPad.record MSpec.current }
+    ScratchPad.recorded.should be_kind_of(RunState)
+    MSpec.stack.should == []
+  end
+end
+
+describe MSpec, ".process" do
+  before :each do
+    MSpec.stub!(:files)
+    MSpec.store :start, []
+    MSpec.store :finish, []
+  end
+
+  it "calls all start actions" do
+    start = mock("start")
+    start.stub!(:start).and_return { ScratchPad.record :start }
+    MSpec.register :start, start
+    MSpec.process
+    ScratchPad.recorded.should == :start
+  end
+
+  it "calls all finish actions" do
+    finish = mock("finish")
+    finish.stub!(:finish).and_return { ScratchPad.record :finish }
+    MSpec.register :finish, finish
+    MSpec.process
+    ScratchPad.recorded.should == :finish
+  end
+
+  it "calls the files method" do
+    MSpec.should_receive(:files)
+    MSpec.process
+  end
+end
+
+describe MSpec, ".files" do
+  before :each do
+    MSpec.store :load, []
+    MSpec.store :unload, []
+    MSpec.register_files [:one, :two, :three]
+    Kernel.stub!(:load)
+  end
+
+  it "calls load actions before each file" do
+    load = mock("load")
+    load.stub!(:load).and_return { ScratchPad.record :load }
+    MSpec.register :load, load
+    MSpec.files
+    ScratchPad.recorded.should == :load
+  end
+
+  it "shuffles the file list if .randomize? is true" do
+    MSpec.randomize
+    MSpec.should_receive(:shuffle)
+    MSpec.files
+    MSpec.randomize false
+  end
+
+  it "registers the current file" do
+    MSpec.should_receive(:store).with(:file, :one)
+    MSpec.should_receive(:store).with(:file, :two)
+    MSpec.should_receive(:store).with(:file, :three)
+    MSpec.files
+  end
+end
+
+describe MSpec, ".shuffle" do
+  before :each do
+    @base = (0..100).to_a
+    @list = @base.clone
+    MSpec.shuffle @list
+  end
+
+  it "does not alter the elements in the list" do
+    @base.each do |elt|
+      @list.should include(elt)
+    end
+  end
+
+  it "changes the order of the list" do
+    # obviously, this spec has a certain probability
+    # of failing. If it fails, run it again.
+    @list.should_not == @base
+  end
+end
+
+describe MSpec, ".tags_path" do
+  before :each do
+    MSpec.store :tags_path, nil
+  end
+
+  it "returns 'spec/tags' if no tags path has been registered" do
+    MSpec.tags_path.should == "spec/tags"
+  end
+
+  it "returns the registered tags path" do
+    MSpec.register_tags_path "/path/to/tags"
+    MSpec.tags_path.should == "/path/to/tags"
+  end
+end
+
+describe MSpec, ".tags_file" do
+  before :each do
+    MSpec.store :file, "/path/to/spec/something/some_spec.rb"
+    MSpec.store :tags_path, nil
+  end
+
+  it "returns the tags file for the current spec file with default tags_path" do
+    MSpec.tags_file.should == "spec/tags/something/some_tags.txt"
+  end
+
+  it "returns the tags file for the current spec file with custom tags_path" do
+    MSpec.register_tags_path "/path/to/tags"
+    MSpec.tags_file.should == "/path/to/tags/something/some_tags.txt"
+  end
+end
+
+describe MSpec, ".read_tags" do
+  before :each do
+    MSpec.stub!(:tags_file).and_return(File.dirname(__FILE__) + '/tags.txt')
+  end
+
+  it "returns a list of tag instances for matching tag names found" do
+    one = SpecTag.new "fail(broken):Some#method? works"
+    MSpec.read_tags("fail", "pass").should == [one]
+  end
+
+  it "returns [] if no tags names match" do
+    MSpec.read_tags("super").should == []
+  end
+end
+
+describe MSpec, ".write_tag" do
+  before :each do
+    FileUtils.stub!(:mkdir_p)
+    MSpec.stub!(:tags_file).and_return(tmp("tags.txt"))
+    @tag = SpecTag.new "fail(broken):Some#method works"
+  end
+
+  after :all do
+    File.delete tmp("tags.txt") rescue nil
+  end
+
+  it "writes a tag to the tags file for the current spec file" do
+    MSpec.write_tag @tag
+    IO.read(tmp("tags.txt")).should == "fail(broken):Some#method works\n"
+  end
+
+  it "does not write a duplicate tag" do
+    File.open(tmp("tags.txt"), "w") { |f| f.puts @tag }
+    MSpec.write_tag @tag
+    IO.read(tmp("tags.txt")).should == "fail(broken):Some#method works\n"
+  end
+end
+
+describe MSpec, ".delete_tag" do
+  before :each do
+    FileUtils.cp File.dirname(__FILE__) + "/tags.txt", tmp("tags.txt")
+    MSpec.stub!(:tags_file).and_return(tmp("tags.txt"))
+    @tag = SpecTag.new "fail(Comments don't matter):Some#method? works"
+  end
+
+  after :each do
+    File.delete tmp("tags.txt") rescue nil
+  end
+
+  it "deletes the tag if it exists" do
+    MSpec.delete_tag(@tag).should == true
+    IO.read(tmp("tags.txt")).should == %[incomplete(20%):The#best method ever
+benchmark(0.01825):The#fastest method today
+]
+  end
+
+  it "does not change the tags file contents if the tag doesn't exist" do
+    @tag.tag = "failed"
+    MSpec.delete_tag(@tag).should == false
+    IO.read(tmp("tags.txt")).should == %[fail(broken):Some#method? works
+incomplete(20%):The#best method ever
+benchmark(0.01825):The#fastest method today
+]
+  end
+
+  it "deletes the tag file if it is empty" do
+    MSpec.delete_tag(@tag).should == true
+    MSpec.delete_tag(SpecTag.new("incomplete:The#best method ever")).should == true
+    MSpec.delete_tag(SpecTag.new("benchmark:The#fastest method today")).should == true
+    File.exist?(tmp("tags.txt")).should == false
+  end
+end

data/spec/runner/shared_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/runner/shared'
+
+describe Object, "#shared" do
+  it "stores the passed block in the MSpec module" do
+    proc = lambda { :shared }
+    shared :shared, &proc
+    MSpec.retrieve(:shared).should == proc
+  end
+end
+
+describe Object, "#it_behaves_like" do
+  before :each do
+  end
+
+  it "retrieves the instance variable set on Object and calls the proc" do
+    proc = lambda { |a| raise Exception, "visited with #{a.inspect}" }
+    shared :shared, &proc
+    lambda {
+      it_behaves_like(:shared, nil)
+    }.should raise_error(Exception, "visited with nil")
+  end
+
+  it "accepts an optional argument to specify the class/module" do
+    proc = lambda { |a, b| raise Exception, "visited with #{a.inspect}, #{b.inspect}" }
+    shared :shared, &proc
+    lambda {
+      it_behaves_like(:shared, :method, :klass)
+    }.should raise_error(Exception, "visited with :method, :klass")
+  end
+
+  it "accepts an optional argument to specify the class/module name" do
+    proc = lambda { |a, b, c|
+      raise Exception, "visited with #{a.inspect}, #{b.inspect}, #{c.inspect}"
+    }
+    shared :shared, &proc
+    lambda {
+      it_behaves_like(:shared, :method, :klass, :name)
+    }.should raise_error(Exception, "visited with :method, :klass, :name")
+  end
+end

data/spec/runner/state_spec.rb

@@ -0,0 +1,535 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/matchers/base'
+require 'mspec/runner/mspec'
+require 'mspec/mocks/mock'
+require 'mspec/runner/state'
+
+describe RunState do
+  before :each do
+    @state = RunState.new
+    @proc = lambda { }
+  end
+
+  it "records before(:all) blocks" do
+    @state.before(:all, &@proc)
+    @state.instance_variable_get(:@start).should == [@proc]
+  end
+
+  it "records before(:each) blocks" do
+    @state.before(:each, &@proc)
+    @state.instance_variable_get(:@before).should == [@proc]
+  end
+
+  it "records after(:all) blocks" do
+    @state.after(:all, &@proc)
+    @state.instance_variable_get(:@finish).should == [@proc]
+  end
+
+  it "records after(:each) blocks" do
+    @state.after(:each, &@proc)
+    @state.instance_variable_get(:@after).should == [@proc]
+  end
+
+  it "records it blocks" do
+    @state.it("message", &@proc)
+    msg, proc = @state.instance_variable_get(:@spec)[0]
+    msg.should == "message"
+    proc.should == @proc
+  end
+
+  it "records describe blocks" do
+    @state.describe(Object, "message", &@proc)
+    @state.instance_variable_get(:@describe).should == "Object message"
+    @state.instance_variable_get(:@block).should == @proc
+  end
+end
+
+describe RunState, "#protect" do
+  it "calls MSpec.protect" do
+    ScratchPad.record []
+    a = lambda { ScratchPad << :a }
+    b = lambda { ScratchPad << :b }
+    RunState.new.protect("message", [a, b])
+    ScratchPad.recorded.should == [:a, :b]
+  end
+end
+
+describe RunState, "#state" do
+  before :each do
+    MSpec.store :before, []
+    MSpec.store :after, []
+
+    @state = RunState.new
+  end
+
+  it "returns nil if no spec is being executed" do
+    @state.state.should == nil
+  end
+
+  it "returns a SpecState instance if a spec is being executed" do
+    ScratchPad.record @state
+    @state.describe("") { }
+    @state.it("") { ScratchPad.record ScratchPad.recorded.state }
+    @state.process
+    @state.state.should == nil
+    ScratchPad.recorded.should be_kind_of(SpecState)
+  end
+end
+
+describe RunState, "#process" do
+  before :each do
+    MSpec.store :before, []
+    MSpec.store :after, []
+
+    @state = RunState.new
+    @state.describe("") { }
+
+    @a = lambda { ScratchPad << :a }
+    @b = lambda { ScratchPad << :b }
+    ScratchPad.record []
+  end
+
+  it "calls each before(:all) block" do
+    @state.before(:all, &@a)
+    @state.before(:all, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == [:a, :b]
+  end
+
+  it "calls each after(:all) block" do
+    @state.after(:all, &@a)
+    @state.after(:all, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == [:a, :b]
+  end
+
+  it "calls each it block" do
+    @state.it("one", &@a)
+    @state.it("two", &@b)
+    @state.process
+    ScratchPad.recorded.should == [:a, :b]
+  end
+
+  it "calls each before(:each) block" do
+    @state.before(:each, &@a)
+    @state.before(:each, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == [:a, :b]
+  end
+
+  it "calls each after(:each) block" do
+    @state.after(:each, &@a)
+    @state.after(:each, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == [:a, :b]
+  end
+
+  it "calls Mock.cleanup for each it block" do
+    @state.it("") { }
+    @state.it("") { }
+    Mock.should_receive(:cleanup).twice
+    @state.process
+  end
+
+  it "calls Mock.verify_count for each it block" do
+    @state.it("") { }
+    @state.it("") { }
+    Mock.should_receive(:verify_count).twice
+    @state.process
+  end
+
+  it "calls the describe block" do
+    ScratchPad.record []
+    @state.describe(Object, "msg") { ScratchPad << :a }
+    @state.process
+    ScratchPad.recorded.should == [:a]
+  end
+
+  it "creates a new SpecState instance for each spec" do
+    ScratchPad.record @state
+    @state.describe("desc") { }
+    @state.it("it") { ScratchPad.record ScratchPad.recorded.state }
+    @state.process
+    ScratchPad.recorded.should be_kind_of(SpecState)
+  end
+
+  it "records exceptions that occur while running the spec" do
+    ScratchPad.record @state
+    exception = Exception.new("bump!")
+    MSpec.stack.push @state
+    @state.describe("describe") { }
+    @state.it("it") { raise exception }
+    @state.after(:each) { ScratchPad.record ScratchPad.recorded.state.exceptions }
+    @state.process
+    ScratchPad.recorded.should == [[nil, exception]]
+  end
+
+  it "shuffles the spec list if MSpec.randomize? is true" do
+    MSpec.randomize
+    MSpec.should_receive(:shuffle)
+    @state.it("") { }
+    @state.process
+    MSpec.randomize false
+  end
+end
+
+describe RunState, "#process in pretend mode" do
+  before :all do
+    MSpec.register_mode :pretend
+  end
+
+  after :all do
+    MSpec.register_mode nil
+  end
+
+  before :each do
+    MSpec.store :before, []
+    MSpec.store :after, []
+
+    @state = RunState.new
+    @state.describe("") { }
+
+    @a = lambda { ScratchPad << :a }
+    @b = lambda { ScratchPad << :b }
+    ScratchPad.record []
+  end
+
+  it "does not call any before(:all) block" do
+    @state.before(:all, &@a)
+    @state.before(:all, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == []
+  end
+
+  it "does not call any after(:all) block" do
+    @state.after(:all, &@a)
+    @state.after(:all, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == []
+  end
+
+  it "does not call any it block" do
+    @state.it("one", &@a)
+    @state.it("two", &@b)
+    @state.process
+    ScratchPad.recorded.should == []
+  end
+
+  it "does not call any before(:each) block" do
+    @state.before(:each, &@a)
+    @state.before(:each, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == []
+  end
+
+  it "does not call any after(:each) block" do
+    @state.after(:each, &@a)
+    @state.after(:each, &@b)
+    @state.it("") { }
+    @state.process
+    ScratchPad.recorded.should == []
+  end
+
+  it "does not call Mock.cleanup" do
+    @state.it("") { }
+    @state.it("") { }
+    Mock.should_not_receive(:cleanup)
+    @state.process
+  end
+
+  it "calls the describe block" do
+    ScratchPad.record []
+    @state.describe(Object, "msg") { ScratchPad << :a }
+    @state.process
+    ScratchPad.recorded.should == [:a]
+  end
+end
+
+describe RunState, "#process" do
+  before :each do
+    MSpec.store :before, []
+    MSpec.store :after, []
+
+    @state = RunState.new
+    @state.describe("") { }
+    @state.it("") { }
+  end
+
+  after :each do
+    MSpec.store :before, nil
+    MSpec.store :after, nil
+  end
+
+  it "calls registered before actions with the current SpecState instance" do
+    before = mock("before")
+    before.should_receive(:before).and_return {
+      ScratchPad.record :before
+      @spec_state = @state.state
+    }
+    MSpec.register :before, before
+    @state.process
+    ScratchPad.recorded.should == :before
+    @spec_state.should be_kind_of(SpecState)
+  end
+
+  it "calls registered after actions with the current SpecState instance" do
+    after = mock("after")
+    after.should_receive(:after).and_return {
+      ScratchPad.record :after
+      @spec_state = @state.state
+    }
+    MSpec.register :after, after
+    @state.process
+    ScratchPad.recorded.should == :after
+    @spec_state.should be_kind_of(SpecState)
+  end
+end
+
+describe RunState, "#process in pretend mode" do
+  before :all do
+    MSpec.register_mode :pretend
+  end
+
+  after :all do
+    MSpec.register_mode nil
+  end
+
+  before :each do
+    MSpec.store :before, []
+    MSpec.store :after, []
+
+    @state = RunState.new
+    @state.describe("") { }
+    @state.it("") { }
+  end
+
+  after :each do
+    MSpec.store :before, nil
+    MSpec.store :after, nil
+  end
+
+  it "calls registered before actions with the current SpecState instance" do
+    before = mock("before")
+    before.should_receive(:before).and_return {
+      ScratchPad.record :before
+      @spec_state = @state.state
+    }
+    MSpec.register :before, before
+    @state.process
+    ScratchPad.recorded.should == :before
+    @spec_state.should be_kind_of(SpecState)
+  end
+
+  it "calls registered after actions with the current SpecState instance" do
+    after = mock("after")
+    after.should_receive(:after).and_return {
+      ScratchPad.record :after
+      @spec_state = @state.state
+    }
+    MSpec.register :after, after
+    @state.process
+    ScratchPad.recorded.should == :after
+    @spec_state.should be_kind_of(SpecState)
+  end
+end
+
+describe RunState, "#process" do
+  before :each do
+    MSpec.store :enter, []
+    MSpec.store :leave, []
+
+    @state = RunState.new
+    @state.describe("") { }
+    @state.it("") { }
+  end
+
+  after :each do
+    MSpec.store :enter, nil
+    MSpec.store :leave, nil
+  end
+
+  it "calls registered enter actions with the current #describe string" do
+    enter = mock("enter")
+    enter.should_receive(:enter).and_return { ScratchPad.record :enter }
+    MSpec.register :enter, enter
+    @state.process
+    ScratchPad.recorded.should == :enter
+  end
+
+  it "calls registered leave actions" do
+    leave = mock("leave")
+    leave.should_receive(:leave).and_return { ScratchPad.record :leave }
+    MSpec.register :leave, leave
+    @state.process
+    ScratchPad.recorded.should == :leave
+  end
+end
+
+describe RunState, "#process in pretend mode" do
+  before :all do
+    MSpec.register_mode :pretend
+  end
+
+  after :all do
+    MSpec.register_mode nil
+  end
+
+  before :each do
+    MSpec.store :enter, []
+    MSpec.store :leave, []
+
+    @state = RunState.new
+    @state.describe("") { }
+    @state.it("") { }
+  end
+
+  after :each do
+    MSpec.store :enter, nil
+    MSpec.store :leave, nil
+  end
+
+  it "calls registered enter actions with the current #describe string" do
+    enter = mock("enter")
+    enter.should_receive(:enter).and_return { ScratchPad.record :enter }
+    MSpec.register :enter, enter
+    @state.process
+    ScratchPad.recorded.should == :enter
+  end
+
+  it "calls registered leave actions" do
+    leave = mock("leave")
+    leave.should_receive(:leave).and_return { ScratchPad.record :leave }
+    MSpec.register :leave, leave
+    @state.process
+    ScratchPad.recorded.should == :leave
+  end
+end
+
+describe SpecState do
+  it "is initialized with the describe and it strings" do
+    SpecState.new("This", "does").should be_kind_of(SpecState)
+  end
+end
+
+describe SpecState, "#describe" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+
+  it "returns the arguments to the #describe block stringified and concatenated" do
+    @state.describe.should == "describe"
+  end
+end
+
+describe SpecState, "#it" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+
+  it "returns the argument to the #it block" do
+    @state.it.should == "it"
+  end
+end
+
+describe SpecState, "#exceptions" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+
+  it "returns an array" do
+    @state.exceptions.should be_kind_of(Array)
+  end
+end
+
+describe SpecState, "#exception?" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+
+  it "returns false if no exceptions were recorded" do
+    @state.exception?.should == false
+  end
+
+  it "returns true if any exceptions were recorded" do
+    @state.exceptions.push :a
+    @state.exception?.should == true
+  end
+end
+
+describe SpecState, "#unfiltered?" do
+  before :each do
+    MSpec.store :include, nil
+    MSpec.store :exclude, nil
+
+    @state = SpecState.new("describe", "it")
+    @filter = mock("filter")
+  end
+
+  it "returns true if MSpec include filters list is empty" do
+    @state.unfiltered?.should == true
+  end
+
+  it "returns true if MSpec include filters match this spec" do
+    @filter.should_receive(:===).and_return(true)
+    MSpec.register :include, @filter
+    @state.unfiltered?.should == true
+  end
+
+  it "returns false if MSpec include filters do not match this spec" do
+    @filter.should_receive(:===).and_return(false)
+    MSpec.register :include, @filter
+    @state.unfiltered?.should == false
+  end
+
+  it "returns true if MSpec exclude filters list is empty" do
+    @state.unfiltered?.should == true
+  end
+
+  it "returns true if MSpec exclude filters do not match this spec" do
+    @filter.should_receive(:===).and_return(false)
+    MSpec.register :exclude, @filter
+    @state.unfiltered?.should == true
+  end
+
+  it "returns false if MSpec exclude filters match this spec" do
+    @filter.should_receive(:===).and_return(true)
+    MSpec.register :exclude, @filter
+    @state.unfiltered?.should == false
+  end
+
+  it "returns false if MSpec include and exclude filters match this spec" do
+    @filter.should_receive(:===).twice.and_return(true)
+    MSpec.register :include, @filter
+    MSpec.register :exclude, @filter
+    @state.unfiltered?.should == false
+  end
+end
+
+describe SpecState, "#filtered?" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+
+  it "returns true if #unfiltered returns false" do
+    @state.should_receive(:unfiltered?).and_return(false)
+    @state.filtered?.should == true
+  end
+
+  it "returns false if #unfiltered returns true" do
+    @state.should_receive(:unfiltered?).and_return(true)
+    @state.filtered?.should == false
+  end
+end
+
+describe SpecState, "#failure?" do
+  before :each do
+    @state = SpecState.new("describe", "it")
+  end
+end