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

data/spec/unit/knife/node_run_list_add_spec.rb

@@ -26,30 +26,30 @@ describe Chef::Knife::NodeRunListAdd do
       :after => nil
     }
     @knife.name_args = [ "adam", "role[monkey]" ]
-    @knife.stub(:output).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
     @node = Chef::Node.new()
-    @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 add to the run list" do
       @knife.run
-      @node.run_list[0].should == 'role[monkey]'
+      expect(@node.run_list[0]).to eq('role[monkey]')
     end
 
     it "should save the node" do
-      @node.should_receive(:save)
+      expect(@node).to receive(:save)
       @knife.run
     end
 
     it "should print the run list" do
-      @knife.should_receive(:output).and_return(true)
+      expect(@knife).to receive(:output).and_return(true)
       @knife.run
     end
 
@@ -59,9 +59,9 @@ describe Chef::Knife::NodeRunListAdd do
         @node.run_list << "role[barn]"
         @knife.config[:after] = "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
-        @node.run_list[2].should == "role[barn]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
+        expect(@node.run_list[2]).to eq("role[barn]")
       end
     end
 
@@ -71,9 +71,9 @@ describe Chef::Knife::NodeRunListAdd do
         @node.run_list << "role[barn]"
         @knife.config[:before] = "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[acorns]"
-        @node.run_list[2].should == "role[barn]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[acorns]")
+        expect(@node.run_list[2]).to eq("role[barn]")
       end
     end
 
@@ -83,8 +83,8 @@ describe Chef::Knife::NodeRunListAdd do
         @node.run_list << "role[barn]"
         @knife.config[:before] = "role[acorns]"
         @knife.config[:after]  = "role[acorns]"
-        @knife.ui.should_receive(:fatal)
-        lambda { @knife.run }.should raise_error(SystemExit)
+        expect(@knife.ui).to receive(:fatal)
+        expect { @knife.run }.to raise_error(SystemExit)
       end
     end
 
@@ -93,9 +93,9 @@ describe Chef::Knife::NodeRunListAdd do
         @knife.name_args = [ "adam", "role[monkey],role[duck]" ]
         @node.run_list << "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
-        @node.run_list[2].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
+        expect(@node.run_list[2]).to eq("role[duck]")
       end
     end
 
@@ -104,9 +104,9 @@ describe Chef::Knife::NodeRunListAdd do
         @knife.name_args = [ "adam", "role[monkey], role[duck]" ]
         @node.run_list << "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
-        @node.run_list[2].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
+        expect(@node.run_list[2]).to eq("role[duck]")
       end
     end
 
@@ -115,9 +115,9 @@ describe Chef::Knife::NodeRunListAdd do
         @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ]
         @node.run_list << "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
-        @node.run_list[2].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
+        expect(@node.run_list[2]).to eq("role[duck]")
       end
     end
 
@@ -126,9 +126,9 @@ describe Chef::Knife::NodeRunListAdd do
         @knife.name_args = [ "adam", "role[monkey]", "role[duck],recipe[bird::fly]" ]
         @node.run_list << "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
-        @node.run_list[2].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
+        expect(@node.run_list[2]).to eq("role[duck]")
       end
     end
 
@@ -137,8 +137,8 @@ describe Chef::Knife::NodeRunListAdd do
         @knife.name_args = [ "adam", "role[monkey]," ]
         @node.run_list << "role[acorns]"
         @knife.run
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[monkey]"
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[monkey]")
       end
     end
   end

data/spec/unit/knife/node_run_list_remove_spec.rb

@@ -27,33 +27,33 @@ describe Chef::Knife::NodeRunListRemove do
     @node = Chef::Node.new()
     @node.name("knifetest-node")
     @node.run_list << "role[monkey]"
-    @node.stub(:save).and_return(true)
+    allow(@node).to receive(:save).and_return(true)
 
-    @knife.ui.stub(:output).and_return(true)
-    @knife.ui.stub(:confirm).and_return(true)
+    allow(@knife.ui).to receive(:output).and_return(true)
+    allow(@knife.ui).to receive(:confirm).and_return(true)
 
-    Chef::Node.stub(:load).and_return(@node)
+    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").and_return(@node)
+      expect(Chef::Node).to receive(:load).with("adam").and_return(@node)
       @knife.run
     end
 
     it "should remove the item from the run list" do
       @knife.run
-      @node.run_list[0].should_not == 'role[monkey]'
+      expect(@node.run_list[0]).not_to eq('role[monkey]')
     end
 
     it "should save the node" do
-      @node.should_receive(:save).and_return(true)
+      expect(@node).to receive(:save).and_return(true)
       @knife.run
     end
 
     it "should print the run list" do
       @knife.config[:print_after] = true
-      @knife.ui.should_receive(:output).with({ "knifetest-node" => { 'run_list' => [] } })
+      expect(@knife.ui).to receive(:output).with({ "knifetest-node" => { 'run_list' => [] } })
       @knife.run
     end
 
@@ -63,12 +63,27 @@ describe Chef::Knife::NodeRunListRemove do
         @node.run_list << 'recipe[duck::type]'
         @knife.name_args = [ 'adam', 'role[monkey],recipe[duck::type]' ]
         @knife.run
-        @node.run_list.should_not include('role[monkey]')
-        @node.run_list.should_not include('recipe[duck::type]')
+        expect(@node.run_list).not_to include('role[monkey]')
+        expect(@node.run_list).not_to include('recipe[duck::type]')
+      end
+
+      it "should remove the items from the run list when name args contains whitespace" do
+        @node.run_list << 'role[monkey]'
+        @node.run_list << 'recipe[duck::type]'
+        @knife.name_args = [ 'adam', 'role[monkey], recipe[duck::type]' ]
+        @knife.run
+        expect(@node.run_list).not_to include('role[monkey]')
+        expect(@node.run_list).not_to include('recipe[duck::type]')
+      end
+
+      it "should remove the items from the run list when name args contains multiple run lists" do
+        @node.run_list << 'role[blah]'
+        @node.run_list << 'recipe[duck::type]'
+        @knife.name_args = [ 'adam', 'role[monkey], recipe[duck::type]', 'role[blah]' ]
+        @knife.run
+        expect(@node.run_list).not_to include('role[monkey]')
+        expect(@node.run_list).not_to include('recipe[duck::type]')
       end
     end
   end
 end
-
-
-

data/spec/unit/knife/node_run_list_set_spec.rb

@@ -24,30 +24,30 @@ describe Chef::Knife::NodeRunListSet do
     @knife = Chef::Knife::NodeRunListSet.new
     @knife.config = {}
     @knife.name_args = [ "adam", "role[monkey]" ]
-    @knife.stub(:output).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
     @node = Chef::Node.new()
-    @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 set the run list" do
       @knife.run
-      @node.run_list[0].should == 'role[monkey]'
+      expect(@node.run_list[0]).to eq('role[monkey]')
     end
 
     it "should save the node" do
-      @node.should_receive(:save)
+      expect(@node).to receive(:save)
       @knife.run
     end
 
     it "should print the run list" do
-      @knife.should_receive(:output).and_return(true)
+      expect(@knife).to receive(:output).and_return(true)
       @knife.run
     end
 
@@ -55,8 +55,8 @@ describe Chef::Knife::NodeRunListSet do
       it "should set the run list to all the entries" do
         @knife.name_args = [ "adam", "role[monkey],role[duck]" ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[duck]")
       end
     end
 
@@ -64,8 +64,8 @@ describe Chef::Knife::NodeRunListSet do
       it "should set the run list to all the entries" do
         @knife.name_args = [ "adam", "role[monkey], role[duck]" ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[duck]")
       end
     end
 
@@ -73,8 +73,8 @@ describe Chef::Knife::NodeRunListSet do
       it "should set the run list to all the entries" do
         @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[duck]")
       end
     end
 
@@ -82,8 +82,8 @@ describe Chef::Knife::NodeRunListSet do
       it "should add to the run list all the entries" do
         @knife.name_args = [ "adam", "role[monkey]", "role[duck],recipe[bird::fly]" ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[duck]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[duck]")
       end
     end
 
@@ -91,7 +91,7 @@ describe Chef::Knife::NodeRunListSet do
       it "should add to the run list one item" do
         @knife.name_args = [ "adam", "role[monkey]," ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
+        expect(@node.run_list[0]).to eq("role[monkey]")
       end
     end
 
@@ -99,15 +99,15 @@ describe Chef::Knife::NodeRunListSet do
       it "should overwrite any existing run list items" do
         @node.run_list << "role[acorns]"
         @node.run_list << "role[zebras]"
-        @node.run_list[0].should == "role[acorns]"
-        @node.run_list[1].should == "role[zebras]"
-        @node.run_list.run_list_items.size.should == 2
+        expect(@node.run_list[0]).to eq("role[acorns]")
+        expect(@node.run_list[1]).to eq("role[zebras]")
+        expect(@node.run_list.run_list_items.size).to eq(2)
 
         @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ]
         @knife.run
-        @node.run_list[0].should == "role[monkey]"
-        @node.run_list[1].should == "role[duck]"
-        @node.run_list.run_list_items.size.should == 2
+        expect(@node.run_list[0]).to eq("role[monkey]")
+        expect(@node.run_list[1]).to eq("role[duck]")
+        expect(@node.run_list.run_list_items.size).to eq(2)
       end
     end
 
@@ -117,13 +117,13 @@ describe Chef::Knife::NodeRunListSet 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" do
@@ -131,8 +131,8 @@ describe Chef::Knife::NodeRunListSet do
 
         begin ; @knife.run ; rescue SystemExit ; end
 
-        @stdout.string.should eq "USAGE: knife node run_list set NODE ENTRIES (options)\n"
-        @stderr.string.should eq "FATAL: You must supply both a node name and a run list.\n"
+        expect(@stdout.string).to eq "USAGE: knife node run_list set NODE ENTRIES (options)\n"
+        expect(@stderr.string).to eq "FATAL: You must supply both a node name and a run list.\n"
       end
     end
 

data/spec/unit/knife/raw_spec.rb

@@ -0,0 +1,43 @@
+#
+# Author:: Steven Danna (<steve@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+describe Chef::Knife::Raw do
+  let(:rest) do
+    r = double('Chef::Knife::Raw::RawInputServerAPI')
+    allow(Chef::Knife::Raw::RawInputServerAPI).to receive(:new).and_return(r)
+    r
+  end
+
+  let(:knife) do
+    k = Chef::Knife::Raw.new
+    k.config[:method] = "GET"
+    k.name_args = [ "/nodes" ]
+    k
+  end
+
+  describe "run" do
+    it "should set the x-ops-request-source header when --proxy-auth is set" do
+      knife.config[:proxy_auth] = true
+      expect(rest).to receive(:request).with(:GET, "/nodes",
+                                              { 'Content-Type' => 'application/json',
+                                                'x-ops-request-source' => 'web'}, false)
+      knife.run
+    end
+  end
+end

data/spec/unit/knife/role_bulk_delete_spec.rb

@@ -27,53 +27,53 @@ describe Chef::Knife::RoleBulkDelete do
     }
     @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)
     @roles = Hash.new
     %w{dev staging production}.each do |role_name|
       role = Chef::Role.new()
       role.name(role_name)
-      role.stub(:destroy).and_return(true)
+      allow(role).to receive(:destroy).and_return(true)
       @roles[role_name] = role
     end
-    Chef::Role.stub(:list).and_return(@roles)
+    allow(Chef::Role).to receive(:list).and_return(@roles)
   end
 
   describe "run" do
 
     it "should get the list of the roles" do
-      Chef::Role.should_receive(:list).and_return(@roles)
+      expect(Chef::Role).to receive(:list).and_return(@roles)
       @knife.run
     end
 
     it "should print the roles you are about to delete" do
       @knife.run
-      @stdout.string.should match(/#{@knife.ui.list(@roles.keys.sort, :columns_down)}/)
+      expect(@stdout.string).to match(/#{@knife.ui.list(@roles.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 role" do
       @roles.each_value do |r|
-        r.should_receive(:destroy)
+        expect(r).to receive(:destroy)
       end
       @knife.run
     end
 
     it "should only delete roles that match the regex" do
       @knife.name_args = ["dev"]
-      @roles["dev"].should_receive(:destroy)
-      @roles["staging"].should_not_receive(:destroy)
-      @roles["production"].should_not_receive(:destroy)
+      expect(@roles["dev"]).to receive(:destroy)
+      expect(@roles["staging"]).not_to receive(:destroy)
+      expect(@roles["production"]).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