chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/run_status_spec.rb

@@ -39,43 +39,43 @@ describe Chef::RunStatus do
     end
 
     it "has a run context" do
-      @run_status.run_context.should equal(@run_context)
+      expect(@run_status.run_context).to equal(@run_context)
     end
 
     it "provides access to the run context's node" do
-      @run_status.node.should equal(@node)
+      expect(@run_status.node).to equal(@node)
     end
 
     it "converts to a hash" do
-      @run_status.to_hash[:node].should equal(@node)
-      @run_status.to_hash[:success].should be_true
+      expect(@run_status.to_hash[:node]).to equal(@node)
+      expect(@run_status.to_hash[:success]).to be_truthy
     end
 
     describe "after it has recorded timing information" do
       before do
         @start_time = Time.new
         @end_time = @start_time + 23
-        Time.stub(:now).and_return(@start_time, @end_time)
+        allow(Time).to receive(:now).and_return(@start_time, @end_time)
         @run_status.start_clock
         @run_status.stop_clock
       end
 
       it "records the start time of the run" do
-        @run_status.start_time.should == @start_time
+        expect(@run_status.start_time).to eq(@start_time)
       end
 
       it "records the end time of the run" do
-        @run_status.end_time.should == @end_time
+        expect(@run_status.end_time).to eq(@end_time)
       end
 
       it "gives the elapsed time of the chef run" do
-        @run_status.elapsed_time.should == 23
+        expect(@run_status.elapsed_time).to eq(23)
       end
 
       it "includes timing information in its hash form" do
-        @run_status.to_hash[:start_time].should == @start_time
-        @run_status.to_hash[:end_time].should == @end_time
-        @run_status.to_hash[:elapsed_time].should == 23
+        expect(@run_status.to_hash[:start_time]).to eq(@start_time)
+        expect(@run_status.to_hash[:end_time]).to eq(@end_time)
+        expect(@run_status.to_hash[:elapsed_time]).to eq(23)
       end
 
     end
@@ -87,16 +87,16 @@ describe Chef::RunStatus do
       end
 
       it "lists all resources" do
-        @run_status.all_resources.should == @all_resources
+        expect(@run_status.all_resources).to eq(@all_resources)
       end
 
       it "has no updated resources" do
-        @run_status.updated_resources.should be_empty
+        expect(@run_status.updated_resources).to be_empty
       end
 
       it "includes the list of all resources in its hash form" do
-        @run_status.to_hash[:all_resources].should == @all_resources
-        @run_status.to_hash[:updated_resources].should be_empty
+        expect(@run_status.to_hash[:all_resources]).to eq(@all_resources)
+        expect(@run_status.to_hash[:updated_resources]).to be_empty
       end
 
       describe "and some have been updated" do
@@ -105,11 +105,11 @@ describe Chef::RunStatus do
         end
 
         it "lists the updated resources" do
-          @run_status.updated_resources.should == [@all_resources.first]
+          expect(@run_status.updated_resources).to eq([@all_resources.first])
         end
 
         it "includes the list of updated resources in its hash form" do
-          @run_status.to_hash[:updated_resources].should == [@all_resources.first]
+          expect(@run_status.to_hash[:updated_resources]).to eq([@all_resources.first])
         end
       end
     end
@@ -123,22 +123,22 @@ describe Chef::RunStatus do
       end
 
       it "stores the exception" do
-        @run_status.exception.should equal(@exception)
+        expect(@run_status.exception).to equal(@exception)
       end
 
       it "stores the backtrace" do
-        @run_status.backtrace.should == @backtrace
+        expect(@run_status.backtrace).to eq(@backtrace)
       end
 
       it "says the run was not successful" do
-        @run_status.success?.should be_false
-        @run_status.failed?.should be_true
+        expect(@run_status.success?).to be_falsey
+        expect(@run_status.failed?).to be_truthy
       end
 
       it "converts to a hash including the exception information" do
-        @run_status.to_hash[:success].should be_false
-        @run_status.to_hash[:exception].should == "Exception: just testing"
-        @run_status.to_hash[:backtrace].should == @backtrace
+        expect(@run_status.to_hash[:success]).to be_falsey
+        expect(@run_status.to_hash[:exception]).to eq("Exception: just testing")
+        expect(@run_status.to_hash[:backtrace]).to eq(@backtrace)
       end
     end
   end

data/spec/unit/scan_access_control_spec.rb

@@ -39,9 +39,9 @@ describe Chef::ScanAccessControl do
     end
 
     it "does not set any fields on the current resource" do
-      @current_resource.owner.should be_nil
-      @current_resource.group.should be_nil
-      @current_resource.mode.should be_nil
+      expect(@current_resource.owner).to be_nil
+      expect(@current_resource.group).to be_nil
+      expect(@current_resource.mode).to be_nil
     end
 
   end
@@ -50,9 +50,9 @@ describe Chef::ScanAccessControl do
 
     before do
       @stat = double("File::Stat for #{@new_resource.path}", :uid => 0, :gid => 0, :mode => 00100644)
-      File.should_receive(:realpath).with(@new_resource.path).and_return(@real_file)
-      File.should_receive(:stat).with(@real_file).and_return(@stat)
-      File.should_receive(:exist?).with(@new_resource.path).and_return(true)
+      expect(File).to receive(:realpath).with(@new_resource.path).and_return(@real_file)
+      expect(File).to receive(:stat).with(@real_file).and_return(@stat)
+      expect(File).to receive(:exist?).with(@new_resource.path).and_return(true)
     end
 
     describe "when new_resource does not specify mode, user or group" do
@@ -62,26 +62,26 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the mode of the current resource to the current mode as a String" do
-        @current_resource.mode.should == "0644"
+        expect(@current_resource.mode).to eq("0644")
       end
 
       context "on unix", :unix_only do
         it "sets the group of the current resource to the current group as a String" do
-          @current_resource.group.should == Etc.getgrgid(0).name
+          expect(@current_resource.group).to eq(Etc.getgrgid(0).name)
         end
 
         it "sets the owner of the current resource to the current owner as a String" do
-          @current_resource.user.should == "root"
+          expect(@current_resource.user).to eq("root")
         end
       end
 
       context "on windows", :windows_only do
         it "sets the group of the current resource to the current group as a String" do
-          @current_resource.group.should == 0
+          expect(@current_resource.group).to eq(0)
         end
 
         it "sets the owner of the current resource to the current owner as a String" do
-          @current_resource.user.should == 0
+          expect(@current_resource.user).to eq(0)
         end
       end
     end
@@ -93,7 +93,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the mode of the current resource to the file's current mode as a string" do
-        @current_resource.mode.should == "0644"
+        expect(@current_resource.mode).to eq("0644")
       end
     end
 
@@ -104,7 +104,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the mode of the current resource to the current mode as a String" do
-        @current_resource.mode.should == "0644"
+        expect(@current_resource.mode).to eq("0644")
       end
 
     end
@@ -117,7 +117,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the owner of current_resource to the UID of the current owner" do
-        @current_resource.user.should == 0
+        expect(@current_resource.user).to eq(0)
       end
     end
 
@@ -129,17 +129,17 @@ describe Chef::ScanAccessControl do
 
       it "sets the owner of current_resource to the username of the current owner" do
         @root_passwd = double("Struct::Passwd for uid 0", :name => "root")
-        Etc.should_receive(:getpwuid).with(0).and_return(@root_passwd)
+        expect(Etc).to receive(:getpwuid).with(0).and_return(@root_passwd)
         @scanner.set_all!
 
-        @current_resource.user.should == "root"
+        expect(@current_resource.user).to eq("root")
       end
 
       describe "and there is no passwd entry for the user" do
         it "sets the owner of the current_resource to the UID" do
-          Etc.should_receive(:getpwuid).with(0).and_raise(ArgumentError)
+          expect(Etc).to receive(:getpwuid).with(0).and_raise(ArgumentError)
           @scanner.set_all!
-          @current_resource.user.should == 0
+          expect(@current_resource.user).to eq(0)
         end
       end
     end
@@ -152,7 +152,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the group of the current_resource to the gid of the current owner" do
-        @current_resource.group.should == 0
+        expect(@current_resource.group).to eq(0)
       end
 
     end
@@ -164,17 +164,17 @@ describe Chef::ScanAccessControl do
 
       it "sets the group of the current resource to the group name" do
         @group_entry = double("Struct::Group for wheel", :name => "wheel")
-        Etc.should_receive(:getgrgid).with(0).and_return(@group_entry)
+        expect(Etc).to receive(:getgrgid).with(0).and_return(@group_entry)
         @scanner.set_all!
 
-        @current_resource.group.should == "wheel"
+        expect(@current_resource.group).to eq("wheel")
       end
 
       describe "and there is no group entry for the group" do
         it "sets the current_resource's group to the GID" do
-          Etc.should_receive(:getgrgid).with(0).and_raise(ArgumentError)
+          expect(Etc).to receive(:getgrgid).with(0).and_raise(ArgumentError)
           @scanner.set_all!
-          @current_resource.group.should == 0
+          expect(@current_resource.group).to eq(0)
         end
       end
 

data/spec/unit/search/query_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Search::Query do
   let(:query) { Chef::Search::Query.new }
 
   shared_context "filtered search" do
-    let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000" }
+    let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0" }
     let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
     let(:args) { { filter_key => filter_hash } }
     let(:filter_hash) {
@@ -65,11 +65,19 @@ describe Chef::Search::Query do
         "total" => 4
       }
     }
+    let(:response_rows) {
+      [
+        { "env" => "elysium", "ruby_plat" => "nudibranch" },
+        { "env" => "hades", "ruby_plat" => "i386-mingw32"},
+        { "env" => "elysium", "ruby_plat" => "centos"},
+        { "env" => "moon", "ruby_plat" => "solaris2"}
+      ]
+    }
   end
 
   before(:each) do
-    Chef::REST.stub(:new).and_return(rest)
-    rest.stub(:get_rest).and_return(response)
+    allow(Chef::REST).to receive(:new).and_return(rest)
+    allow(rest).to receive(:get_rest).and_return(response)
   end
 
   describe "search" do
@@ -132,59 +140,59 @@ describe Chef::Search::Query do
       "total" => 4
     } }
 
-    it "should accept a type as the first argument" do
-      lambda { query.search("node") }.should_not raise_error
-      lambda { query.search(:node) }.should_not raise_error
-      lambda { query.search(Hash.new) }.should raise_error(Chef::Exceptions::InvalidSearchQuery, /(Hash)/)
+    it "accepts a type as the first argument" do
+      expect { query.search("node") }.not_to raise_error
+      expect { query.search(:node) }.not_to raise_error
+      expect { query.search(Hash.new) }.to raise_error(Chef::Exceptions::InvalidSearchQuery, /(Hash)/)
     end
 
-    it "should query for every object of a type by default" do
-      rest.should_receive(:get_rest).with("search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(response)
+    it "queries for every object of a type by default" do
+      expect(rest).to receive(:get_rest).with("search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0").and_return(response)
       query.search(:node)
     end
 
-    it "should allow a custom query" do
-      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(response)
+    it "allows a custom query" do
+      expect(rest).to receive(:get_rest).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0").and_return(response)
       query.search(:node, "platform:rhel")
     end
 
-    it "should let you set a sort order" do
-      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=0&rows=1000").and_return(response)
-      query.search(:node, "platform:rhel", "id desc")
+    it "lets you set a sort order" do
+      expect(rest).to receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=0").and_return(response)
+      query.search(:node, "platform:rhel", sort: "id desc")
     end
 
-    it "should let you set a starting object" do
-      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=2&rows=1000").and_return(response)
-      query.search(:node, "platform:rhel", "id desc", 2)
+    it "lets you set a starting object" do
+      expect(rest).to receive(:get_rest).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=2").and_return(response)
+      query.search(:node, "platform:rhel", start: 2)
     end
 
-    it "should let you set how many rows to return" do
-      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=2&rows=40").and_return(response)
-      query.search(:node, "platform:rhel", "id desc", 2, 40)
+    it "lets you set how many rows to return" do
+      expect(rest).to receive(:get_rest).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=40").and_return(response)
+      query.search(:node, "platform:rhel", rows: 40)
     end
 
-    it "should throw an exception if you pass to many options" do
-      lambda { query.search(:node, "platform:rhel", "id desc", 2, 40, "wrong") }
-        .should raise_error(Chef::Exceptions::InvalidSearchQuery, "Too many arguments! (4 for <= 3)")
+    it "throws an exception if you pass an incorrect option" do
+      expect { query.search(:node, "platform:rhel", total: 10) }
+        .to raise_error(ArgumentError, /unknown keyword: total/)
     end
 
-    it "should return the raw rows, start, and total if no block is passed" do
+    it "returns the raw rows, start, and total if no block is passed" do
       rows, start, total = query.search(:node)
-      rows.should equal(response["rows"])
-      start.should equal(response["start"])
-      total.should equal(response["total"])
+      expect(rows).to equal(response["rows"])
+      expect(start).to equal(response["start"])
+      expect(total).to equal(response["total"])
     end
 
-    it "should call a block for each object in the response" do
+    it "calls a block for each object in the response" do
       @call_me = double("blocky")
-      response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
+      response["rows"].each { |r| expect(@call_me).to receive(:do).with(r) }
       query.search(:node) { |r| @call_me.do(r) }
     end
 
-    it "should page through the responses" do
+    it "pages through the responses" do
       @call_me = double("blocky")
-      response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
-      query.search(:node, "*:*", nil, 0, 1) { |r| @call_me.do(r) }
+      response["rows"].each { |r| expect(@call_me).to receive(:do).with(r) }
+      query.search(:node, "*:*", sort: nil, start: 0, rows: 1) { |r| @call_me.do(r) }
     end
 
     context "when :filter_result is provided as a result" do
@@ -192,34 +200,22 @@ describe Chef::Search::Query do
         let(:filter_key) { :filter_result }
 
         before(:each) do
-          rest.should_receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
+          expect(rest).to receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
         end
 
-        it "should return start" do
+        it "returns start" do
           start = query.search(:node, "platform:rhel", args)[1]
-          start.should == response['start']
+          expect(start).to eq(response['start'])
         end
 
-        it "should return total" do
+        it "returns total" do
           total = query.search(:node, "platform:rhel", args)[2]
-          total.should == response['total']
+          expect(total).to eq(response['total'])
         end
 
-        it "should return rows with the filter applied" do
-          results = query.search(:node, "platform:rhel", args)[0]
-
-          results.each_with_index do |result, idx|
-            expected = response["rows"][idx]
-
-            result.should have_key("url")
-            result["url"].should == expected["url"]
-
-            result.should have_key("data")
-            filter_hash.keys.each do |filter_key|
-              result["data"].should have_key(filter_key)
-              result["data"][filter_key].should == expected["data"][filter_key]
-            end
-          end
+        it "returns rows with the filter applied" do
+          filtered_rows = query.search(:node, "platform:rhel", args)[0]
+          expect(filtered_rows).to match_array(response_rows)
         end
 
       end
@@ -230,25 +226,17 @@ describe Chef::Search::Query do
     include_context "filtered search" do
       let(:filter_key) { :keys }
 
-      it "should emit a deprecation warning" do
+      it "emits a deprecation warning" do
         # partial_search calls search, so we'll stub search to return empty
-        query.stub(:search).and_return( [ [], 0, 0 ] )
-        Chef::Log.should_receive(:warn).with("DEPRECATED: The 'partial_search' api is deprecated, please use the search api with 'filter_result'")
+        allow(query).to receive(:search).and_return( [ [], 0, 0 ] )
+        expect(Chef::Log).to receive(:warn).with(/DEPRECATED: The 'partial_search' API is deprecated/)
         query.partial_search(:node, "platform:rhel", args)
       end
 
-      it "should return an array of filtered hashes" do
-        rest.should_receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
+      it "returns an array of filtered hashes" do
+        expect(rest).to receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
         results = query.partial_search(:node, "platform:rhel", args)
-
-        results.each_with_index do |result, idx|
-          expected = response["rows"][idx]
-
-          filter_hash.keys.each do |filter_key|
-            result.should have_key(filter_key)
-            result[filter_key].should == expected["data"][filter_key]
-          end
-        end
+        expect(results[0]).to match_array(response_rows)
       end
     end
   end

data/spec/unit/shell/model_wrapper_spec.rb

@@ -32,12 +32,12 @@ describe Shell::ModelWrapper do
     end
 
     it "uses the explicit model symbol" do
-      @wrapper.model_symbol.should == :client
+      expect(@wrapper.model_symbol).to eq(:client)
     end
   end
 
   it "determines the model symbol from the class name" do
-    @wrapper.model_symbol.should == :node
+    expect(@wrapper.model_symbol).to eq(:node)
   end
 
   describe "when listing objects" do
@@ -48,16 +48,16 @@ describe Shell::ModelWrapper do
       @node_2.name("yummy")
       @server_response = {:node_1 => @node_1, :node_2 => @node_2}
       @wrapper = Shell::ModelWrapper.new(Chef::Node)
-      Chef::Node.stub(:list).and_return(@server_response)
+      allow(Chef::Node).to receive(:list).and_return(@server_response)
     end
 
     it "lists fully inflated objects without the resource IDs" do
-      @wrapper.all.should have(2).nodes
-      @wrapper.all.should include(@node_1, @node_2)
+      expect(@wrapper.all.size).to eq(2)
+      expect(@wrapper.all).to include(@node_1, @node_2)
     end
 
     it "maps the listed nodes when given a block" do
-      @wrapper.all {|n| n.name }.sort.reverse.should == %w{yummy sammich}
+      expect(@wrapper.all {|n| n.name }.sort.reverse).to eq(%w{yummy sammich})
     end
   end
 
@@ -72,23 +72,23 @@ describe Shell::ModelWrapper do
 
       # Creating a Chef::Search::Query object tries to read the private key...
       @searcher = double("Chef::Search::Query #{__FILE__}:#{__LINE__}")
-      Chef::Search::Query.stub(:new).and_return(@searcher)
+      allow(Chef::Search::Query).to receive(:new).and_return(@searcher)
     end
 
     it "falls back to listing the objects when the 'query' is :all" do
-      Chef::Node.stub(:list).and_return(@server_response)
-      @wrapper.find(:all).should include(@node_1, @node_2)
+      allow(Chef::Node).to receive(:list).and_return(@server_response)
+      expect(@wrapper.find(:all)).to include(@node_1, @node_2)
     end
 
     it "searches for objects using the given query string" do
-      @searcher.should_receive(:search).with(:node, 'name:app*').and_yield(@node_1).and_yield(@node_2)
-      @wrapper.find("name:app*").should include(@node_1, @node_2)
+      expect(@searcher).to receive(:search).with(:node, 'name:app*').and_yield(@node_1).and_yield(@node_2)
+      expect(@wrapper.find("name:app*")).to include(@node_1, @node_2)
     end
 
     it "creates a 'AND'-joined query string from a HASH" do
       # Hash order woes
-      @searcher.should_receive(:search).with(:node, 'name:app* AND name:app*').and_yield(@node_1).and_yield(@node_2)
-      @wrapper.find(:name=>"app*",'name'=>"app*").should include(@node_1, @node_2)
+      expect(@searcher).to receive(:search).with(:node, 'name:app* AND name:app*').and_yield(@node_1).and_yield(@node_2)
+      expect(@wrapper.find(:name=>"app*",'name'=>"app*")).to include(@node_1, @node_2)
     end
 
   end