chef 18.8.11 → 18.8.46

data/spec/unit/dsl/registry_helper_spec.rb

@@ -1,52 +0,0 @@
-#
-# Author:: Prajakta Purohit (<prajakta@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 "chef/dsl/registry_helper"
-require "spec_helper"
-
-describe Chef::Resource::RegistryKey do
-
-  before(:all) do
-    events = Chef::EventDispatch::Dispatcher.new
-    node = Chef::Node.new
-    node.consume_external_attrs(OHAI_SYSTEM.data, {})
-    run_context = Chef::RunContext.new(node, {}, events)
-    @resource = Chef::Resource.new("foo", run_context)
-  end
-
-  context "tests registry dsl" do
-    it "resource can access registry_helper method registry_key_exists" do
-      expect(@resource.respond_to?(:registry_key_exists?)).to eq(true)
-    end
-    it "resource can access registry_helper method registry_get_values" do
-      expect(@resource.respond_to?(:registry_get_values)).to eq(true)
-    end
-    it "resource can access registry_helper method registry_has_subkey" do
-      expect(@resource.respond_to?(:registry_has_subkeys?)).to eq(true)
-    end
-    it "resource can access registry_helper method registry_get_subkeys" do
-      expect(@resource.respond_to?(:registry_get_subkeys)).to eq(true)
-    end
-    it "resource can access registry_helper method registry_value_exists" do
-      expect(@resource.respond_to?(:registry_value_exists?)).to eq(true)
-    end
-    it "resource can access registry_helper method data_value_exists" do
-      expect(@resource.respond_to?(:registry_data_exists?)).to eq(true)
-    end
-  end
-end

data/spec/unit/dsl/render_helpers_spec.rb

@@ -1,102 +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.
-#
-
-require "spec_helper"
-require "chef/dsl/render_helpers"
-
-describe Chef::DSL::RenderHelpers do
-
-  hash = {
-          "golf": "hotel",
-          "kilo": %w{lima mike},
-          "india": {
-                    "juliett": "blue",
-                   },
-          "alpha": {
-                    "charlie": true,
-                    "bravo": 10,
-                   },
-          "echo": "foxtrot",
-         }
-
-  context "render_json" do
-    json = Chef::DSL::RenderHelpers.render_json(hash)
-    describe "JSON content" do
-      it "expected JSON output" do
-        expected = <<-EXPECTED
-{
-  "golf": "hotel",
-  "kilo": [
-    "lima",
-    "mike"
-  ],
-  "india": {
-    "juliett": "blue"
-  },
-  "alpha": {
-    "charlie": true,
-    "bravo": 10
-  },
-  "echo": "foxtrot"
-}
-        EXPECTED
-        expect(json).to eq(expected)
-      end
-    end
-  end
-
-  context "render_toml" do
-    toml = Chef::DSL::RenderHelpers.render_toml(hash)
-    describe "TOML content" do
-      it "expected TOML output" do
-        expected = <<-EXPECTED
-echo = "foxtrot"
-golf = "hotel"
-kilo = ["lima", "mike"]
-[alpha]
-bravo = 10
-charlie = true
-[india]
-juliett = "blue"
-        EXPECTED
-        expect(toml).to eq(expected)
-      end
-    end
-  end
-
-  context "render_yaml" do
-    yaml = Chef::DSL::RenderHelpers.render_yaml(hash)
-    describe "YAML content" do
-      it "expected YAML output" do
-        expected = <<-EXPECTED
----
-golf: hotel
-kilo:
-- lima
-- mike
-india:
-  juliett: blue
-alpha:
-  charlie: true
-  bravo: 10
-echo: foxtrot
-        EXPECTED
-        expect(yaml).to eq(expected)
-      end
-    end
-  end
-end

data/spec/unit/dsl/resources_spec.rb

@@ -1,85 +0,0 @@
-#
-# Author:: Noah Kantrowitz (<noah@coderanger.net>)
-# Copyright:: Copyright 2015-2016, Noah Kantrowitz
-# 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/dsl/resources"
-
-describe Chef::DSL::Resources do
-  let(:declared_resources) { [] }
-  let(:test_class) do
-    r = declared_resources
-    Class.new do
-      include Chef::DSL::Resources
-      define_method(:declare_resource) do |dsl_name, name, _created_at|
-        r << [dsl_name, name]
-      end
-    end
-  end
-  subject { declared_resources }
-  after do
-    # Always clean up after ourselves.
-    described_class.remove_resource_dsl(:test_resource)
-  end
-
-  context "with a resource added" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-    it { is_expected.to eq [[:test_resource, "test_name"]] }
-  end
-
-  context "with no resource added" do
-    subject do
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-
-    it { expect { subject }.to raise_error NoMethodError }
-  end
-
-  context "with a resource added and removed" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      Chef::DSL::Resources.remove_resource_dsl(:test_resource)
-    end
-    subject do
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-
-    it { expect { subject }.to raise_error NoMethodError }
-  end
-
-  context "with a nameless resource" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      test_class.new.instance_eval do
-        test_resource {}
-      end
-    end
-    it { is_expected.to eq [[:test_resource, nil]] }
-  end
-end

data/spec/unit/dsl/secret_spec.rb

@@ -1,175 +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 "spec_helper"
-require "chef/exceptions"
-require "chef/dsl/secret"
-require "chef/secret_fetcher/base"
-
-class SecretDSLTester
-  include Chef::DSL::Secret
-
-  # Because DSL is invoked in the context of a recipe or attribute file
-  # we expect run_context to always be available when SecretFetcher::Base
-  # requests it - making it safe to mock here
-  def run_context
-    nil
-  end
-end
-
-class SecretFetcherImpl < Chef::SecretFetcher::Base
-  def do_fetch(name, version)
-    name
-  end
-end
-
-describe Chef::DSL::Secret do
-  let(:dsl) { SecretDSLTester.new }
-  let(:run_context) { Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new) }
-
-  before do
-    allow(dsl).to receive(:run_context).and_return(run_context)
-  end
-
-  %w{
-      secret
-      default_secret_service
-      default_secret_config
-      with_secret_service
-      with_secret_config
-    }.each do |m|
-      it "responds to ##{m}" do
-        expect(dsl.respond_to?(m)).to eq true
-      end
-    end
-
-  describe "#default_secret_service" do
-    let(:service) { :hashi_vault }
-
-    it "persists the service passed in as an argument" do
-      expect(dsl.default_secret_service).to eq(nil)
-      dsl.default_secret_service(service)
-      expect(dsl.default_secret_service).to eq(service)
-    end
-
-    it "returns run_context.default_secret_service value when no argument is given" do
-      run_context.default_secret_service = :my_thing
-      expect(dsl.default_secret_service).to eq(:my_thing)
-    end
-
-    it "raises exception when service given is not valid" do
-      stub_const("Chef::SecretFetcher::SECRET_FETCHERS", %i{service_a service_b})
-      expect { dsl.default_secret_service(:unknown_service) }.to raise_error(Chef::Exceptions::Secret::InvalidFetcherService)
-    end
-  end
-
-  describe "#with_secret_config" do
-    let(:service) { :hashi_vault }
-
-    it "sets the service for the scope of the block only" do
-      expect(dsl.default_secret_service).to eq(nil)
-      dsl.with_secret_service(service) do
-        expect(dsl.default_secret_service).to eq(service)
-      end
-      expect(dsl.default_secret_service).to eq(nil)
-    end
-
-    it "raises exception when block is not given" do
-      expect { dsl.with_secret_service(service) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#default_secret_config" do
-    let(:config) { { my_key: "value" } }
-
-    it "persists the config passed in as argument" do
-      expect(dsl.default_secret_config).to eq({})
-      dsl.default_secret_config(**config)
-      expect(dsl.default_secret_config).to eq(config)
-    end
-
-    it "returns run_context.default_secret_config value when no argument is given" do
-      run_context.default_secret_config = { my_thing: "that" }
-      expect(dsl.default_secret_config).to eq({ my_thing: "that" })
-    end
-  end
-
-  describe "#with_secret_config" do
-    let(:config) { { my_key: "value" } }
-
-    it "sets the config for the scope of the block only" do
-      expect(dsl.default_secret_config).to eq({})
-      dsl.with_secret_config(**config) do
-        expect(dsl.default_secret_config).to eq(config)
-      end
-      expect(dsl.default_secret_config).to eq({})
-    end
-
-    it "raises exception when block is not given" do
-      expect { dsl.with_secret_config(**config) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#secret" do
-    it "uses SecretFetcher.for_service to find the fetcher" do
-      substitute_fetcher = SecretFetcherImpl.new({}, nil)
-      expect(Chef::SecretFetcher).to receive(:for_service).with(:example, {}, run_context).and_return(substitute_fetcher)
-      expect(substitute_fetcher).to receive(:fetch).with("key1", nil)
-      dsl.secret(name: "key1", service: :example, config: {})
-    end
-
-    it "resolves a secret when using the example fetcher" do
-      secret_value = dsl.secret(name: "test1", service: :example, config: { "test1" => "secret value" })
-      expect(secret_value).to eq "secret value"
-    end
-
-    context "when used within a resource" do
-      let(:run_context) {
-        Chef::RunContext.new(Chef::Node.new,
-                             Chef::CookbookCollection.new(Chef::CookbookLoader.new(File.join(CHEF_SPEC_DATA, "cookbooks"))),
-                             Chef::EventDispatch::Dispatcher.new)
-      }
-
-      it "marks that resource as 'sensitive'" do
-        recipe = Chef::Recipe.new("secrets", "test", run_context)
-        recipe.zen_master "secret_test" do
-          peace secret(name: "test1", service: :example, config: { "test1" => true })
-        end
-        expect(run_context.resource_collection.lookup("zen_master[secret_test]").sensitive).to eql(true)
-      end
-    end
-
-    it "passes default service to SecretFetcher.for_service" do
-      service = :example
-      dsl.default_secret_service(service)
-      substitute_fetcher = SecretFetcherImpl.new({}, nil)
-      expect(Chef::SecretFetcher).to receive(:for_service).with(service, {}, run_context).and_return(substitute_fetcher)
-      allow(substitute_fetcher).to receive(:fetch).with("key1", nil)
-      dsl.secret(name: "key1")
-    end
-
-    it "passes default config to SecretFetcher.for_service" do
-      config = { my_config: "value" }
-      dsl.default_secret_config(**config)
-      substitute_fetcher = SecretFetcherImpl.new({}, nil)
-      expect(Chef::SecretFetcher).to receive(:for_service).with(:example, config, run_context).and_return(substitute_fetcher)
-      allow(substitute_fetcher).to receive(:fetch).with("key1", nil)
-      dsl.secret(name: "key1", service: :example)
-    end
-  end
-end

data/spec/unit/encrypted_data_bag_item/check_encrypted_spec.rb

@@ -1,97 +0,0 @@
-#
-# Author:: Tyler Ball (<tball@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/encrypted_data_bag_item/check_encrypted"
-
-class CheckEncryptedTester
-  include Chef::EncryptedDataBagItem::CheckEncrypted
-end
-
-describe Chef::EncryptedDataBagItem::CheckEncrypted do
-
-  let(:tester) { CheckEncryptedTester.new }
-
-  it "detects the item is not encrypted when the data is empty" do
-    expect(tester.encrypted?({})).to eq(false)
-  end
-
-  it "detects the item is not encrypted when the data only contains an id" do
-    expect(tester.encrypted?({ id: "foo" })).to eq(false)
-  end
-
-  context "when the item is encrypted" do
-
-    let(:default_secret) { "abc123SECRET" }
-    let(:item_name) { "item_name" }
-    let(:raw_data) do
-      {
-        "id" => item_name,
-        "greeting" => "hello",
-        "nested" => {
-            "a1" => [1, 2, 3],
-            "a2" => { "b1" => true },
-        },
-    }
-    end
-
-    let(:version) { 1 }
-    let(:encoded_data) do
-      Chef::Config[:data_bag_encrypt_version] = version
-      Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret)
-    end
-
-    it "does not detect encryption when the item version is unknown" do
-      # It shouldn't be possible for someone to normally encrypt an item with an unknown version - they would have to
-      # do something funky like encrypting it and then manually changing the version
-      modified_encoded_data = encoded_data
-      modified_encoded_data["greeting"]["version"] = 4
-      expect(tester.encrypted?(modified_encoded_data)).to eq(false)
-    end
-
-    shared_examples_for "encryption detected" do
-      it "detects encrypted data bag" do
-        expect( encryptor ).to receive(:encryptor_keys).at_least(:once).and_call_original
-        expect(tester.encrypted?(encoded_data)).to eq(true)
-      end
-    end
-
-    context "when encryption version is 1" do
-      include_examples "encryption detected" do
-        let(:version) { 1 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor }
-      end
-    end
-
-    context "when encryption version is 2" do
-      include_examples "encryption detected" do
-        let(:version) { 2 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor }
-      end
-    end
-
-    context "when encryption version is 3", :aes_256_gcm_only do
-      include_examples "encryption detected" do
-        let(:version) { 3 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor }
-      end
-    end
-
-  end
-
-end