chef 18.8.11 → 18.8.54

data/spec/unit/scan_access_control_spec.rb

@@ -1,183 +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 "chef/scan_access_control"
-
-describe Chef::ScanAccessControl do
-
-  before do
-    @new_resource = Chef::Resource::File.new("/tmp/foo/bar/baz/link")
-    @real_file = "/tmp/foo/bar/real/file"
-    @current_resource = Chef::Resource::File.new(@new_resource.path)
-    @scanner = Chef::ScanAccessControl.new(@new_resource, @current_resource)
-  end
-
-  describe "when the fs entity does not exist" do
-
-    before do
-      @new_resource.tap do |f|
-        f.owner("root")
-        f.group("root")
-        f.mode("0755")
-      end
-      @scanner.set_all!
-    end
-
-    it "does not set any fields on the current resource" do
-      expect(@current_resource.owner).to be_nil
-      expect(@current_resource.group).to be_nil
-      expect(@current_resource.mode).to be_nil
-    end
-
-  end
-
-  describe "when the fs entity exists" do
-
-    before do
-      @stat = double("File::Stat for #{@new_resource.path}", uid: 0, gid: 0, mode: 00100644)
-      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
-      # these tests are necessary for minitest-chef-handler to use as an API, see CHEF-3235
-      before do
-        @scanner.set_all!
-      end
-
-      it "sets the mode of the current resource to the current mode as a String" do
-        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
-          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
-          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
-          expect(@current_resource.group).to eq(0)
-        end
-
-        it "sets the owner of the current resource to the current owner as a String" do
-          expect(@current_resource.user).to eq(0)
-        end
-      end
-    end
-
-    describe "when new_resource specifies the mode with a string" do
-      before do
-        @new_resource.mode("0755")
-        @scanner.set_all!
-      end
-
-      it "sets the mode of the current resource to the file's current mode as a string" do
-        expect(@current_resource.mode).to eq("0644")
-      end
-    end
-
-    describe "when new_resource specified the mode with an integer" do
-      before do
-        @new_resource.mode(00755)
-        @scanner.set_all!
-      end
-
-      it "sets the mode of the current resource to the current mode as a String" do
-        expect(@current_resource.mode).to eq("0644")
-      end
-
-    end
-
-    describe "when new_resource specifies the user with a UID" do
-
-      before do
-        @new_resource.user(0)
-        @scanner.set_all!
-      end
-
-      it "sets the owner of current_resource to the UID of the current owner" do
-        expect(@current_resource.user).to eq(0)
-      end
-    end
-
-    describe "when new_resource specifies the user with a username" do
-
-      before do
-        @new_resource.user("root")
-      end
-
-      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")
-        expect(Etc).to receive(:getpwuid).with(0).and_return(@root_passwd)
-        @scanner.set_all!
-
-        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
-          expect(Etc).to receive(:getpwuid).with(0).and_raise(ArgumentError)
-          @scanner.set_all!
-          expect(@current_resource.user).to eq(0)
-        end
-      end
-    end
-
-    describe "when new_resource specifies the group with a GID" do
-
-      before do
-        @new_resource.group(0)
-        @scanner.set_all!
-      end
-
-      it "sets the group of the current_resource to the gid of the current owner" do
-        expect(@current_resource.group).to eq(0)
-      end
-
-    end
-
-    describe "when new_resource specifies the group with a group name" do
-      before do
-        @new_resource.group("wheel")
-      end
-
-      it "sets the group of the current resource to the group name" do
-        @group_entry = double("Struct::Group for wheel", name: "wheel")
-        expect(Etc).to receive(:getgrgid).with(0).and_return(@group_entry)
-        @scanner.set_all!
-
-        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
-          expect(Etc).to receive(:getgrgid).with(0).and_raise(ArgumentError)
-          @scanner.set_all!
-          expect(@current_resource.group).to eq(0)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/search/query_spec.rb

@@ -1,291 +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/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&rows=#{default_rows}" }
-    let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
-    let(:args) { { filter_key => filter_hash } }
-    let(:filter_hash) do
-      {
-        "env" => [ "chef_environment" ],
-        "ruby_plat" => %w{languages ruby platform},
-      }
-    end
-    let(:response) do
-      {
-        "rows" => [
-          { "url" => "#{server_url}/my-name-is-node",
-            "data" => {
-              "env" => "elysium",
-              "ruby_plat" => "nudibranch",
-            },
-          },
-          { "url" => "#{server_url}/my-name-is-jonas",
-            "data" => {
-              "env" => "hades",
-              "ruby_plat" => "i386-mingw32",
-            },
-          },
-          { "url" => "#{server_url}/my-name-is-flipper",
-            "data" => {
-              "env" => "elysium",
-              "ruby_plat" => "centos",
-            },
-          },
-          { "url" => "#{server_url}/my-name-is-butters",
-            "data" => {
-              "env" => "moon",
-              "ruby_plat" => "solaris2",
-            },
-          },
-        ],
-        "start" => 0,
-        "total" => 4,
-      }
-    end
-    let(:response_rows) do
-      [
-        { "env" => "elysium", "ruby_plat" => "nudibranch" },
-        { "env" => "hades", "ruby_plat" => "i386-mingw32" },
-        { "env" => "elysium", "ruby_plat" => "centos" },
-        { "env" => "moon", "ruby_plat" => "solaris2" },
-      ]
-    end
-  end
-
-  before(:each) do
-    allow(Chef::ServerAPI).to receive(:new).and_return(rest)
-    allow(rest).to receive(:get).and_return(response)
-  end
-
-  describe "search" do
-    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" }
-
-    let(:response) do
-      {
-      "rows" => [
-        { "name" => "my-name-is-node",
-          "chef_environment" => "elysium",
-          "platform" => "rhel",
-          "run_list" => [],
-          "automatic" => {
-            "languages" => {
-              "ruby" => {
-                "platform" => "nudibranch",
-                "version" => "1.9.3",
-                "target" => "ming-the-merciless",
-              },
-            },
-          },
-        },
-        { "name" => "my-name-is-jonas",
-          "chef_environment" => "hades",
-          "platform" => "rhel",
-          "run_list" => [],
-          "automatic" => {
-            "languages" => {
-              "ruby" => {
-                "platform" => "i386-mingw32",
-                "version" => "1.9.3",
-                "target" => "bilbo",
-              },
-            },
-          },
-        },
-        { "name" => "my-name-is-flipper",
-          "chef_environment" => "elysium",
-          "platform" => "rhel",
-          "run_list" => [],
-          "automatic" => {
-            "languages" => {
-              "ruby" => {
-                "platform" => "centos",
-                "version" => "2.0.0",
-                "target" => "uno",
-              },
-            },
-          },
-        },
-        { "name" => "my-name-is-butters",
-          "chef_environment" => "moon",
-          "platform" => "rhel",
-          "run_list" => [],
-          "automatic" => {
-            "languages" => {
-              "ruby" => {
-                "platform" => "solaris2",
-                "version" => "2.1.2",
-                "target" => "random",
-              },
-            },
-          },
-        },
-      ],
-      "start" => 0,
-      "total" => 4,
-    }
-    end
-
-    let(:big_response_empty) do
-      {
-        "start" => 0,
-        "total" => 8,
-        "rows" => [],
-      }
-    end
-
-    let(:big_response_end) do
-      r = response.dup
-      r["start"] = 4
-      r["total"] = 8
-      r
-    end
-
-    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({}) }.to raise_error(Chef::Exceptions::InvalidSearchQuery, /(Hash)/)
-    end
-
-    it "queries for every object of a type by default" do
-      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&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&rows=#{default_rows}").and_return(response)
-      query.search(:node, "platform:rhel", start: 2)
-    end
-
-    it "lets you set how many rows to return" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=0&rows=40").and_return(response)
-      query.search(:node, "platform:rhel", rows: 40)
-    end
-
-    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 "returns the raw rows, start, and total if no block is passed" do
-      rows, start, total = query.search(:node)
-      expect(rows).to equal(response["rows"])
-      expect(start).to equal(response["start"])
-      expect(total).to equal(response["total"])
-    end
-
-    it "calls a block for each object in the response" do
-      @call_me = double("blocky")
-      response["rows"].each { |r| expect(@call_me).to receive(:do).with(Chef::Node.from_hash(r)) }
-      query.search(:node) { |r| @call_me.do(r) }
-    end
-
-    it "pages through the responses" do
-      @call_me = double("blocky")
-      response["rows"].each { |r| expect(@call_me).to receive(:do).with(Chef::Node.from_hash(r)) }
-      query.search(:node, "*:*", start: 0, rows: 4) { |r| @call_me.do(r) }
-    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
-    end
-
-    it "paginates correctly in the face of filtered nodes" do
-      expect(rest).to receive(:get).with(query_string_with_rows).and_return(big_response_empty)
-      expect(rest).to receive(:get).with(query_string_continue_with_rows).and_return(big_response_end)
-      query.search(:node, "platform:rhel", rows: 4) do |r|
-        nil
-      end
-    end
-
-    it "fuzzifies node searches when fuzz is set and type is a symbol" 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&rows=#{default_rows}"
-      ).and_return(response)
-      query.search(:node, "free.messi", fuzz: true)
-    end
-
-    it "fuzzifies node searches when fuzz is set and type is a string" 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&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&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&rows=#{default_rows}"
-      ).and_return(response)
-      query.search(:client, "messi", fuzz: true)
-    end
-
-    context "when :filter_result is provided as a result" do
-      include_context "filtered search" do
-        let(:filter_key) { :filter_result }
-
-        before(:each) do
-          expect(rest).to receive(:post).with(query_string, args[filter_key]).and_return(response)
-        end
-
-        it "returns start" do
-          start = query.search(:node, "platform:rhel", args)[1]
-          expect(start).to eq(response["start"])
-        end
-
-        it "returns total" do
-          total = query.search(:node, "platform:rhel", args)[2]
-          expect(total).to eq(response["total"])
-        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
-    end
-  end
-
-end

data/spec/unit/secret_fetcher/akeyless_vault_spec.rb

@@ -1,37 +0,0 @@
-#
-# Author:: Marc Paradise <marc@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_relative "../../spec_helper"
-require "chef/secret_fetcher/akeyless_vault"
-
-describe Chef::SecretFetcher::AKeylessVault do
-  let(:node) { {} }
-  let(:run_context) { double("run_context", node: node) }
-
-  context "when validating provided AKeyless Vault configuration" do
-    it "raises ConfigurationInvalid when :secret_access_key is not provided" do
-      fetcher = Chef::SecretFetcher::AKeylessVault.new( { access_id: "provided" }, run_context)
-      expect { fetcher.validate! }.to raise_error(Chef::Exceptions::Secret::ConfigurationInvalid, /:secret_access_key/)
-    end
-
-    it "raises ConfigurationInvalid when :access_key_id is not provided" do
-      fetcher = Chef::SecretFetcher::AKeylessVault.new( { access_key: "provided" }, run_context)
-      expect { fetcher.validate! }.to raise_error(Chef::Exceptions::Secret::ConfigurationInvalid, /:access_key_id/)
-    end
-  end
-end

data/spec/unit/secret_fetcher/aws_secrets_manager_spec.rb

@@ -1,70 +0,0 @@
-#
-# Author:: Marc Paradise <marc@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_relative "../../spec_helper"
-require "chef/secret_fetcher/aws_secrets_manager"
-
-describe Chef::SecretFetcher::AWSSecretsManager do
-  let(:node) { {} }
-  let(:aws_global_config) { {} }
-  let(:fetcher_config) { {} }
-  let(:run_context) { double("run_context", node: node) }
-  let(:fetcher) {
-    Chef::SecretFetcher::AWSSecretsManager.new( fetcher_config, run_context )
-  }
-
-  before do
-    allow(Aws).to receive(:config).and_return(aws_global_config)
-  end
-
-  context "when region is provided" do
-    let(:fetcher_config) { { region: "region-from-caller" } }
-    it "uses the provided region" do
-      fetcher.validate!
-      expect(fetcher.config[:region]).to eq "region-from-caller"
-    end
-  end
-
-  context "when region is not provided" do
-    context "and no region exists in AWS config or node attributes" do
-      it "raises a ConfigurationInvalid error" do
-        expect { fetcher.validate! }.to raise_error Chef::Exceptions::Secret::ConfigurationInvalid
-      end
-    end
-
-    context "and region exists in AWS config and node attributes" do
-      let(:aws_global_config)  { { region: "region-from-aws-global-config" } }
-      let(:node) { { "ec2" => { "region" => "region-from-ohai-data" } } }
-      it "uses the region from AWS config" do
-        fetcher.validate!
-        expect(fetcher.config[:region]).to eq "region-from-aws-global-config"
-      end
-    end
-
-    context "and region exists only in node attributes" do
-      let(:node) { { "ec2" => { "region" => "region-from-ohai-data" } } }
-      it "uses the region from AWS config" do
-        fetcher.validate!
-        expect(fetcher.config[:region]).to eq "region-from-ohai-data"
-      end
-
-    end
-
-  end
-end