chef 13.2.20 → 13.3.42

data/spec/unit/provider/windows_task_spec.rb

@@ -118,6 +118,7 @@ describe Chef::Provider::WindowsTask do
 
       it "creates the task if it's not already existing" do
         allow(provider).to receive(:task_need_update?).and_return(true)
+        allow(provider).to receive(:basic_validation).and_return(true)
         expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
         provider.run_action(:create)
         expect(new_resource).to be_updated_by_last_action
@@ -126,6 +127,7 @@ describe Chef::Provider::WindowsTask do
       it "updates the task XML if random_delay is provided" do
         new_resource.random_delay "20"
         allow(provider).to receive(:task_need_update?).and_return(true)
+        allow(provider).to receive(:basic_validation).and_return(true)
         expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
         expect(provider).to receive(:update_task_xml)
         provider.run_action(:create)
@@ -135,6 +137,7 @@ describe Chef::Provider::WindowsTask do
       it "updates the task XML if execution_time_limit is provided" do
         new_resource.execution_time_limit "20"
         allow(provider).to receive(:task_need_update?).and_return(true)
+        allow(provider).to receive(:basic_validation).and_return(true)
         expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
         expect(provider).to receive(:update_task_xml)
         provider.run_action(:create)
@@ -280,6 +283,29 @@ describe Chef::Provider::WindowsTask do
     end
   end
 
+  describe "#basic_validation" do
+    context "when command doesn't exist" do
+      it "raise error" do
+        new_resource.command ""
+        expect { provider.send(:basic_validation) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      end
+    end
+
+    context "when task_name doesn't exist" do
+      let(:new_resource) { Chef::Resource::WindowsTask.new("") }
+      it "raise error" do
+        expect { provider.send(:basic_validation) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      end
+    end
+
+    context "when task_name and command exists" do
+      it "returns true" do
+        new_resource.command "cd ~/"
+        expect(provider.send(:basic_validation)).to be(true)
+      end
+    end
+  end
+
   describe "#task_need_update?" do
     context "when task doesn't exist" do
       before do
@@ -325,6 +351,20 @@ describe Chef::Provider::WindowsTask do
           expect(provider.send(:task_need_update?)).to be(true)
         end
       end
+
+      context "when start_day is updated" do
+        it "returns true" do
+          new_resource.start_day "01/01/2000"
+          expect(provider.send(:task_need_update?)).to be(true)
+        end
+      end
+
+      context "when start_time updated" do
+        it "returns true" do
+          new_resource.start_time "01:01"
+          expect(provider.send(:task_need_update?)).to be(true)
+        end
+      end
     end
   end
 

data/spec/unit/resource/apt_preference_spec.rb

@@ -0,0 +1,41 @@
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: 2016-2017, 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::Resource::AptPreference do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::AptPreference.new("libmysqlclient16", run_context) }
+
+  it "should create a new Chef::Resource::AptPreference" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::AptPreference)
+  end
+
+  it "should resolve to a Noop class when apt-get is not found" do
+    expect(Chef::Provider::AptPreference).to receive(:which).with("apt-get").and_return(false)
+    expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+  end
+
+  it "should resolve to a AptPreference class when apt-get is found" do
+    expect(Chef::Provider::AptPreference).to receive(:which).with("apt-get").and_return(true)
+    expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::AptPreference)
+  end
+end

data/spec/unit/resource/execute_spec.rb

@@ -77,7 +77,7 @@ describe Chef::Resource::Execute do
   shared_examples_for "it received invalid credentials" do
     describe "the validation method" do
       it "should raise an error" do
-        expect { execute_resource.validate_identity_platform(username, password, domain) }.to raise_error(ArgumentError)
+        expect { execute_resource.validate_identity_platform(username, password, domain, elevated) }.to raise_error(ArgumentError)
       end
     end
   end
@@ -113,6 +113,7 @@ describe Chef::Resource::Execute do
 
       context "when a valid username is specified" do
         let(:username) { "starchild" }
+        let(:elevated) { false }
         context "when a valid domain is specified" do
           let(:domain) { "mothership" }
 
@@ -129,6 +130,7 @@ describe Chef::Resource::Execute do
 
         context "when the domain is not specified" do
           let(:domain) { nil }
+          let(:elevated) { false }
 
           context "when the password is not specified" do
             let(:password) { nil }
@@ -179,6 +181,24 @@ describe Chef::Resource::Execute do
           it_behaves_like "it received invalid username and domain"
         end
       end
+
+      context "when elevated is passed" do
+        let(:elevated) { true }
+
+        context "when username and password are not passed" do
+          let(:username) { nil }
+          let(:domain) { nil }
+          let(:password) { nil }
+          it_behaves_like "it received invalid credentials"
+        end
+
+        context "when username and password are passed" do
+          let(:username) { "user" }
+          let(:domain) { nil }
+          let(:password) { "we.funk!" }
+          it_behaves_like "it received valid credentials"
+        end
+      end
     end
 
     context "when not running on Windows" do

data/spec/unit/resource/powershell_script_spec.rb

@@ -59,9 +59,9 @@ describe Chef::Resource::PowershellScript do
       allow(resource).to receive(:updated).and_return(true)
     end
 
-    it "inherits exactly the :cwd, :environment, :group, :path, :user, :umask, and :architecture attributes from a parent resource class" do
+    it "inherits exactly the :cwd, :environment, :group, :path, :user, :umask, :architecture, :elevated attributes from a parent resource class" do
       inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes -
-        [:cwd, :environment, :group, :path, :user, :umask, :architecture ]
+        [:cwd, :environment, :group, :path, :user, :umask, :architecture, :elevated ]
 
       expect(inherited_difference).to eq([])
     end

data/spec/unit/resource/zypper_repository_spec.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: Copyright (c) 2017 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::Resource::ZypperRepository do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::ZypperRepository.new("repo-source", run_context) }
+
+  context "on linux", :linux_only do
+    it "should create a new Chef::Resource::ZypperRepository" do
+      expect(resource).to be_a_kind_of(Chef::Resource)
+      expect(resource).to be_a_kind_of(Chef::Resource::ZypperRepository)
+    end
+
+    it "should have a name of repo-source" do
+      expect(resource.name).to eql("repo-source")
+    end
+
+    it "should have a default action of create" do
+      expect(resource.action).to eql([:create])
+    end
+
+    it "supports all valid actions" do
+      expect { resource.action :add }.not_to raise_error
+      expect { resource.action :remove }.not_to raise_error
+      expect { resource.action :create }.not_to raise_error
+      expect { resource.action :refresh }.not_to raise_error
+      expect { resource.action :delete }.to raise_error(ArgumentError)
+    end
+
+    it "should resolve to a Noop class when zypper is not found" do
+      expect(Chef::Provider::ZypperRepository).to receive(:which).with("zypper").and_return(false)
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+    end
+
+    it "should resolve to a ZypperRepository class when zypper is found" do
+      expect(Chef::Provider::ZypperRepository).to receive(:which).with("zypper").and_return(true)
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::ZypperRepository)
+    end
+  end
+
+  context "on windows", :windows_only do
+    it "should resolve to a NoOp provider" do
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+    end
+  end
+end

data/spec/unit/search/query_spec.rb

@@ -22,9 +22,10 @@ require "chef/search/query"
 describe Chef::Search::Query do
   let(:rest) { double("Chef::ServerAPI") }
   let(:query) { Chef::Search::Query.new }
+  let(:default_rows) { 1000 }
 
   shared_context "filtered search" do
-    let(:query_string) { "search/node?q=platform:rhel&start=0" }
+    let(:query_string) { "search/node?q=platform:rhel&start=0&rows=#{default_rows}" }
     let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
     let(:args) { { filter_key => filter_hash } }
     let(:filter_hash) do
@@ -81,8 +82,8 @@ describe Chef::Search::Query do
   end
 
   describe "search" do
-    let(:query_string) { "search/node?q=platform:rhel&start=0" }
-    let(:query_string_continue) { "search/node?q=platform:rhel&start=4" }
+    let(:query_string) { "search/node?q=platform:rhel&start=0&rows=#{default_rows}" }
+    let(:query_string_continue) { "search/node?q=platform:rhel&start=4&rows=#{default_rows}" }
     let(:query_string_with_rows) { "search/node?q=platform:rhel&start=0&rows=4" }
     let(:query_string_continue_with_rows) { "search/node?q=platform:rhel&start=4&rows=4" }
 
@@ -150,12 +151,6 @@ describe Chef::Search::Query do
       "total" => 4,
     } end
 
-    let(:big_response) do
-      r = response.dup
-      r["total"] = 8
-      r
-    end
-
     let(:big_response_empty) do
       {
         "start" => 0,
@@ -178,17 +173,17 @@ describe Chef::Search::Query do
     end
 
     it "queries for every object of a type by default" do
-      expect(rest).to receive(:get).with("search/node?q=*:*&start=0").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=*:*&start=0&rows=#{default_rows}").and_return(response)
       query.search(:node)
     end
 
     it "allows a custom query" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=0").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=0&rows=#{default_rows}").and_return(response)
       query.search(:node, "platform:rhel")
     end
 
     it "lets you set a starting object" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=2").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=2&rows=#{default_rows}").and_return(response)
       query.search(:node, "platform:rhel", start: 2)
     end
 
@@ -221,9 +216,9 @@ describe Chef::Search::Query do
       query.search(:node, "*:*", start: 0, rows: 4) { |r| @call_me.do(r) }
     end
 
-    it "sends multiple API requests when the server indicates there is more data" do
-      expect(rest).to receive(:get).with(query_string).and_return(big_response)
-      expect(rest).to receive(:get).with(query_string_continue).and_return(big_response_end)
+    # This test would loop infinitely if pagination didn't advance
+    it "paginates correctly in the face of filtered nodes without explicit rows" do
+      allow(rest).to receive(:get).with(query_string).and_return(big_response_empty)
       query.search(:node, "platform:rhel") do |r|
         nil
       end
@@ -239,21 +234,21 @@ describe Chef::Search::Query do
 
     it "fuzzifies node searches when fuzz is set" do
       expect(rest).to receive(:get).with(
-        "search/node?q=tags:*free.messi*%20OR%20roles:*free.messi*%20OR%20fqdn:*free.messi*%20OR%20addresses:*free.messi*%20OR%20policy_name:*free.messi*%20OR%20policy_group:*free.messi*&start=0"
+        "search/node?q=tags:*free.messi*%20OR%20roles:*free.messi*%20OR%20fqdn:*free.messi*%20OR%20addresses:*free.messi*%20OR%20policy_name:*free.messi*%20OR%20policy_group:*free.messi*&start=0&rows=#{default_rows}"
       ).and_return(response)
       query.search(:node, "free.messi", fuzz: true)
     end
 
     it "does not fuzzify node searches when fuzz is not set" do
       expect(rest).to receive(:get).with(
-        "search/node?q=free.messi&start=0"
+        "search/node?q=free.messi&start=0&rows=#{default_rows}"
       ).and_return(response)
       query.search(:node, "free.messi")
     end
 
     it "does not fuzzify client searches" do
       expect(rest).to receive(:get).with(
-        "search/client?q=messi&start=0"
+        "search/client?q=messi&start=0&rows=#{default_rows}"
       ).and_return(response)
       query.search(:client, "messi", fuzz: true)
     end

data/spec/unit/server_api_spec.rb

@@ -26,12 +26,22 @@ b857vWviwPX2/P6+E3GPdl8IVsKXCvGWOBZWTuNTjQtwbDzsUepWoMgXnlQJSn5I
 YSlLxQKBgQD16Gw9kajpKlzsPa6XoQeGmZALT6aKWJQlrKtUQIrsIWM0Z6eFtX12
 2jjHZ0awuCQ4ldqwl8IfRogWMBkHOXjTPVK0YKWWlxMpD/5+bGPARa5fir8O1Zpo
 Y6S6MeZ69Rp89ma4ttMZ+kwi1+XyHqC/dlcVRW42Zl5Dc7BALRlJjQ==
------END RSA PRIVATE KEY-----"
+-----END RSA PRIVATE KEY-----".freeze
 
 describe Chef::ServerAPI do
   let(:url) { "http://chef.example.com:4000" }
   let(:key_path) { "/tmp/foo" }
 
+  let(:client) do
+    Chef::ServerAPI.new(url)
+  end
+
+  before do
+    Chef::Config[:node_name] = "silent-bob"
+    Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
+    Chef::Config[:http_retry_delay] = 0
+  end
+
   describe "#initialize" do
     it "uses the configured key file" do
       allow(IO).to receive(:read).with(key_path).and_return(SIGNING_KEY_DOT_PEM)
@@ -47,4 +57,68 @@ describe Chef::ServerAPI do
       expect(api.options[:raw_key]).to eql(SIGNING_KEY_DOT_PEM)
     end
   end
+
+  context "versioned apis" do
+    class VersionedClassV0
+      extend Chef::Mixin::VersionedAPI
+      minimum_api_version 0
+    end
+
+    class VersionedClassV2
+      extend Chef::Mixin::VersionedAPI
+      minimum_api_version 2
+    end
+
+    class VersionedClassVersions
+      extend Chef::Mixin::VersionedAPIFactory
+      add_versioned_api_class VersionedClassV0
+      add_versioned_api_class VersionedClassV2
+    end
+
+    before do
+      Chef::ServerAPIVersions.instance.reset!
+    end
+
+    let(:versioned_client) do
+      Chef::ServerAPI.new(url, version_class: VersionedClassVersions)
+    end
+
+    it "on protocol negotiation it posts the same message body without doubly-encoding the json string" do
+      WebMock.disable_net_connect!
+      post_body = { bar: "baz" }
+      body_406 = '{"error":"invalid-x-ops-server-api-version","message":"Specified version 2 not supported","min_version":0,"max_version":1}'
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: { "X-Ops-Server-Api-Version" => "2" }).to_return(status: [406, "Not Acceptable"], body: body_406 )
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: { "X-Ops-Server-Api-Version" => "0" }).to_return(status: 200, body: "", headers: {})
+      versioned_client.post("foo", post_body)
+    end
+  end
+
+  context "retrying normal requests" do
+    it "500 on a post retries and posts correctly " do
+      WebMock.disable_net_connect!
+      post_body = { bar: "baz" }
+      headers = { "Accept" => "application/json", "Content-Type" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Content-Length" => "13", "Host" => "chef.example.com:4000", "X-Chef-Version" => Chef::VERSION, "X-Ops-Sign" => "algorithm=sha1;version=1.1;", "X-Ops-Userid" => "silent-bob" }
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: headers).to_return(status: [500, "Internal Server Error"])
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: headers).to_return(status: 200, body: "", headers: {})
+      client.post("foo", post_body)
+    end
+
+    it "500 on a put retries and puts correctly " do
+      WebMock.disable_net_connect!
+      put_body = { bar: "baz" }
+      headers = { "Accept" => "application/json", "Content-Type" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Content-Length" => "13", "Host" => "chef.example.com:4000", "X-Chef-Version" => Chef::VERSION, "X-Ops-Sign" => "algorithm=sha1;version=1.1;", "X-Ops-Userid" => "silent-bob" }
+      stub_request(:put, "http://chef.example.com:4000/foo").with(body: put_body.to_json, headers: headers).to_return(status: [500, "Internal Server Error"])
+      stub_request(:put, "http://chef.example.com:4000/foo").with(body: put_body.to_json, headers: headers).to_return(status: 200, body: "", headers: {})
+      client.put("foo", put_body)
+    end
+
+    it "500 on a get retries and gets correctly " do
+      WebMock.disable_net_connect!
+      get_body = { bar: "baz" }
+      headers = { "Accept" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Host" => "chef.example.com:4000", "X-Chef-Version" => Chef::VERSION, "X-Ops-Sign" => "algorithm=sha1;version=1.1;", "X-Ops-Userid" => "silent-bob" }
+      stub_request(:get, "http://chef.example.com:4000/foo").with(headers: headers).to_return(status: [500, "Internal Server Error"])
+      stub_request(:get, "http://chef.example.com:4000/foo").with(headers: headers).to_return(status: 200, body: "", headers: {})
+      client.get("foo")
+    end
+  end
 end

data/spec/unit/server_api_versions_spec.rb

@@ -22,10 +22,28 @@ describe Chef::ServerAPIVersions do
     Chef::ServerAPIVersions.instance.reset!
   end
 
+  describe "#reset!" do
+    it "resets the version information" do
+      Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
+      Chef::ServerAPIVersions.instance.reset!
+      expect(Chef::ServerAPIVersions.instance.min_server_version).to be_nil
+    end
+
+    it "resets the unversioned flag" do
+      Chef::ServerAPIVersions.instance.unversioned!
+      Chef::ServerAPIVersions.instance.reset!
+      expect(Chef::ServerAPIVersions.instance.unversioned?).to be false
+    end
+  end
+
   describe "#min_server_version" do
     it "returns nil if no versions have been recorded" do
       expect(Chef::ServerAPIVersions.instance.min_server_version).to be_nil
     end
+    it "returns 0 if unversioned" do
+      Chef::ServerAPIVersions.instance.unversioned!
+      expect(Chef::ServerAPIVersions.instance.min_server_version).to eq(0)
+    end
     it "returns the correct value" do
       Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
       expect(Chef::ServerAPIVersions.instance.min_server_version).to eq(0)
@@ -36,6 +54,10 @@ describe Chef::ServerAPIVersions do
     it "returns nil if no versions have been recorded" do
       expect(Chef::ServerAPIVersions.instance.max_server_version).to be_nil
     end
+    it "returns 0 if unversioned" do
+      Chef::ServerAPIVersions.instance.unversioned!
+      expect(Chef::ServerAPIVersions.instance.min_server_version).to eq(0)
+    end
     it "returns the correct value" do
       Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
       expect(Chef::ServerAPIVersions.instance.max_server_version).to eq(2)