chef-utils 18.0.172 → 18.0.185

data/spec/unit/dsl/which_spec.rb

@@ -1,171 +1,171 @@
-# frozen_string_literal: true
-#
-# 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"
-
-RSpec.describe ChefUtils::DSL::Which do
-
-  class WhichTestClass
-    include ChefUtils::DSL::Which
-  end
-
-  let(:test) { WhichTestClass.new }
-
-  describe "#which" do
-    def self.test_which(description, *args, path: ["/dir1", "/dir2" ].join(File::PATH_SEPARATOR), finds: nil, others: [], directory: false, &block)
-      it description do
-        # stub the ENV['PATH']
-        expect(ENV).to receive(:[]).with("PATH").and_return(path)
-        expect(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
-
-        # most files should not be found
-        allow(File).to receive(:executable?).and_return(false)
-        allow(File).to receive(:directory?).and_return(false)
-
-        # stub the expectation
-        expect(File).to receive(:executable?).with(finds).and_return(true) if finds
-
-        # if the file we find is a directory
-        expect(File).to receive(:directory?).with(finds).and_return(true) if finds && directory
-
-        # allow for stubbing other paths to exist that we should not find
-        others.each do |other|
-          allow(File).to receive(:executable?).with(other).and_return(true)
-        end
-
-        # setup the actual expectation on the return value
-        if finds && !directory
-          expect(test.which(*args, &block)).to eql(finds)
-        else
-          expect(test.which(*args, &block)).to eql(false)
-        end
-      end
-    end
-
-    context "simple usage" do
-      test_which("returns false when it does not find anything", "foo1")
-
-      ["/dir1", "/dir2" ].each do |dir|
-        test_which("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: "#{dir}/foo1")
-      end
-
-      test_which("does not find an executable directory", "foo1", finds: "/dir1/foo1", directory: true)
-    end
-
-    context "with an array of args" do
-      test_which("finds the first arg", "foo1", "foo2", finds: "/dir2/foo1")
-
-      test_which("finds the second arg", "foo1", "foo2", finds: "/dir2/foo2")
-
-      test_which("finds the first arg when there's both", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ])
-
-      test_which("and the directory order can be reversed", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir2/foo2" ])
-
-      test_which("or be the same", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir1/foo2" ])
-    end
-
-    context "with a block" do
-      test_which("doesn't find it if its false", "foo1", others: [ "/dir1/foo1" ]) do |f|
-        false
-      end
-
-      test_which("finds it if its true", "foo1", finds: "/dir1/foo1") do |f|
-        true
-      end
-
-      test_which("passes in the filename as the arg", "foo1", finds: "/dir1/foo1") do |f|
-        raise "bad arg to block" unless f == "/dir1/foo1"
-
-        true
-      end
-
-      test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
-        raise "bad arg to block" unless ["/dir2/foo1", "/dir1/foo2"].include?(f)
-
-        true
-      end
-    end
-
-    context "nil path" do
-      test_which("returns false when it does not find anything", "foo1", path: nil)
-    end
-  end
-
-  describe "#where" do
-    def self.test_where(description, *args, path: ["/dir1", "/dir2" ].join(File::PATH_SEPARATOR), finds: [], others: [], &block)
-      it description do
-        # stub the ENV['PATH']
-        expect(ENV).to receive(:[]).with("PATH").and_return(path)
-        expect(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
-
-        # most files should not be found
-        allow(File).to receive(:executable?).and_return(false)
-        allow(File).to receive(:directory?).and_return(false)
-
-        # allow for stubbing other paths to exist that we should not return
-        others.each do |other|
-          allow(File).to receive(:executable?).with(other).and_return(true)
-        end
-
-        # stub the expectation
-        finds.each do |path|
-          expect(File).to receive(:executable?).with(path).and_return(true)
-        end
-
-        # setup the actual expectation on the return value
-        expect(test.where(*args, &block)).to eql(finds)
-      end
-    end
-
-    context "simple usage" do
-      test_where("returns empty array when it doesn't find anything", "foo1")
-
-      ["/dir1", "/dir2" ].each do |dir|
-        test_where("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: [ "#{dir}/foo1" ])
-      end
-
-      test_where("finds `foo1` in all directories", "foo1", finds: [ "/dir1/foo1", "/dir2/foo1" ])
-    end
-
-    context "with an array of args" do
-      test_where("finds the first arg", "foo1", "foo2", finds: [ "/dir2/foo1" ])
-
-      test_where("finds the second arg", "foo1", "foo2", finds: [ "/dir2/foo2" ])
-
-      test_where("finds foo1 before foo2 if the dirs are reversed", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir2/foo2" ])
-
-      test_where("finds them both in the same directory", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir1/foo2" ])
-
-      test_where("finds foo2 first if they're reversed", "foo2", "foo1", finds: [ "/dir1/foo2", "/dir1/foo1" ])
-    end
-
-    context "with a block do" do
-      test_where("finds foo1 and foo2 if they exist and the block is true", "foo1", "foo2", finds: [ "/dir1/foo2", "/dir2/foo2" ]) do
-        true
-      end
-
-      test_where("does not finds foo1 and foo2 if they exist and the block is false", "foo1", "foo2", others: [ "/dir1/foo2", "/dir2/foo2" ]) do
-        false
-      end
-    end
-
-    context "with a nil path" do
-      test_where("returns empty array when it doesn't find anything", "foo1", path: nil)
-    end
-  end
-end
+# frozen_string_literal: true
+#
+# 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"
+
+RSpec.describe ChefUtils::DSL::Which do
+
+  class WhichTestClass
+    include ChefUtils::DSL::Which
+  end
+
+  let(:test) { WhichTestClass.new }
+
+  describe "#which" do
+    def self.test_which(description, *args, path: ["/dir1", "/dir2" ].join(File::PATH_SEPARATOR), finds: nil, others: [], directory: false, &block)
+      it description do
+        # stub the ENV['PATH']
+        expect(ENV).to receive(:[]).with("PATH").and_return(path)
+        expect(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
+
+        # most files should not be found
+        allow(File).to receive(:executable?).and_return(false)
+        allow(File).to receive(:directory?).and_return(false)
+
+        # stub the expectation
+        expect(File).to receive(:executable?).with(finds).and_return(true) if finds
+
+        # if the file we find is a directory
+        expect(File).to receive(:directory?).with(finds).and_return(true) if finds && directory
+
+        # allow for stubbing other paths to exist that we should not find
+        others.each do |other|
+          allow(File).to receive(:executable?).with(other).and_return(true)
+        end
+
+        # setup the actual expectation on the return value
+        if finds && !directory
+          expect(test.which(*args, &block)).to eql(finds)
+        else
+          expect(test.which(*args, &block)).to eql(false)
+        end
+      end
+    end
+
+    context "simple usage" do
+      test_which("returns false when it does not find anything", "foo1")
+
+      ["/dir1", "/dir2" ].each do |dir|
+        test_which("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: "#{dir}/foo1")
+      end
+
+      test_which("does not find an executable directory", "foo1", finds: "/dir1/foo1", directory: true)
+    end
+
+    context "with an array of args" do
+      test_which("finds the first arg", "foo1", "foo2", finds: "/dir2/foo1")
+
+      test_which("finds the second arg", "foo1", "foo2", finds: "/dir2/foo2")
+
+      test_which("finds the first arg when there's both", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ])
+
+      test_which("and the directory order can be reversed", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir2/foo2" ])
+
+      test_which("or be the same", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir1/foo2" ])
+    end
+
+    context "with a block" do
+      test_which("doesn't find it if its false", "foo1", others: [ "/dir1/foo1" ]) do |f|
+        false
+      end
+
+      test_which("finds it if its true", "foo1", finds: "/dir1/foo1") do |f|
+        true
+      end
+
+      test_which("passes in the filename as the arg", "foo1", finds: "/dir1/foo1") do |f|
+        raise "bad arg to block" unless f == "/dir1/foo1"
+
+        true
+      end
+
+      test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
+        raise "bad arg to block" unless ["/dir2/foo1", "/dir1/foo2"].include?(f)
+
+        true
+      end
+    end
+
+    context "nil path" do
+      test_which("returns false when it does not find anything", "foo1", path: nil)
+    end
+  end
+
+  describe "#where" do
+    def self.test_where(description, *args, path: ["/dir1", "/dir2" ].join(File::PATH_SEPARATOR), finds: [], others: [], &block)
+      it description do
+        # stub the ENV['PATH']
+        expect(ENV).to receive(:[]).with("PATH").and_return(path)
+        expect(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
+
+        # most files should not be found
+        allow(File).to receive(:executable?).and_return(false)
+        allow(File).to receive(:directory?).and_return(false)
+
+        # allow for stubbing other paths to exist that we should not return
+        others.each do |other|
+          allow(File).to receive(:executable?).with(other).and_return(true)
+        end
+
+        # stub the expectation
+        finds.each do |path|
+          expect(File).to receive(:executable?).with(path).and_return(true)
+        end
+
+        # setup the actual expectation on the return value
+        expect(test.where(*args, &block)).to eql(finds)
+      end
+    end
+
+    context "simple usage" do
+      test_where("returns empty array when it doesn't find anything", "foo1")
+
+      ["/dir1", "/dir2" ].each do |dir|
+        test_where("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: [ "#{dir}/foo1" ])
+      end
+
+      test_where("finds `foo1` in all directories", "foo1", finds: [ "/dir1/foo1", "/dir2/foo1" ])
+    end
+
+    context "with an array of args" do
+      test_where("finds the first arg", "foo1", "foo2", finds: [ "/dir2/foo1" ])
+
+      test_where("finds the second arg", "foo1", "foo2", finds: [ "/dir2/foo2" ])
+
+      test_where("finds foo1 before foo2 if the dirs are reversed", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir2/foo2" ])
+
+      test_where("finds them both in the same directory", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir1/foo2" ])
+
+      test_where("finds foo2 first if they're reversed", "foo2", "foo1", finds: [ "/dir1/foo2", "/dir1/foo1" ])
+    end
+
+    context "with a block do" do
+      test_where("finds foo1 and foo2 if they exist and the block is true", "foo1", "foo2", finds: [ "/dir1/foo2", "/dir2/foo2" ]) do
+        true
+      end
+
+      test_where("does not finds foo1 and foo2 if they exist and the block is false", "foo1", "foo2", others: [ "/dir1/foo2", "/dir2/foo2" ]) do
+        false
+      end
+    end
+
+    context "with a nil path" do
+      test_where("returns empty array when it doesn't find anything", "foo1", path: nil)
+    end
+  end
+end

data/spec/unit/dsl/windows_spec.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-#
-# 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"
-
-WINDOWS_BOOL_HELPERS = %i{windows_server_core? windows_server? windows_workstation?}.freeze
-
-def windows_reports_true_for(*args)
-  args.each do |method|
-    it "reports true for #{method}" do
-      expect(described_class.send(method, node)).to be true
-    end
-  end
-  (WINDOWS_BOOL_HELPERS - args).each do |method|
-    it "reports false for #{method}" do
-      expect(described_class.send(method, node)).to be false
-    end
-  end
-end
-
-RSpec.describe ChefUtils::DSL::Windows do
-  ( HELPER_MODULES - [ described_class ] ).each do |klass|
-    it "does not have methods that collide with #{klass}" do
-      expect((klass.methods - Module.methods) & WINDOWS_HELPERS).to be_empty
-    end
-  end
-
-  WINDOWS_HELPERS.each do |helper|
-    it "has the #{helper} in the ChefUtils module" do
-      expect(ChefUtils).to respond_to(helper)
-    end
-  end
-
-  context "windows boolean helpers" do
-    context "on Windows Server Core" do
-      let(:node) { { "kernel" => { "server_core" => true } } }
-
-      windows_reports_true_for(:windows_server_core?)
-    end
-
-    context "on Windows Workstation" do
-      let(:node) { { "kernel" => { "product_type" => "Workstation" } } }
-
-      windows_reports_true_for(:windows_workstation?)
-    end
-
-    context "on Windows Server" do
-      let(:node) { { "kernel" => { "product_type" => "Server" } } }
-
-      windows_reports_true_for(:windows_server?)
-    end
-  end
-
-  context "#windows_nt_version on Windows Server 2012 R2" do
-    let(:node) { { "os_version" => "6.3.9600" } }
-    it "it returns a ChefUtils::VersionString object with 6.3.9600" do
-      expect(described_class.send(:windows_nt_version, node)).to eq "6.3.9600"
-      expect(described_class.send(:windows_nt_version, node)).to be_a_kind_of ChefUtils::VersionString
-    end
-  end
-
-  context "#powershell_version on Windows Server 2012 R2" do
-    let(:node) { { "languages" => { "powershell" => { "version" => "4.0" } } } }
-    it "it returns a ChefUtils::VersionString object with 4.0" do
-      expect(described_class.send(:powershell_version, node)).to eq "4.0"
-      expect(described_class.send(:powershell_version, node)).to be_a_kind_of ChefUtils::VersionString
-    end
-  end
-end
+# frozen_string_literal: true
+#
+# 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"
+
+WINDOWS_BOOL_HELPERS = %i{windows_server_core? windows_server? windows_workstation?}.freeze
+
+def windows_reports_true_for(*args)
+  args.each do |method|
+    it "reports true for #{method}" do
+      expect(described_class.send(method, node)).to be true
+    end
+  end
+  (WINDOWS_BOOL_HELPERS - args).each do |method|
+    it "reports false for #{method}" do
+      expect(described_class.send(method, node)).to be false
+    end
+  end
+end
+
+RSpec.describe ChefUtils::DSL::Windows do
+  ( HELPER_MODULES - [ described_class ] ).each do |klass|
+    it "does not have methods that collide with #{klass}" do
+      expect((klass.methods - Module.methods) & WINDOWS_HELPERS).to be_empty
+    end
+  end
+
+  WINDOWS_HELPERS.each do |helper|
+    it "has the #{helper} in the ChefUtils module" do
+      expect(ChefUtils).to respond_to(helper)
+    end
+  end
+
+  context "windows boolean helpers" do
+    context "on Windows Server Core" do
+      let(:node) { { "kernel" => { "server_core" => true } } }
+
+      windows_reports_true_for(:windows_server_core?)
+    end
+
+    context "on Windows Workstation" do
+      let(:node) { { "kernel" => { "product_type" => "Workstation" } } }
+
+      windows_reports_true_for(:windows_workstation?)
+    end
+
+    context "on Windows Server" do
+      let(:node) { { "kernel" => { "product_type" => "Server" } } }
+
+      windows_reports_true_for(:windows_server?)
+    end
+  end
+
+  context "#windows_nt_version on Windows Server 2012 R2" do
+    let(:node) { { "os_version" => "6.3.9600" } }
+    it "it returns a ChefUtils::VersionString object with 6.3.9600" do
+      expect(described_class.send(:windows_nt_version, node)).to eq "6.3.9600"
+      expect(described_class.send(:windows_nt_version, node)).to be_a_kind_of ChefUtils::VersionString
+    end
+  end
+
+  context "#powershell_version on Windows Server 2012 R2" do
+    let(:node) { { "languages" => { "powershell" => { "version" => "4.0" } } } }
+    it "it returns a ChefUtils::VersionString object with 4.0" do
+      expect(described_class.send(:powershell_version, node)).to eq "4.0"
+      expect(described_class.send(:powershell_version, node)).to be_a_kind_of ChefUtils::VersionString
+    end
+  end
+end

data/spec/unit/mash_spec.rb

@@ -1,51 +1,51 @@
-# frozen_string_literal: true
-#
-# Author:: Matthew Kent (<mkent@magoazul.com>)
-# 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"
-
-RSpec.describe ChefUtils::Mash do
-  it "should duplicate a simple key/value mash to a new mash" do
-    data = { x: "one", y: "two", z: "three" }
-    @orig = ChefUtils::Mash.new(data)
-    @copy = @orig.dup
-    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
-    @copy[:x] = "four"
-    expect(@orig[:x]).to eq("one")
-  end
-
-  it "should duplicate a mash with an array to a new mash" do
-    data = { x: "one", y: "two", z: [1, 2, 3] }
-    @orig = ChefUtils::Mash.new(data)
-    @copy = @orig.dup
-    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
-    @copy[:z] << 4
-    expect(@orig[:z]).to eq([1, 2, 3])
-  end
-
-  it "should duplicate a nested mash to a new mash" do
-    data = { x: "one", y: "two", z: ChefUtils::Mash.new({ a: [1, 2, 3] }) }
-    @orig = ChefUtils::Mash.new(data)
-    @copy = @orig.dup
-    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
-    @copy[:z][:a] << 4
-    expect(@orig[:z][:a]).to eq([1, 2, 3])
-  end
-
-  # add more!
-end
+# frozen_string_literal: true
+#
+# Author:: Matthew Kent (<mkent@magoazul.com>)
+# 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"
+
+RSpec.describe ChefUtils::Mash do
+  it "should duplicate a simple key/value mash to a new mash" do
+    data = { x: "one", y: "two", z: "three" }
+    @orig = ChefUtils::Mash.new(data)
+    @copy = @orig.dup
+    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
+    @copy[:x] = "four"
+    expect(@orig[:x]).to eq("one")
+  end
+
+  it "should duplicate a mash with an array to a new mash" do
+    data = { x: "one", y: "two", z: [1, 2, 3] }
+    @orig = ChefUtils::Mash.new(data)
+    @copy = @orig.dup
+    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
+    @copy[:z] << 4
+    expect(@orig[:z]).to eq([1, 2, 3])
+  end
+
+  it "should duplicate a nested mash to a new mash" do
+    data = { x: "one", y: "two", z: ChefUtils::Mash.new({ a: [1, 2, 3] }) }
+    @orig = ChefUtils::Mash.new(data)
+    @copy = @orig.dup
+    expect(@copy.to_hash).to eq(ChefUtils::Mash.new(data).to_hash)
+    @copy[:z][:a] << 4
+    expect(@orig[:z][:a]).to eq([1, 2, 3])
+  end
+
+  # add more!
+end