chef 18.8.11 → 18.8.54

data/spec/unit/resource_collection_spec.rb

@@ -1,408 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Christopher Walters (<cw@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"
-
-describe Chef::ResourceCollection do
-  let(:rc) { Chef::ResourceCollection.new }
-  let(:resource) { Chef::Resource::ZenMaster.new("makoto") }
-
-  it "should throw an error when calling a non-delegated method" do
-    expect { rc.not_a_method }.to raise_error(NoMethodError)
-  end
-
-  describe "initialize" do
-    it "should return a Chef::ResourceCollection" do
-      expect(rc).to be_kind_of(Chef::ResourceCollection)
-    end
-  end
-
-  describe "[]" do
-    it "should accept Chef::Resources through [index]" do
-      expect { rc[0] = resource }.not_to raise_error
-      expect { rc[0] = "string" }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to fetch Chef::Resources by position" do
-      rc[0] = resource
-      expect(rc[0]).to eql(resource)
-    end
-  end
-
-  describe "push" do
-    it "should accept Chef::Resources through pushing" do
-      expect { rc.push(resource) }.not_to raise_error
-      expect { rc.push("string") }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "<<" do
-    it "should accept the << operator" do
-      expect { rc << resource }.not_to raise_error
-    end
-  end
-
-  describe "insert" do
-    it "should accept only Chef::Resources" do
-      expect { rc.insert(resource) }.not_to raise_error
-      expect { rc.insert("string") }.to raise_error(ArgumentError)
-    end
-
-    it "should accept named arguments in any order" do
-      rc.insert(resource, instance_name: "foo", resource_type: "bar")
-      expect(rc[0]).to eq(resource)
-    end
-
-    it "should append resources to the end of the collection when not executing a run" do
-      zmr = Chef::Resource::ZenMaster.new("there is no spoon")
-      rc.insert(resource)
-      rc.insert(zmr)
-      expect(rc[0]).to eql(resource)
-      expect(rc[1]).to eql(zmr)
-    end
-
-    it "should insert resources to the middle of the collection if called while executing a run" do
-      resource_to_inject = Chef::Resource::ZenMaster.new("there is no spoon")
-      zmr = Chef::Resource::ZenMaster.new("morpheus")
-      dummy = Chef::Resource::ZenMaster.new("keanu reeves")
-      rc.insert(zmr)
-      rc.insert(dummy)
-
-      rc.execute_each_resource do |resource|
-        rc.insert(resource_to_inject) if resource == zmr
-      end
-
-      expect(rc[0]).to eql(zmr)
-      expect(rc[1]).to eql(resource_to_inject)
-      expect(rc[2]).to eql(dummy)
-    end
-  end
-
-  describe "each" do
-    it "should allow you to iterate over every resource in the collection" do
-      load_up_resources
-      results = []
-      expect do
-        rc.each do |r|
-          results << r.name
-        end
-      end.not_to raise_error
-      results.each_index do |i|
-        case i
-        when 0
-          expect(results[i]).to eql("dog")
-        when 1
-          expect(results[i]).to eql("cat")
-        when 2
-          expect(results[i]).to eql("monkey")
-        end
-      end
-    end
-  end
-
-  describe "each_index" do
-    it "should allow you to iterate over every resource by index" do
-      load_up_resources
-      results = []
-      expect do
-        rc.each_index do |i|
-          results << rc[i].name
-        end
-      end.not_to raise_error
-      results.each_index do |i|
-        case i
-        when 0
-          expect(results[i]).to eql("dog")
-        when 1
-          expect(results[i]).to eql("cat")
-        when 2
-          expect(results[i]).to eql("monkey")
-        end
-      end
-    end
-  end
-
-  describe "lookup" do
-    it "should allow you to find resources by name via lookup" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      rc << zmr
-      expect(rc.lookup(zmr.to_s)).to eql(zmr)
-
-      zmr = Chef::Resource::ZenMaster.new("cat")
-      rc[0] = zmr
-      expect(rc.lookup(zmr)).to eql(zmr)
-
-      zmr = Chef::Resource::ZenMaster.new("monkey")
-      rc.push(zmr)
-      expect(rc.lookup(zmr)).to eql(zmr)
-    end
-
-    it "should raise an exception if you send something strange to lookup" do
-      expect { rc.lookup(:symbol) }.to raise_error(ArgumentError)
-    end
-
-    it "should raise an exception if it cannot find a resource with lookup" do
-      expect { rc.lookup("zen_master[dog]") }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-  end
-
-  describe "delete" do
-    it "should allow you to delete resources by name via delete" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      rc << zmr
-      expect(rc).not_to be_empty
-      expect(rc.delete(zmr.to_s)).to eql(zmr)
-      expect(rc).to be_empty
-
-      zmr = Chef::Resource::ZenMaster.new("cat")
-      rc[0] = zmr
-      expect(rc).not_to be_empty
-      expect(rc.delete(zmr)).to eql(zmr)
-      expect(rc).to be_empty
-
-      zmr = Chef::Resource::ZenMaster.new("monkey")
-      rc.push(zmr)
-      expect(rc).not_to be_empty
-      expect(rc.delete(zmr)).to eql(zmr)
-      expect(rc).to be_empty
-    end
-
-    it "should allow to delete resources with different providers" do
-      pkg = Chef::Resource::YumPackage.new("monkey")
-      rc.insert(pkg, instance_name: "monkey", resource_type: "package")
-      expect(rc).not_to be_empty
-      expect(rc.delete("package[monkey]")).to eql(pkg)
-      expect(rc).to be_empty
-    end
-
-    it "should raise an exception if you send something strange to delete" do
-      expect { rc.delete(:symbol) }.to raise_error(ArgumentError)
-    end
-
-    it "should raise an exception if it cannot find a resource with delete" do
-      expect { rc.delete("zen_master[dog]") }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-  end
-
-  describe "resources" do
-
-    it "should find a resource by symbol and name (:zen_master => monkey)" do
-      load_up_resources
-      expect(rc.resources(zen_master: "monkey").name).to eql("monkey")
-    end
-
-    it "should find a resource by symbol and array of names (:zen_master => [a,b])" do
-      load_up_resources
-      results = rc.resources(zen_master: %w{monkey dog})
-      expect(results.length).to eql(2)
-      check_by_names(results, "monkey", "dog")
-    end
-
-    it "should find resources of multiple kinds (:zen_master => a, :file => b)" do
-      load_up_resources
-      results = rc.resources(zen_master: "monkey", file: "something")
-      expect(results.length).to eql(2)
-      check_by_names(results, "monkey", "something")
-    end
-
-    it "should find a resource by string zen_master[a]" do
-      load_up_resources
-      expect(rc.resources("zen_master[monkey]").name).to eql("monkey")
-    end
-
-    it "should find resources by strings of zen_master[a,b]" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      load_up_resources
-      results = rc.resources("zen_master[monkey,dog]")
-      expect(results.length).to eql(2)
-      check_by_names(results, "monkey", "dog")
-    end
-
-    it "should find resources of multiple types by strings of zen_master[a]" do
-      load_up_resources
-      results = rc.resources("zen_master[monkey]", "file[something]")
-      expect(results.length).to eql(2)
-      check_by_names(results, "monkey", "something")
-    end
-
-    it "should raise an exception if you pass a bad name to resources" do
-      expect { rc.resources("michael jackson") }.to raise_error(ArgumentError)
-    end
-
-    it "should raise an exception if you pass something other than a string or hash to resource" do
-      expect { rc.resources([[]]) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an error when attempting to find a resource that does not exist" do
-      expect { rc.find("script[nonesuch]") }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-
-  end
-
-  describe "when validating a resource query object" do
-    it "accepts a string of the form 'resource_type[resource_name]'" do
-      expect(rc.validate_lookup_spec!("resource_type[resource_name]")).to be_truthy
-    end
-
-    it "accepts a single-element :resource_type => 'resource_name' Hash" do
-      expect(rc.validate_lookup_spec!(service: "apache2")).to be_truthy
-    end
-
-    it "accepts a chef resource object" do
-      res = Chef::Resource.new("foo", nil)
-      expect(rc.validate_lookup_spec!(res)).to be_truthy
-    end
-
-    it "rejects a malformed query string" do
-      expect do
-        rc.validate_lookup_spec!("resource_type[missing-end-bracket")
-      end.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
-    end
-
-    it "rejects an argument that is not a String, Hash, or Chef::Resource" do
-      expect do
-        rc.validate_lookup_spec!(Object.new)
-      end.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
-    end
-
-  end
-
-  describe "to_json" do
-    it "should serialize to json" do
-      json = rc.to_json
-      expect(json).to match(/json_class/)
-      expect(json).to match(/instance_vars/)
-    end
-
-    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { rc }
-    end
-  end
-
-  describe "self.from_json" do
-    it "should not respond to this method" do
-      expect(rc.respond_to?(:from_json)).to eq(false)
-    end
-
-    it "should convert from json using the Chef::JSONCompat library" do
-      rc << resource
-      json = Chef::JSONCompat.to_json(rc)
-      s_rc = Chef::ResourceCollection.from_json(json)
-      expect(s_rc).to be_a_kind_of(Chef::ResourceCollection)
-      expect(s_rc[0].name).to eql(resource.name)
-    end
-  end
-
-  describe "provides access to the raw resources array" do
-    it "returns the resources via the all_resources method" do
-      expect(rc.all_resources).to equal(rc.instance_variable_get(:@resource_list).instance_variable_get(:@resources))
-    end
-  end
-
-  describe "provides access to stepable iterator" do
-    it "returns the iterator object" do
-      rc.instance_variable_get(:@resource_list).instance_variable_set(:@iterator, :fooboar)
-      expect(rc.iterator).to eq(:fooboar)
-    end
-  end
-
-  describe "multiple run_contexts" do
-    let(:node) { Chef::Node.new }
-    let(:parent_run_context) { Chef::RunContext.new(node, {}, nil) }
-    let(:parent_resource_collection) { parent_run_context.resource_collection }
-    let(:child_run_context) { parent_run_context.create_child }
-    let(:child_resource_collection) { child_run_context.resource_collection }
-
-    it "should find resources in the parent run_context with lookup" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      parent_resource_collection << zmr
-      expect(child_resource_collection.lookup(zmr.to_s)).to eql(zmr)
-    end
-
-    it "should not find resources in the parent run_context with lookup_local" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      parent_resource_collection << zmr
-      expect { child_resource_collection.lookup_local(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-
-    it "should find resources in the child run_context with lookup_local" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      child_resource_collection << zmr
-      expect(child_resource_collection.lookup_local(zmr.to_s)).to eql(zmr)
-    end
-
-    it "should find resources in the parent run_context with find" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      parent_resource_collection << zmr
-      expect(child_resource_collection.find(zmr.to_s)).to eql(zmr)
-    end
-
-    it "should not find resources in the parent run_context with find_local" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      parent_resource_collection << zmr
-      expect { child_resource_collection.find_local(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-
-    it "should find resources in the child run_context with find_local" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      child_resource_collection << zmr
-      expect(child_resource_collection.find_local(zmr.to_s)).to eql(zmr)
-    end
-
-    it "should not find resources in the child run_context in any way from the parent" do
-      zmr = Chef::Resource::ZenMaster.new("dog")
-      child_resource_collection << zmr
-      expect { parent_resource_collection.find_local(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-      expect { parent_resource_collection.find(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-      expect { parent_resource_collection.lookup_local(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-      expect { parent_resource_collection.lookup(zmr.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-
-    it "should behave correctly when there is an identically named resource in the child and parent" do
-      a = Chef::Resource::File.new("something")
-      a.content("foo")
-      parent_resource_collection << a
-      b = Chef::Resource::File.new("something")
-      b.content("bar")
-      child_resource_collection << b
-      expect(child_resource_collection.find_local("file[something]").content).to eql("bar")
-      expect(child_resource_collection.find("file[something]").content).to eql("bar")
-      expect(child_resource_collection.lookup_local("file[something]").content).to eql("bar")
-      expect(child_resource_collection.lookup("file[something]").content).to eql("bar")
-      expect(parent_resource_collection.find_local("file[something]").content).to eql("foo")
-      expect(parent_resource_collection.find("file[something]").content).to eql("foo")
-      expect(parent_resource_collection.lookup_local("file[something]").content).to eql("foo")
-      expect(parent_resource_collection.lookup("file[something]").content).to eql("foo")
-    end
-  end
-
-  def check_by_names(results, *names)
-    names.each do |res_name|
-      expect(results.detect { |res| res.name == res_name }).not_to eql(nil)
-    end
-  end
-
-  def load_up_resources
-    %w{dog cat monkey}.each do |n|
-      rc << Chef::Resource::ZenMaster.new(n)
-    end
-    rc << Chef::Resource::File.new("something")
-  end
-
-end

data/spec/unit/resource_definition_spec.rb

@@ -1,117 +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"
-
-describe Chef::ResourceDefinition do
-  let(:defn) { Chef::ResourceDefinition.new }
-
-  describe "initialize" do
-    it "should be a Chef::ResourceDefinition" do
-      expect(defn).to be_a_kind_of(Chef::ResourceDefinition)
-    end
-
-    it "should not initialize a new node if one is not provided" do
-      expect(defn.node).to eql(nil)
-    end
-
-    it "should accept a node as an argument" do
-      node = Chef::Node.new
-      node.name("bobo")
-      defn = Chef::ResourceDefinition.new(node)
-      expect(defn.node.name).to eq("bobo")
-    end
-  end
-
-  describe "node" do
-    it "should set the node with node=" do
-      node = Chef::Node.new
-      node.name("bobo")
-      defn.node = node
-      expect(defn.node.name).to eq("bobo")
-    end
-
-    it "should return the node" do
-      defn.node = Chef::Node.new
-      expect(defn.node).to be_a_kind_of(Chef::Node)
-    end
-  end
-
-  it "should accept a new definition with a symbol for a name" do
-    expect do
-      defn.define :smoke do
-      end
-    end.not_to raise_error
-    expect do
-      defn.define "george washington" do
-      end
-    end.to raise_error(ArgumentError)
-    expect(defn.name).to eql(:smoke)
-  end
-
-  it "should accept a new definition with a hash" do
-    expect do
-      defn.define :smoke, cigar: "cuban", cigarette: "marlboro" do
-      end
-    end.not_to raise_error
-  end
-
-  it "should expose the prototype hash params in the params hash" do
-    defn.define(:smoke, cigar: "cuban", cigarette: "marlboro") {}
-    expect(defn.params[:cigar]).to eql("cuban")
-    expect(defn.params[:cigarette]).to eql("marlboro")
-  end
-
-  it "should store the block passed to define as a proc under recipe" do
-    defn.define :smoke do
-      "I am what I am"
-    end
-    expect(defn.recipe).to be_a_kind_of(Proc)
-    expect(defn.recipe.call).to eql("I am what I am")
-  end
-
-  it "should set parameters based on method_missing" do
-    defn.mind "to fly"
-    expect(defn.params[:mind]).to eql("to fly")
-  end
-
-  it "should raise an exception if prototype_params is not a hash" do
-    expect do
-      defn.define :monkey, [] do
-      end
-    end.to raise_error(ArgumentError)
-  end
-
-  it "should raise an exception if define is called without a block" do
-    expect do
-      defn.define :monkey
-    end.to raise_error(ArgumentError)
-  end
-
-  it "should load a description from a file" do
-    defn.from_file(File.join(CHEF_SPEC_DATA, "definitions", "test.rb"))
-    expect(defn.name).to eql(:rico_suave)
-    expect(defn.params[:rich]).to eql("smooth")
-  end
-
-  it "should turn itself into a string based on the name with to_s" do
-    defn.name = :woot
-    expect(defn.to_s).to eql("woot")
-  end
-
-end

data/spec/unit/resource_inspector_spec.rb

@@ -1,101 +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/resource_inspector"
-
-COMBINED_RESOURCE_TEXT = <<~EOF.freeze
-  class Dummy1 < Chef::Resource::LWRPBase
-    resource_name :dummy1
-    description "A dummy resource"
-    property :first, String, description: "My First Property", introduced: "14.0"
-  end
-
-  class Dummy2 < Chef::Resource::LWRPBase
-    resource_name :dummy2
-    description "Another dummy resource"
-    property :second, String, description: "My Second Property", introduced: "14.0"
-  end
-EOF
-
-class DummyResource < Chef::Resource
-  resource_name :dummy
-  description "A dummy resource"
-  examples <<~EOH
-    dummy "foo" do
-      first "yes"
-    end
-  EOH
-  introduced "14.0"
-  property :first, String, description: "My First Property", introduced: "14.0"
-
-  action :dummy, description: "Dummy action" do
-    return true
-  end
-
-  action :dummy_no_desc do
-    return true
-  end
-end
-
-describe Chef::ResourceInspector do
-  describe "inspecting a resource" do
-    subject { Chef::ResourceInspector.extract_resource(DummyResource, false) }
-
-    it "returns a hash with required data" do
-      expect(subject[:description]).to eq "A dummy resource"
-      expect(subject[:actions]).to eq({ nothing: nil, dummy: "Dummy action",
-                                        dummy_no_desc: nil })
-    end
-
-    context "excluding built in properties" do
-      it "returns a single property" do
-        expect(subject[:properties].count).to eq 1
-        expect(subject[:properties].first[:name]).to eq :first
-      end
-    end
-
-    context "including built in properties" do
-      subject { Chef::ResourceInspector.extract_resource(DummyResource, true) }
-      it "returns many properties" do
-        expect(subject[:properties].count).to be > 1
-        expect(subject[:properties].map { |n| n[:name] }).to include(:name, :first, :sensitive)
-      end
-    end
-  end
-
-  describe "inspecting a multi-resource file" do
-    # Call the inspector with a fake file containing two resources, and ensure that we get
-    # both of them back!
-    subject {
-      Chef::ResourceInspector.load_from_resources([
-        { "full_path" => "/cookbooks/fake_cookbook/resources/big_resource.rb" },
-      ], false)
-    }
-    it "has elephants" do
-      allow(File).to receive(:file?).with("/cookbooks/fake_cookbook/resources/big_resource.rb").and_return(true)
-      allow(File).to receive(:readable?).with("/cookbooks/fake_cookbook/resources/big_resource.rb").and_return(true)
-      allow(IO).to receive(:read).with("/cookbooks/fake_cookbook/resources/big_resource.rb").and_return(COMBINED_RESOURCE_TEXT)
-      expect(subject.keys.count).to be 2
-      expect(subject.keys.sort).to eq(%i{dummy1 dummy2})
-      # This is correct - because they're not fully realised resources at this point, sensitive and friends are not added yet.
-      expect(subject[:dummy1][:properties].count).to be 1
-      expect(subject[:dummy2][:properties].count).to be 1
-      expect(subject[:dummy1][:properties][0][:description]).to eq "My First Property"
-      expect(subject[:dummy2][:properties][0][:description]).to eq "My Second Property"
-    end
-  end
-end