chef 12.4.0.rc.0-universal-mingw32

data/spec/unit/mixin/path_sanity_spec.rb

@@ -0,0 +1,86 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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'
+
+class PathSanityTestHarness
+  include Chef::Mixin::PathSanity
+end
+
+describe Chef::Mixin::PathSanity do
+
+  before do
+    @sanity = PathSanityTestHarness.new
+  end
+
+  describe "when enforcing path sanity" do
+    before do
+      Chef::Config[:enforce_path_sanity] = true
+      @ruby_bindir = '/some/ruby/bin'
+      @gem_bindir = '/some/gem/bin'
+      allow(Gem).to receive(:bindir).and_return(@gem_bindir)
+      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return(@ruby_bindir)
+      allow(ChefConfig).to receive(:windows?).and_return(false)
+    end
+
+    it "adds all useful PATHs even if environment is an empty hash" do
+      env={}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("#{@ruby_bindir}:#{@gem_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
+    end
+
+    it "adds all useful PATHs that are not yet in PATH to PATH" do
+      env = {"PATH" => ""}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("#{@ruby_bindir}:#{@gem_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
+    end
+
+    it "does not re-add paths that already exist in PATH" do
+      env = {"PATH" => "/usr/bin:/sbin:/bin"}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("/usr/bin:/sbin:/bin:#{@ruby_bindir}:#{@gem_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin")
+    end
+
+    it "adds the current executing Ruby's bindir and Gem bindir to the PATH" do
+      env = {"PATH" => ""}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("#{@ruby_bindir}:#{@gem_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
+    end
+
+    it "does not create entries for Ruby/Gem bindirs if they exist in SANE_PATH or PATH" do
+      ruby_bindir = '/usr/bin'
+      gem_bindir = '/yo/gabba/gabba'
+      allow(Gem).to receive(:bindir).and_return(gem_bindir)
+      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return(ruby_bindir)
+      env = {"PATH" => gem_bindir}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("/yo/gabba/gabba:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
+    end
+
+    it "builds a valid windows path" do
+      ruby_bindir = 'C:\ruby\bin'
+      gem_bindir = 'C:\gems\bin'
+      allow(Gem).to receive(:bindir).and_return(gem_bindir)
+      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return(ruby_bindir)
+      allow(ChefConfig).to receive(:windows?).and_return(true)
+      env = {"PATH" => 'C:\Windows\system32;C:\mr\softie'}
+      @sanity.enforce_path_sanity(env)
+      expect(env["PATH"]).to eq("C:\\Windows\\system32;C:\\mr\\softie;#{ruby_bindir};#{gem_bindir}")
+    end
+  end
+end

data/spec/unit/mixin/powershell_type_coercions_spec.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+# Copyright:: Copyright (c) 2015 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/powershell_type_coercions'
+require 'base64'
+
+class Chef::PSTypeTester
+  include Chef::Mixin::PowershellTypeCoercions
+end
+
+describe Chef::Mixin::PowershellTypeCoercions do
+  let (:test_class) { Chef::PSTypeTester.new }
+
+  describe '#translate_type' do
+    it 'should single quote a string' do
+      expect(test_class.translate_type('foo')).to eq("'foo'")
+    end
+
+    ["'", '"', '#', '`'].each do |c|
+      it "should base64 encode a string that contains #{c}" do
+        expect(test_class.translate_type("#{c}")).to match(Base64.strict_encode64(c))
+      end
+    end
+
+    it 'should not quote an integer' do
+      expect(test_class.translate_type(123)).to eq('123')
+    end
+
+    it 'should not quote a floating point number' do
+      expect(test_class.translate_type(123.4)).to eq('123.4')
+    end
+
+    it 'should return $false when an instance of FalseClass is provided' do
+      expect(test_class.translate_type(false)).to eq('$false')
+    end
+
+    it 'should return $true when an instance of TrueClass is provided' do
+      expect(test_class.translate_type(true)).to eq('$true')
+    end
+
+    it 'should translate all members of a hash and wrap them in @{} separated by ;' do
+      expect(test_class.translate_type({"a" => 1, "b" => 1.2, "c" => false, "d" => true
+      })).to eq("@{a=1;b=1.2;c=$false;d=$true}")
+    end
+
+    it 'should translat all members of an array and them by a ,' do
+      expect(test_class.translate_type([true, false])).to eq('@($true,$false)')
+    end
+
+    it 'should fall back :to_psobject if we have not defined at explicit rule' do
+      ps_obj = double("PSObject")
+      expect(ps_obj).to receive(:to_psobject).and_return('$true')
+      expect(test_class.translate_type(ps_obj)).to eq('($true)')
+    end
+  end
+end

data/spec/unit/mixin/securable_spec.rb

@@ -0,0 +1,314 @@
+# encoding: UTF-8
+#
+# Author:: Mark Mzyk (<mmzyk@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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(File.dirname(__FILE__), "..", "..", "..", "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(File.dirname(__FILE__), "..", "..", "..", "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