yard 0.8.7.6 → 0.9.0

data/spec/cli/config_spec.rb

@@ -6,86 +6,86 @@ describe YARD::CLI::Config do
   before do
     @config = YARD::CLI::Config.new
     YARD::Config.options = YARD::Config::DEFAULT_CONFIG_OPTIONS.dup
-    YARD::Config.stub!(:save)
+    allow(YARD::Config).to receive(:save)
   end
 
   def run(*args)
     @config.run(*args)
   end
 
-  describe 'Listing configuration' do
-    it "should accept --list" do
+  describe "Listing configuration" do
+    it "accepts --list" do
       opts = YARD::Config.options
-      YAML.should_receive(:dump).twice.and_return("--- foo\nbar\nbaz")
-      log.should_receive(:puts).twice.with("bar\nbaz")
+      expect(YAML).to receive(:dump).twice.and_return("--- foo\nbar\nbaz")
+      expect(log).to receive(:puts).twice.with("bar\nbaz")
       run
       run('--list')
-      YARD::Config.options.should == opts
+      expect(YARD::Config.options).to eq opts
     end
   end
 
-  describe 'Viewing an item' do
-    it "should view item if no value is given" do
+  describe "Viewing an item" do
+    it "views item if no value is given" do
       YARD::Config.options[:foo] = 'bar'
-      log.should_receive(:puts).with('"bar"')
+      expect(log).to receive(:puts).with('"bar"')
       run 'foo'
-      YARD::Config.options[:foo].should == 'bar'
+      expect(YARD::Config.options[:foo]).to eq 'bar'
     end
   end
 
-  describe 'Modifying an item' do
-    it "should accept --reset to set value" do
+  describe "Modifying an item" do
+    it "accepts --reset to set value" do
       YARD::Config.options[:load_plugins] = 'foo'
       run('--reset', 'load_plugins')
-      YARD::Config.options[:load_plugins].should == false
+      expect(YARD::Config.options[:load_plugins]).to be false
     end
 
-    it "should accept --as-list to force single item as list" do
+    it "accepts --as-list to force single item as list" do
       run('--as-list', 'foo', 'bar')
-      YARD::Config.options[:foo].should == ['bar']
+      expect(YARD::Config.options[:foo]).to eq ['bar']
     end
 
-    it "should accept --append to append values to existing key" do
+    it "accepts --append to append values to existing key" do
       YARD::Config.options[:foo] = ['bar']
       run('--append', 'foo', 'baz', 'quux')
-      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux']
+      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux']
       run('-a', 'foo', 'last')
-      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux', 'last']
+      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux', 'last']
     end
 
-    it "should turn key into list if --append is used on single item" do
+    it "turns key into list if --append is used on single item" do
       YARD::Config.options[:foo] = 'bar'
       run('-a', 'foo', 'baz')
-      YARD::Config.options[:foo].should == ['bar', 'baz']
+      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz']
     end
 
-    it "should modify item if value is given" do
+    it "modifies item if value is given" do
       run('foo', 'xxx')
-      YARD::Config.options[:foo].should == 'xxx'
+      expect(YARD::Config.options[:foo]).to eq 'xxx'
     end
 
-    it "should turn list of values into array of values" do
+    it "turns list of values into array of values" do
       run('foo', 'a', 'b', '1', 'true', 'false')
-      YARD::Config.options[:foo].should == ['a', 'b', 1, true, false]
+      expect(YARD::Config.options[:foo]).to eq ['a', 'b', 1, true, false]
     end
 
-    it "should turn number into numeric Ruby type" do
+    it "turns number into numeric Ruby type" do
       run('foo', '1')
-      YARD::Config.options[:foo].should == 1
+      expect(YARD::Config.options[:foo]).to eq 1
     end
 
-    it "should turn true into TrueClass" do
+    it "turns true into TrueClass" do
       run('foo', 'true')
-      YARD::Config.options[:foo].should == true
+      expect(YARD::Config.options[:foo]).to be true
     end
 
-    it "should turn false into FalseClass" do
+    it "turns false into FalseClass" do
       run('foo', 'false')
-      YARD::Config.options[:foo].should == false
+      expect(YARD::Config.options[:foo]).to be false
     end
 
-    it "should save on modification" do
-      YARD::Config.should_receive(:save)
+    it "saves on modification" do
+      expect(YARD::Config).to receive(:save)
       run('foo', 'true')
     end
   end

data/spec/cli/diff_spec.rb

@@ -4,20 +4,20 @@ require 'open-uri'
 
 describe YARD::CLI::Diff do
   before do
-    CLI::Yardoc.stub!(:run)
-    CLI::Gems.stub!(:run)
+    allow(CLI::Yardoc).to receive(:run)
+    allow(CLI::Gems).to receive(:run)
     @diff = CLI::Diff.new
   end
 
-  describe 'Argument handling' do
-    it "should exit if there is only one gem name" do
-      @diff.should_receive(:exit)
-      log.should_receive(:puts).with(/Usage/)
+  describe "Argument handling" do
+    it "exits if there is only one gem name" do
+      expect(@diff).to receive(:exit)
+      expect(log).to receive(:puts).with(/Usage/)
       @diff.run
     end
   end
 
-  describe 'Diffing' do
+  describe "Diffing" do
     before do
       @objects1 = nil
       @objects2 = nil
@@ -29,7 +29,7 @@ describe YARD::CLI::Diff do
       @objects1 ||= %w( C#fooey C#baz D.bar )
       @objects2 ||= %w( A A::B A::B::C A.foo A#foo B C.foo C.bar C#baz )
       @objects = [@objects1, @objects2]
-      @diff.should_receive(:load_gem_data).ordered.with('gem1') do
+      expect(@diff).to receive(:load_gem_data).ordered.with('gem1') do
         Registry.clear
         YARD.parse_string <<-eof
           class C
@@ -41,7 +41,7 @@ describe YARD::CLI::Diff do
           end
         eof
       end
-      @diff.should_receive(:load_gem_data).ordered.with('gem2') do
+      expect(@diff).to receive(:load_gem_data).ordered.with('gem2') do
         Registry.clear
         YARD.parse_string <<-eof
           module A
@@ -58,14 +58,14 @@ describe YARD::CLI::Diff do
           end
         eof
       end
-      log.stub!(:print) {|data| @data << data }
-      log.stub!(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
+      allow(log).to receive(:print) {|data| @data << data }
+      allow(log).to receive(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
       @diff.run(*(args + ['gem1', 'gem2']))
     end
 
-    it "should show differences between objects" do
+    it "shows differences between objects" do
       run
-      @data.string.should == <<-eof
+      expect(@data.string).to eq <<-eof
 Added objects:
 
   A ((stdin):1) (...)
@@ -85,9 +85,9 @@ Removed objects:
 eof
     end
 
-    it "should accept --compact" do
+    it "accepts --compact" do
       run('--compact')
-      @data.string.should == <<-eof
+      expect(@data.string).to eq <<-eof
 A A ((stdin):1) (...)
 A A::B::C ((stdin):3)
 A C.bar ((stdin):10)
@@ -98,10 +98,10 @@ D D ((stdin):5) (...)
 eof
     end
 
-    it "should accept -a/--all" do
+    it "accepts -a/--all" do
       ['-a', '--all'].each do |opt|
         run(opt)
-        @data.string.should == <<-eof
+        expect(@data.string).to eq <<-eof
 Added objects:
 
   A ((stdin):1)
@@ -126,9 +126,9 @@ eof
       end
     end
 
-    it "should accept --compact and --all" do
+    it "accepts --compact and --all" do
       run('--compact', '--all')
-      @data.string.should == <<-eof
+      expect(@data.string).to eq <<-eof
 A A ((stdin):1)
 A A#foo ((stdin):6)
 A A.foo ((stdin):5)
@@ -143,9 +143,9 @@ D D.bar ((stdin):6)
 eof
     end
 
-    it "should accept --no-modified" do
+    it "accepts --no-modified" do
       run('--compact', '--no-modified')
-      @data.string.should == <<-eof
+      expect(@data.string).to eq <<-eof
 A A ((stdin):1) (...)
 A A::B::C ((stdin):3)
 A C.bar ((stdin):10)
@@ -155,9 +155,9 @@ D D ((stdin):5) (...)
 eof
     end
 
-    it "should accept --query" do
+    it "accepts --query" do
       run('--compact', '--query', 'o.type == :method')
-      @data.string.should == <<-eof
+      expect(@data.string).to eq <<-eof
 A A#foo ((stdin):6)
 A A.foo ((stdin):5)
 A C.bar ((stdin):10)
@@ -169,91 +169,87 @@ eof
     end
   end
 
-  describe 'File searching' do
+  describe "File searching" do
     before do
-      @diff.stub!(:generate_yardoc)
+      allow(@diff).to receive(:generate_yardoc)
     end
 
-    it "should search for gem/.yardoc" do
-      File.should_receive(:directory?).with('gem1/.yardoc').and_return(true)
-      File.should_receive(:directory?).with('gem2/.yardoc').and_return(true)
-      Registry.should_receive(:load_yardoc).with('gem1/.yardoc')
-      Registry.should_receive(:load_yardoc).with('gem2/.yardoc')
+    it "searches for gem/.yardoc" do
+      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(true)
+      expect(File).to receive(:directory?).with('gem2/.yardoc').and_return(true)
+      expect(Registry).to receive(:load_yardoc).with('gem1/.yardoc')
+      expect(Registry).to receive(:load_yardoc).with('gem2/.yardoc')
       @diff.run('gem1', 'gem2')
     end
 
-    it "should search for argument as yardoc" do
-      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem2/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem1').and_return(true)
-      File.should_receive(:directory?).with('gem2').and_return(true)
-      Registry.should_receive(:load_yardoc).with('gem1')
-      Registry.should_receive(:load_yardoc).with('gem2')
+    it "searches for argument as yardoc" do
+      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem2/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem1').and_return(true)
+      expect(File).to receive(:directory?).with('gem2').and_return(true)
+      expect(Registry).to receive(:load_yardoc).with('gem1')
+      expect(Registry).to receive(:load_yardoc).with('gem2')
       @diff.run('gem1', 'gem2')
     end
 
-    it "should search for installed gem" do
-      File.should_receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
-      File.should_receive(:directory?).with('gem2-1.0.0').and_return(false)
-      gemmock = mock(:gemmock)
-      spec1 = mock(:spec)
-      spec2 = mock(:spec)
-      gemmock.should_receive(:find_name).at_least(1).times.and_return([spec1, spec2])
-      Gem.should_receive(:source_index).at_least(1).times.and_return(gemmock)
-      spec1.stub!(:full_name).and_return('gem1-1.0.0')
-      spec1.stub!(:name).and_return('gem1')
-      spec1.stub!(:version).and_return('1.0.0')
-      spec2.stub!(:full_name).and_return('gem2-1.0.0')
-      spec2.stub!(:name).and_return('gem2')
-      spec2.stub!(:version).and_return('1.0.0')
-      Registry.should_receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
-      Registry.should_receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
-      Registry.should_receive(:load_yardoc).with('/path/to/file')
-      CLI::Gems.should_receive(:run).with('gem2', '1.0.0').and_return(nil)
-      Dir.stub!(:chdir)
+    it "searches for installed gem" do
+      expect(File).to receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
+      expect(File).to receive(:directory?).with('gem2-1.0.0').and_return(false)
+      gemmock = double(:gemmock)
+      spec1   = double(:spec)
+      spec2   = double(:spec)
+      expect(gemmock).to receive(:find_name).at_least(1).times.and_return([spec1, spec2])
+      expect(Gem).to receive(:source_index).at_least(1).times.and_return(gemmock)
+      allow(spec1).to receive(:full_name).and_return('gem1-1.0.0')
+      allow(spec1).to receive(:name).and_return('gem1')
+      allow(spec1).to receive(:version).and_return('1.0.0')
+      allow(spec2).to receive(:full_name).and_return('gem2-1.0.0')
+      allow(spec2).to receive(:name).and_return('gem2')
+      allow(spec2).to receive(:version).and_return('1.0.0')
+      expect(Registry).to receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
+      expect(Registry).to receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
+      expect(Registry).to receive(:load_yardoc).with('/path/to/file')
+      expect(CLI::Gems).to receive(:run).with('gem2', '1.0.0').and_return(nil)
+      allow(Dir).to receive(:chdir)
       @diff.run('gem1-1.0.0.gem', 'gem2-1.0.0')
     end
 
-    it "should search for .gem file" do
-      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem1').and_return(false)
-      File.should_receive(:directory?).with('gem2.gem').and_return(false)
-      File.should_receive(:directory?).any_number_of_times
-      File.should_receive(:exist?).with('gem1.gem').and_return(true)
-      File.should_receive(:exist?).with('gem2.gem').and_return(true)
-      File.should_receive(:exist?).any_number_of_times
-      File.should_receive(:open).with('gem1.gem', 'rb')
-      File.should_receive(:open).with('gem2.gem', 'rb')
-      FileUtils.stub(:mkdir_p)
-      Gem::Package.stub(:open)
-      FileUtils.stub(:rm_rf)
+    it "searches for .gem file" do
+      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem1').and_return(false)
+      expect(File).to receive(:directory?).with('gem2.gem').and_return(false)
+      expect(File).to receive(:exist?).with('gem1.gem').and_return(true)
+      expect(File).to receive(:exist?).with('gem2.gem').and_return(true)
+      expect(File).to receive(:open).with('gem1.gem', 'rb')
+      expect(File).to receive(:open).with('gem2.gem', 'rb')
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(Gem::Package).to receive(:open)
+      allow(FileUtils).to receive(:rm_rf)
       @diff.run('gem1', 'gem2.gem')
     end
 
-    it "should search for .gem file on rubygems.org" do
-      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
-      File.should_receive(:directory?).with('gem1').and_return(false)
-      File.should_receive(:directory?).with('gem2.gem').and_return(false)
-      File.should_receive(:directory?).any_number_of_times
-      File.should_receive(:exist?).with('gem1.gem').and_return(false)
-      File.should_receive(:exist?).with('gem2.gem').and_return(false)
-      File.should_receive(:exist?).any_number_of_times
-      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem1.gem')
-      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem2.gem')
-      FileUtils.stub(:mkdir_p)
-      Gem::Package.stub(:open)
-      FileUtils.stub(:rm_rf)
+    it "searches for .gem file on rubygems.org" do
+      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      expect(File).to receive(:directory?).with('gem1').and_return(false)
+      expect(File).to receive(:directory?).with('gem2.gem').and_return(false)
+      expect(File).to receive(:exist?).with('gem1.gem').and_return(false)
+      expect(File).to receive(:exist?).with('gem2.gem').and_return(false)
+      expect(@diff).to receive(:open).with('http://rubygems.org/downloads/gem1.gem')
+      expect(@diff).to receive(:open).with('http://rubygems.org/downloads/gem2.gem')
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(Gem::Package).to receive(:open)
+      allow(FileUtils).to receive(:rm_rf)
       @diff.run('gem1', 'gem2.gem')
     end
 
-    it "should error if gem is not found" do
-      log.should_receive(:error).with("Cannot find gem gem1")
-      log.should_receive(:error).with("Cannot find gem gem2.gem")
-      @diff.stub!(:load_gem_data).and_return(false)
+    it "raises an error if gem is not found" do
+      expect(log).to receive(:error).with("Cannot find gem gem1")
+      expect(log).to receive(:error).with("Cannot find gem gem2.gem")
+      allow(@diff).to receive(:load_gem_data).and_return(false)
       @diff.run('gem1', 'gem2.gem')
     end
   end

data/spec/cli/display_spec.rb

@@ -2,29 +2,29 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe YARD::CLI::Display do
   before do
-    Registry.stub(:load)
+    allow(Registry).to receive(:load)
     @object = CodeObjects::ClassObject.new(:root, :Foo)
     @object.docstring = 'Foo bar'
   end
 
   it "displays an object" do
     YARD::CLI::Display.run('-f', 'text', 'Foo')
-    log.io.string.strip.should eq(@object.format.strip)
+    expect(log.io.string.strip).to eq(@object.format.strip)
   end
 
   it "wraps output with -l (defaulting to layout)" do
     YARD::CLI::Display.run('-l', '-f', 'html', 'Foo')
     formatted_output = @object.format(:format => :html).strip
     actual_output = log.io.string.strip
-    actual_output.should_not eq(formatted_output)
-    actual_output.should include(formatted_output)
+    expect(actual_output).not_to eq(formatted_output)
+    expect(actual_output).to include(formatted_output)
   end
 
   it "wraps output with --layout onefile" do
     YARD::CLI::Display.run('--layout', 'onefile', '-f', 'html', 'Foo')
     formatted_output = @object.format(:format => :html).strip
     actual_output = log.io.string.strip
-    actual_output.should_not eq(formatted_output)
-    actual_output.should include(formatted_output)
+    expect(actual_output).not_to eq(formatted_output)
+    expect(actual_output).to include(formatted_output)
   end
 end

data/spec/cli/gems_spec.rb

@@ -19,62 +19,62 @@ describe YARD::CLI::Gems do
 
   def build_specs(*specs)
     specs.each do |themock|
-      Registry.should_receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}").and_return(themock.yardoc_file)
-      File.should_receive(:directory?).with(themock.yardoc_file).and_return(@rebuild)
-      File.should_receive(:directory?).with(themock.full_gem_path).and_return(true)
-      Registry.should_receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}", true).and_return(themock.yardoc_file)
-      Dir.should_receive(:chdir).with(themock.full_gem_path)
+      expect(Registry).to receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}").and_return(themock.yardoc_file)
+      expect(File).to receive(:directory?).with(themock.yardoc_file).and_return(@rebuild)
+      expect(File).to receive(:directory?).with(themock.full_gem_path).and_return(true)
+      expect(Registry).to receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}", true).and_return(themock.yardoc_file)
+      expect(Dir).to receive(:chdir).with(themock.full_gem_path)
     end
-    Registry.should_receive(:clear).exactly(specs.size).times
-    CLI::Yardoc.should_receive(:run).exactly(specs.size).times
+    expect(Registry).to receive(:clear).exactly(specs.size).times
+    expect(CLI::Yardoc).to receive(:run).exactly(specs.size).times
   end
 
-  describe '#run' do
-    it "should build all gem indexes if no gem is specified" do
+  describe "#run" do
+    it "builds all gem indexes if no gem is specified" do
       build_specs(@gem1, @gem2)
-      Gem.source_index.should_receive(:find_name).with('').and_return([@gem1, @gem2])
+      expect(Gem.source_index).to receive(:find_name).with('').and_return([@gem1, @gem2])
       CLI::Gems.run
     end
 
-    it "should allow gem to be specified" do
+    it "allows gem to be specified" do
       build_specs(@gem1)
-      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 0').and_return([@gem1])
+      expect(Gem.source_index).to receive(:find_name).with(@gem1.name, '>= 0').and_return([@gem1])
       CLI::Gems.run(@gem1.name)
     end
 
-    it "should allow multiple gems to be specified for building" do
+    it "allows multiple gems to be specified for building" do
       build_specs(@gem1, @gem2)
-      Gem.source_index.should_receive(:find_name).with(@gem1.name, @gem1.version).and_return([@gem1])
-      Gem.source_index.should_receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
+      expect(Gem.source_index).to receive(:find_name).with(@gem1.name, @gem1.version).and_return([@gem1])
+      expect(Gem.source_index).to receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
       CLI::Gems.run(@gem1.name, @gem1.version, @gem2.name)
     end
 
-    it "should allow version to be specified with gem" do
+    it "allows version to be specified with gem" do
       build_specs(@gem1)
-      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 1.0').and_return([@gem1])
+      expect(Gem.source_index).to receive(:find_name).with(@gem1.name, '>= 1.0').and_return([@gem1])
       CLI::Gems.run(@gem1.name, '>= 1.0')
     end
 
-    it "should warn if one of the gems is not found, but it should process others" do
+    it "warns if one of the gems is not found, but it should process others" do
       build_specs(@gem2)
-      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
-      Gem.source_index.should_receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
-      log.should_receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
+      expect(Gem.source_index).to receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
+      expect(Gem.source_index).to receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
+      expect(log).to receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
       CLI::Gems.run(@gem1.name, '>= 2.0', @gem2.name)
     end
 
-    it "should fail if specified gem(s) is/are not found" do
-      CLI::Yardoc.should_not_receive(:run)
-      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
-      log.should_receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
-      log.should_receive(:error).with(/No specified gems could be found/)
+    it "fails if specified gem(s) is/are not found" do
+      expect(CLI::Yardoc).not_to receive(:run)
+      expect(Gem.source_index).to receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
+      expect(log).to receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
+      expect(log).to receive(:error).with(/No specified gems could be found/)
       CLI::Gems.run(@gem1.name, '>= 2.0')
     end
 
-    it "should accept --rebuild" do
+    it "accepts --rebuild" do
       @rebuild = true
       build_specs(@gem1)
-      Gem.source_index.should_receive(:find_name).with('').and_return([@gem1])
+      expect(Gem.source_index).to receive(:find_name).with('').and_return([@gem1])
       CLI::Gems.run('--rebuild')
     end
   end