chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/knife/environment_create_spec.rb

@@ -21,49 +21,49 @@ require 'spec_helper'
 describe Chef::Knife::EnvironmentCreate do
   before(:each) do
     @knife = Chef::Knife::EnvironmentCreate.new
-    @knife.stub(:msg).and_return true
-    @knife.stub(:output).and_return true
-    @knife.stub(:show_usage).and_return true
+    allow(@knife).to receive(:msg).and_return true
+    allow(@knife).to receive(:output).and_return true
+    allow(@knife).to receive(:show_usage).and_return true
     @knife.name_args = [ "production" ]
 
     @environment = Chef::Environment.new
-    @environment.stub(:save)
+    allow(@environment).to receive(:save)
 
-    Chef::Environment.stub(:new).and_return @environment
-    @knife.stub(:edit_data).and_return @environment
+    allow(Chef::Environment).to receive(:new).and_return @environment
+    allow(@knife).to receive(:edit_data).and_return @environment
   end
 
   describe "run" do
     it "should create a new environment" do
-      Chef::Environment.should_receive(:new)
+      expect(Chef::Environment).to receive(:new)
       @knife.run
     end
 
     it "should set the environment name" do
-      @environment.should_receive(:name).with("production")
+      expect(@environment).to receive(:name).with("production")
       @knife.run
     end
 
     it "should not print the environment" do
-      @knife.should_not_receive(:output)
+      expect(@knife).not_to receive(:output)
       @knife.run
     end
 
     it "should prompt you to edit the data" do
-      @knife.should_receive(:edit_data).with(@environment)
+      expect(@knife).to receive(:edit_data).with(@environment)
       @knife.run
     end
 
     it "should save the environment" do
-      @environment.should_receive(:save)
+      expect(@environment).to receive(:save)
       @knife.run
     end
 
     it "should show usage and exit when no environment name is provided" do
       @knife.name_args = [ ]
-      @knife.ui.should_receive(:fatal)
-      @knife.should_receive(:show_usage)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife.ui).to receive(:fatal)
+      expect(@knife).to receive(:show_usage)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     describe "with --description" do
@@ -72,7 +72,7 @@ describe Chef::Knife::EnvironmentCreate do
       end
 
       it "should set the description" do
-        @environment.should_receive(:description).with("This is production")
+        expect(@environment).to receive(:description).with("This is production")
         @knife.run
       end
     end
@@ -83,7 +83,7 @@ describe Chef::Knife::EnvironmentCreate do
       end
 
       it "should pretty print the environment, formatted for display" do
-        @knife.should_receive(:output).with(@environment)
+        expect(@knife).to receive(:output).with(@environment)
         @knife.run
       end
     end

data/spec/unit/knife/environment_delete_spec.rb

@@ -21,50 +21,50 @@ require 'spec_helper'
 describe Chef::Knife::EnvironmentDelete do
   before(:each) do
     @knife = Chef::Knife::EnvironmentDelete.new
-    @knife.stub(:msg).and_return true
-    @knife.stub(:output).and_return true
-    @knife.stub(:show_usage).and_return true
-    @knife.stub(:confirm).and_return true
+    allow(@knife).to receive(:msg).and_return true
+    allow(@knife).to receive(:output).and_return true
+    allow(@knife).to receive(:show_usage).and_return true
+    allow(@knife).to receive(:confirm).and_return true
     @knife.name_args = [ "production" ]
 
     @environment = Chef::Environment.new
     @environment.name("production")
     @environment.description("Please delete me")
-    @environment.stub(:destroy).and_return true
-    Chef::Environment.stub(:load).and_return @environment
+    allow(@environment).to receive(:destroy).and_return true
+    allow(Chef::Environment).to receive(:load).and_return @environment
   end
 
   it "should confirm that you want to delete" do
-    @knife.should_receive(:confirm)
+    expect(@knife).to receive(:confirm)
     @knife.run
   end
 
   it "should load the environment" do
-    Chef::Environment.should_receive(:load).with("production")
+    expect(Chef::Environment).to receive(:load).with("production")
     @knife.run
   end
 
   it "should delete the environment" do
-    @environment.should_receive(:destroy)
+    expect(@environment).to receive(:destroy)
     @knife.run
   end
 
   it "should not print the environment" do
-    @knife.should_not_receive(:output)
+    expect(@knife).not_to receive(:output)
     @knife.run
   end
 
   it "should show usage and exit when no environment name is provided" do
     @knife.name_args = []
-    @knife.ui.should_receive(:fatal)
-    @knife.should_receive(:show_usage)
-    lambda { @knife.run }.should raise_error(SystemExit)
+    expect(@knife.ui).to receive(:fatal)
+    expect(@knife).to receive(:show_usage)
+    expect { @knife.run }.to raise_error(SystemExit)
   end
 
   describe "with --print-after" do
     it "should pretty print the environment, formatted for display" do
       @knife.config[:print_after] = true
-      @knife.should_receive(:output).with(@environment)
+      expect(@knife).to receive(:output).with(@environment)
       @knife.run
     end
   end

data/spec/unit/knife/environment_edit_spec.rb

@@ -21,26 +21,26 @@ require 'spec_helper'
 describe Chef::Knife::EnvironmentEdit do
   before(:each) do
     @knife = Chef::Knife::EnvironmentEdit.new
-    @knife.ui.stub(:msg).and_return true
-    @knife.ui.stub(:output).and_return true
-    @knife.ui.stub(:show_usage).and_return true
+    allow(@knife.ui).to receive(:msg).and_return true
+    allow(@knife.ui).to receive(:output).and_return true
+    allow(@knife.ui).to receive(:show_usage).and_return true
     @knife.name_args = [ "production" ]
 
     @environment = Chef::Environment.new
     @environment.name("production")
     @environment.description("Please edit me")
-    @environment.stub(:save).and_return true
-    Chef::Environment.stub(:load).and_return @environment
-    @knife.ui.stub(:edit_data).and_return @environment
+    allow(@environment).to receive(:save).and_return true
+    allow(Chef::Environment).to receive(:load).and_return @environment
+    allow(@knife.ui).to receive(:edit_data).and_return @environment
   end
 
   it "should load the environment" do
-    Chef::Environment.should_receive(:load).with("production")
+    expect(Chef::Environment).to receive(:load).with("production")
     @knife.run
   end
 
   it "should let you edit the environment" do
-    @knife.ui.should_receive(:edit_data).with(@environment)
+    expect(@knife.ui).to receive(:edit_data).with(@environment)
     @knife.run
   end
 
@@ -48,31 +48,31 @@ describe Chef::Knife::EnvironmentEdit do
     pansy = Chef::Environment.new
 
     @environment.name("new_environment_name")
-    @knife.ui.should_receive(:edit_data).with(@environment).and_return(pansy)
-    pansy.should_receive(:save)
+    expect(@knife.ui).to receive(:edit_data).with(@environment).and_return(pansy)
+    expect(pansy).to receive(:save)
     @knife.run
   end
 
   it "should not save the unedited environment data" do
-    @environment.should_not_receive(:save)
+    expect(@environment).not_to receive(:save)
     @knife.run
   end
 
   it "should not print the environment" do
-    @knife.should_not_receive(:output)
+    expect(@knife).not_to receive(:output)
     @knife.run
   end
 
   it "shoud show usage and exit when no environment name is provided" do
     @knife.name_args = []
-    @knife.should_receive(:show_usage)
-    lambda { @knife.run }.should raise_error(SystemExit)
+    expect(@knife).to receive(:show_usage)
+    expect { @knife.run }.to raise_error(SystemExit)
   end
 
   describe "with --print-after" do
     it "should pretty print the environment, formatted for display" do
       @knife.config[:print_after] = true
-      @knife.ui.should_receive(:output).with(@environment)
+      expect(@knife.ui).to receive(:output).with(@environment)
       @knife.run
     end
   end

data/spec/unit/knife/environment_from_file_spec.rb

@@ -23,24 +23,24 @@ Chef::Knife::EnvironmentFromFile.load_deps
 
 describe Chef::Knife::EnvironmentFromFile do
   before(:each) do
-    Chef::Platform.stub(:windows?) { false }
+    allow(Chef::Platform).to receive(:windows?) { false }
     @knife = Chef::Knife::EnvironmentFromFile.new
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
     @knife.name_args = [ "spec.rb" ]
 
     @environment = Chef::Environment.new
     @environment.name("spec")
     @environment.description("runs the unit tests")
     @environment.cookbook_versions({"apt" => "= 1.2.3"})
-    @environment.stub(:save).and_return true
-    @knife.loader.stub(:load_from).and_return @environment
+    allow(@environment).to receive(:save).and_return true
+    allow(@knife.loader).to receive(:load_from).and_return @environment
   end
 
   describe "run" do
     it "loads the environment data from a file and saves it" do
-      @knife.loader.should_receive(:load_from).with('environments', 'spec.rb').and_return(@environment)
-      @environment.should_receive(:save)
+      expect(@knife.loader).to receive(:load_from).with('environments', 'spec.rb').and_return(@environment)
+      expect(@environment).to receive(:save)
       @knife.run
     end
 
@@ -48,41 +48,41 @@ describe Chef::Knife::EnvironmentFromFile do
       before(:each) do
         @env_apple = @environment.dup
         @env_apple.name("apple")
-        @knife.loader.stub(:load_from).with("apple.rb").and_return @env_apple
+        allow(@knife.loader).to receive(:load_from).with("apple.rb").and_return @env_apple
       end
 
       it "loads multiple environments if given" do
         @knife.name_args = [ "spec.rb", "apple.rb" ]
-        @environment.should_receive(:save).twice
+        expect(@environment).to receive(:save).twice
         @knife.run
       end
 
       it "loads all environments with -a" do
-        File.stub(:expand_path).with("./environments/").and_return("/tmp/environments")
-        Dir.stub(:glob).with("/tmp/environments/*.{json,rb}").and_return(["spec.rb", "apple.rb"])
+        allow(File).to receive(:expand_path).with("./environments/").and_return("/tmp/environments")
+        allow(Dir).to receive(:glob).with("/tmp/environments/*.{json,rb}").and_return(["spec.rb", "apple.rb"])
         @knife.name_args = []
-        @knife.stub(:config).and_return({:all => true})
-        @environment.should_receive(:save).twice
+        allow(@knife).to receive(:config).and_return({:all => true})
+        expect(@environment).to receive(:save).twice
         @knife.run
       end
     end
 
     it "should not print the environment" do
-      @knife.should_not_receive(:output)
+      expect(@knife).not_to receive(:output)
       @knife.run
     end
 
     it "should show usage and exit if not filename is provided" do
       @knife.name_args = []
-      @knife.ui.should_receive(:fatal)
-      @knife.should_receive(:show_usage)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife.ui).to receive(:fatal)
+      expect(@knife).to receive(:show_usage)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     describe "with --print-after" do
       it "should pretty print the environment, formatted for display" do
         @knife.config[:print_after] = true
-        @knife.should_receive(:output)
+        expect(@knife).to receive(:output)
         @knife.run
       end
     end

data/spec/unit/knife/environment_list_spec.rb

@@ -21,33 +21,33 @@ require 'spec_helper'
 describe Chef::Knife::EnvironmentList do
   before(:each) do
     @knife = Chef::Knife::EnvironmentList.new
-    @knife.stub(:msg).and_return true
-    @knife.stub(:output).and_return true
-    @knife.stub(:show_usage).and_return true
+    allow(@knife).to receive(:msg).and_return true
+    allow(@knife).to receive(:output).and_return true
+    allow(@knife).to receive(:show_usage).and_return true
 
     @environments = {
       "production" => "http://localhost:4000/environments/production",
       "development" => "http://localhost:4000/environments/development",
       "testing" => "http://localhost:4000/environments/testing"
     }
-    Chef::Environment.stub(:list).and_return @environments
+    allow(Chef::Environment).to receive(:list).and_return @environments
   end
 
   it "should make an api call to list the environments" do
-    Chef::Environment.should_receive(:list)
+    expect(Chef::Environment).to receive(:list)
     @knife.run
   end
 
   it "should print the environment names in a sorted list" do
     names = @environments.keys.sort { |a,b| a <=> b }
-    @knife.should_receive(:output).with(names)
+    expect(@knife).to receive(:output).with(names)
     @knife.run
   end
 
   describe "with --with-uri" do
     it "should print and unsorted list of the environments and their URIs" do
       @knife.config[:with_uri] = true
-      @knife.should_receive(:output).with(@environments)
+      expect(@knife).to receive(:output).with(@environments)
       @knife.run
     end
   end

data/spec/unit/knife/environment_show_spec.rb

@@ -21,32 +21,32 @@ require 'spec_helper'
 describe Chef::Knife::EnvironmentShow do
   before(:each) do
     @knife = Chef::Knife::EnvironmentShow.new
-    @knife.stub(:msg).and_return true
-    @knife.stub(:output).and_return true
-    @knife.stub(:show_usage).and_return true
+    allow(@knife).to receive(:msg).and_return true
+    allow(@knife).to receive(:output).and_return true
+    allow(@knife).to receive(:show_usage).and_return true
     @knife.name_args = [ "production" ]
 
     @environment = Chef::Environment.new
     @environment.name("production")
     @environment.description("Look at me!")
-    Chef::Environment.stub(:load).and_return @environment
+    allow(Chef::Environment).to receive(:load).and_return @environment
   end
 
   it "should load the environment" do
-    Chef::Environment.should_receive(:load).with("production")
+    expect(Chef::Environment).to receive(:load).with("production")
     @knife.run
   end
 
   it "should pretty print the environment, formatted for display" do
-    @knife.should_receive(:format_for_display).with(@environment)
-    @knife.should_receive(:output)
+    expect(@knife).to receive(:format_for_display).with(@environment)
+    expect(@knife).to receive(:output)
     @knife.run
   end
 
   it "should show usage and exit when no environment name is provided" do
     @knife.name_args = []
-    @knife.ui.should_receive(:fatal)
-    @knife.should_receive(:show_usage)
-    lambda { @knife.run }.should raise_error(SystemExit)
+    expect(@knife.ui).to receive(:fatal)
+    expect(@knife).to receive(:show_usage)
+    expect { @knife.run }.to raise_error(SystemExit)
   end
 end

data/spec/unit/knife/index_rebuild_spec.rb

@@ -24,18 +24,18 @@ describe Chef::Knife::IndexRebuild do
   let(:rest_client){double(Chef::REST)}
 
   let(:stub_rest!) do
-    knife.should_receive(:rest).and_return(rest_client)
+    expect(knife).to receive(:rest).and_return(rest_client)
   end
 
   before :each do
     # This keeps the test output clean
-    knife.ui.stub(:stdout).and_return(StringIO.new)
+    allow(knife.ui).to receive(:stdout).and_return(StringIO.new)
   end
 
   context "#grab_api_info" do
     let(:http_not_found_response) do
       e = Net::HTTPNotFound.new("1.1", 404, "blah")
-      e.stub(:[]).with("x-ops-api-info").and_return(api_header_value)
+      allow(e).to receive(:[]).with("x-ops-api-info").and_return(api_header_value)
       e
     end
 
@@ -45,20 +45,20 @@ describe Chef::Knife::IndexRebuild do
 
     before(:each) do
       stub_rest!
-      rest_client.stub(:get_rest).and_raise(http_server_exception)
+      allow(rest_client).to receive(:get_rest).and_raise(http_server_exception)
     end
 
     context "against a Chef 11 server" do
       let(:api_header_value){"flavor=osc;version=11.0.0;erchef=1.2.3"}
       it "retrieves API information" do
-        knife.grab_api_info.should == {"flavor" => "osc", "version" => "11.0.0", "erchef" => "1.2.3"}
+        expect(knife.grab_api_info).to eq({"flavor" => "osc", "version" => "11.0.0", "erchef" => "1.2.3"})
       end
     end # Chef 11
 
     context "against a Chef 10 server" do
       let(:api_header_value){nil}
       it "finds no API information" do
-        knife.grab_api_info.should == {}
+        expect(knife.grab_api_info).to eq({})
       end
     end # Chef 10
   end # grab_api_info
@@ -66,18 +66,18 @@ describe Chef::Knife::IndexRebuild do
   context "#unsupported_version?" do
     context "with Chef 11 API metadata" do
       it "is unsupported" do
-        knife.unsupported_version?({"version" => "11.0.0", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true
+        expect(knife.unsupported_version?({"version" => "11.0.0", "flavor" => "osc", "erchef" => "1.2.3"})).to be_truthy
       end
 
       it "only truly relies on the version being non-nil" do
-        knife.unsupported_version?({"version" => "1", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true
+        expect(knife.unsupported_version?({"version" => "1", "flavor" => "osc", "erchef" => "1.2.3"})).to be_truthy
       end
     end
 
     context "with Chef 10 API metadata" do
       it "is supported" do
         # Chef 10 will have no metadata
-        knife.unsupported_version?({}).should be_false
+        expect(knife.unsupported_version?({})).to be_falsey
       end
     end
   end # unsupported_version?
@@ -85,7 +85,7 @@ describe Chef::Knife::IndexRebuild do
   context "Simulating a 'knife index rebuild' run" do
 
     before :each do
-      knife.should_receive(:grab_api_info).and_return(api_info)
+      expect(knife).to receive(:grab_api_info).and_return(api_info)
       server_specific_stubs!
     end
 
@@ -97,8 +97,8 @@ describe Chef::Knife::IndexRebuild do
         }
       end
       let(:server_specific_stubs!) do
-        knife.should_receive(:unsupported_server_message).with(api_info)
-        knife.should_receive(:exit).with(1)
+        expect(knife).to receive(:unsupported_server_message).with(api_info)
+        expect(knife).to receive(:exit).with(1)
       end
 
       it "should not be allowed" do
@@ -110,11 +110,11 @@ describe Chef::Knife::IndexRebuild do
       let(:api_info){ {} }
       let(:server_specific_stubs!) do
         stub_rest!
-        rest_client.should_receive(:post_rest).with("/search/reindex", {}).and_return("representative output")
-        knife.should_not_receive(:unsupported_server_message)
-        knife.should_receive(:deprecated_server_message)
-        knife.should_receive(:nag)
-        knife.should_receive(:output).with("representative output")
+        expect(rest_client).to receive(:post_rest).with("/search/reindex", {}).and_return("representative output")
+        expect(knife).not_to receive(:unsupported_server_message)
+        expect(knife).to receive(:deprecated_server_message)
+        expect(knife).to receive(:nag)
+        expect(knife).to receive(:output).with("representative output")
       end
       it "should be allowed" do
         knife.run