chef 12.0.0.alpha.1-x86-mingw32 → 12.0.0.alpha.2-x86-mingw32

data/spec/unit/util/path_helper_spec.rb

@@ -20,101 +20,184 @@ require 'chef/util/path_helper'
 require 'spec_helper'
 
 describe Chef::Util::PathHelper do
-  let(:path_helper) { Chef::Util::PathHelper }
+  PathHelper = Chef::Util::PathHelper
+
+  [ false, true ].each do |is_windows|
+    context "on #{is_windows ? "windows" : "unix"}" do
+      before(:each) do
+        Chef::Platform.stub(:windows?).and_return(is_windows)
+      end
+
+      describe "join" do
+        it "joins components when some end with separators" do
+          expected = PathHelper.cleanpath("/foo/bar/baz")
+          expected = "C:#{expected}" if is_windows
+          PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar", "baz").should == expected
+        end
+
+        it "joins components when some end and start with separators" do
+          expected = PathHelper.cleanpath("/foo/bar/baz")
+          expected = "C:#{expected}" if is_windows
+          PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar/", "/baz").should == expected
+        end
+
+        it "joins components that don't end in separators" do
+          expected = PathHelper.cleanpath("/foo/bar/baz")
+          expected = "C:#{expected}" if is_windows
+          PathHelper.join(is_windows ? 'C:\\foo' : "/foo", "bar", "baz").should == expected
+        end
+
+        it "joins starting with '' resolve to absolute paths" do
+          PathHelper.join('', 'a', 'b').should == "#{PathHelper.path_separator}a#{PathHelper.path_separator}b"
+        end
+
+        it "joins ending with '' add a / to the end" do
+          PathHelper.join('a', 'b', '').should == "a#{PathHelper.path_separator}b#{PathHelper.path_separator}"
+        end
+
+        if is_windows
+          it "joins components on Windows when some end with unix separators" do
+            PathHelper.join('C:\\foo/', "bar", "baz").should == 'C:\\foo\\bar\\baz'
+          end
+        end
+      end
+
+      if is_windows
+        it "path_separator is \\" do
+          PathHelper.path_separator.should == '\\'
+        end
+      else
+        it "path_separator is /" do
+          PathHelper.path_separator.should == '/'
+        end
+      end
+
+      if is_windows
+        it "cleanpath changes slashes into backslashes and leaves backslashes alone" do
+          PathHelper.cleanpath('/a/b\\c/d/').should == '\\a\\b\\c\\d'
+        end
+        it "cleanpath does not remove leading double backslash" do
+          PathHelper.cleanpath('\\\\a/b\\c/d/').should == '\\\\a\\b\\c\\d'
+        end
+      else
+        it "cleanpath removes extra slashes alone" do
+          PathHelper.cleanpath('/a///b/c/d/').should == '/a/b/c/d'
+        end
+      end
+
+      describe "dirname" do
+        it "dirname('abc') is '.'" do
+          PathHelper.dirname('abc').should == '.'
+        end
+        it "dirname('/') is '/'" do
+          PathHelper.dirname(PathHelper.path_separator).should == PathHelper.path_separator
+        end
+        it "dirname('a/b/c') is 'a/b'" do
+          PathHelper.dirname(PathHelper.join('a', 'b', 'c')).should == PathHelper.join('a', 'b')
+        end
+        it "dirname('a/b/c/') is 'a/b'" do
+          PathHelper.dirname(PathHelper.join('a', 'b', 'c', '')).should == PathHelper.join('a', 'b')
+        end
+        it "dirname('/a/b/c') is '/a/b'" do
+          PathHelper.dirname(PathHelper.join('', 'a', 'b', 'c')).should == PathHelper.join('', 'a', 'b')
+        end
+      end
+    end
+  end
 
   describe "validate_path" do
     context "on windows" do
       before(:each) do
         # pass by default
         Chef::Platform.stub(:windows?).and_return(true)
-        path_helper.stub(:printable?).and_return(true)
-        path_helper.stub(:windows_max_length_exceeded?).and_return(false)
+        PathHelper.stub(:printable?).and_return(true)
+        PathHelper.stub(:windows_max_length_exceeded?).and_return(false)
       end
 
       it "returns the path if the path passes the tests" do
-        expect(path_helper.validate_path("C:\\ThisIsRigged")).to eql("C:\\ThisIsRigged")
+        expect(PathHelper.validate_path("C:\\ThisIsRigged")).to eql("C:\\ThisIsRigged")
       end
 
       it "does not raise an error if everything looks great" do
-        expect { path_helper.validate_path("C:\\cool path\\dude.exe") }.not_to raise_error
+        expect { PathHelper.validate_path("C:\\cool path\\dude.exe") }.not_to raise_error
       end
 
       it "raises an error if the path has invalid characters" do
-        path_helper.stub(:printable?).and_return(false)
-        expect { path_helper.validate_path("Newline!\n") }.to raise_error(Chef::Exceptions::ValidationFailed)
+        PathHelper.stub(:printable?).and_return(false)
+        expect { PathHelper.validate_path("Newline!\n") }.to raise_error(Chef::Exceptions::ValidationFailed)
       end
 
       it "Adds the \\\\?\\ prefix if the path exceeds MAX_LENGTH and does not have it" do
         long_path = "C:\\" + "a" * 250 + "\\" + "b" * 250
         prefixed_long_path = "\\\\?\\" + long_path
-        path_helper.stub(:windows_max_length_exceeded?).and_return(true)
-        expect(path_helper.validate_path(long_path)).to eql(prefixed_long_path)
+        PathHelper.stub(:windows_max_length_exceeded?).and_return(true)
+        expect(PathHelper.validate_path(long_path)).to eql(prefixed_long_path)
       end
     end
   end
 
   describe "windows_max_length_exceeded?" do
     it "returns true if the path is too long (259 + NUL) for the API" do
-      expect(path_helper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 6)).to be_true
+      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 6)).to be_true
     end
 
     it "returns false if the path is not too long (259 + NUL) for the standard API" do
-      expect(path_helper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 5)).to be_false
+      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 5)).to be_false
     end
 
     it "returns false if the path is over 259 characters but uses the \\\\?\\ prefix" do
-      expect(path_helper.windows_max_length_exceeded?("\\\\?\\C:\\" + "a" * 250 + "\\" + "b" * 250)).to be_false
+      expect(PathHelper.windows_max_length_exceeded?("\\\\?\\C:\\" + "a" * 250 + "\\" + "b" * 250)).to be_false
     end
   end
 
   describe "printable?" do
     it "returns true if the string contains no non-printable characters" do
-      expect(path_helper.printable?("C:\\Program Files (x86)\\Microsoft Office\\Files.lst")).to be_true
+      expect(PathHelper.printable?("C:\\Program Files (x86)\\Microsoft Office\\Files.lst")).to be_true
     end
 
     it "returns true when given 'abc' in unicode" do
-      expect(path_helper.printable?("\u0061\u0062\u0063")).to be_true
+      expect(PathHelper.printable?("\u0061\u0062\u0063")).to be_true
     end
 
     it "returns true when given japanese unicode" do
-      expect(path_helper.printable?("\uff86\uff87\uff88")).to be_true
+      expect(PathHelper.printable?("\uff86\uff87\uff88")).to be_true
     end
 
     it "returns false if the string contains a non-printable character" do
-      expect(path_helper.printable?("\my files\work\notes.txt")).to be_false
+      expect(PathHelper.printable?("\my files\work\notes.txt")).to be_false
     end
 
     # This isn't necessarily a requirement, but here to be explicit about functionality.
     it "returns false if the string contains a newline or tab" do
-      expect(path_helper.printable?("\tThere's no way,\n\t *no* way,\n\t that you came from my loins.\n")).to be_false
+      expect(PathHelper.printable?("\tThere's no way,\n\t *no* way,\n\t that you came from my loins.\n")).to be_false
     end
   end
 
   describe "canonical_path" do
     context "on windows", :windows_only do
       it "returns an absolute path with backslashes instead of slashes" do
-        expect(path_helper.canonical_path("\\\\?\\C:/windows/win.ini")).to eq("\\\\?\\c:\\windows\\win.ini")
+        expect(PathHelper.canonical_path("\\\\?\\C:/windows/win.ini")).to eq("\\\\?\\c:\\windows\\win.ini")
       end
 
       it "adds the \\\\?\\ prefix if it is missing" do
-        expect(path_helper.canonical_path("C:/windows/win.ini")).to eq("\\\\?\\c:\\windows\\win.ini")
+        expect(PathHelper.canonical_path("C:/windows/win.ini")).to eq("\\\\?\\c:\\windows\\win.ini")
       end
 
       it "returns a lowercase path" do
-        expect(path_helper.canonical_path("\\\\?\\C:\\CASE\\INSENSITIVE")).to eq("\\\\?\\c:\\case\\insensitive")
+        expect(PathHelper.canonical_path("\\\\?\\C:\\CASE\\INSENSITIVE")).to eq("\\\\?\\c:\\case\\insensitive")
       end
     end
 
     context "not on windows", :unix_only  do
       context "ruby is at least 1.9", :ruby_gte_19_only do
         it "returns a canonical path" do
-          expect(path_helper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default")).to eq("/etc/apache.d/sites-available/default")
+          expect(PathHelper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default")).to eq("/etc/apache.d/sites-available/default")
         end
       end
 
       context "ruby is less than 1.9", :ruby_18_only do
         it "returns a canonical path" do
-          expect { path_helper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default") }.to raise_error(NotImplementedError)
+          expect { PathHelper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default") }.to raise_error(NotImplementedError)
         end
       end
     end
@@ -122,15 +205,15 @@ describe Chef::Util::PathHelper do
 
   describe "paths_eql?" do
     it "returns true if the paths are the same" do
-      path_helper.stub(:canonical_path).with("bandit").and_return("c:/bandit/bandit")
-      path_helper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
-      expect(path_helper.paths_eql?("bandit", "../bandit/bandit")).to be_true
+      PathHelper.stub(:canonical_path).with("bandit").and_return("c:/bandit/bandit")
+      PathHelper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_true
     end
 
     it "returns false if the paths are different" do
-      path_helper.stub(:canonical_path).with("bandit").and_return("c:/Bo/Bandit")
-      path_helper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
-      expect(path_helper.paths_eql?("bandit", "../bandit/bandit")).to be_false
+      PathHelper.stub(:canonical_path).with("bandit").and_return("c:/Bo/Bandit")
+      PathHelper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_false
      end
   end
 end

data/spec/unit/workstation_config_loader_spec.rb

@@ -0,0 +1,283 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 2014 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 'tempfile'
+require 'chef/workstation_config_loader'
+
+describe Chef::WorkstationConfigLoader do
+
+  let(:explicit_config_location) { nil }
+
+  let(:env) { {} }
+
+  let(:config_loader) do
+    described_class.new(explicit_config_location).tap do |c|
+      allow(c).to receive(:env).and_return(env)
+    end
+  end
+
+  # Test methods that do I/O or reference external state which are stubbed out
+  # elsewhere.
+  describe "external dependencies" do
+    let(:config_loader) { described_class.new(nil) }
+
+    it "delegates to ENV for env" do
+      expect(config_loader.env).to equal(ENV)
+    end
+
+    it "tests a path's existence" do
+      expect(config_loader.path_exists?('/nope/nope/nope/nope/frab/jab/nab')).to be(false)
+      expect(config_loader.path_exists?(__FILE__)).to be(true)
+    end
+
+  end
+
+  describe "locating the config file" do
+    context "without an explicit config" do
+
+      before do
+        allow(config_loader).to receive(:path_exists?).with(an_instance_of(String)).and_return(false)
+      end
+
+      it "has no config if HOME is not set" do
+        expect(config_loader.config_location).to be(nil)
+        expect(config_loader.no_config_found?).to be(true)
+      end
+
+      context "when HOME is set and contains a knife.rb" do
+
+        let(:home) { "/Users/example.user" }
+
+        before do
+          env["HOME"] = home
+          allow(config_loader).to receive(:path_exists?).with("#{home}/.chef/knife.rb").and_return(true)
+        end
+
+        it "uses the config in HOME/.chef/knife.rb" do
+          expect(config_loader.config_location).to eq("#{home}/.chef/knife.rb")
+        end
+
+        context "and has a config.rb" do
+
+          before do
+            allow(config_loader).to receive(:path_exists?).with("#{home}/.chef/config.rb").and_return(true)
+          end
+
+          it "uses the config in HOME/.chef/config.rb" do
+            expect(config_loader.config_location).to eq("#{home}/.chef/config.rb")
+          end
+
+          context "and/or a parent dir contains a .chef dir" do
+
+            let(:env_pwd) { "/path/to/cwd" }
+
+            before do
+              if Chef::Platform.windows?
+                env["CD"] = env_pwd
+              else
+                env["PWD"] = env_pwd
+              end
+
+              allow(config_loader).to receive(:path_exists?).with("#{env_pwd}/.chef/knife.rb").and_return(true)
+              allow(File).to receive(:exist?).with("#{env_pwd}/.chef").and_return(true)
+              allow(File).to receive(:directory?).with("#{env_pwd}/.chef").and_return(true)
+            end
+
+            it "prefers the config from parent_dir/.chef" do
+              expect(config_loader.config_location).to eq("#{env_pwd}/.chef/knife.rb")
+            end
+
+            context "and the parent dir's .chef dir has a config.rb" do
+
+              before do
+                allow(config_loader).to receive(:path_exists?).with("#{env_pwd}/.chef/config.rb").and_return(true)
+              end
+
+              it "prefers the config from parent_dir/.chef" do
+                expect(config_loader.config_location).to eq("#{env_pwd}/.chef/config.rb")
+              end
+
+              context "and/or the current working directory contains a .chef dir" do
+
+                let(:cwd) { Dir.pwd }
+
+                before do
+                  allow(config_loader).to receive(:path_exists?).with("#{cwd}/knife.rb").and_return(true)
+                end
+
+                it "prefers a knife.rb located in the cwd" do
+                  expect(config_loader.config_location).to eq("#{cwd}/knife.rb")
+                end
+
+                context "and the CWD's .chef dir has a config.rb" do
+
+                  before do
+                    allow(config_loader).to receive(:path_exists?).with("#{cwd}/config.rb").and_return(true)
+                  end
+
+                  it "prefers a config located in the cwd" do
+                    expect(config_loader.config_location).to eq("#{cwd}/config.rb")
+                  end
+
+
+                  context "and/or KNIFE_HOME is set" do
+
+                    let(:knife_home) { "/path/to/knife/home" }
+
+                    before do
+                      env["KNIFE_HOME"] = knife_home
+                      allow(config_loader).to receive(:path_exists?).with("#{knife_home}/knife.rb").and_return(true)
+                    end
+
+                    it "prefers a knife located in KNIFE_HOME" do
+                      expect(config_loader.config_location).to eq("/path/to/knife/home/knife.rb")
+                    end
+
+                    context "and KNIFE_HOME contains a config.rb" do
+
+                      before do
+                        env["KNIFE_HOME"] = knife_home
+                        allow(config_loader).to receive(:path_exists?).with("#{knife_home}/config.rb").and_return(true)
+                      end
+
+                      it "prefers a config.rb located in KNIFE_HOME" do
+                        expect(config_loader.config_location).to eq("/path/to/knife/home/config.rb")
+                      end
+
+                    end
+
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "when the current working dir is inside a symlinked directory" do
+        before do
+          # pwd according to your shell is /home/someuser/prod/chef-repo, but
+          # chef-repo is a symlink to /home/someuser/codes/chef-repo
+          env["CD"] = "/home/someuser/prod/chef-repo" # windows
+          env["PWD"] = "/home/someuser/prod/chef-repo" # unix
+
+          Dir.stub(:pwd).and_return("/home/someuser/codes/chef-repo")
+        end
+
+        it "loads the config from the non-dereferenced directory path" do
+          expect(File).to receive(:exist?).with("/home/someuser/prod/chef-repo/.chef").and_return(false)
+          expect(File).to receive(:exist?).with("/home/someuser/prod/.chef").and_return(true)
+          expect(File).to receive(:directory?).with("/home/someuser/prod/.chef").and_return(true)
+
+          expect(config_loader).to receive(:path_exists?).with("/home/someuser/prod/.chef/knife.rb").and_return(true)
+
+          expect(config_loader.config_location).to eq("/home/someuser/prod/.chef/knife.rb")
+        end
+      end
+    end
+
+    context "when given an explicit config to load" do
+
+      let(:explicit_config_location) { "/path/to/explicit/config.rb" }
+
+      it "prefers the explicit config" do
+        expect(config_loader.config_location).to eq(explicit_config_location)
+      end
+
+    end
+  end
+
+
+  describe "loading the config file" do
+
+    context "when no explicit config is specifed and no implicit config is found" do
+
+      before do
+        allow(config_loader).to receive(:path_exists?).with(an_instance_of(String)).and_return(false)
+      end
+
+      it "skips loading" do
+        expect(config_loader.config_location).to be(nil)
+        expect(config_loader.load).to be(false)
+      end
+
+    end
+
+    context "when an explict config is given but it doesn't exist" do
+
+      let(:explicit_config_location) { "/nope/nope/nope/frab/jab/nab" }
+
+      it "raises a configuration error" do
+        expect { config_loader.load }.to raise_error(Chef::Exceptions::ConfigurationError)
+      end
+
+    end
+
+    context "when the config file exists" do
+
+      let(:config_content) { "" }
+
+      let(:explicit_config_location) do
+        # could use described_class, but remove all ':' from the path if so.
+        t = Tempfile.new("Chef-WorkstationConfigLoader-rspec-test")
+        t.print(config_content)
+        t.close
+        t.path
+      end
+
+      after { File.unlink(explicit_config_location) }
+
+      context "and is valid" do
+
+        let(:config_content) { "config_file_evaluated(true)" }
+
+        it "loads the config" do
+          expect(config_loader.load).to be(true)
+          expect(Chef::Config.config_file_evaluated).to be(true)
+        end
+
+        it "sets Chef::Config.config_file" do
+          config_loader.load
+          expect(Chef::Config.config_file).to eq(explicit_config_location)
+        end
+      end
+
+      context "and has a syntax error" do
+
+        let(:config_content) { "{{{{{:{{" }
+
+        it "raises a ConfigurationError" do
+          expect { config_loader.load }.to raise_error(Chef::Exceptions::ConfigurationError)
+        end
+      end
+
+      context "and raises a ruby exception during evaluation" do
+
+        let(:config_content) { ":foo\n:bar\nraise 'oops'\n:baz\n" }
+
+        it "raises a ConfigurationError" do
+          expect { config_loader.load }.to raise_error(Chef::Exceptions::ConfigurationError)
+        end
+      end
+
+    end
+
+  end
+
+end