chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/knife/cookbook_delete_spec.rb

@@ -24,29 +24,29 @@ describe Chef::Knife::CookbookDelete do
     @knife.name_args = ['foobar']
     @knife.cookbook_name = 'foobar'
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
     @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
   end
 
   describe 'run' do
     it 'should print usage and exit when a cookbook name is not provided' do
       @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     describe 'when specifying a cookbook name' do
       it 'should delete the cookbook without a specific version' do
-        @knife.should_receive(:delete_without_explicit_version)
+        expect(@knife).to receive(:delete_without_explicit_version)
         @knife.run
       end
 
       describe 'and a version' do
         it 'should delete the specific version of the cookbook' do
           @knife.name_args << '1.0.0'
-          @knife.should_receive(:delete_explicit_version)
+          expect(@knife).to receive(:delete_explicit_version)
           @knife.run
         end
       end
@@ -54,7 +54,7 @@ describe Chef::Knife::CookbookDelete do
       describe 'with -a or --all' do
         it 'should delete all versions of the cookbook' do
           @knife.config[:all] = true
-          @knife.should_receive(:delete_all_versions)
+          expect(@knife).to receive(:delete_all_versions)
           @knife.run
         end
       end
@@ -62,9 +62,9 @@ describe Chef::Knife::CookbookDelete do
       describe 'with -p or --purge' do
         it 'should prompt to purge the files' do
           @knife.config[:purge] = true
-          @knife.should_receive(:confirm).
+          expect(@knife).to receive(:confirm).
                  with(/.+Are you sure you want to purge files.+/)
-          @knife.should_receive(:delete_without_explicit_version)
+          expect(@knife).to receive(:delete_without_explicit_version)
           @knife.run
         end
       end
@@ -75,10 +75,10 @@ describe Chef::Knife::CookbookDelete do
     it 'should delete the specific cookbook version' do
       @knife.cookbook_name = 'foobar'
       @knife.version = '1.0.0'
-      @knife.should_receive(:delete_object).with(Chef::CookbookVersion,
+      expect(@knife).to receive(:delete_object).with(Chef::CookbookVersion,
                                                  'foobar version 1.0.0',
                                                  'cookbook').and_yield()
-      @knife.should_receive(:delete_request).with('cookbooks/foobar/1.0.0')
+      expect(@knife).to receive(:delete_request).with('cookbooks/foobar/1.0.0')
       @knife.delete_explicit_version
     end
   end
@@ -86,8 +86,8 @@ describe Chef::Knife::CookbookDelete do
   describe 'delete_all_versions' do
     it 'should prompt to delete all versions of the cookbook' do
       @knife.cookbook_name = 'foobar'
-      @knife.should_receive(:confirm).with('Do you really want to delete all versions of foobar')
-      @knife.should_receive(:delete_all_without_confirmation)
+      expect(@knife).to receive(:confirm).with('Do you really want to delete all versions of foobar')
+      expect(@knife).to receive(:delete_all_without_confirmation)
       @knife.delete_all_versions
     end
   end
@@ -95,9 +95,9 @@ describe Chef::Knife::CookbookDelete do
   describe 'delete_all_without_confirmation' do
     it 'should delete all versions without confirmation' do
       versions = ['1.0.0', '1.1.0']
-      @knife.should_receive(:available_versions).and_return(versions)
+      expect(@knife).to receive(:available_versions).and_return(versions)
       versions.each do |v|
-        @knife.should_receive(:delete_version_without_confirmation).with(v)
+        expect(@knife).to receive(:delete_version_without_confirmation).with(v)
       end
       @knife.delete_all_without_confirmation
     end
@@ -105,20 +105,20 @@ describe Chef::Knife::CookbookDelete do
 
   describe 'delete_without_explicit_version' do
     it 'should exit if there are no available versions' do
-      @knife.should_receive(:available_versions).and_return(nil)
-      lambda { @knife.delete_without_explicit_version }.should raise_error(SystemExit)
+      expect(@knife).to receive(:available_versions).and_return(nil)
+      expect { @knife.delete_without_explicit_version }.to raise_error(SystemExit)
     end
 
     it 'should delete the version if only one is found' do
-      @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0'])
-      @knife.should_receive(:delete_explicit_version)
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0'])
+      expect(@knife).to receive(:delete_explicit_version)
       @knife.delete_without_explicit_version
     end
 
     it 'should ask which version(s) to delete if multiple are found' do
-      @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0', '1.1.0'])
-      @knife.should_receive(:ask_which_versions_to_delete).and_return(['1.0.0', '1.1.0'])
-      @knife.should_receive(:delete_versions_without_confirmation).with(['1.0.0', '1.1.0'])
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0', '1.1.0'])
+      expect(@knife).to receive(:ask_which_versions_to_delete).and_return(['1.0.0', '1.1.0'])
+      expect(@knife).to receive(:delete_versions_without_confirmation).with(['1.0.0', '1.1.0'])
       @knife.delete_without_explicit_version
     end
   end
@@ -126,7 +126,7 @@ describe Chef::Knife::CookbookDelete do
   describe 'available_versions' do
     before(:each) do
       @rest_mock = double('rest')
-      @knife.should_receive(:rest).and_return(@rest_mock)
+      expect(@knife).to receive(:rest).and_return(@rest_mock)
       @cookbook_data = { 'foobar' => { 'versions' => [{'version' => '1.0.0'},
                                                       {'version' => '1.1.0'},
                                                       {'version' => '2.0.0'} ]}
@@ -134,85 +134,85 @@ describe Chef::Knife::CookbookDelete do
     end
 
     it 'should return the list of versions of the cookbook' do
-      @rest_mock.should_receive(:get_rest).with('cookbooks/foobar').and_return(@cookbook_data)
-      @knife.available_versions.should == ['1.0.0', '1.1.0', '2.0.0']
+      expect(@rest_mock).to receive(:get_rest).with('cookbooks/foobar').and_return(@cookbook_data)
+      expect(@knife.available_versions).to eq(['1.0.0', '1.1.0', '2.0.0'])
     end
 
     it 'should raise if an error other than HTTP 404 is returned' do
       exception = Net::HTTPServerException.new('500 Internal Server Error', '500')
-      @rest_mock.should_receive(:get_rest).and_raise(exception)
-      lambda { @knife.available_versions }.should raise_error Net::HTTPServerException
+      expect(@rest_mock).to receive(:get_rest).and_raise(exception)
+      expect { @knife.available_versions }.to raise_error Net::HTTPServerException
     end
 
     describe "if the cookbook can't be found" do
       before(:each) do
-        @rest_mock.should_receive(:get_rest).
+        expect(@rest_mock).to receive(:get_rest).
           and_raise(Net::HTTPServerException.new('404 Not Found', '404'))
       end
 
       it 'should print an error' do
         @knife.available_versions
-        @stderr.string.should match /error.+cannot find a cookbook named foobar/i
+        expect(@stderr.string).to match /error.+cannot find a cookbook named foobar/i
       end
 
       it 'should return nil' do
-        @knife.available_versions.should == nil
+        expect(@knife.available_versions).to eq(nil)
       end
     end
   end
 
   describe 'ask_which_version_to_delete' do
     before(:each) do
-      @knife.stub(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0'])
+      allow(@knife).to receive(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0'])
     end
 
     it 'should prompt the user to select a version' do
       prompt = /Which version\(s\) do you want to delete\?.+1\. foobar 1\.0\.0.+2\. foobar 1\.1\.0.+3\. foobar 2\.0\.0.+4\. All versions.+/m
-      @knife.should_receive(:ask_question).with(prompt).and_return('1')
+      expect(@knife).to receive(:ask_question).with(prompt).and_return('1')
       @knife.ask_which_versions_to_delete
     end
 
     it "should print an error and exit if a version wasn't specified" do
-      @knife.should_receive(:ask_question).and_return('')
-      @knife.ui.should_receive(:error).with(/no versions specified/i)
-      lambda { @knife.ask_which_versions_to_delete }.should raise_error(SystemExit)
+      expect(@knife).to receive(:ask_question).and_return('')
+      expect(@knife.ui).to receive(:error).with(/no versions specified/i)
+      expect { @knife.ask_which_versions_to_delete }.to raise_error(SystemExit)
     end
 
     it 'should print an error if an invalid choice was selected' do
-      @knife.should_receive(:ask_question).and_return('100')
-      @knife.ui.should_receive(:error).with(/100 is not a valid choice/i)
+      expect(@knife).to receive(:ask_question).and_return('100')
+      expect(@knife.ui).to receive(:error).with(/100 is not a valid choice/i)
       @knife.ask_which_versions_to_delete
     end
 
     it 'should return the selected versions' do
-      @knife.should_receive(:ask_question).and_return('1, 3')
-      @knife.ask_which_versions_to_delete.should == ['1.0.0', '2.0.0']
+      expect(@knife).to receive(:ask_question).and_return('1, 3')
+      expect(@knife.ask_which_versions_to_delete).to eq(['1.0.0', '2.0.0'])
     end
 
     it "should return all of the versions if 'all' was selected" do
-      @knife.should_receive(:ask_question).and_return('4')
-      @knife.ask_which_versions_to_delete.should == [:all]
+      expect(@knife).to receive(:ask_question).and_return('4')
+      expect(@knife.ask_which_versions_to_delete).to eq([:all])
     end
   end
 
   describe 'delete_version_without_confirmation' do
     it 'should delete the cookbook version' do
-      @knife.should_receive(:delete_request).with('cookbooks/foobar/1.0.0')
+      expect(@knife).to receive(:delete_request).with('cookbooks/foobar/1.0.0')
       @knife.delete_version_without_confirmation('1.0.0')
     end
 
     it 'should output that the cookbook was deleted' do
-      @knife.stub(:delete_request)
+      allow(@knife).to receive(:delete_request)
       @knife.delete_version_without_confirmation('1.0.0')
-      @stderr.string.should match /deleted cookbook\[foobar\]\[1.0.0\]/im
+      expect(@stderr.string).to match /deleted cookbook\[foobar\]\[1.0.0\]/im
     end
 
     describe 'with --print-after' do
       it 'should display the cookbook data' do
         object = ''
         @knife.config[:print_after] = true
-        @knife.stub(:delete_request).and_return(object)
-        @knife.should_receive(:format_for_display).with(object)
+        allow(@knife).to receive(:delete_request).and_return(object)
+        expect(@knife).to receive(:format_for_display).with(object)
         @knife.delete_version_without_confirmation('1.0.0')
       end
     end
@@ -222,7 +222,7 @@ describe Chef::Knife::CookbookDelete do
     it 'should delete each version without confirmation' do
       versions = ['1.0.0', '1.1.0']
       versions.each do |v|
-        @knife.should_receive(:delete_version_without_confirmation).with(v)
+        expect(@knife).to receive(:delete_version_without_confirmation).with(v)
       end
       @knife.delete_versions_without_confirmation(versions)
     end
@@ -230,7 +230,7 @@ describe Chef::Knife::CookbookDelete do
     describe 'with -a or --all' do
       it 'should delete all versions without confirmation' do
         versions = [:all]
-        @knife.should_receive(:delete_all_without_confirmation)
+        expect(@knife).to receive(:delete_all_without_confirmation)
         @knife.delete_versions_without_confirmation(versions)
       end
     end

data/spec/unit/knife/cookbook_download_spec.rb

@@ -22,22 +22,22 @@ describe Chef::Knife::CookbookDownload do
   before(:each) do
     @knife = Chef::Knife::CookbookDownload.new
     @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
   end
 
   describe 'run' do
     it 'should print usage and exit when a cookbook name is not provided' do
       @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal).with(/must specify a cookbook name/)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal).with(/must specify a cookbook name/)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should exit with a fatal error when there is no cookbook on the server' do
       @knife.name_args = ['foobar', nil]
-      @knife.should_receive(:determine_version).and_return(nil)
-      @knife.ui.should_receive(:fatal).with('No such cookbook found')
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:determine_version).and_return(nil)
+      expect(@knife.ui).to receive(:fatal).with('No such cookbook found')
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     describe 'with a cookbook name' do
@@ -45,7 +45,7 @@ describe Chef::Knife::CookbookDownload do
         @knife.name_args = ['foobar']
         @knife.config[:download_directory] = '/var/tmp/chef'
         @rest_mock = double('rest')
-        @knife.stub(:rest).and_return(@rest_mock)
+        allow(@knife).to receive(:rest).and_return(@rest_mock)
 
         @manifest_data = {
           :recipes => [
@@ -67,17 +67,17 @@ describe Chef::Knife::CookbookDownload do
         }
 
         @cookbook_mock = double('cookbook')
-        @cookbook_mock.stub(:version).and_return('1.0.0')
-        @cookbook_mock.stub(:manifest).and_return(@manifest_data)
-        @rest_mock.should_receive(:get_rest).with('cookbooks/foobar/1.0.0').
+        allow(@cookbook_mock).to receive(:version).and_return('1.0.0')
+        allow(@cookbook_mock).to receive(:manifest).and_return(@manifest_data)
+        expect(@rest_mock).to receive(:get_rest).with('cookbooks/foobar/1.0.0').
                                              and_return(@cookbook_mock)
       end
 
       it 'should determine which version if one was not explicitly specified'do
-        @cookbook_mock.stub(:manifest).and_return({})
-        @knife.should_receive(:determine_version).and_return('1.0.0')
-        File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
-        Chef::CookbookVersion.stub(:COOKBOOK_SEGEMENTS).and_return([])
+        allow(@cookbook_mock).to receive(:manifest).and_return({})
+        expect(@knife).to receive(:determine_version).and_return('1.0.0')
+        expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
+        allow(Chef::CookbookVersion).to receive(:COOKBOOK_SEGEMENTS).and_return([])
         @knife.run
       end
 
@@ -88,50 +88,50 @@ describe Chef::Knife::CookbookDownload do
           @files_mocks = {}
           @files.map { |f| File.basename(f) }.flatten.uniq.each do |f|
             @files_mocks[f] = double("#{f}_mock")
-            @files_mocks[f].stub(:path).and_return("/var/tmp/#{f}")
+            allow(@files_mocks[f]).to receive(:path).and_return("/var/tmp/#{f}")
           end
         end
 
         it 'should print an error and exit if the cookbook download directory already exists' do
-          File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
-          @knife.ui.should_receive(:fatal).with(/\/var\/tmp\/chef\/foobar-1\.0\.0 exists/i)
-          lambda { @knife.run }.should raise_error(SystemExit)
+          expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
+          expect(@knife.ui).to receive(:fatal).with(/\/var\/tmp\/chef\/foobar-1\.0\.0 exists/i)
+          expect { @knife.run }.to raise_error(SystemExit)
         end
 
         describe 'when downloading the cookbook' do
           before(:each) do
             @files.map { |f| File.dirname(f) }.flatten.uniq.each do |dir|
-              FileUtils.should_receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}").
+              expect(FileUtils).to receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}").
               at_least(:once)
             end
 
             @files_mocks.each_pair do |file, mock|
-              @rest_mock.should_receive(:get_rest).with("http://example.org/files/#{file}", true).
+              expect(@rest_mock).to receive(:get_rest).with("http://example.org/files/#{file}", true).
               and_return(mock)
             end
 
-            @rest_mock.should_receive(:sign_on_redirect=).with(false).at_least(:once)
+            expect(@rest_mock).to receive(:sign_on_redirect=).with(false).at_least(:once)
             @files.each do |f|
-              FileUtils.should_receive(:mv).
+              expect(FileUtils).to receive(:mv).
                         with("/var/tmp/#{File.basename(f)}", "/var/tmp/chef/foobar-1.0.0/#{f}")
             end
           end
 
           it "should download the cookbook when the cookbook download directory doesn't exist" do
-            File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
+            expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
             @knife.run
             ['attributes', 'recipes', 'templates'].each do |segment|
-              @stderr.string.should match /downloading #{segment}/im
+              expect(@stderr.string).to match /downloading #{segment}/im
             end
-            @stderr.string.should match /downloading foobar cookbook version 1\.0\.0/im
-            @stderr.string.should match /cookbook downloaded to \/var\/tmp\/chef\/foobar-1\.0\.0/im
+            expect(@stderr.string).to match /downloading foobar cookbook version 1\.0\.0/im
+            expect(@stderr.string).to match /cookbook downloaded to \/var\/tmp\/chef\/foobar-1\.0\.0/im
           end
 
           describe 'with -f or --force' do
             it 'should remove the existing the cookbook download directory if it exists' do
               @knife.config[:force] = true
-              File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
-              FileUtils.should_receive(:rm_rf).with('/var/tmp/chef/foobar-1.0.0')
+              expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
+              expect(FileUtils).to receive(:rm_rf).with('/var/tmp/chef/foobar-1.0.0')
               @knife.run
             end
           end
@@ -145,30 +145,30 @@ describe Chef::Knife::CookbookDownload do
   describe 'determine_version' do
 
     it 'should return nil if there are no versions' do
-      @knife.should_receive(:available_versions).and_return(nil)
-      @knife.determine_version.should == nil
-      @knife.version.should == nil
+      expect(@knife).to receive(:available_versions).and_return(nil)
+      expect(@knife.determine_version).to eq(nil)
+      expect(@knife.version).to eq(nil)
     end
 
     it 'should return and set the version if there is only one version' do
-      @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0'])
-      @knife.determine_version.should == '1.0.0'
-      @knife.version.should == '1.0.0'
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0'])
+      expect(@knife.determine_version).to eq('1.0.0')
+      expect(@knife.version).to eq('1.0.0')
     end
 
     it 'should ask which version to download and return it if there is more than one' do
-      @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0'])
-      @knife.should_receive(:ask_which_version).and_return('1.0.0')
-      @knife.determine_version.should == '1.0.0'
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0'])
+      expect(@knife).to receive(:ask_which_version).and_return('1.0.0')
+      expect(@knife.determine_version).to eq('1.0.0')
     end
 
     describe 'with -N or --latest' do
       it 'should return and set the version to the latest version' do
         @knife.config[:latest] = true
-        @knife.should_receive(:available_versions).at_least(:once).
+        expect(@knife).to receive(:available_versions).at_least(:once).
                                                    and_return(['1.0.0', '1.1.0', '2.0.0'])
         @knife.determine_version
-        @knife.version.to_s.should == '2.0.0'
+        expect(@knife.version.to_s).to eq('2.0.0')
       end
     end
   end
@@ -179,23 +179,23 @@ describe Chef::Knife::CookbookDownload do
     end
 
     it 'should return nil if there are no versions' do
-      Chef::CookbookVersion.should_receive(:available_versions).
+      expect(Chef::CookbookVersion).to receive(:available_versions).
                             with('foobar').
                             and_return(nil)
-      @knife.available_versions.should == nil
+      expect(@knife.available_versions).to eq(nil)
     end
 
     it 'should return the available versions' do
-      Chef::CookbookVersion.should_receive(:available_versions).
+      expect(Chef::CookbookVersion).to receive(:available_versions).
                             with('foobar').
                             and_return(['1.1.0', '2.0.0', '1.0.0'])
-      @knife.available_versions.should == [Chef::Version.new('1.0.0'),
+      expect(@knife.available_versions).to eq([Chef::Version.new('1.0.0'),
                                            Chef::Version.new('1.1.0'),
-                                           Chef::Version.new('2.0.0')]
+                                           Chef::Version.new('2.0.0')])
     end
 
     it 'should avoid multiple API calls to the server' do
-      Chef::CookbookVersion.should_receive(:available_versions).
+      expect(Chef::CookbookVersion).to receive(:available_versions).
                             once.
                             with('foobar').
                             and_return(['1.1.0', '2.0.0', '1.0.0'])
@@ -207,31 +207,31 @@ describe Chef::Knife::CookbookDownload do
   describe 'ask_which_version' do
     before(:each) do
       @knife.cookbook_name = 'foobar'
-      @knife.stub(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0'])
+      allow(@knife).to receive(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0'])
     end
 
     it 'should prompt the user to select a version' do
       prompt = /Which version do you want to download\?.+1\. foobar 1\.0\.0.+2\. foobar 1\.1\.0.+3\. foobar 2\.0\.0.+/m
-      @knife.should_receive(:ask_question).with(prompt).and_return('1')
+      expect(@knife).to receive(:ask_question).with(prompt).and_return('1')
       @knife.ask_which_version
     end
 
     it "should set the version to the user's selection" do
-      @knife.should_receive(:ask_question).and_return('1')
+      expect(@knife).to receive(:ask_question).and_return('1')
       @knife.ask_which_version
-      @knife.version.should == '1.0.0'
+      expect(@knife.version).to eq('1.0.0')
     end
 
     it "should print an error and exit if a version wasn't specified" do
-      @knife.should_receive(:ask_question).and_return('')
-      @knife.ui.should_receive(:error).with(/is not a valid value/i)
-      lambda { @knife.ask_which_version }.should raise_error(SystemExit)
+      expect(@knife).to receive(:ask_question).and_return('')
+      expect(@knife.ui).to receive(:error).with(/is not a valid value/i)
+      expect { @knife.ask_which_version }.to raise_error(SystemExit)
     end
 
     it 'should print an error if an invalid choice was selected' do
-      @knife.should_receive(:ask_question).and_return('100')
-      @knife.ui.should_receive(:error).with(/'100' is not a valid value/i)
-      lambda { @knife.ask_which_version }.should raise_error(SystemExit)
+      expect(@knife).to receive(:ask_question).and_return('100')
+      expect(@knife.ui).to receive(:error).with(/'100' is not a valid value/i)
+      expect { @knife.ask_which_version }.to raise_error(SystemExit)
     end
   end