rspec 0.8.2 → 0.9.0

data/spec/spec/runner/object_ext_spec.rb

@@ -2,9 +2,9 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Runner
-    context "ObjectExt" do
-      specify "should add copy_instance_variables_from to object" do
-        Object.new.should_respond_to :copy_instance_variables_from
+    describe "ObjectExt" do
+      it "should add copy_instance_variables_from to object" do
+        Object.new.should respond_to(:copy_instance_variables_from)
       end
     end
   end

data/spec/spec/runner/option_parser_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "OptionParser" do
-  setup do
+describe "OptionParser" do
+  before(:each) do
     @out = StringIO.new
     @err = StringIO.new
     @parser = Spec::Runner::OptionParser.new
@@ -11,170 +11,195 @@ context "OptionParser" do
     @parser.parse(args, @err, @out, true)
   end
 
-  specify "should accept dry run option" do
+  def behaviour_runner(args)
+    @parser.create_behaviour_runner(args, @err, @out, true)
+  end
+
+  it "should accept dry run option" do
     options = parse(["--dry-run"])
-    options.dry_run.should_be(true)
+    options.dry_run.should be_true
   end
 
-  specify "should eval and use custom formatter when none of the builtins" do
+  it "should eval and use custom formatter when none of the builtins" do
     options = parse(["--format", "Custom::Formatter"])
-    options.formatter_type.should equal(Custom::Formatter)
+    options.formatters[0].class.should be(Custom::Formatter)
   end
-
-  specify "should not be verbose by default" do
+  
+  it "should support formatters with relative and absolute paths, even on windows" do
+    options = parse([
+      "--format", "Custom::Formatter:C:\\foo\\bar",
+      "--format", "Custom::Formatter:foo/bar",
+      "--format", "Custom::Formatter:foo\\bar",
+      "--format", "Custom::Formatter:/foo/bar"
+    ])
+    options.formatters[0].where.should eql("C:\\foo\\bar")
+    options.formatters[1].where.should eql("foo/bar")
+    options.formatters[2].where.should eql("foo\\bar")
+    options.formatters[3].where.should eql("/foo/bar")
+  end
+
+  it "should not be verbose by default" do
     options = parse([])
-    options.verbose.should_be(nil)
+    options.verbose.should be_nil
   end
 
-  specify "should not use colour by default" do
+  it "should not use colour by default" do
     options = parse([])
-    options.colour.should_be(nil)
+    options.colour.should be_nil
   end
 
-  specify "should print help to stdout" do
+  it "should print help to stdout" do
     options = parse(["--help"])
     @out.rewind
-    @out.read.should_match(/Usage: spec \[options\] \(FILE\|DIRECTORY\|GLOB\)\+/n)
+    @out.read.should match(/Usage: spec \(FILE\|DIRECTORY\|GLOB\)\+ \[options\]/m)
   end
 
-  specify "should print instructions about how to fix bad formatter" do
+  it "should print instructions about how to fix bad formatter" do
     options = parse(["--format", "Custom::BadFormatter"])
-    @err.string.should_match(/Couldn't find formatter class Custom::BadFormatter/n)
+    @err.string.should match(/Couldn't find formatter class Custom::BadFormatter/n)
   end
 
-  specify "should print usage to err if no dir specified" do
+  it "should print usage to err if no dir specified" do
     options = parse([])
-    @err.string.should_match(/Usage: spec/)
+    @err.string.should match(/Usage: spec/)
   end
 
-  specify "should print version to stdout" do
+  it "should print version to stdout" do
     options = parse(["--version"])
     @out.rewind
-    @out.read.should_match(/RSpec-\d+\.\d+\.\d+ \(r\d+\) - BDD for Ruby\nhttp:\/\/rspec.rubyforge.org\/\n/n)
+    @out.read.should match(/RSpec-\d+\.\d+\.\d+.*\(r\d+\) - BDD for Ruby\nhttp:\/\/rspec.rubyforge.org\/\n/n)
   end
   
-  specify "should accept -o option" do
-    options = parse(["-o", "#{File.expand_path(File.dirname(__FILE__))}/output_file.txt"])
-    options.out.should_be_an_instance_of File
-    options.out.path.should == "#{File.expand_path(File.dirname(__FILE__))}/output_file.txt"
-    File.delete(options.out.path) rescue nil
-  end
-
-  specify "should require file when require specified" do
+  it "should require file when require specified" do
     lambda do
       parse(["--require", "whatever"])
-    end.should_raise(LoadError)
-  end
-
-  specify "should select dry run for rdoc formatter" do
-    options = parse(["--format", "rdoc"])
-    options.dry_run.should_be(true)
+    end.should raise_error(LoadError)
   end
 
-  specify "should support c option" do
+  it "should support c option" do
     options = parse(["-c"])
-    options.colour.should_be(true)
+    options.colour.should be_true
   end
 
-  specify "should support queens colour option" do
+  it "should support queens colour option" do
     options = parse(["--colour"])
-    options.colour.should_be(true)
+    options.colour.should be_true
   end
 
-  specify "should support us color option" do
+  it "should support us color option" do
     options = parse(["--color"])
-    options.colour.should_be(true)
+    options.colour.should be_true
   end
 
-  specify "should support single spec with s option" do
+  it "should support single example with -e option" do
+    options = parse(["-e", "something or other"])
+    options.examples.should eql(["something or other"])
+  end
+
+  it "should support single example with -s option (will be removed when autotest supports -e)" do
     options = parse(["-s", "something or other"])
-    options.spec_name.should_eql("something or other")
+    options.examples.should eql(["something or other"])
+  end
+
+  it "should support single example with --example option" do
+    options = parse(["--example", "something or other"])
+    options.examples.should eql(["something or other"])
   end
 
-  specify "should support single spec with spec option" do
-    options = parse(["--spec", "something or other"])
-    options.spec_name.should_eql("something or other")
+  it "should read several example names from file if --example is given an existing file name" do
+    options = parse(["--example", File.dirname(__FILE__) + '/examples.txt'])
+    options.examples.should eql([
+      "Sir, if you were my husband, I would poison your drink.", 
+      "Madam, if you were my wife, I would drink it."])
   end
 
-  specify "should use html formatter when format is h" do
+  it "should use html formatter when format is h" do
     options = parse(["--format", "h"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::HtmlFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
   end
 
-  specify "should use html formatter when format is html" do
+  it "should use html formatter when format is html" do
     options = parse(["--format", "html"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::HtmlFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
   end
 
-  specify "should use noisy backtrace tweaker with b option" do
+  it "should use html formatter with explicit output when format is html:test.html" do
+    FileUtils.rm 'test.html' if File.exist?('test.html')
+    options = parse(["--format", "html:test.html"])
+    File.should be_exist('test.html')
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::HtmlFormatter)
+    FileUtils.rm 'test.html'
+  end
+
+  it "should use noisy backtrace tweaker with b option" do
     options = parse(["-b"])
-    options.backtrace_tweaker.should_be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
+    options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
   end
 
-  specify "should use noisy backtrace tweaker with backtrace option" do
+  it "should use noisy backtrace tweaker with backtrace option" do
     options = parse(["--backtrace"])
-    options.backtrace_tweaker.should_be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
+    options.backtrace_tweaker.should be_instance_of(Spec::Runner::NoisyBacktraceTweaker)
   end
 
-  specify "should use quiet backtrace tweaker by default" do
+  it "should use quiet backtrace tweaker by default" do
     options = parse([])
-    options.backtrace_tweaker.should_be_instance_of(Spec::Runner::QuietBacktraceTweaker)
+    options.backtrace_tweaker.should be_instance_of(Spec::Runner::QuietBacktraceTweaker)
   end
 
-  specify "should use progress bar formatter by default" do
+  it "should use progress bar formatter by default" do
     options = parse([])
-    options.formatter_type.should equal(Spec::Runner::Formatter::ProgressBarFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::ProgressBarFormatter)
   end
 
-  specify "should use rdoc formatter when format is r" do
+  it "should use rdoc formatter when format is r" do
     options = parse(["--format", "r"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::RdocFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::RdocFormatter)
   end
 
-  specify "should use rdoc formatter when format is rdoc" do
+  it "should use rdoc formatter when format is rdoc" do
     options = parse(["--format", "rdoc"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::RdocFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::RdocFormatter)
   end
 
-  specify "should use specdoc formatter when format is s" do
+  it "should use specdoc formatter when format is s" do
     options = parse(["--format", "s"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::SpecdocFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter)
   end
 
-  specify "should use specdoc formatter when format is specdoc" do
+  it "should use specdoc formatter when format is specdoc" do
     options = parse(["--format", "specdoc"])
-    options.formatter_type.should equal(Spec::Runner::Formatter::SpecdocFormatter)
+    options.formatters[0].class.should equal(Spec::Runner::Formatter::SpecdocFormatter)
   end
 
-  specify "should support diff option when format is not specified" do
+  it "should support diff option when format is not specified" do
     options = parse(["--diff"])
-    options.diff_format.should_be :unified
+    options.diff_format.should == :unified
   end
 
-  specify "should use unified diff format option when format is unified" do
+  it "should use unified diff format option when format is unified" do
     options = parse(["--diff", "unified"])
-    options.diff_format.should_be :unified
-    options.differ_class.should_be Spec::Expectations::Differs::Default
+    options.diff_format.should == :unified
+    options.differ_class.should equal(Spec::Expectations::Differs::Default)
   end
 
-  specify "should use context diff format option when format is context" do
+  it "should use context diff format option when format is context" do
     options = parse(["--diff", "context"])
-    options.diff_format.should eql(:context)
-    options.differ_class.should_eql Spec::Expectations::Differs::Default
+    options.diff_format.should == :context
+    options.differ_class.should == Spec::Expectations::Differs::Default
   end
 
-  specify "should use custom diff format option when format is a custom format" do
+  it "should use custom diff format option when format is a custom format" do
     options = parse(["--diff", "Custom::Formatter"])
-    options.diff_format.should_be :custom
-    options.differ_class.should_eql Custom::Formatter
+    options.diff_format.should == :custom
+    options.differ_class.should == Custom::Formatter
   end
 
-  specify "should print instructions about how to fix bad differ" do
+  it "should print instructions about how to fix bad differ" do
     options = parse(["--diff", "Custom::BadFormatter"])
-    @err.string.should_match(/Couldn't find differ class Custom::BadFormatter/n)
+    @err.string.should match(/Couldn't find differ class Custom::BadFormatter/n)
   end
 
-  specify "should support --line to identify spec" do
+  it "should support --line to identify spec" do
     spec_parser = mock("spec_parser")
     @parser.instance_variable_set('@spec_parser', spec_parser)
 
@@ -186,11 +211,11 @@ context "OptionParser" do
     spec_parser.should_receive(:spec_name_for).with("fake_io", 169).and_return("some spec")
 
     options = parse(["some file", "--line", "169"])
-    options.spec_name.should_eql("some spec")
-    File.__verify
+    options.examples.should eql(["some spec"])
+    File.rspec_verify
   end
 
-  specify "should fail with error message if file is dir along with --line" do
+  it "should fail with error message if file is dir along with --line" do
     spec_parser = mock("spec_parser")
     @parser.instance_variable_set('@spec_parser', spec_parser)
 
@@ -200,10 +225,10 @@ context "OptionParser" do
     @parser.instance_variable_set('@file_factory', file_factory)
 
     options = parse(["some file", "--line", "169"])
-    @err.string.should_match(/You must specify one file, not a directory when using the --line option/n)
+    @err.string.should match(/You must specify one file, not a directory when using the --line option/n)
   end
 
-  specify "should fail with error message if file is dir along with --line" do
+  it "should fail with error message if file is dir along with --line" do
     spec_parser = mock("spec_parser")
     @parser.instance_variable_set('@spec_parser', spec_parser)
 
@@ -213,57 +238,101 @@ context "OptionParser" do
     @parser.instance_variable_set('@file_factory', file_factory)
 
     options = parse(["some file", "--line", "169"])
-    @err.string.should_match(/some file does not exist/n)
+    @err.string.should match(/some file does not exist/n)
   end
 
-  specify "should fail with error message if more than one files are specified along with --line" do
+  it "should fail with error message if more than one files are specified along with --line" do
     spec_parser = mock("spec_parser")
     @parser.instance_variable_set('@spec_parser', spec_parser)
 
     options = parse(["some file", "some other file", "--line", "169"])
-    @err.string.should_match(/Only one file can be specified when using the --line option/n)
+    @err.string.should match(/Only one file can be specified when using the --line option/n)
   end
 
-  specify "should fail with error message if --spec and --line are used simultaneously" do
+  it "should fail with error message if --example and --line are used simultaneously" do
     spec_parser = mock("spec_parser")
     @parser.instance_variable_set('@spec_parser', spec_parser)
 
-    options = parse(["some file", "--spec", "some spec", "--line", "169"])
-    @err.string.should_match(/You cannot use both --line and --spec/n)
+    options = parse(["some file", "--example", "some example", "--line", "169"])
+    @err.string.should match(/You cannot use both --line and --example/n)
   end
 
   if(PLATFORM != "i386-mswin32")
-    specify "should heckle when --heckle is specified (and platform is not windows)" do
+    it "should heckle when --heckle is specified (and platform is not windows)" do
       options = parse(["--heckle", "Spec"])
-      options.heckle_runner.should_be_instance_of(Spec::Runner::HeckleRunner)
+      options.heckle_runner.should be_instance_of(Spec::Runner::HeckleRunner)
     end
   else
-    specify "should barf when --heckle is specified (and platform is windows)" do
+    it "should barf when --heckle is specified (and platform is windows)" do
       lambda do
         options = parse(["--heckle", "Spec"])
-      end.should_raise(StandardError, "Heckle not supported on Windows")
+      end.should raise_error(StandardError, "Heckle not supported on Windows")
     end
   end
-   
-  specify "should read options from file when --options is specified" do
+
+  it "should read options from file when --options is specified" do
     Spec::Runner::CommandLine.should_receive(:run).with(["--diff", "--colour"], @err, @out, true, true)
     options = parse(["--options", File.dirname(__FILE__) + "/spec.opts"])
   end
 
-  specify "should append options from file when --options is specified" do
+  it "should append options from file when --options is specified" do
     Spec::Runner::CommandLine.should_receive(:run).with(["some/spec.rb", "--diff", "--colour"], @err, @out, true, true)
     options = parse(["some/spec.rb", "--options", File.dirname(__FILE__) + "/spec.opts"])
   end
+  
+  it "should read spaced and multi-line options from file when --options is specified" do
+    Spec::Runner::CommandLine.should_receive(:run).with(["--diff", "--colour", "--format", "s"], @err, @out, true, true)
+    options = parse(["--options", File.dirname(__FILE__) + "/spec_spaced.opts"])
+  end
    
-  specify "should save config to file when --generate-options is specified" do
-    FileUtils.rm 'spec.opts' rescue nil
-    options = parse(["--colour", "--generate-options", "spec.opts", "--diff"])
-    File.open('spec.opts').read.should == "--colour\n--diff\n"
-    FileUtils.rm 'spec.opts' rescue nil
+  it "should save config to file when --generate-options is specified" do
+    FileUtils.rm 'test.spec.opts' rescue nil
+    options = parse(["--colour", "--generate-options", "test.spec.opts", "--diff"])
+    File.open('test.spec.opts').read.should == "--colour\n--diff\n"
+    FileUtils.rm 'test.spec.opts' rescue nil
   end
 
-  specify "should call DrbCommandLine when --drb is specified" do
+  it "should call DrbCommandLine when --drb is specified" do
     Spec::Runner::DrbCommandLine.should_receive(:run).with(["some/spec.rb", "--diff", "--colour"], @err, @out, true, true)
     options = parse(["some/spec.rb", "--diff", "--drb", "--colour"])
   end
+  
+  it "should reverse spec order when --reverse is specified" do
+    options = parse(["some/spec.rb", "--reverse"])
+  end
+
+  it "should set an mtime comparator when --loadby mtime" do
+    behaviour_runner = behaviour_runner(["--loadby", 'mtime'])
+    Dir.chdir(File.dirname(__FILE__)) do
+      FileUtils.touch "most_recent_spec.rb"
+      all_files = ['command_line_spec.rb', 'most_recent_spec.rb']
+      sorted_files = behaviour_runner.sort_paths(all_files)
+      sorted_files.should == ["most_recent_spec.rb", "command_line_spec.rb"]
+      FileUtils.rm "most_recent_spec.rb"
+    end
+  end
+
+  it "should not use a runner by default" do
+    options = parse([])
+    options.runner_type.should be_nil
+  end
+
+  it "should use a custom runner when given" do
+    options = parse(["--runner", "Custom::BehaviourRunner"])
+    options.runner_type.should equal(Custom::BehaviourRunner)
+  end
+
+  it "should fail when custom runner not found" do
+    parse(["--runner", "whatever"])
+    @err.string.should match(/Couldn't find behaviour runner class/)
+  end
+
+  it "should return the correct default behaviour runner" do
+    @parser.create_behaviour_runner([], @err, @out, true).should be_instance_of(Spec::Runner::BehaviourRunner)
+  end
+
+  it "should return the correct default behaviour runner" do
+    @parser.create_behaviour_runner(["--runner", "Custom::BehaviourRunner"], @err, @out, true).should be_instance_of(Custom::BehaviourRunner)
+  end
+
 end

data/spec/spec/runner/quiet_backtrace_tweaker_spec.rb

@@ -2,26 +2,26 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Runner
-    context "QuietBacktraceTweaker" do
-      setup do
+    describe "QuietBacktraceTweaker" do
+      before(:each) do
         @error = RuntimeError.new
         @tweaker = QuietBacktraceTweaker.new
       end
 
-      specify "should not barf on nil backtrace" do
+      it "should not barf on nil backtrace" do
         lambda do
           @tweaker.tweak_backtrace(@error, "spec name")
-        end.should_not_raise
+        end.should_not raise_error
       end
 
-      specify "should remove anything from textmate ruby bundle" do
+      it "should remove anything from textmate ruby bundle" do
         @error.set_backtrace(["/Applications/TextMate.app/Contents/SharedSupport/Bundles/Ruby.tmbundle/Support/tmruby.rb:147"])
         @tweaker.tweak_backtrace(@error, "spec name")
-        @error.backtrace.should_be_empty
+        @error.backtrace.should be_empty
       end
 
-      specify "should remove anything in lib spec dir" do
-        ["expectations", "mocks", "runner", "callback"].each do |child|
+      it "should remove anything in lib spec dir" do
+        ["expectations", "mocks", "runner"].each do |child|
           element="/lib/spec/#{child}/anything.rb"
           @error.set_backtrace([element])
           @tweaker.tweak_backtrace(@error, "spec name")
@@ -31,16 +31,25 @@ module Spec
         end
       end
 
-      specify "should remove bin spec" do
+      it "should remove mock_frameworks/rspec" do
+        element = "mock_frameworks/rspec"
+        @error.set_backtrace([element])
+        @tweaker.tweak_backtrace(@error, "spec name")
+        unless (@error.backtrace.empty?)
+          raise("Should have tweaked away '#{element}'")
+        end
+      end
+
+      it "should remove bin spec" do
         @error.set_backtrace(["bin/spec:"])
         @tweaker.tweak_backtrace(@error, "spec name")
-        @error.backtrace.should_be_empty
+        @error.backtrace.should be_empty
       end
       
-      specify "should clean up double slashes" do
+      it "should clean up double slashes" do
         @error.set_backtrace(["/a//b/c//d.rb"])
         @tweaker.tweak_backtrace(@error, "spec name")
-        @error.backtrace.should_include "/a/b/c/d.rb"
+        @error.backtrace.should include("/a/b/c/d.rb")
       end
     end
   end