chef 18.8.11 → 18.8.54

data/spec/support/shared/unit/user_and_client_shared.rb

@@ -1,114 +0,0 @@
-#
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-shared_examples_for "user or client create" do
-
-  context "when server API V1 is valid on the Chef Server receiving the request" do
-
-    it "creates a new object via the API" do
-      expect(rest_v1).to receive(:post).with(url, payload).and_return({})
-      object.create
-    end
-
-    it "creates a new object via the API with a public_key when it exists" do
-      object.public_key "some_public_key"
-      expect(rest_v1).to receive(:post).with(url, payload.merge({ public_key: "some_public_key" })).and_return({})
-      object.create
-    end
-
-    context "raise error when create_key and public_key are both set" do
-
-      before do
-        object.public_key "key"
-        object.create_key true
-      end
-
-      it "rasies the proper error" do
-        expect { object.create }.to raise_error(error)
-      end
-    end
-
-    context "when create_key == true" do
-      before do
-        object.create_key true
-      end
-
-      it "creates a new object via the API with create_key" do
-        expect(rest_v1).to receive(:post).with(url, payload.merge({ create_key: true })).and_return({})
-        object.create
-      end
-    end
-
-    context "when chef_key is returned by the server" do
-      let(:chef_key) do
-        {
-          "chef_key" => {
-            "public_key" => "some_public_key",
-          },
-        }
-      end
-
-      it "puts the public key into the object returned by create" do
-        expect(rest_v1).to receive(:post).with(url, payload).and_return(payload.merge(chef_key))
-        new_object = object.create
-        expect(new_object.public_key).to eq("some_public_key")
-      end
-
-      context "when private_key is returned in chef_key" do
-        let(:chef_key) do
-          {
-            "chef_key" => {
-              "public_key" => "some_public_key",
-              "private_key" => "some_private_key",
-            },
-          }
-        end
-
-        it "puts the private key into the object returned by create" do
-          expect(rest_v1).to receive(:post).with(url, payload).and_return(payload.merge(chef_key))
-          new_object = object.create
-          expect(new_object.private_key).to eq("some_private_key")
-        end
-      end
-    end # when chef_key is returned by the server
-
-  end # when server API V1 is valid on the Chef Server receiving the request
-
-  context "when server API V1 is not valid on the Chef Server receiving the request" do
-
-    context "when the server supports API V0" do
-      before do
-        allow(object).to receive(:server_client_api_version_intersection).and_return([0])
-        allow(rest_v1).to receive(:post).and_raise(exception_406)
-      end
-
-      it "creates a new object via the API" do
-        expect(rest_v0).to receive(:post).with(url, payload).and_return({})
-        object.create
-      end
-
-      it "creates a new object via the API with a public_key when it exists" do
-        object.public_key "some_public_key"
-        expect(rest_v0).to receive(:post).with(url, payload.merge({ public_key: "some_public_key" })).and_return({})
-        object.create
-      end
-
-    end # when the server supports API V0
-  end # when server API V1 is not valid on the Chef Server receiving the request
-
-end # user or client create

data/spec/support/shared/unit/windows_script_resource.rb

@@ -1,65 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-# Copyright:: Copyright (c) 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 "support/shared/unit/execute_resource"
-require "support/shared/unit/script_resource"
-
-shared_examples_for "a Windows script resource" do
-  it "should be a kind of Chef::Resource::WindowsScript" do
-    expect(windows_script_resource).to be_a_kind_of(Chef::Resource)
-    expect(windows_script_resource).to be_a_kind_of(Chef::Resource::WindowsScript)
-  end
-
-  context "when evaluating guards" do
-    it "should have a default_guard_interpreter attribute that is the same as the resource" do
-      expect(windows_script_resource.default_guard_interpreter).to eq(windows_script_resource.resource_name)
-    end
-
-    it "should default to using guard_interpreter attribute that is the same as the resource" do
-      expect(windows_script_resource.guard_interpreter).to eq(windows_script_resource.resource_name)
-    end
-
-    it "should use a resource to evaluate the guard when guard_interpreter is not specified" do
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate).and_return(true)
-      expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
-      windows_script_resource.only_if "echo hi"
-      expect(windows_script_resource.should_skip?(:run)).to eq(nil)
-    end
-
-    describe "when the guard is given a ruby block" do
-      it "should evaluate the guard if the guard_interpreter is set to its default value" do
-        windows_script_resource.only_if { true }
-        expect(windows_script_resource.should_skip?(:run)).to eq(nil)
-      end
-
-      it "should raise an exception if the guard_interpreter is overridden from its default value" do
-        windows_script_resource.guard_interpreter :bash
-        windows_script_resource.only_if { true }
-        expect { windows_script_resource.should_skip?(:run) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "script with a default guard interpreter" do
-    let(:script_resource) { windows_script_resource }
-
-    before { windows_script_resource.guard_interpreter :default }
-
-    it_should_behave_like "a script resource"
-  end
-end

data/spec/tiny_server.rb

@@ -1,193 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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 "webrick"
-require "webrick/https"
-require "rack"
-require "rackup"
-require "singleton"
-require "open-uri"
-require "chef/config"
-
-module TinyServer
-
-  class Manager
-
-    # 5 == debug, 3 == warning
-    LOGGER = WEBrick::Log.new(STDOUT, 3)
-    DEFAULT_OPTIONS = {
-      Port: 9000,
-      Host: "localhost",
-      Logger: LOGGER,
-      # SSLEnable: options[:ssl],
-      # SSLCertName: [ [ 'CN', WEBrick::Utils::getservername ] ],
-      AccessLog: [], # Remove this option to enable the access log when debugging.
-    }.freeze
-
-    def initialize(**options)
-      @options = DEFAULT_OPTIONS.merge(options)
-      @creator = caller.first
-    end
-
-    attr_reader :options
-    attr_reader :creator
-    attr_reader :server
-
-    def start(timeout = 5)
-      raise "Server already started!" if server
-
-      # Create the server (but don't start yet)
-      start_queue = Queue.new
-      @server = create_server(StartCallback: proc { start_queue << true })
-
-      @server_thread = Thread.new do
-        # Ensure any exceptions will cause the main rspec thread to fail too
-        Thread.current.abort_on_exception = true
-        server.start
-      end
-
-      # Wait for the StartCallback to tell us we've started
-      Timeout.timeout(timeout) do
-        start_queue.pop
-      end
-    end
-
-    def stop(timeout = 5)
-      if server
-        server.shutdown
-        @server = nil
-      end
-
-      if server_thread
-        begin
-          # Wait for a normal shutdown
-          server_thread.join(timeout)
-        rescue
-          # If it wouldn't shut down normally, kill it.
-          server_thread.kill
-          server_thread.join(timeout)
-        end
-        @server_thread = nil
-      end
-    end
-
-    private
-
-    attr_reader :server_thread
-
-    def create_server(**extra_options)
-      server = WEBrick::HTTPServer.new(**options, **extra_options)
-      server.mount("/", Rackup::Handler::WEBrick, API.instance)
-      server
-    end
-  end
-
-  class API
-    include Singleton
-
-    GET     = "GET".freeze
-    PUT     = "PUT".freeze
-    POST    = "POST".freeze
-    DELETE  = "DELETE".freeze
-
-    attr_reader :routes
-
-    def initialize
-      clear
-    end
-
-    def clear
-      @routes = { GET => [], PUT => [], POST => [], DELETE => [] }
-    end
-
-    def get(path, response_code, data = nil, headers = nil, &block)
-      @routes[GET] << Route.new(path, Response.new(response_code, data, headers, &block))
-    end
-
-    def put(path, response_code, data = nil, headers = nil, &block)
-      @routes[PUT] << Route.new(path, Response.new(response_code, data, headers, &block))
-    end
-
-    def post(path, response_code, data = nil, headers = nil, &block)
-      @routes[POST] << Route.new(path, Response.new(response_code, data, headers, &block))
-    end
-
-    def delete(path, response_code, data = nil, headers = nil, &block)
-      @routes[DELETE] << Route.new(path, Response.new(response_code, data, headers, &block))
-    end
-
-    def call(env)
-      if response = response_for_request(env)
-        response.call
-      else
-        debug_info = { message: "no data matches the request for #{env["REQUEST_URI"]}",
-                       available_routes: @routes, request: env }
-        # Uncomment me for glorious debugging
-        # pp :not_found => debug_info
-        [404, { "Content-Type" => "application/json" }, [ Chef::JSONCompat.to_json(debug_info) ]]
-      end
-    end
-
-    def response_for_request(env)
-      if route = @routes[env["REQUEST_METHOD"]].find { |route| route.matches_request?(env["REQUEST_URI"]) }
-        route.response
-      end
-    end
-  end
-
-  class Route
-    attr_reader :response
-
-    def initialize(path_spec, response)
-      @path_spec, @response = path_spec, response
-    end
-
-    def matches_request?(uri)
-      uri = URI.parse(uri).request_uri
-      @path_spec === uri
-    end
-
-    def to_s
-      "#{@path_spec} => (#{@response})"
-    end
-
-  end
-
-  class Response
-    HEADERS = { "Content-Type" => "application/json" }.freeze
-
-    def initialize(response_code = 200, data = nil, headers = nil, &block)
-      @response_code, @data = response_code, data
-      # .merge creates a new hash, headers is sometimes passed as nil, @response_headers gets mutated somewhere
-      # in processing
-      @response_headers = HEADERS.merge(headers || {})
-      @block = block_given? ? block : nil
-    end
-
-    def call
-      data = @data || @block.call
-      [@response_code, @response_headers, Array(data)]
-    end
-
-    def to_s
-      "#{@response_code} => #{(@data || @block)}"
-    end
-
-  end
-
-end

data/spec/unit/action_collection_spec.rb

@@ -1,19 +0,0 @@
-#
-# Copyright:: Copyright (c) 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.
-#
-
-# all the testing done on the action_collection presently is done in the
-# resource reporter and data collector tests

data/spec/unit/api_client/registration_spec.rb

@@ -1,278 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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"
-require "tempfile"
-
-require "chef/api_client/registration"
-
-describe Chef::ApiClient::Registration do
-
-  let(:key_location) do
-    make_tmpname("client-registration-key")
-  end
-
-  let(:client_name) { "silent-bob" }
-
-  subject(:registration) { Chef::ApiClient::Registration.new(client_name, key_location) }
-
-  let(:private_key_data) do
-    File.open(Chef::Config[:validation_key], "r") { |f| f.read.chomp }
-  end
-
-  let(:http_mock) { double("Chef::ServerAPI mock") }
-
-  let(:expected_post_data) do
-    { name: client_name, admin: false, public_key: generated_public_key.to_pem }
-  end
-
-  let(:expected_put_data) do
-    { name: client_name, admin: false, public_key: generated_public_key.to_pem }
-  end
-
-  let(:server_v10_response) do
-    {
-      "uri" => "https://chef.local/clients/#{client_name}",
-      "private_key" => "--begin rsa key etc--",
-    }
-  end
-
-  # Server v11 includes `json_class` on all replies
-  let(:server_v11_response) do
-    response = Chef::ApiClient.new
-    response.name(client_name)
-    response.private_key("--begin rsa key etc--")
-    response
-  end
-
-  let(:response_409) { Net::HTTPConflict.new("1.1", "409", "Conflict") }
-  let(:exception_409) { Net::HTTPClientException.new("409 conflict", response_409) }
-
-  let(:generated_private_key_pem) { IO.read(File.expand_path("ssl/private_key.pem", CHEF_SPEC_DATA)) }
-  let(:generated_private_key) { OpenSSL::PKey::RSA.new(generated_private_key_pem) }
-  let(:generated_public_key) { generated_private_key.public_key }
-
-  let(:create_with_pkey_response) do
-    {
-      "uri" => "",
-      "chef_key" => {
-        "public_key" => generated_public_key.to_pem,
-      },
-    }
-  end
-
-  let(:update_with_pkey_response) do
-    { "name" => client_name,
-      "admin" => false,
-      "public_key" => generated_public_key,
-      "validator" => false,
-      "private_key" => false,
-      "clientname" => client_name }
-  end
-
-  before do
-    Chef::Config[:validation_client_name] = "test-validator"
-    Chef::Config[:validation_key] = File.expand_path("ssl/private_key.pem", CHEF_SPEC_DATA)
-    allow(OpenSSL::PKey::RSA).to receive(:generate).with(2048).and_return(generated_private_key)
-  end
-
-  after do
-    File.unlink(key_location) if File.exist?(key_location)
-  end
-
-  it "has an HTTP client configured with validator credentials" do
-    expect(registration.http_api).to be_a_kind_of(Chef::ServerAPI)
-    expect(registration.http_api.options[:client_name]).to eq("test-validator")
-    auth = registration.http_api.middlewares.find { |klass| klass.is_a? Chef::HTTP::Authenticator }
-    expect(auth.client_name).to eq("test-validator")
-  end
-
-  describe "when creating/updating the client on the server" do
-    before do
-      allow(registration).to receive(:http_api).and_return(http_mock)
-    end
-
-    it "posts a locally generated public key to the server to create a client" do
-      expect(http_mock).to receive(:post)
-        .with("clients", expected_post_data)
-        .and_return(create_with_pkey_response)
-      expect(registration.run.public_key).to eq(create_with_pkey_response["chef_key"]["public_key"])
-      expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-    end
-
-    it "puts a locally generated public key to the server to update a client" do
-      expect(http_mock).to receive(:post)
-        .with("clients", expected_post_data)
-        .and_raise(exception_409)
-      expect(http_mock).to receive(:put)
-        .with("clients/#{client_name}", expected_put_data)
-        .and_return(update_with_pkey_response)
-      expect(registration.run.public_key).to eq(update_with_pkey_response["public_key"].to_pem)
-      expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-    end
-
-    it "writes the generated private key to disk" do
-      expect(http_mock).to receive(:post)
-        .with("clients", expected_post_data)
-        .and_return(create_with_pkey_response)
-      registration.run
-      expect(OpenSSL::PKey::RSA.new(IO.read(key_location)).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-    end
-
-    context "and the client already exists on a Chef 11 server" do
-      it "requests a new key from the server and saves it" do
-        expect(http_mock).to receive(:post).and_raise(exception_409)
-        expect(http_mock).to receive(:put)
-          .with("clients/#{client_name}", expected_put_data)
-          .and_return(update_with_pkey_response)
-        expect(registration.run.public_key).to eq(update_with_pkey_response["public_key"].to_pem)
-        expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-      end
-    end
-
-    context "when local key generation is disabled" do
-
-      let(:expected_post_data) do
-        { name: client_name, admin: false }
-      end
-
-      let(:expected_put_data) do
-        { name: client_name, admin: false, private_key: true }
-      end
-
-      before do
-        Chef::Config[:local_key_generation] = false
-        expect(OpenSSL::PKey::RSA).not_to receive(:generate)
-      end
-
-      it "creates a new ApiClient on the server using the validator identity" do
-        expect(http_mock).to receive(:post)
-          .with("clients", expected_post_data)
-          .and_return(server_v10_response)
-        expect(registration.run.private_key).to eq(server_v10_response["private_key"])
-        expect(registration.private_key).to eq("--begin rsa key etc--")
-      end
-
-      context "and the client already exists on a Chef 11 server" do
-        it "requests a new key from the server and saves it" do
-          expect(http_mock).to receive(:post).and_raise(exception_409)
-          expect(http_mock).to receive(:put)
-            .with("clients/#{client_name}", expected_put_data)
-            .and_return(server_v11_response)
-          expect(registration.run).to eq(server_v11_response)
-          expect(registration.private_key).to eq("--begin rsa key etc--")
-        end
-      end
-
-      context "and the client already exists on a Chef 10 server" do
-        it "requests a new key from the server and saves it" do
-          expect(http_mock).to receive(:post).with("clients", expected_post_data)
-            .and_raise(exception_409)
-          expect(http_mock).to receive(:put)
-            .with("clients/#{client_name}", expected_put_data)
-            .and_return(server_v10_response)
-          expect(registration.run.private_key).to eq(server_v10_response["private_key"])
-          expect(registration.private_key).to eq("--begin rsa key etc--")
-        end
-      end
-    end
-  end
-
-  describe "when writing the private key to disk" do
-    before do
-      allow(registration).to receive(:private_key).and_return("--begin rsa key etc--")
-    end
-
-    # Permission read via File.stat is busted on windows, though creating the
-    # file with 0600 has the desired effect of giving access rights to the
-    # owner only. A platform-specific functional test would be helpful.
-    it "creates the file with 0600 permissions", :unix_only do
-      expect(File).not_to exist(key_location)
-      registration.write_key
-      expect(File).to exist(key_location)
-      stat = File.stat(key_location)
-      expect(stat.mode & 07777).to eq(0600)
-    end
-
-    it "writes the private key content to the file" do
-      registration.write_key
-      expect(IO.read(key_location)).to eq("--begin rsa key etc--")
-    end
-
-    context "when the client key location is a symlink" do
-      it "does not follow the symlink", :unix_only do
-        expected_flags = (File::CREAT | File::TRUNC | File::RDWR)
-
-        if defined?(File::NOFOLLOW)
-          expected_flags |= File::NOFOLLOW
-        end
-
-        expect(registration.file_flags).to eq(expected_flags)
-      end
-
-      context "with follow_client_key_symlink set to true" do
-        before do
-          Chef::Config[:follow_client_key_symlink] = true
-        end
-
-        it "follows the symlink", :unix_only do
-          expect(registration.file_flags).to eq(File::CREAT | File::TRUNC | File::RDWR)
-        end
-      end
-    end
-  end
-
-  describe "when registering a client" do
-
-    before do
-      allow(registration).to receive(:http_api).and_return(http_mock)
-    end
-
-    it "creates the client on the server and writes the key" do
-      expect(http_mock).to receive(:post).ordered.and_return(server_v10_response)
-      registration.run
-      expect(OpenSSL::PKey::RSA.new(IO.read(key_location)).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-    end
-
-    it "retries up to 5 times" do
-      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
-      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
-
-      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 1
-      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 2
-      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 3
-      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 4
-      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 5
-
-      expect(http_mock).to receive(:post).ordered.and_return(server_v10_response)
-      registration.run
-      expect(OpenSSL::PKey::RSA.new(IO.read(key_location)).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
-    end
-
-    it "gives up retrying after the max attempts" do
-      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
-      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
-
-      expect(http_mock).to receive(:post).exactly(6).times.and_raise(exception_500)
-
-      expect { registration.run }.to raise_error(Net::HTTPFatalError)
-    end
-
-  end
-
-end