chef 12.2.1-x86-mingw32 → 12.3.0.rc.0-x86-mingw32

data/spec/integration/client/ipv6_spec.rb

@@ -76,7 +76,7 @@ END_CLIENT_RB
 
   let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
 
-  let(:chef_client_cmd) { %Q[ruby '#{chef_dir}/chef-client' -c "#{path_to('config/client.rb')}" -lwarn] }
+  let(:chef_client_cmd) { %Q[ruby '#{chef_dir}/chef-client' --minimal-ohai -c "#{path_to('config/client.rb')}" -lwarn] }
 
   after do
     FileUtils.rm_rf(cache_path)

data/spec/integration/knife/common_options_spec.rb

@@ -39,7 +39,7 @@ describe 'knife common options', :workstation do
 
         it 'knife raw /nodes/x should retrieve the node' do
           knife('raw /nodes/x').should_succeed( /"name": "x"/ )
-          expect(Chef::Config.chef_server_url).to eq('http://localhost:9999')
+          expect(Chef::Config.chef_server_url).to eq('chefzero://localhost:9999')
         end
       end
 
@@ -101,7 +101,7 @@ EOM
 
     it 'knife raw -z --chef-zero-port=9999 /nodes/x retrieves the node' do
       knife('raw -z --chef-zero-port=9999 /nodes/x').should_succeed( /"name": "x"/ )
-      expect(Chef::Config.chef_server_url).to eq('http://localhost:9999')
+      expect(Chef::Config.chef_server_url).to eq('chefzero://localhost:9999')
     end
 
     context 'when the default port (8889) is already bound' do
@@ -149,7 +149,7 @@ EOM
 
     it 'knife raw -z --chef-zero-port=9999 /nodes/x retrieves the node' do
       knife('raw -z --chef-zero-port=9999 /nodes/x').should_succeed( /"name": "x"/ )
-      expect(Chef::Config.chef_server_url).to eq('http://localhost:9999')
+      expect(Chef::Config.chef_server_url).to eq('chefzero://localhost:9999')
     end
   end
 end

data/spec/integration/recipes/lwrp_inline_resources_spec.rb

@@ -16,7 +16,7 @@ describe "LWRPs with inline resources" do
   # machine that has omnibus chef installed. In that case we need to ensure
   # we're running `chef-client` from the source tree and not the external one.
   # cf. CHEF-4914
-  let(:chef_client) { "ruby '#{chef_dir}/chef-client'" }
+  let(:chef_client) { "ruby '#{chef_dir}/chef-client' --minimal-ohai" }
 
   when_the_repository "has a cookbook with a nested LWRP" do
     before do

data/spec/integration/solo/solo_spec.rb

@@ -15,6 +15,8 @@ describe "chef-solo" do
 
   let(:cookbook_ancient_100_metadata_rb) { cb_metadata("ancient", "1.0.0") }
 
+  let(:chef_solo) { "ruby bin/chef-solo --minimal-ohai" }
+
   when_the_repository "has a cookbook with a basic recipe" do
     before do
       file 'cookbooks/x/metadata.rb', cookbook_x_100_metadata_rb
@@ -26,7 +28,7 @@ describe "chef-solo" do
 cookbook_path "#{path_to('cookbooks')}"
 file_cache_path "#{path_to('config/cache')}"
 EOM
-      result = shell_out("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -o 'x::default' -l debug", :cwd => chef_dir)
+      result = shell_out("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' -l debug", :cwd => chef_dir)
       result.error!
       expect(result.stdout).to include("ITWORKS")
     end
@@ -41,7 +43,7 @@ EOM
 {"run_list":["x::default"]}
 E
 
-      result = shell_out("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -j '#{path_to('config/node.json')}' -l debug", :cwd => chef_dir)
+      result = shell_out("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -j '#{path_to('config/node.json')}' -l debug", :cwd => chef_dir)
       result.error!
       expect(result.stdout).to include("ITWORKS")
     end
@@ -62,7 +64,7 @@ E
 cookbook_path "#{path_to('cookbooks')}"
 file_cache_path "#{path_to('config/cache')}"
 EOM
-      result = shell_out("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -o 'x::default' -l debug", :cwd => chef_dir)
+      result = shell_out("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' -l debug", :cwd => chef_dir)
       expect(result.exitstatus).to eq(0) # For CHEF-5120 this becomes 1
       expect(result.stdout).to include("WARN: MissingCookbookDependency")
     end
@@ -95,14 +97,14 @@ EOM
           chef_dir = File.join(File.dirname(__FILE__), "..", "..", "..")
 
           # Instantiate the first chef-solo run
-          s1 = Process.spawn("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
+          s1 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
 -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
 
           # Give it some time to progress
           sleep 1
 
           # Instantiate the second chef-solo run
-          s2 = Process.spawn("ruby bin/chef-solo -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
+          s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
 -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
 
           Process.waitpid(s1)

data/spec/unit/application/client_spec.rb

@@ -131,6 +131,16 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
   end
 
+  describe "when --no-listen is set" do
+
+    it "configures listen = false" do
+      app.config[:listen] = false
+      app.reconfigure
+      expect(Chef::Config[:listen]).to eq(false)
+    end
+
+  end
+
   describe "when the json_attribs configuration option is specified" do
 
     let(:json_attribs) { {"a" => "b"} }

data/spec/unit/chef_class_spec.rb

@@ -0,0 +1,91 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 2015 Opscode, 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 class" do
+  let(:platform) { "debian" }
+
+  let(:node) do
+    node = Chef::Node.new
+    node.automatic['platform'] = platform
+    node
+  end
+
+  let(:run_context) do
+    Chef::RunContext.new(node, nil, nil)
+  end
+
+  let(:resource_priority_map) do
+    double("Chef::Platform::ResourcePriorityMap")
+  end
+
+  let(:provider_priority_map) do
+    double("Chef::Platform::ProviderPriorityMap")
+  end
+
+  before do
+    Chef.set_run_context(run_context)
+    Chef.set_node(node)
+    Chef.set_resource_priority_map(resource_priority_map)
+    Chef.set_provider_priority_map(provider_priority_map)
+  end
+
+  after do
+    Chef.reset!
+  end
+
+  context "priority maps" do
+    context "#get_provider_priority_array" do
+      it "should use the current node to get the right priority_map" do
+        expect(provider_priority_map).to receive(:get_priority_array).with(node, :http_request).and_return("stuff")
+        expect(Chef.get_provider_priority_array(:http_request)).to eql("stuff")
+      end
+    end
+    context "#get_resource_priority_array" do
+      it "should use the current node to get the right priority_map" do
+        expect(resource_priority_map).to receive(:get_priority_array).with(node, :http_request).and_return("stuff")
+        expect(Chef.get_resource_priority_array(:http_request)).to eql("stuff")
+      end
+    end
+    context "#set_provider_priority_array" do
+      it "should delegate to the provider_priority_map" do
+        expect(provider_priority_map).to receive(:set_priority_array).with(:http_request, ["a", "b"], platform: "debian").and_return("stuff")
+        expect(Chef.set_provider_priority_array(:http_request, ["a", "b"], platform: "debian")).to eql("stuff")
+      end
+    end
+    context "#set_priority_map_for_resource" do
+      it "should delegate to the resource_priority_map" do
+        expect(resource_priority_map).to receive(:set_priority_array).with(:http_request, ["a", "b"], platform: "debian").and_return("stuff")
+        expect(Chef.set_resource_priority_array(:http_request, ["a", "b"], platform: "debian")).to eql("stuff")
+      end
+    end
+  end
+
+  context "#run_context" do
+    it "should return the injected RunContext" do
+      expect(Chef.run_context).to eql(run_context)
+    end
+  end
+
+  context "#node" do
+    it "should return the injected Node" do
+      expect(Chef.node).to eql(node)
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -78,6 +78,19 @@ describe Chef::Client do
     allow(Ohai::System).to receive(:new).and_return(ohai_system)
   end
 
+  context "when minimal ohai is configured" do
+    before do
+      Chef::Config[:minimal_ohai] = true
+    end
+
+    it "runs ohai with only the minimum required plugins" do
+      expected_filter = %w[fqdn machinename hostname platform platform_version os os_version]
+      expect(ohai_system).to receive(:all_plugins).with(expected_filter)
+      client.run_ohai
+    end
+
+  end
+
   describe "authentication protocol selection" do
     after do
       Chef::Config[:authentication_protocol_version] = "1.0"

data/spec/unit/http/basic_client_spec.rb

@@ -21,7 +21,7 @@ require 'chef/http/basic_client'
 describe "HTTP Connection" do
 
   let(:uri) { URI("https://example.com:4443") }
-  subject { Chef::HTTP::BasicClient.new(uri) }
+  subject(:basic_client) { Chef::HTTP::BasicClient.new(uri) }
 
   describe ".new" do
     it "creates an instance" do
@@ -45,11 +45,6 @@ describe "HTTP Connection" do
       let(:proxy_port) { 8080 }
       let(:proxy) { "#{proxy_prefix}#{proxy_host}:#{proxy_port}" }
 
-      before do
-        Chef::Config["#{uri.scheme}_proxy"] = proxy
-        Chef::Config[:no_proxy] = nil
-      end
-
       it "should contain the host" do
         proxy_uri = subject.proxy_uri
         expect(proxy_uri.host).to eq(proxy_host)
@@ -63,14 +58,56 @@ describe "HTTP Connection" do
 
     context "when the config setting is normalized (does not contain the scheme)" do
       include_examples "a proxy uri" do
+
         let(:proxy_prefix) { "" }
+
+        before do
+          Chef::Config["#{uri.scheme}_proxy"] = proxy
+          Chef::Config[:no_proxy] = nil
+        end
+
       end
     end
 
     context "when the config setting is not normalized (contains the scheme)" do
       include_examples "a proxy uri" do
         let(:proxy_prefix) { "#{uri.scheme}://" }
+
+        before do
+          Chef::Config["#{uri.scheme}_proxy"] = proxy
+          Chef::Config[:no_proxy] = nil
+        end
+
+      end
+    end
+
+    context "when the proxy is set by the environment" do
+
+      include_examples "a proxy uri" do
+
+        let(:env) do
+          {
+            "https_proxy" => "https://proxy.mycorp.com:8080",
+            "https_proxy_user" => "jane_username",
+            "https_proxy_pass" => "opensesame"
+          }
+        end
+
+        let(:proxy_uri) { URI.parse(env["https_proxy"]) }
+
+        before do
+          allow(basic_client).to receive(:env).and_return(env)
+        end
+
+        it "sets the proxy user" do
+          expect(basic_client.http_proxy_user(proxy_uri)).to eq("jane_username")
+        end
+
+        it "sets the proxy pass" do
+          expect(basic_client.http_proxy_pass(proxy_uri)).to eq("opensesame")
+        end
       end
+
     end
   end
 end

data/spec/unit/http/socketless_chef_zero_client_spec.rb

@@ -0,0 +1,174 @@
+#--
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) 2015 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 'chef/http/socketless_chef_zero_client'
+
+describe Chef::HTTP::SocketlessChefZeroClient do
+
+  let(:relative_url) { "" }
+  let(:uri_str) { "chefzero://localhost:1/#{relative_url}" }
+  let(:uri) { URI(uri_str) }
+
+  subject(:zero_client) { Chef::HTTP::SocketlessChefZeroClient.new(uri) }
+
+  it "has a host" do
+    expect(zero_client.host).to eq("localhost")
+  end
+
+  it "has a port" do
+    expect(zero_client.port).to eq(1)
+  end
+
+  describe "converting requests to rack format" do
+
+    let(:expected_rack_req) do
+      {
+        "SCRIPT_NAME"     => "",
+        "SERVER_NAME"     => "localhost",
+        "REQUEST_METHOD"  => method.to_s.upcase,
+        "PATH_INFO"       => uri.path,
+        "QUERY_STRING"    => uri.query,
+        "SERVER_PORT"     => uri.port,
+        "HTTP_HOST"       => "localhost:#{uri.port}",
+        "rack.url_scheme" => "chefzero",
+      }
+    end
+
+    context "when the request has no body" do
+
+      let(:method) { :GET }
+      let(:relative_url) { "clients" }
+      let(:headers) { { "Accept" => "application/json" } }
+      let(:body) { false }
+      let(:expected_body_str) { "" }
+
+      let(:rack_req) { zero_client.req_to_rack(method, uri, body, headers) }
+
+      it "creates a rack request env" do
+        # StringIO doesn't implement == in a way that we can compare, so we
+        # check rack.input individually and then iterate over everything else
+        expect(rack_req["rack.input"].string).to eq(expected_body_str)
+        expected_rack_req.each do |key, value|
+          expect(rack_req[key]).to eq(value)
+        end
+      end
+
+    end
+
+    context "when the request has a body" do
+
+      let(:method) { :PUT }
+      let(:relative_url) { "clients/foo" }
+      let(:headers) { { "Accept" => "application/json" } }
+      let(:body) { "bunch o' JSON" }
+      let(:expected_body_str) { "bunch o' JSON" }
+
+      let(:rack_req) { zero_client.req_to_rack(method, uri, body, headers) }
+
+      it "creates a rack request env" do
+        # StringIO doesn't implement == in a way that we can compare, so we
+        # check rack.input individually and then iterate over everything else
+        expect(rack_req["rack.input"].string).to eq(expected_body_str)
+        expected_rack_req.each do |key, value|
+          expect(rack_req[key]).to eq(value)
+        end
+      end
+
+    end
+
+  end
+
+  describe "converting responses to Net::HTTP objects" do
+
+    let(:net_http_response) { zero_client.to_net_http(code, headers, body) }
+
+    context "when the request was successful (2XX)" do
+
+      let(:code) { 200 }
+      let(:headers) { { "Content-Type" => "Application/JSON" } }
+      let(:body) { [ "bunch o' JSON" ] }
+
+      it "creates a Net::HTTP success response object" do
+        expect(net_http_response).to be_a_kind_of(Net::HTTPOK)
+        expect(net_http_response.read_body).to eq("bunch o' JSON")
+        expect(net_http_response["content-type"]).to eq("Application/JSON")
+      end
+
+      it "does not fail when calling read_body with a block" do
+        expect(net_http_response.read_body {|chunk| chunk }).to eq("bunch o' JSON")
+      end
+
+    end
+
+    context "when the requested object doesn't exist (404)" do
+
+      let(:code) { 404 }
+      let(:headers) { { "Content-Type" => "Application/JSON" } }
+      let(:body) { [ "nope" ] }
+
+      it "creates a Net::HTTPNotFound response object" do
+        expect(net_http_response).to be_a_kind_of(Net::HTTPNotFound)
+      end
+    end
+
+  end
+
+  describe "request-response round trip" do
+
+    let(:method) { :GET }
+    let(:relative_url) { "clients" }
+    let(:headers) { { "Accept" => "application/json" } }
+    let(:body) { false }
+
+    let(:expected_rack_req) do
+      {
+        "SCRIPT_NAME"     => "",
+        "SERVER_NAME"     => "localhost",
+        "REQUEST_METHOD"  => method.to_s.upcase,
+        "PATH_INFO"       => uri.path,
+        "QUERY_STRING"    => uri.query,
+        "SERVER_PORT"     => uri.port,
+        "HTTP_HOST"       => "localhost:#{uri.port}",
+        "rack.url_scheme" => "chefzero",
+        "rack.input"      => an_instance_of(StringIO),
+      }
+    end
+
+
+    let(:response_code) { 200 }
+    let(:response_headers) { { "Content-Type" => "Application/JSON" } }
+    let(:response_body) { [ "bunch o' JSON" ] }
+
+    let(:rack_response) { [ response_code, response_headers, response_body ] }
+
+    let(:response) { zero_client.request(method, uri, body, headers) }
+
+    before do
+      expect(ChefZero::SocketlessServerMap).to receive(:request).with(1, expected_rack_req).and_return(rack_response)
+    end
+
+    it "makes a rack request to Chef Zero and returns the response as a Net::HTTP object" do
+      _client, net_http_response = response
+      expect(net_http_response).to be_a_kind_of(Net::HTTPOK)
+      expect(net_http_response.code).to eq("200")
+      expect(net_http_response.body).to eq("bunch o' JSON")
+    end
+
+  end
+
+end