chef 18.8.11 → 18.8.54

data/spec/unit/decorator/lazy_array_spec.rb

@@ -1,58 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@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::Decorator::LazyArray do
-  def foo
-    @foo ||= 1
-  end
-
-  def bar
-    @bar ||= 2
-  end
-
-  let(:decorator) do
-    Chef::Decorator::LazyArray.new { [ foo, bar ] }
-  end
-
-  it "behaves like an array" do
-    expect(decorator[0]).to eql(1)
-    expect(decorator[1]).to eql(2)
-  end
-
-  it "accessing the array elements is lazy" do
-    expect(decorator[0].class).to eql(Chef::Decorator::Lazy)
-    expect(decorator[1].class).to eql(Chef::Decorator::Lazy)
-    expect(@foo).to be nil
-    expect(@bar).to be nil
-  end
-
-  it "calling a method on the array element runs the proc (and both elements are autovivified)" do
-    expect(decorator[0].nil?).to be false
-    expect(@foo).to equal(1)
-    expect(@bar).to equal(2)
-  end
-
-  it "if we loop over the elements and do nothing then its not lazy" do
-    # we don't know how many elements there are unless we evaluate the proc
-    decorator.each { |i| }
-    expect(@foo).to equal(1)
-    expect(@bar).to equal(2)
-  end
-end

data/spec/unit/decorator/lazy_spec.rb

@@ -1,39 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@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::Decorator::Lazy do
-  let(:decorator) do
-    @a = 0
-    Chef::Decorator::Lazy.new { @a += 1 }
-  end
-
-  it "decorates an object" do
-    expect(decorator.even?).to be false
-  end
-
-  it "the proc runs and does work" do
-    expect(decorator).to eql(1)
-  end
-
-  it "creating the decorator does not cause the proc to run" do
-    decorator
-    expect(@a).to eql(0)
-  end
-end

data/spec/unit/decorator_spec.rb

@@ -1,142 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@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::Decorator do
-  def self.impersonates_a(klass)
-    it "#is_a?(#{klass}) is true" do
-      expect(decorator.is_a?(klass)).to be true
-    end
-
-    it "#is_a?(Chef::Decorator) is true" do
-      expect(decorator.is_a?(Chef::Decorator)).to be true
-    end
-
-    it "#kind_of?(#{klass}) is true" do
-      expect(decorator.is_a?(klass)).to be true
-    end
-
-    it "#kind_of?(Chef::Decorator) is true" do
-      expect(decorator.is_a?(Chef::Decorator)).to be true
-    end
-
-    it "#instance_of?(#{klass}) is false" do
-      expect(decorator.instance_of?(klass)).to be false
-    end
-
-    it "#instance_of?(Chef::Decorator) is true" do
-      expect(decorator.instance_of?(Chef::Decorator)).to be true
-    end
-
-    it "#class is Chef::Decorator" do
-      expect(decorator.class).to eql(Chef::Decorator)
-    end
-  end
-
-  let(:obj) {}
-  let(:decorator) { Chef::Decorator.new(obj) }
-
-  context "when the obj is a string" do
-    let(:obj) { "STRING" }
-
-    impersonates_a(String)
-
-    it "#nil? is false" do
-      expect(decorator.nil?).to be false
-    end
-
-    it "!! is true" do
-      expect(!!decorator).to be true
-    end
-
-    it "dup returns a decorator" do
-      expect(decorator.dup.class).to be Chef::Decorator
-    end
-
-    it "dup dup's the underlying thing" do
-      expect(decorator.dup.__getobj__).not_to equal(decorator.__getobj__)
-    end
-  end
-
-  context "when the obj is a nil" do
-    let(:obj) { nil }
-
-    it "#nil? is true" do
-      expect(decorator.nil?).to be true
-    end
-
-    it "!! is false" do
-      expect(!!decorator).to be false
-    end
-
-    impersonates_a(NilClass)
-  end
-
-  context "when the obj is an empty Hash" do
-    let(:obj) { {} }
-
-    impersonates_a(Hash)
-
-    it "formats it correctly through ffi-yajl and not the JSON gem" do
-      # this relies on a quirk of pretty formatting whitespace between yajl and ruby's JSON
-      expect(FFI_Yajl::Encoder.encode(decorator, pretty: true)).to eql("{\n\n}\n")
-    end
-  end
-
-  context "whent he obj is a Hash with elements" do
-    let(:obj) { { foo: "bar", baz: "qux" } }
-
-    impersonates_a(Hash)
-
-    it "dup is shallow on the Hash" do
-      expect(decorator.dup[:baz]).to equal(decorator[:baz])
-    end
-
-    it "deep mutating the dup'd hash mutates the origin" do
-      decorator.dup[:baz] << "qux"
-      expect(decorator[:baz]).to eql("quxqux")
-    end
-  end
-
-  context "memoizing methods" do
-    let(:obj) { {} }
-
-    it "calls method_missing only once" do
-      expect(decorator).to receive(:method_missing).once.and_call_original
-      expect(decorator.keys).to eql([])
-      expect(decorator.keys).to eql([])
-    end
-
-    it "switching a Hash to an Array responds to keys then does not" do
-      expect(decorator.respond_to?(:keys)).to be true
-      expect(decorator.keys).to eql([])
-      decorator.__setobj__([])
-      expect(decorator.respond_to?(:keys)).to be false
-      expect { decorator.keys }.to raise_error(NoMethodError)
-    end
-
-    it "memoization of methods happens on the instances, not the classes" do
-      decorator2 = Chef::Decorator.new([])
-      expect(decorator.respond_to?(:keys)).to be true
-      expect(decorator.keys).to eql([])
-      expect(decorator2.respond_to?(:keys)).to be false
-      expect { decorator2.keys }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/unit/delayed_evaluator_spec.rb

@@ -1,35 +0,0 @@
-#
-# Copyright:: Copyright (c) Progress 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::DelayedEvaluator do
-  let(:magic) { "This is magic!" }
-  let(:de) { Chef::DelayedEvaluator.new { magic } }
-
-  describe "#inspect" do
-    it "inspects the result rather than the Proc" do
-      expect(de.inspect).to eq("lazy { (evaluates to) #{magic.inspect} }")
-    end
-  end
-
-  describe "#call" do
-    it "evaluates correctly" do
-      expect(de.call).to eq(magic)
-    end
-  end
-end

data/spec/unit/deprecated_spec.rb

@@ -1,65 +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/deprecated"
-
-describe Chef::Deprecated do
-  class TestDeprecation < Chef::Deprecated::Base
-    target 999, "test"
-  end
-
-  context "loading a deprecation class" do
-    it "loads the correct class" do
-      expect(Chef::Deprecated.create(:test_deprecation, nil, nil)).to be_an_instance_of(TestDeprecation)
-    end
-
-    it "sets a message" do
-      deprecation = Chef::Deprecated.create(:test_deprecation, "A test message", nil)
-      expect(deprecation.message).to eql("A test message")
-    end
-
-    it "sets the location" do
-      deprecation = Chef::Deprecated.create(:test_deprecation, nil, "A test location")
-      expect(deprecation.location).to eql("A test location")
-    end
-  end
-
-  context "formatting deprecation warnings" do
-    let(:message) { "A test message" }
-    let(:location) { "the location" }
-
-    it "displays the full URL" do
-      expect(TestDeprecation.new.url).to eql("https://docs.chef.io/deprecations_test/")
-    end
-
-    it "formats a complete deprecation message" do
-      expect(TestDeprecation.new(message, location).to_s).to eql("Deprecation CHEF-999 from the location\n\n  A test message\n\nPlease see https://docs.chef.io/deprecations_test/ for further details and information on how to correct this problem.")
-    end
-  end
-
-  it "has no overlapping deprecation IDs" do
-    id_map = {}
-    ObjectSpace.each_object(Class).select { |cls| cls < Chef::Deprecated::Base }.each do |cls|
-      (id_map[cls.deprecation_id] ||= []) << cls
-    end
-    collisions = id_map.select { |k, v| v.size != 1 }
-    unless collisions.empty?
-      raise "Found deprecation ID collisions:\n#{collisions.map { |k, v| "* #{k} #{v.map(&:name).join(", ")}" }.join("\n")}"
-    end
-  end
-end

data/spec/unit/deprecation_spec.rb

@@ -1,129 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@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/deprecation/warnings"
-
-describe Chef::Deprecation do
-
-  # Support code for Chef::Deprecation
-
-  def self.class_from_string(str)
-    str.split("::").inject(Object) do |mod, class_name|
-      mod.const_get(class_name)
-    end
-  end
-
-  module DeprecatedMethods
-    def deprecated_method(value)
-      @value = value
-    end
-
-    def get_value
-      @value
-    end
-  end
-
-  class TestClass
-    extend Chef::Deprecation::Warnings
-    include DeprecatedMethods
-    add_deprecation_warnings_for(DeprecatedMethods.instance_methods)
-  end
-
-  context "when Chef::Config[:treat_deprecation_warnings_as_errors] is off" do
-    before do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-    end
-
-    context "deprecation warning messages" do
-      it "should be enabled for deprecated methods" do
-        expect(Chef).to receive(:deprecated).with(:internal_api, /Method.*of 'TestClass'/)
-        TestClass.new.deprecated_method(10)
-      end
-    end
-
-    it "deprecated methods should still be called" do
-      test_instance = TestClass.new
-      test_instance.deprecated_method(10)
-      expect(test_instance.get_value).to eq(10)
-    end
-  end
-
-  it "should raise when deprecation warnings are treated as errors" do
-    # rspec should set this
-    expect(Chef::Config[:treat_deprecation_warnings_as_errors]).to be true
-    test_instance = TestClass.new
-    expect { test_instance.deprecated_method(10) }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
-  end
-
-  context "When a class has deprecated_attr, _reader and _writer" do
-    before(:context) do
-      class DeprecatedAttrTest
-        extend Chef::Mixin::Deprecation
-        def initialize
-          @a = @r = @w = 1
-        end
-        deprecated_attr :a, "a"
-        deprecated_attr_reader :r, "r"
-        deprecated_attr_writer :w, "w"
-      end
-    end
-
-    it "The deprecated_attr emits warnings" do
-      test = DeprecatedAttrTest.new
-      expect { test.a = 10 }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
-      expect { test.a }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
-    end
-
-    it "The deprecated_attr_writer emits warnings, and does not create a reader" do
-      test = DeprecatedAttrTest.new
-      expect { test.w = 10 }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
-      expect { test.w }.to raise_error(NoMethodError)
-    end
-
-    it "The deprecated_attr_reader emits warnings, and does not create a writer" do
-      test = DeprecatedAttrTest.new
-      expect { test.r = 10 }.to raise_error(NoMethodError)
-      expect { test.r }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
-    end
-
-    context "With deprecation warnings not throwing exceptions" do
-      before do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      end
-
-      it "The deprecated_attr can be written to and read from" do
-        test = DeprecatedAttrTest.new
-        test.a = 10
-        expect(test.a).to eq 10
-      end
-
-      it "The deprecated_attr_reader can be read from" do
-        test = DeprecatedAttrTest.new
-        expect(test.r).to eq 1
-      end
-
-      it "The deprecated_attr_writer can be written to" do
-        test = DeprecatedAttrTest.new
-        test.w = 10
-        expect(test.instance_eval { @w }).to eq 10
-      end
-    end
-  end
-
-end

data/spec/unit/digester_spec.rb

@@ -1,49 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# 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::Digester do
-  before(:each) do
-    @cache = Chef::Digester.instance
-  end
-
-  describe "when computing checksums of cookbook files and templates" do
-
-    it "proxies the class method checksum_for_file to the instance" do
-      expect(@cache).to receive(:checksum_for_file).with("a_file_or_a_fail")
-      Chef::Digester.checksum_for_file("a_file_or_a_fail")
-    end
-
-    it "computes a checksum of a file" do
-      fixture_file = CHEF_SPEC_DATA + "/checksum/random.txt"
-      expected = "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
-      expect(@cache.checksum_for_file(fixture_file)).to eq(expected)
-    end
-
-    it "generates a checksum from a non-file IO object" do
-      io = StringIO.new("riseofthemachines\nriseofthechefs\n")
-      expected_md5 = "0e157ac1e2dd73191b76067fb6b4bceb"
-      expect(@cache.generate_md5_checksum(io)).to eq(expected_md5)
-    end
-
-  end
-
-end

data/spec/unit/dsl/data_query_spec.rb

@@ -1,108 +0,0 @@
-#
-# Author:: Seth Falcon (<seth@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/dsl/data_query"
-
-class DataQueryDSLTester
-  include Chef::DSL::DataQuery
-end
-
-describe Chef::DSL::DataQuery do
-  let(:node) { {} }
-
-  let(:language) do
-    language = DataQueryDSLTester.new
-    allow(language).to receive(:node).and_return(@node)
-    language
-  end
-
-  describe "::data_bag" do
-    it "lists the items in a data bag" do
-      allow(Chef::DataBag).to receive(:load)
-        .with("bag_name")
-        .and_return("item_1" => "http://url_for/item_1", "item_2" => "http://url_for/item_2")
-      expect( language.data_bag("bag_name").sort ).to eql %w{item_1 item_2}
-    end
-  end
-
-  shared_examples_for "a data bag item" do
-    it "validates the name of the data bag you're trying to load an item from" do
-      expect { language.send(method_name, " %%^& ", "item_name") }.to raise_error(Chef::Exceptions::InvalidDataBagName)
-    end
-
-    it "validates the id of the data bag item you're trying to load" do
-      expect { language.send(method_name, "bag_name", " 987 (*&()") }.to raise_error(Chef::Exceptions::InvalidDataBagItemID)
-    end
-
-    it "validates that the id of the data bag item is not nil" do
-      expect { language.send(method_name, "bag_name", nil) }.to raise_error(Chef::Exceptions::InvalidDataBagItemID)
-    end
-  end
-
-  describe "::data_bag_item" do
-    let(:bag_name) { "bag_name" }
-
-    let(:item_name) { "item_name" }
-
-    let(:raw_data) do
-      {
-      "id" => item_name,
-      "greeting" => "hello",
-      "nested" => {
-        "a1" => [1, 2, 3],
-        "a2" => { "b1" => true },
-      },
-    }
-    end
-
-    let(:item) do
-      item = Chef::DataBagItem.new
-      item.data_bag(bag_name)
-      item.raw_data = raw_data
-      item
-    end
-
-    it "fetches a data bag item" do
-      allow( Chef::DataBagItem ).to receive(:load).with(bag_name, item_name).and_return(item)
-      expect( language.data_bag_item(bag_name, item_name) ).to eql item
-    end
-
-    include_examples "a data bag item" do
-      let(:method_name) { :data_bag_item }
-    end
-
-    context "when the item is encrypted" do
-      let(:secret) { "abc123SECRET" }
-      let(:enc_data_bag) { double("Chef::EncryptedDataBagItem") }
-
-      before do
-        allow( Chef::DataBagItem ).to receive(:load).with(bag_name, item_name).and_return(item)
-        expect(language).to receive(:encrypted?).and_return(true)
-        expect( Chef::EncryptedDataBagItem ).to receive(:load_secret).and_return(secret)
-      end
-
-      it "detects encrypted data bag" do
-        expect( Chef::EncryptedDataBagItem ).to receive(:new).with(raw_data, secret).and_return(enc_data_bag)
-        expect( Chef::Log ).to receive(:debug).with(/Data bag item looks encrypted/)
-        expect(language.data_bag_item(bag_name, item_name)).to eq(enc_data_bag)
-      end
-
-    end
-  end
-end