chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/knife/knife_help.rb

@@ -26,66 +26,66 @@ describe Chef::Knife::Help do
   end
 
   it "should return a list of help topics" do
-    @knife.help_topics.should include("knife-status")
+    expect(@knife.help_topics).to include("knife-status")
   end
 
   it "should run man for you" do
     @knife.name_args = [ "shell" ]
-    @knife.should_receive(:exec).with(/^man \/.*\/shell.1$/)
+    expect(@knife).to receive(:exec).with(/^man \/.*\/shell.1$/)
     @knife.run
   end
 
   it "should suggest topics" do
     @knife.name_args = [ "list" ]
-    @knife.ui.stub(:msg)
-    @knife.ui.should_receive(:info).with("Available help topics are: ")
-    @knife.ui.should_receive(:msg).with(/knife/)
-    @knife.stub(:exec)
-    @knife.should_receive(:exit).with(1)
+    allow(@knife.ui).to receive(:msg)
+    expect(@knife.ui).to receive(:info).with("Available help topics are: ")
+    expect(@knife.ui).to receive(:msg).with(/knife/)
+    allow(@knife).to receive(:exec)
+    expect(@knife).to receive(:exit).with(1)
     @knife.run
   end
 
   describe "find_manpage_path" do
     it "should find the man page in the gem" do
-      @knife.find_manpage_path("shell").should =~ /distro\/common\/man\/man1\/chef-shell.1$/
+      expect(@knife.find_manpage_path("shell")).to match(/distro\/common\/man\/man1\/chef-shell.1$/)
     end
 
     it "should provide the man page name if not in the gem" do
-      @knife.find_manpage_path("foo").should == "foo"
+      expect(@knife.find_manpage_path("foo")).to eq("foo")
     end
   end
 
   describe "find_manpages_for_query" do
     it "should error if it does not find a match" do
-      @knife.ui.stub(:error)
-      @knife.ui.stub(:info)
-      @knife.ui.stub(:msg)
-      @knife.should_receive(:exit).with(1)
-      @knife.ui.should_receive(:error).with("No help found for 'chickens'")
-      @knife.ui.should_receive(:msg).with(/knife/)
+      allow(@knife.ui).to receive(:error)
+      allow(@knife.ui).to receive(:info)
+      allow(@knife.ui).to receive(:msg)
+      expect(@knife).to receive(:exit).with(1)
+      expect(@knife.ui).to receive(:error).with("No help found for 'chickens'")
+      expect(@knife.ui).to receive(:msg).with(/knife/)
       @knife.find_manpages_for_query("chickens")
     end
   end
 
   describe "print_help_topics" do
     it "should print the known help topics" do
-      @knife.ui.stub(:msg)
-      @knife.ui.stub(:info)
-      @knife.ui.should_receive(:msg).with(/knife/)
+      allow(@knife.ui).to receive(:msg)
+      allow(@knife.ui).to receive(:info)
+      expect(@knife.ui).to receive(:msg).with(/knife/)
       @knife.print_help_topics
     end
 
     it "should shorten topics prefixed by knife-" do
-      @knife.ui.stub(:msg)
-      @knife.ui.stub(:info)
-      @knife.ui.should_receive(:msg).with(/node/)
+      allow(@knife.ui).to receive(:msg)
+      allow(@knife.ui).to receive(:info)
+      expect(@knife.ui).to receive(:msg).with(/node/)
       @knife.print_help_topics
     end
 
     it "should not leave topics prefixed by knife-" do
-      @knife.ui.stub(:msg)
-      @knife.ui.stub(:info)
-      @knife.ui.should_not_receive(:msg).with(/knife-node/)
+      allow(@knife.ui).to receive(:msg)
+      allow(@knife.ui).to receive(:info)
+      expect(@knife.ui).not_to receive(:msg).with(/knife-node/)
       @knife.print_help_topics
     end
   end

data/spec/unit/knife/node_bulk_delete_spec.rb

@@ -26,8 +26,8 @@ describe Chef::Knife::NodeBulkDelete do
     @knife = Chef::Knife::NodeBulkDelete.new
     @knife.name_args = ["."]
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
-    @knife.ui.stub(:confirm).and_return(true)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:confirm).and_return(true)
     @nodes = Hash.new
     %w{adam brent jacob}.each do |node_name|
       @nodes[node_name] = "http://localhost:4000/nodes/#{node_name}"
@@ -40,11 +40,11 @@ describe Chef::Knife::NodeBulkDelete do
         inflatedish[name] = Chef::Node.new.tap {|n| n.name(name)}
         inflatedish
       end
-      Chef::Node.should_receive(:list).and_return(@nodes)
+      expect(Chef::Node).to receive(:list).and_return(@nodes)
       # I hate not having == defined for anything :(
       actual = @knife.all_nodes
-      actual.keys.should =~ expected.keys
-      actual.values.map {|n| n.name }.should =~ %w[adam brent jacob]
+      expect(actual.keys).to match_array(expected.keys)
+      expect(actual.values.map {|n| n.name }).to match_array(%w[adam brent jacob])
     end
   end
 
@@ -53,41 +53,41 @@ describe Chef::Knife::NodeBulkDelete do
       @inflatedish_list = @nodes.keys.inject({}) do |nodes_by_name, name|
         node = Chef::Node.new()
         node.name(name)
-        node.stub(:destroy).and_return(true)
+        allow(node).to receive(:destroy).and_return(true)
         nodes_by_name[name] = node
         nodes_by_name
       end
-      @knife.stub(:all_nodes).and_return(@inflatedish_list)
+      allow(@knife).to receive(:all_nodes).and_return(@inflatedish_list)
     end
 
     it "should print the nodes you are about to delete" do
       @knife.run
-      @stdout.string.should match(/#{@knife.ui.list(@nodes.keys.sort, :columns_down)}/)
+      expect(@stdout.string).to match(/#{@knife.ui.list(@nodes.keys.sort, :columns_down)}/)
     end
 
     it "should confirm you really want to delete them" do
-      @knife.ui.should_receive(:confirm)
+      expect(@knife.ui).to receive(:confirm)
       @knife.run
     end
 
     it "should delete each node" do
       @inflatedish_list.each_value do |n|
-        n.should_receive(:destroy)
+        expect(n).to receive(:destroy)
       end
       @knife.run
     end
 
     it "should only delete nodes that match the regex" do
       @knife.name_args = ['adam']
-      @inflatedish_list['adam'].should_receive(:destroy)
-      @inflatedish_list['brent'].should_not_receive(:destroy)
-      @inflatedish_list['jacob'].should_not_receive(:destroy)
+      expect(@inflatedish_list['adam']).to receive(:destroy)
+      expect(@inflatedish_list['brent']).not_to receive(:destroy)
+      expect(@inflatedish_list['jacob']).not_to receive(:destroy)
       @knife.run
     end
 
     it "should exit if the regex is not provided" do
       @knife.name_args = []
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
   end

data/spec/unit/knife/node_delete_spec.rb

@@ -26,41 +26,41 @@ describe Chef::Knife::NodeDelete do
       :print_after => nil
     }
     @knife.name_args = [ "adam" ]
-    @knife.stub(:output).and_return(true)
-    @knife.stub(:confirm).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
+    allow(@knife).to receive(:confirm).and_return(true)
     @node = Chef::Node.new()
-    @node.stub(:destroy).and_return(true)
-    Chef::Node.stub(:load).and_return(@node)
+    allow(@node).to receive(:destroy).and_return(true)
+    allow(Chef::Node).to receive(:load).and_return(@node)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe "run" do
     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 node" do
-      Chef::Node.should_receive(:load).with("adam").and_return(@node)
+      expect(Chef::Node).to receive(:load).with("adam").and_return(@node)
       @knife.run
     end
 
     it "should delete the node" do
-      @node.should_receive(:destroy).and_return(@node)
+      expect(@node).to receive(:destroy).and_return(@node)
       @knife.run
     end
 
     it "should not print the node" do
-      @knife.should_not_receive(:output).with("poop")
+      expect(@knife).not_to receive(:output).with("poop")
       @knife.run
     end
 
     describe "with -p or --print-after" do
       it "should pretty print the node, formatted for display" do
         @knife.config[:print_after] = true
-        @knife.should_receive(:format_for_display).with(@node).and_return("poop")
-        @knife.should_receive(:output).with("poop")
+        expect(@knife).to receive(:format_for_display).with(@node).and_return("poop")
+        expect(@knife).to receive(:output).with("poop")
         @knife.run
       end
     end

data/spec/unit/knife/node_edit_spec.rb

@@ -39,13 +39,13 @@ describe Chef::Knife::NodeEdit do
   end
 
   it "should load the node" do
-    Chef::Node.should_receive(:load).with("adam").and_return(@node)
+    expect(Chef::Node).to receive(:load).with("adam").and_return(@node)
     @knife.node
   end
 
   describe "after loading the node" do
     before do
-      @knife.stub(:node).and_return(@node)
+      allow(@knife).to receive(:node).and_return(@node)
       @node.automatic_attrs = {:go => :away}
       @node.default_attrs = {:hide => :me}
       @node.override_attrs = {:dont => :show}
@@ -56,37 +56,37 @@ describe Chef::Knife::NodeEdit do
 
     it "creates a view of the node without attributes from roles or ohai" do
       actual = deserialized_json_view
-      actual.should_not have_key("automatic")
-      actual.should_not have_key("override")
-      actual.should_not have_key("default")
-      actual["normal"].should == {"do_show" => "these"}
-      actual["run_list"].should == ["recipe[foo]"]
-      actual["chef_environment"].should == "prod"
+      expect(actual).not_to have_key("automatic")
+      expect(actual).not_to have_key("override")
+      expect(actual).not_to have_key("default")
+      expect(actual["normal"]).to eq({"do_show" => "these"})
+      expect(actual["run_list"]).to eq(["recipe[foo]"])
+      expect(actual["chef_environment"]).to eq("prod")
     end
 
     it "shows the extra attributes when given the --all option" do
       @knife.config[:all_attributes] = true
 
       actual = deserialized_json_view
-      actual["automatic"].should == {"go" => "away"}
-      actual["override"].should == {"dont" => "show"}
-      actual["default"].should == {"hide" => "me"}
-      actual["normal"].should == {"do_show" => "these"}
-      actual["run_list"].should == ["recipe[foo]"]
-      actual["chef_environment"].should == "prod"
+      expect(actual["automatic"]).to eq({"go" => "away"})
+      expect(actual["override"]).to eq({"dont" => "show"})
+      expect(actual["default"]).to eq({"hide" => "me"})
+      expect(actual["normal"]).to eq({"do_show" => "these"})
+      expect(actual["run_list"]).to eq(["recipe[foo]"])
+      expect(actual["chef_environment"]).to eq("prod")
     end
 
     it "does not consider unedited data updated" do
       view = deserialized_json_view
       @knife.node_editor.send(:apply_updates, view)
-      @knife.node_editor.should_not be_updated
+      expect(@knife.node_editor).not_to be_updated
     end
 
     it "considers edited data updated" do
       view = deserialized_json_view
       view["run_list"] << "role[fuuu]"
       @knife.node_editor.send(:apply_updates, view)
-      @knife.node_editor.should be_updated
+      expect(@knife.node_editor).to be_updated
     end
 
   end
@@ -94,7 +94,7 @@ describe Chef::Knife::NodeEdit do
   describe "edit_node" do
 
     before do
-      @knife.stub(:node).and_return(@node)
+      allow(@knife).to receive(:node).and_return(@node)
     end
 
     let(:subject) { @knife.node_editor.edit_node }

data/spec/unit/knife/node_environment_set_spec.rb

@@ -23,32 +23,32 @@ describe Chef::Knife::NodeEnvironmentSet do
     Chef::Config[:node_name]  = "webmonkey.example.com"
     @knife = Chef::Knife::NodeEnvironmentSet.new
     @knife.name_args = [ "adam", "bar" ]
-    @knife.stub(:output).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
     @node = Chef::Node.new()
     @node.name("knifetest-node")
     @node.chef_environment << "foo"
-    @node.stub(:save).and_return(true)
-    Chef::Node.stub(:load).and_return(@node)
+    allow(@node).to receive(:save).and_return(true)
+    allow(Chef::Node).to receive(:load).and_return(@node)
   end
 
   describe "run" do
     it "should load the node" do
-      Chef::Node.should_receive(:load).with("adam")
+      expect(Chef::Node).to receive(:load).with("adam")
       @knife.run
     end
 
     it "should update the environment" do
       @knife.run
-      @node.chef_environment.should == 'bar'
+      expect(@node.chef_environment).to eq('bar')
     end
 
     it "should save the node" do
-      @node.should_receive(:save)
+      expect(@node).to receive(:save)
       @knife.run
     end
 
     it "should print the environment" do
-      @knife.should_receive(:output).and_return(true)
+      expect(@knife).to receive(:output).and_return(true)
       @knife.run
     end
 
@@ -58,13 +58,13 @@ describe Chef::Knife::NodeEnvironmentSet do
         @stdout = StringIO.new
         @stderr = StringIO.new
 
-        @knife.ui.stub(:stdout).and_return(@stdout)
-        @knife.ui.stub(:stderr).and_return(@stderr)
+        allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+        allow(@knife.ui).to receive(:stderr).and_return(@stderr)
       end
 
       it "should exit" do
         @knife.name_args = [ "adam" ]
-        lambda { @knife.run }.should raise_error SystemExit
+        expect { @knife.run }.to raise_error SystemExit
       end
 
       it "should show the user the usage and an error" do
@@ -72,8 +72,8 @@ describe Chef::Knife::NodeEnvironmentSet do
 
         begin ; @knife.run ; rescue SystemExit ; end
 
-        @stdout.string.should eq "USAGE: knife node environment set NODE ENVIRONMENT\n"
-        @stderr.string.should eq "FATAL: You must specify a node name and an environment.\n"
+        expect(@stdout.string).to eq "USAGE: knife node environment set NODE ENVIRONMENT\n"
+        expect(@stderr.string).to eq "FATAL: You must specify a node name and an environment.\n"
       end
     end
   end

data/spec/unit/knife/node_from_file_spec.rb

@@ -28,30 +28,30 @@ describe Chef::Knife::NodeFromFile do
       :print_after => nil
     }
     @knife.name_args = [ "adam.rb" ]
-    @knife.stub(:output).and_return(true)
-    @knife.stub(:confirm).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
+    allow(@knife).to receive(:confirm).and_return(true)
     @node = Chef::Node.new()
-    @node.stub(:save)
-    @knife.loader.stub(:load_from).and_return(@node)
+    allow(@node).to receive(:save)
+    allow(@knife.loader).to receive(:load_from).and_return(@node)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe "run" do
     it "should load from a file" do
-      @knife.loader.should_receive(:load_from).with('nodes', 'adam.rb').and_return(@node)
+      expect(@knife.loader).to receive(:load_from).with('nodes', 'adam.rb').and_return(@node)
       @knife.run
     end
 
     it "should not print the Node" do
-      @knife.should_not_receive(:output)
+      expect(@knife).not_to receive(:output)
       @knife.run
     end
 
     describe "with -p or --print-after" do
       it "should print the Node" do
         @knife.config[:print_after] = true
-        @knife.should_receive(:output)
+        expect(@knife).to receive(:output)
         @knife.run
       end
     end

data/spec/unit/knife/node_list_spec.rb

@@ -23,38 +23,38 @@ describe Chef::Knife::NodeList do
     Chef::Config[:node_name]  = "webmonkey.example.com"
     Chef::Config[:environment] = nil # reset this value each time, as it is not reloaded
     @knife = Chef::Knife::NodeList.new
-    @knife.stub(:output).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
     @list = {
       "foo" => "http://example.com/foo",
       "bar" => "http://example.com/foo"
     }
-    Chef::Node.stub(:list).and_return(@list)
-    Chef::Node.stub(:list_by_environment).and_return(@list)
+    allow(Chef::Node).to receive(:list).and_return(@list)
+    allow(Chef::Node).to receive(:list_by_environment).and_return(@list)
   end
 
   describe "run" do
     it "should list all of the nodes if -E is not specified" do
-      Chef::Node.should_receive(:list).and_return(@list)
+      expect(Chef::Node).to receive(:list).and_return(@list)
       @knife.run
     end
 
     it "should pretty print the list" do
-      Chef::Node.should_receive(:list).and_return(@list)
-      @knife.should_receive(:output).with([ "bar", "foo" ])
+      expect(Chef::Node).to receive(:list).and_return(@list)
+      expect(@knife).to receive(:output).with([ "bar", "foo" ])
       @knife.run
     end
 
     it "should list nodes in the specific environment if -E ENVIRONMENT is specified" do
       Chef::Config[:environment] = "prod"
-      Chef::Node.should_receive(:list_by_environment).with("prod").and_return(@list)
+      expect(Chef::Node).to receive(:list_by_environment).with("prod").and_return(@list)
       @knife.run
     end
 
     describe "with -w or --with-uri" do
       it "should pretty print the hash" do
         @knife.config[:with_uri] = true
-        Chef::Node.should_receive(:list).and_return(@list)
-        @knife.should_receive(:output).with(@list)
+        expect(Chef::Node).to receive(:list).and_return(@list)
+        expect(@knife).to receive(:output).with(@list)
         @knife.run
       end
     end