chef 18.8.11 → 18.8.54

data/spec/unit/mixin/properties_spec.rb

@@ -1,107 +0,0 @@
-require "support/shared/integration/integration_helper"
-require "chef/mixin/properties"
-
-module ChefMixinPropertiesSpec
-  describe "Chef::Resource.property" do
-    include IntegrationSupport
-
-    context "with a base class A with properties a, ab, and ac" do
-      class A
-        include Chef::Mixin::Properties
-        property :a, "a", default: "a"
-        property :ab, %w{a b}, default: "a"
-        property :ac, %w{a c}, default: "a"
-        property :d, "d", description: "The d property", introduced: "14.0"
-      end
-
-      context "and a module B with properties b, ab and bc" do
-        module B
-          include Chef::Mixin::Properties
-          property :b, "b", default: "b"
-          property :ab, default: "b"
-          property :bc, %w{b c}, default: "c"
-        end
-
-        context "and a derived class C < A with properties c, ac and bc" do
-          class C < A
-            include B
-            property :c, "c", default: "c"
-            property :ac, default: "c"
-            property :bc, default: "c"
-          end
-
-          it "A.properties has a, ab, and ac with types 'a', ['a', 'b'], and ['b', 'c']" do
-            expect(A.properties.keys).to eq %i{a ab ac d}
-            expect(A.properties[:a].validation_options[:is]).to eq "a"
-            expect(A.properties[:ab].validation_options[:is]).to eq %w{a b}
-            expect(A.properties[:ac].validation_options[:is]).to eq %w{a c}
-          end
-
-          it "A.properties can get the description of `d`" do
-            expect(A.properties[:d].description).to eq "The d property"
-          end
-
-          it "A.properties can get the release that introduced `d`" do
-            expect(A.properties[:d].introduced).to eq "14.0"
-          end
-
-          it "B.properties has b, ab, and bc with types 'b', nil and ['b', 'c']" do
-            expect(B.properties.keys).to eq %i{b ab bc}
-            expect(B.properties[:b].validation_options[:is]).to eq "b"
-            expect(B.properties[:ab].validation_options[:is]).to be_nil
-            expect(B.properties[:bc].validation_options[:is]).to eq %w{b c}
-          end
-          it "C.properties has a, b, c, ac and bc with merged types" do
-            expect(C.properties.keys).to eq %i{a ab ac d b bc c}
-            expect(C.properties[:a].validation_options[:is]).to eq "a"
-            expect(C.properties[:b].validation_options[:is]).to eq "b"
-            expect(C.properties[:c].validation_options[:is]).to eq "c"
-            expect(C.properties[:ac].validation_options[:is]).to eq %w{a c}
-            expect(C.properties[:bc].validation_options[:is]).to eq %w{b c}
-          end
-          it "C.properties has ab with a non-merged type (from B)" do
-            expect(C.properties[:ab].validation_options[:is]).to be_nil
-          end
-
-          context "and an instance of C" do
-            let(:c) { C.new }
-
-            it "all properties can be retrieved and merged properties default to ab->b, ac->c, bc->c" do
-              expect(c.a).to  eq("a")
-              expect(c.b).to  eq("b")
-              expect(c.c).to  eq("c")
-              expect(c.ab).to eq("b")
-              expect(c.ac).to eq("c")
-              expect(c.bc).to eq("c")
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "with an Inner module" do
-    module Inner
-      include Chef::Mixin::Properties
-      property :inner
-    end
-
-    context "and an Outer module including it" do
-      module Outer
-        include Inner
-        property :outer
-      end
-
-      context "and an Outerest class including that" do
-        class Outerest
-          include Outer
-          property :outerest
-        end
-
-        it "Outerest.properties.validation_options[:is] inner, outer, outerest" do
-          expect(Outerest.properties.keys).to eq %i{inner outer outerest}
-        end
-      end
-    end
-  end
-end

data/spec/unit/mixin/proxified_socket_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/mixin/proxified_socket"
-require "proxifier/proxy"
-
-class TestProxifiedSocket
-  include Chef::Mixin::ProxifiedSocket
-end
-
-describe Chef::Mixin::ProxifiedSocket do
-
-  before(:all) do
-    @original_env = ENV.to_hash
-  end
-
-  after(:all) do
-    ENV.clear
-    ENV.update(@original_env)
-  end
-
-  let(:host) { "host" }
-  let(:port) { 7979 }
-  let(:test_instance) { TestProxifiedSocket.new }
-  let(:socket_double) { instance_double(TCPSocket) }
-  let(:proxifier_double) { instance_double(Proxifier::Proxy) }
-  let(:http_uri) { "http://somehost:1" }
-  let(:https_uri) { "https://somehost:1" }
-  let(:no_proxy_spec) { nil }
-
-  shared_examples "proxified socket" do
-    it "wraps the Socket in a Proxifier::Proxy" do
-      expect(Proxifier).to receive(:Proxy).with(proxy_uri).and_return(proxifier_double)
-      expect(proxifier_double).to receive(:open).with(host, port).and_return(socket_double)
-      expect(test_instance.proxified_socket(host, port)).to eq(socket_double)
-    end
-  end
-
-  context "when no proxy is set" do
-    it "returns a plain TCPSocket" do
-      ENV["http_proxy"] = nil
-      ENV["https_proxy"] = nil
-      expect(TCPSocket).to receive(:new).with(host, port).and_return(socket_double)
-      expect(test_instance.proxified_socket(host, port)).to eq(socket_double)
-    end
-  end
-
-  context "when https_proxy is set" do
-    before do
-      # I'm purposefully setting both of these because we prefer the https
-      # variable
-      ENV["https_proxy"] = https_uri
-      ENV["http_proxy"] = http_uri
-    end
-
-    let(:proxy_uri) { https_uri }
-    include_examples "proxified socket"
-
-    context "when no_proxy is set" do
-      # This is testing that no_proxy is also provided to Proxified
-      # when it is set
-      before do
-        ENV["no_proxy"] = no_proxy_spec
-      end
-
-      let(:no_proxy_spec) { "somehost1,somehost2" }
-      include_examples "proxified socket"
-    end
-  end
-
-  context "when http_proxy is set" do
-    before do
-      ENV["https_proxy"] = nil
-      ENV["http_proxy"] = http_uri
-    end
-
-    let(:proxy_uri) { http_uri }
-    include_examples "proxified socket"
-  end
-
-end

data/spec/unit/mixin/securable_spec.rb

@@ -1,313 +0,0 @@
-#
-# Author:: Mark Mzyk (<mmzyk@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::Mixin::Securable do
-
-  before(:each) do
-    @securable = Object.new
-    @securable.send(:extend, Chef::Mixin::Securable)
-    @securable.send(:extend, Chef::Mixin::ParamsValidate)
-  end
-
-  it "should accept a group name or id for group" do
-    expect { @securable.group "root" }.not_to raise_error
-    expect { @securable.group 123 }.not_to raise_error
-    expect { @securable.group "+bad:group" }.to raise_error(ArgumentError)
-  end
-
-  it "should accept a user name or id for owner" do
-    expect { @securable.owner "root" }.not_to raise_error
-    expect { @securable.owner 123 }.not_to raise_error
-    expect { @securable.owner "+bad:owner" }.to raise_error(ArgumentError)
-  end
-
-  it "allows the owner to be specified as #user" do
-    expect(@securable).to respond_to(:user)
-  end
-
-  describe "unix-specific behavior" do
-    before(:each) do
-      platform_mock :unix do
-        load File.join(__dir__, "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
-        @securable = Object.new
-        @securable.send(:extend, Chef::Mixin::Securable)
-        @securable.send(:extend, Chef::Mixin::ParamsValidate)
-      end
-    end
-
-    it "should accept group/owner names with spaces and backslashes" do
-      expect { @securable.group "test\\ group" }.not_to raise_error
-      expect { @securable.owner "test\\ group" }.not_to raise_error
-    end
-
-    it "should accept group/owner names that are a single character or digit" do
-      expect { @securable.group "v" }.not_to raise_error
-      expect { @securable.group "1" }.not_to raise_error
-      expect { @securable.owner "v" }.not_to raise_error
-      expect { @securable.owner "1" }.not_to raise_error
-    end
-
-    it "should not accept group/owner names starting with '-', '+', or '~'" do
-      expect { @securable.group "-test" }.to raise_error(ArgumentError)
-      expect { @securable.group "+test" }.to raise_error(ArgumentError)
-      expect { @securable.group "~test" }.to raise_error(ArgumentError)
-      expect { @securable.group "te-st" }.not_to raise_error
-      expect { @securable.group "te+st" }.not_to raise_error
-      expect { @securable.group "te~st" }.not_to raise_error
-      expect { @securable.owner "-test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "+test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "~test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te-st" }.not_to raise_error
-      expect { @securable.owner "te+st" }.not_to raise_error
-      expect { @securable.owner "te~st" }.not_to raise_error
-    end
-
-    it "should not accept group/owner names containing ':', ',' or non-space whitespace" do
-      expect { @securable.group ":test" }.to raise_error(ArgumentError)
-      expect { @securable.group "te:st" }.to raise_error(ArgumentError)
-      expect { @securable.group ",test" }.to raise_error(ArgumentError)
-      expect { @securable.group "te,st" }.to raise_error(ArgumentError)
-      expect { @securable.group "\ttest" }.to raise_error(ArgumentError)
-      expect { @securable.group "te\tst" }.to raise_error(ArgumentError)
-      expect { @securable.group "\rtest" }.to raise_error(ArgumentError)
-      expect { @securable.group "te\rst" }.to raise_error(ArgumentError)
-      expect { @securable.group "\ftest" }.to raise_error(ArgumentError)
-      expect { @securable.group "te\fst" }.to raise_error(ArgumentError)
-      expect { @securable.group "\0test" }.to raise_error(ArgumentError)
-      expect { @securable.group "te\0st" }.to raise_error(ArgumentError)
-      expect { @securable.owner ":test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te:st" }.to raise_error(ArgumentError)
-      expect { @securable.owner ",test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te,st" }.to raise_error(ArgumentError)
-      expect { @securable.owner "\ttest" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te\tst" }.to raise_error(ArgumentError)
-      expect { @securable.owner "\rtest" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te\rst" }.to raise_error(ArgumentError)
-      expect { @securable.owner "\ftest" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te\fst" }.to raise_error(ArgumentError)
-      expect { @securable.owner "\0test" }.to raise_error(ArgumentError)
-      expect { @securable.owner "te\0st" }.to raise_error(ArgumentError)
-    end
-
-    it "should accept Active Directory-style domain names pulled in via LDAP (on unix hosts)" do
-      expect { @securable.owner "domain\@user" }.not_to raise_error
-      expect { @securable.owner "domain\\user" }.not_to raise_error
-      expect { @securable.group "domain\@group" }.not_to raise_error
-      expect { @securable.group "domain\\group" }.not_to raise_error
-      expect { @securable.group "domain\\group^name" }.not_to raise_error
-    end
-
-    it "should not accept group/owner names containing embedded carriage returns" do
-      skip "XXX: params_validate needs to be extended to support multi-line regex"
-      # lambda { @securable.group "\ntest" }.should raise_error(ArgumentError)
-      # lambda { @securable.group "te\nst" }.should raise_error(ArgumentError)
-      # lambda { @securable.owner "\ntest" }.should raise_error(ArgumentError)
-      # lambda { @securable.owner "te\nst" }.should raise_error(ArgumentError)
-    end
-
-    it "should accept group/owner names in UTF-8" do
-      expect { @securable.group "tëst" }.not_to raise_error
-      expect { @securable.group "ë" }.not_to raise_error
-      expect { @securable.owner "tëst" }.not_to raise_error
-      expect { @securable.owner "ë" }.not_to raise_error
-    end
-
-    it "should accept a unix file mode in string form as an octal number" do
-      expect { @securable.mode "0" }.not_to raise_error
-      expect { @securable.mode "0000" }.not_to raise_error
-      expect { @securable.mode "0111" }.not_to raise_error
-      expect { @securable.mode "0444" }.not_to raise_error
-
-      expect { @securable.mode "111" }.not_to raise_error
-      expect { @securable.mode "444" }.not_to raise_error
-      expect { @securable.mode "7777" }.not_to raise_error
-      expect { @securable.mode "07777" }.not_to raise_error
-
-      expect { @securable.mode "-01" }.to raise_error(ArgumentError)
-      expect { @securable.mode "010000" }.to raise_error(ArgumentError)
-      expect { @securable.mode "-1" }.to raise_error(ArgumentError)
-      expect { @securable.mode "10000" }.to raise_error(ArgumentError)
-
-      expect { @securable.mode "07778" }.to raise_error(ArgumentError)
-      expect { @securable.mode "7778" }.to raise_error(ArgumentError)
-      expect { @securable.mode "4095" }.to raise_error(ArgumentError)
-
-      expect { @securable.mode "0foo1234" }.to raise_error(ArgumentError)
-      expect { @securable.mode "foo1234" }.to raise_error(ArgumentError)
-    end
-
-    it "should accept a unix file mode in numeric form as a ruby-interpreted integer" do
-      expect { @securable.mode(0) }.not_to raise_error
-      expect { @securable.mode(0000) }.not_to raise_error
-      expect { @securable.mode(444) }.not_to raise_error
-      expect { @securable.mode(0444) }.not_to raise_error
-      expect { @securable.mode(07777) }.not_to raise_error
-
-      expect { @securable.mode(292) }.not_to raise_error
-      expect { @securable.mode(4095) }.not_to raise_error
-
-      expect { @securable.mode(0111) }.not_to raise_error
-      expect { @securable.mode(73) }.not_to raise_error
-
-      expect { @securable.mode(-01) }.to raise_error(ArgumentError)
-      expect { @securable.mode(010000) }.to raise_error(ArgumentError)
-      expect { @securable.mode(-1) }.to raise_error(ArgumentError)
-      expect { @securable.mode(4096) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "windows-specific behavior" do
-    before(:each) do
-      platform_mock :windows do
-        load File.join(__dir__, "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
-        securable_class = Class.new do
-          include Chef::Mixin::Securable
-          include Chef::Mixin::ParamsValidate
-        end
-        @securable = securable_class.new
-      end
-    end
-
-    it "should not accept a group name or id for group with spaces and multiple backslashes" do
-      expect { @securable.group "test\\ \\group" }.to raise_error(ArgumentError)
-    end
-
-    it "should accept a unix file mode in string form as an octal number" do
-      expect { @securable.mode "0" }.not_to raise_error
-      expect { @securable.mode "0000" }.not_to raise_error
-      expect { @securable.mode "0111" }.not_to raise_error
-      expect { @securable.mode "0444" }.not_to raise_error
-
-      expect { @securable.mode "111" }.not_to raise_error
-      expect { @securable.mode "444" }.not_to raise_error
-      expect { @securable.mode "7777" }.to raise_error(ArgumentError)
-      expect { @securable.mode "07777" }.to raise_error(ArgumentError)
-
-      expect { @securable.mode "-01" }.to raise_error(ArgumentError)
-      expect { @securable.mode "010000" }.to raise_error(ArgumentError)
-      expect { @securable.mode "-1" }.to raise_error(ArgumentError)
-      expect { @securable.mode "10000" }.to raise_error(ArgumentError)
-
-      expect { @securable.mode "07778" }.to raise_error(ArgumentError)
-      expect { @securable.mode "7778" }.to raise_error(ArgumentError)
-      expect { @securable.mode "4095" }.to raise_error(ArgumentError)
-
-      expect { @securable.mode "0foo1234" }.to raise_error(ArgumentError)
-      expect { @securable.mode "foo1234" }.to raise_error(ArgumentError)
-    end
-
-    it "should accept a unix file mode in numeric form as a ruby-interpreted integer" do
-      expect { @securable.mode 0 }.not_to raise_error
-      expect { @securable.mode 0000 }.not_to raise_error
-      expect { @securable.mode 444 }.not_to raise_error
-      expect { @securable.mode 0444 }.not_to raise_error
-      expect { @securable.mode 07777 }.to raise_error(ArgumentError)
-
-      expect { @securable.mode 292 }.not_to raise_error
-      expect { @securable.mode 4095 }.to raise_error(ArgumentError)
-
-      expect { @securable.mode 0111 }.not_to raise_error
-      expect { @securable.mode 73 }.not_to raise_error
-
-      expect { @securable.mode(-01) }.to raise_error(ArgumentError)
-      expect { @securable.mode 010000 }.to raise_error(ArgumentError)
-      expect { @securable.mode(-1) }.to raise_error(ArgumentError)
-      expect { @securable.mode 4096 }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to specify :full_control, :modify, :read_execute, :read, and :write rights" do
-      expect { @securable.rights :full_control, "The Dude" }.not_to raise_error
-      expect { @securable.rights :modify, "The Dude" }.not_to raise_error
-      expect { @securable.rights :read_execute, "The Dude" }.not_to raise_error
-      expect { @securable.rights :read, "The Dude" }.not_to raise_error
-      expect { @securable.rights :write, "The Dude" }.not_to raise_error
-      expect { @securable.rights :to_party, "The Dude" }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to specify :full_control, :modify, :read_execute, :read, and :write deny_rights" do
-      expect { @securable.deny_rights :full_control, "The Dude" }.not_to raise_error
-      expect { @securable.deny_rights :modify, "The Dude" }.not_to raise_error
-      expect { @securable.deny_rights :read_execute, "The Dude" }.not_to raise_error
-      expect { @securable.deny_rights :read, "The Dude" }.not_to raise_error
-      expect { @securable.deny_rights :write, "The Dude" }.not_to raise_error
-      expect { @securable.deny_rights :to_party, "The Dude" }.to raise_error(ArgumentError)
-    end
-
-    it "should accept a principal as a string or an array" do
-      expect { @securable.rights :read, "The Dude" }.not_to raise_error
-      expect { @securable.rights :read, ["The Dude", "Donny"] }.not_to raise_error
-      expect { @securable.rights :read, 3 }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to specify whether the permissions applies_to_children with true/false/:containers_only/:objects_only" do
-      expect { @securable.rights :read, "The Dude", applies_to_children: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: :containers_only }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: :objects_only }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: "poop" }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to specify whether the permissions applies_to_self with true/false" do
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, applies_to_self: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_self: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_self: "poop" }.to raise_error(ArgumentError)
-    end
-
-    it "should allow you to specify whether the permissions applies one_level_deep with true/false" do
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, one_level_deep: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, one_level_deep: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, one_level_deep: "poop" }.to raise_error(ArgumentError)
-    end
-
-    it "should allow multiple rights and deny_rights declarations" do
-      @securable.rights :read, "The Dude"
-      @securable.deny_rights :full_control, "The Dude"
-      @securable.rights :full_control, "The Dude"
-      @securable.rights :write, "The Dude"
-      @securable.deny_rights :read, "The Dude"
-      expect(@securable.rights.size).to eq(3)
-      expect(@securable.deny_rights.size).to eq(2)
-    end
-
-    it "should allow you to specify whether the permission applies_to_self only if you specified applies_to_children" do
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, applies_to_self: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, applies_to_self: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: false, applies_to_self: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: false, applies_to_self: false }.to raise_error(ArgumentError)
-      expect { @securable.rights :read, "The Dude", applies_to_self: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_self: false }.not_to raise_error
-    end
-
-    it "should allow you to specify whether the permission applies one_level_deep only if you specified applies_to_children" do
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, one_level_deep: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: true, one_level_deep: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", applies_to_children: false, one_level_deep: true }.to raise_error(ArgumentError)
-      expect { @securable.rights :read, "The Dude", applies_to_children: false, one_level_deep: false }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", one_level_deep: true }.not_to raise_error
-      expect { @securable.rights :read, "The Dude", one_level_deep: false }.not_to raise_error
-    end
-
-    it "should allow you to specify whether the permissions inherit with true/false" do
-      expect { @securable.inherits true }.not_to raise_error
-      expect { @securable.inherits false }.not_to raise_error
-      expect { @securable.inherits "monkey" }.to raise_error(ArgumentError)
-    end
-  end
-end