chef 13.7.16-universal-mingw32 → 13.8.0-universal-mingw32

data/spec/unit/mixin/properties_spec.rb

@@ -1,97 +1,97 @@
-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"
-      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 [ :a, :ab, :ac ]
-            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 "B.properties has b, ab, and bc with types 'b', nil and ['b', 'c']" do
-            expect(B.properties.keys).to eq [ :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 [ :a, :ab, :ac, :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 [:inner, :outer, :outerest]
-        end
-      end
-    end
-  end
-end
+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"
+      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 [ :a, :ab, :ac ]
+            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 "B.properties has b, ab, and bc with types 'b', nil and ['b', 'c']" do
+            expect(B.properties.keys).to eq [ :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 [ :a, :ab, :ac, :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 [:inner, :outer, :outerest]
+        end
+      end
+    end
+  end
+end

data/spec/unit/mixin/proxified_socket_spec.rb

@@ -1,97 +1,97 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Copyright:: Copyright 2014-2016, 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
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright 2014-2016, 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,314 +1,314 @@
-# encoding: UTF-8
-#
-# Author:: Mark Mzyk (<mmzyk@chef.io>)
-# Copyright:: Copyright 2011-2016, 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(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
+# encoding: UTF-8
+#
+# Author:: Mark Mzyk (<mmzyk@chef.io>)
+# Copyright:: Copyright 2011-2016, 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(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