chef 18.8.11 → 18.8.46

data/spec/unit/api_client_v1_spec.rb

@@ -1,455 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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 "chef/api_client_v1"
-require "tempfile"
-
-describe Chef::ApiClientV1 do
-  before(:each) do
-    @client = Chef::ApiClientV1.new
-  end
-
-  it "has a name attribute" do
-    @client.name("ops_master")
-    expect(@client.name).to eq("ops_master")
-  end
-
-  it "does not allow spaces in the name" do
-    expect { @client.name "ops master" }.to raise_error(ArgumentError)
-  end
-
-  it "only allows string values for the name" do
-    expect { @client.name({}) }.to raise_error(ArgumentError)
-  end
-
-  it "has an admin flag attribute" do
-    @client.admin(true)
-    expect(@client.admin).to be_truthy
-  end
-
-  it "defaults to non-admin" do
-    expect(@client.admin).to be_falsey
-  end
-
-  it "allows only boolean values for the admin flag" do
-    expect { @client.admin(false) }.not_to raise_error
-    expect { @client.admin({}) }.to raise_error(ArgumentError)
-  end
-
-  it "has an create_key flag attribute" do
-    @client.create_key(true)
-    expect(@client.create_key).to be_truthy
-  end
-
-  it "create_key defaults to false" do
-    expect(@client.create_key).to be_falsey
-  end
-
-  it "allows only boolean values for the create_key flag" do
-    expect { @client.create_key(false) }.not_to raise_error
-    expect { @client.create_key({}) }.to raise_error(ArgumentError)
-  end
-
-  it "has a 'validator' flag attribute" do
-    @client.validator(true)
-    expect(@client.validator).to be_truthy
-  end
-
-  it "defaults to non-validator" do
-    expect(@client.validator).to be_falsey
-  end
-
-  it "allows only boolean values for the 'validator' flag" do
-    expect { @client.validator(false) }.not_to raise_error
-    expect { @client.validator({}) }.to raise_error(ArgumentError)
-  end
-
-  it "has a public key attribute" do
-    @client.public_key("super public")
-    expect(@client.public_key).to eq("super public")
-  end
-
-  it "accepts only String values for the public key" do
-    expect { @client.public_key "" }.not_to raise_error
-    expect { @client.public_key({}) }.to raise_error(ArgumentError)
-  end
-
-  it "has a private key attribute" do
-    @client.private_key("super private")
-    expect(@client.private_key).to eq("super private")
-  end
-
-  it "accepts only String values for the private key" do
-    expect { @client.private_key "" }.not_to raise_error
-    expect { @client.private_key({}) }.to raise_error(ArgumentError)
-  end
-
-  describe "when serializing to JSON" do
-    before(:each) do
-      @client.name("black")
-      @client.public_key("crowes")
-      @json = @client.to_json
-    end
-
-    it "serializes as a JSON object" do
-      expect(@json).to match(/^\{.+\}$/)
-    end
-
-    it "includes the name value" do
-      expect(@json).to include(%q{"name":"black"})
-    end
-
-    it "includes the public key value" do
-      expect(@json).to include(%{"public_key":"crowes"})
-    end
-
-    it "includes the 'admin' flag" do
-      expect(@json).to include(%q{"admin":false})
-    end
-
-    it "includes the 'validator' flag" do
-      expect(@json).to include(%q{"validator":false})
-    end
-
-    it "includes the 'create_key' flag when present" do
-      @client.create_key(true)
-      @json = @client.to_json
-      expect(@json).to include(%q{"create_key":true})
-    end
-
-    it "includes the private key when present" do
-      @client.private_key("monkeypants")
-      expect(@client.to_json).to include(%q{"private_key":"monkeypants"})
-    end
-
-    it "does not include the private key if not present" do
-      expect(@json).not_to include("private_key")
-    end
-
-    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { @client }
-    end
-  end
-
-  describe "when deserializing from JSON (string) using ApiClient#from_json" do
-    let(:client_string) do
-      "{\"name\":\"black\",\"public_key\":\"crowes\",\"private_key\":\"monkeypants\",\"admin\":true,\"validator\":true,\"create_key\":true}"
-    end
-
-    let(:client) do
-      Chef::ApiClientV1.from_json(client_string)
-    end
-
-    it "does not require a 'json_class' string" do
-      expect(Chef::JSONCompat.parse(client_string)["json_class"]).to eq(nil)
-    end
-
-    it "should deserialize to a Chef::ApiClientV1 object" do
-      expect(client).to be_a_kind_of(Chef::ApiClientV1)
-    end
-
-    it "preserves the name" do
-      expect(client.name).to eq("black")
-    end
-
-    it "preserves the public key" do
-      expect(client.public_key).to eq("crowes")
-    end
-
-    it "preserves the admin status" do
-      expect(client.admin).to be_truthy
-    end
-
-    it "preserves the create_key status" do
-      expect(client.create_key).to be_truthy
-    end
-
-    it "preserves the 'validator' status" do
-      expect(client.validator).to be_truthy
-    end
-
-    it "includes the private key if present" do
-      expect(client.private_key).to eq("monkeypants")
-    end
-  end
-
-  describe "when deserializing from JSON (hash) using ApiClientV1#from_json" do
-    let(:client_hash) do
-      {
-        "name" => "black",
-        "public_key" => "crowes",
-        "private_key" => "monkeypants",
-        "admin" => true,
-        "validator" => true,
-        "create_key" => true,
-      }
-    end
-
-    let(:client) do
-      Chef::ApiClientV1.from_json(Chef::JSONCompat.to_json(client_hash))
-    end
-
-    it "should deserialize to a Chef::ApiClientV1 object" do
-      expect(client).to be_a_kind_of(Chef::ApiClientV1)
-    end
-
-    it "preserves the name" do
-      expect(client.name).to eq("black")
-    end
-
-    it "preserves the public key" do
-      expect(client.public_key).to eq("crowes")
-    end
-
-    it "preserves the admin status" do
-      expect(client.admin).to be_truthy
-    end
-
-    it "preserves the create_key status" do
-      expect(client.create_key).to be_truthy
-    end
-
-    it "preserves the 'validator' status" do
-      expect(client.validator).to be_truthy
-    end
-
-    it "includes the private key if present" do
-      expect(client.private_key).to eq("monkeypants")
-    end
-  end
-
-  describe "when loading from JSON" do
-    before do
-    end
-
-    before(:each) do
-      client = {
-        "name" => "black",
-        "clientname" => "black",
-        "public_key" => "crowes",
-        "private_key" => "monkeypants",
-        "admin" => true,
-        "create_key" => true,
-        "validator" => true,
-      }
-
-      @http_client = double("Chef::ServerAPI mock")
-      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
-      expect(@http_client).to receive(:get).with("clients/black").and_return(client)
-      @client = Chef::ApiClientV1.load(client["name"])
-    end
-
-    it "should deserialize to a Chef::ApiClientV1 object" do
-      expect(@client).to be_a_kind_of(Chef::ApiClientV1)
-    end
-
-    it "preserves the name" do
-      expect(@client.name).to eq("black")
-    end
-
-    it "preserves the public key" do
-      expect(@client.public_key).to eq("crowes")
-    end
-
-    it "preserves the admin status" do
-      expect(@client.admin).to be_a_kind_of(TrueClass)
-    end
-
-    it "preserves the create_key status" do
-      expect(@client.create_key).to be_a_kind_of(TrueClass)
-    end
-
-    it "preserves the 'validator' status" do
-      expect(@client.validator).to be_a_kind_of(TrueClass)
-    end
-
-    it "includes the private key if present" do
-      expect(@client.private_key).to eq("monkeypants")
-    end
-
-  end
-
-  describe "with correctly configured API credentials" do
-    before do
-      Chef::Config[:node_name] = "silent-bob"
-      Chef::Config[:client_key] = File.expand_path("ssl/private_key.pem", CHEF_SPEC_DATA)
-    end
-
-    after do
-      Chef::Config[:node_name] = nil
-      Chef::Config[:client_key] = nil
-    end
-
-    let :private_key_data do
-      File.open(Chef::Config[:client_key], "r") { |f| f.read.chomp }
-    end
-
-  end
-
-  describe "when requesting a new key" do
-    before do
-      @http_client = double("Chef::ServerAPI mock")
-      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
-    end
-
-    context "and the client does not exist on the server" do
-      before do
-        @a_404_response = Net::HTTPNotFound.new("404 not found and such", nil, nil)
-        @a_404_exception = Net::HTTPClientException.new("404 not found exception", @a_404_response)
-
-        expect(@http_client).to receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
-      end
-
-      it "raises a 404 error" do
-        expect { Chef::ApiClientV1.reregister("lost-my-key") }.to raise_error(Net::HTTPClientException)
-      end
-    end
-  end
-
-  describe "Versioned API Interactions" do
-    let(:response_406) { OpenStruct.new(code: "406") }
-    let(:exception_406) { Net::HTTPClientException.new("406 Not Acceptable", response_406) }
-    let(:payload) do
-      {
-        name: "some_name",
-        validator: true,
-        admin: true,
-      }
-    end
-
-    before do
-      @client = Chef::ApiClientV1.new
-      allow(@client).to receive(:chef_rest_v0).and_return(double("chef rest root v0 object"))
-      allow(@client).to receive(:chef_rest_v1).and_return(double("chef rest root v1 object"))
-      @client.name "some_name"
-      @client.validator true
-      @client.admin true
-    end
-
-    describe "create" do
-
-      # from spec/support/shared/unit/user_and_client_shared.rb
-      it_should_behave_like "user or client create" do
-        let(:object)  { @client }
-        let(:error)   { Chef::Exceptions::InvalidClientAttribute }
-        let(:rest_v0) { @client.chef_rest_v0 }
-        let(:rest_v1) { @client.chef_rest_v1 }
-        let(:url)     { "clients" }
-      end
-
-      context "when API V1 is not supported by the server" do
-        # from spec/support/shared/unit/api_versioning.rb
-        it_should_behave_like "version handling" do
-          let(:object)    { @client }
-          let(:method)    { :create }
-          let(:http_verb) { :post }
-          let(:rest_v1)   { @client.chef_rest_v1 }
-        end
-      end
-
-    end # create
-
-    describe "update" do
-      context "when a valid client is defined" do
-
-        shared_examples_for "client updating" do
-          it "updates the client" do
-            expect(rest). to receive(:put).with("clients/some_name", payload).and_return(payload)
-            @client.update
-          end
-
-          context "when only the name field exists" do
-
-            before do
-              # needed since there is no way to set to nil via code
-              @client.instance_variable_set(:@validator, nil)
-              @client.instance_variable_set(:@admin, nil)
-            end
-
-            after do
-              @client.validator true
-              @client.admin true
-            end
-
-            it "updates the client with only the name" do
-              expect(rest). to receive(:put).with("clients/some_name", { name: "some_name" }).and_return({ name: "some_name" })
-              @client.update
-            end
-          end
-
-        end
-
-        context "when API V1 is supported by the server" do
-
-          it_should_behave_like "client updating" do
-            let(:rest) { @client.chef_rest_v1 }
-          end
-
-        end # when API V1 is supported by the server
-
-        context "when API V1 is not supported by the server" do
-          context "when no version is supported" do
-            # from spec/support/shared/unit/api_versioning.rb
-            it_should_behave_like "version handling" do
-              let(:object)    { @client }
-              let(:method)    { :create }
-              let(:http_verb) { :post }
-              let(:rest_v1)   { @client.chef_rest_v1 }
-            end
-          end # when no version is supported
-
-          context "when API V0 is supported" do
-
-            before do
-              allow(@client.chef_rest_v1).to receive(:put).and_raise(exception_406)
-              allow(@client).to receive(:server_client_api_version_intersection).and_return([0])
-            end
-
-            it_should_behave_like "client updating" do
-              let(:rest) { @client.chef_rest_v0 }
-            end
-
-          end
-
-        end # when API V1 is not supported by the server
-      end # when a valid client is defined
-    end # update
-
-    # DEPRECATION
-    # This can be removed after API V0 support is gone
-    describe "reregister" do
-      context "when server API V0 is valid on the Chef Server receiving the request" do
-        it "creates a new object via the API" do
-          expect(@client.chef_rest_v0).to receive(:put).with("clients/#{@client.name}", payload.merge({ private_key: true })).and_return({})
-          @client.reregister
-        end
-      end # when server API V0 is valid on the Chef Server receiving the request
-
-      context "when server API V0 is not supported by the Chef Server" do
-        # from spec/support/shared/unit/api_versioning.rb
-        it_should_behave_like "user and client reregister" do
-          let(:object)    { @client }
-          let(:rest_v0)   { @client.chef_rest_v0 }
-        end
-      end # when server API V0 is not supported by the Chef Server
-    end # reregister
-
-  end
-end

data/spec/unit/application/apply_spec.rb

@@ -1,116 +0,0 @@
-#
-# Author:: Bryan W. Berry (<bryan.berry@gmail.com>)
-# Copyright:: Copyright 2012-2016, Bryan W. Berry
-# 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::Application::Apply do
-
-  before do
-    @app = Chef::Application::Apply.new
-    allow(@app).to receive(:configure_logging).and_return(true)
-    allow(Chef::Log).to receive(:debug).with("FIPS mode is enabled.")
-    @recipe_text = "package 'nyancat'"
-    Chef::Config[:solo_legacy_mode] = true
-  end
-
-  describe "configuring the application" do
-    it "should set solo mode to true" do
-      @app.reconfigure
-      expect(Chef::Config[:solo_legacy_mode]).to be_truthy
-    end
-  end
-  describe "read_recipe_file" do
-    before do
-      @recipe_file_name = "foo.rb"
-      @recipe_path = File.expand_path(@recipe_file_name)
-      @recipe_file = double("Tempfile (mock)", read: @recipe_text)
-      allow(@app).to receive(:open).with(@recipe_path).and_return(@recipe_file)
-      allow(File).to receive(:exist?).with(@recipe_path).and_return(true)
-      allow(Chef::Application).to receive(:fatal!).and_return(true)
-    end
-
-    it "should read text properly" do
-      expect(@app.read_recipe_file(@recipe_file_name)[0]).to eq(@recipe_text)
-    end
-
-    it "should return a file_handle" do
-      expect(@app.read_recipe_file(@recipe_file_name)[1]).to be_instance_of(RSpec::Mocks::Double)
-    end
-
-    describe "when recipe is nil" do
-      it "should raise a fatal with the missing filename message" do
-        expect(Chef::Application).to receive(:fatal!).with("No recipe file was provided",
-          Chef::Exceptions::RecipeNotFound.new)
-        @app.read_recipe_file(nil)
-      end
-    end
-
-    describe "when recipe doesn't exist" do
-      before do
-        allow(File).to receive(:exist?).with(@recipe_path).and_return(false)
-      end
-      it "should raise a fatal with the file doesn't exist message" do
-        expect(Chef::Application).to receive(:fatal!).with(/^No file exists at/,
-          Chef::Exceptions::RecipeNotFound.new)
-        @app.read_recipe_file(@recipe_file_name)
-      end
-    end
-  end
-
-  describe "temp_recipe_file" do
-    before do
-      @app.instance_variable_set(:@recipe_text, @recipe_text)
-      @app.temp_recipe_file
-      @recipe_fh = @app.instance_variable_get(:@recipe_fh)
-    end
-    it "should open a tempfile" do
-      expect(@recipe_fh.path).to match(/.*recipe-temporary-file.*/)
-    end
-    it "should write recipe text to the tempfile" do
-      expect(@recipe_fh.read).to eq(@recipe_text)
-    end
-    it "should save the filename for later use" do
-      expect(@recipe_fh.path).to eq(@app.instance_variable_get(:@recipe_filename))
-    end
-  end
-  describe "recipe_file_arg" do
-    before do
-      ARGV.clear
-    end
-    it "should exit and log message" do
-      expect(Chef::Log).to receive(:debug).with(/^No recipe file provided/)
-      expect { @app.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
-    end
-
-  end
-  describe "when the json_attribs configuration option is specified" do
-    let(:json_attribs) { { "a" => "b" } }
-    let(:config_fetcher) { double(Chef::ConfigFetcher, fetch_json: json_attribs) }
-    let(:json_source) { "https://foo.com/foo.json" }
-
-    before do
-      Chef::Config[:json_attribs] = json_source
-      expect(Chef::ConfigFetcher).to receive(:new).with(json_source)
-        .and_return(config_fetcher)
-    end
-
-    it "reads the JSON attributes from the specified source" do
-      @app.reconfigure
-      expect(@app.json_attribs).to eq(json_attribs)
-    end
-  end
-end

data/spec/unit/application/base_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe Chef::Application::Base, "setup_application" do
-  let(:validation_path) { "" }
-
-  context "when validation key is supplied" do
-    before do
-      @app = Chef::Application::Base.new
-      tempfile = Tempfile.new(validation_path)
-      tempfile.write "string"
-      tempfile.close
-      @path = tempfile.path
-      Chef::Config.validation_key = @path
-    end
-
-    context "when key is in current directory" do
-      it "should find with full path of validation_key" do
-        validation_path = "validation.pem"
-        expect(Chef::Config.validation_key).to eql(@path)
-      end
-    end
-
-    context "when path is given" do
-      validation_path = "/tmp/validation.pem"
-      it "should find validation_key" do
-        expect(Chef::Config.validation_key).to eql(@path)
-      end
-    end
-  end
-
-  context "when validation key is not supplied" do
-    it "should return default path for validation_key" do
-      if windows?
-        expect(Chef::Config.validation_key).to eql("C:\\chef\\validation.pem")
-      else
-        expect(Chef::Config.validation_key).to eql("/etc/chef/validation.pem")
-      end
-    end
-  end
-end