chef 12.0.0.alpha.1 → 12.0.0.alpha.2

data/spec/integration/knife/upload_spec.rb

@@ -487,7 +487,7 @@ EOM
 Updated /cookbooks/x
 EOM
           # Modify a file and attempt to upload
-          file 'cookbooks/x/metadata.rb', "name 'x'; version '1.0.0'#different"
+          file 'cookbooks/x/metadata.rb', 'name "x"; version "1.0.0"#different'
           knife('upload /cookbooks/x').should_fail "ERROR: /cookbooks failed to write: Cookbook x is frozen\n"
         end
       end
@@ -1216,4 +1216,157 @@ EOM
       end
     end
   end
+
+  when_the_chef_server "is in Enterprise mode", :osc_compat => false, :single_org => false do
+    before do
+      user 'foo', {}
+      user 'bar', {}
+      user 'foobar', {}
+      organization 'foo', { 'full_name' => 'Something'}
+    end
+
+    before :each do
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo')
+    end
+
+    context 'and has nothing but a single group named blah' do
+      group 'blah', {}
+
+      when_the_repository 'has one of each thing' do
+
+        before do
+          # TODO We have to upload acls for an existing group due to a lack of
+          # dependency detection during upload.  Fix that!
+          file 'acls/groups/blah.json', {}
+          file 'clients/x.json', { 'public_key' => ChefZero::PUBLIC_KEY }
+          file 'containers/x.json', {}
+          file 'cookbooks/x/metadata.rb', cb_metadata("x", "1.0.0")
+          file 'data_bags/x/y.json', {}
+          file 'environments/x.json', {}
+          file 'groups/x.json', {}
+          file 'invitations.json', [ 'foo' ]
+          file 'members.json', [ 'bar' ]
+          file 'nodes/x.json', {}
+          file 'org.json', { 'full_name' => 'wootles' }
+          file 'roles/x.json', {}
+        end
+
+        it 'knife upload / uploads everything' do
+          knife('upload /').should_succeed <<EOM
+Updated /acls/groups/blah.json
+Created /clients/x.json
+Created /containers/x.json
+Created /cookbooks/x
+Created /data_bags/x
+Created /data_bags/x/y.json
+Created /environments/x.json
+Created /groups/x.json
+Updated /invitations.json
+Updated /members.json
+Created /nodes/x.json
+Updated /org.json
+Created /roles/x.json
+EOM
+          api.get('association_requests').map { |a| a['username'] }.should == [ 'foo' ]
+          api.get('users').map { |a| a['user']['username'] }.should == [ 'bar' ]
+        end
+      end
+
+      when_the_repository 'has an org.json that does not change full_name' do
+        before do
+          file 'org.json', { 'full_name' => 'Something' }
+        end
+
+        it 'knife upload / emits a warning for bar and adds foo and foobar' do
+          knife('upload /').should_succeed ''
+          api.get('/')['full_name'].should == 'Something'
+        end
+      end
+
+      when_the_repository 'has an org.json that changes full_name' do
+        before do
+          file 'org.json', { 'full_name' => 'Something Else'}
+        end
+
+        it 'knife upload / emits a warning for bar and adds foo and foobar' do
+          knife('upload /').should_succeed "Updated /org.json\n"
+          api.get('/')['full_name'].should == 'Something Else'
+        end
+      end
+
+      context 'and has invited foo and bar is already a member' do
+        org_invite 'foo'
+        org_member 'bar'
+
+        when_the_repository 'wants to invite foo, bar and foobar' do
+          before do
+            file 'invitations.json', [ 'foo', 'bar', 'foobar' ]
+          end
+
+          it 'knife upload / emits a warning for bar and invites foobar' do
+            knife('upload /').should_succeed "Updated /invitations.json\n", :stderr => "WARN: Could not invite bar to organization foo: User bar is already in organization foo\n"
+            api.get('association_requests').map { |a| a['username'] }.should == [ 'foo', 'foobar' ]
+            api.get('users').map { |a| a['user']['username'] }.should == [ 'bar' ]
+          end
+        end
+
+        when_the_repository 'wants to make foo, bar and foobar members' do
+          before do
+            file 'members.json', [ 'foo', 'bar', 'foobar' ]
+          end
+
+          it 'knife upload / emits a warning for bar and adds foo and foobar' do
+            knife('upload /').should_succeed "Updated /members.json\n"
+            api.get('association_requests').map { |a| a['username'] }.should == [ ]
+            api.get('users').map { |a| a['user']['username'] }.should == [ 'bar', 'foo', 'foobar' ]
+          end
+        end
+
+        when_the_repository 'wants to invite foo and have bar as a member' do
+          before do
+            file 'invitations.json', [ 'foo' ]
+            file 'members.json', [ 'bar' ]
+          end
+
+          it 'knife upload / does nothing' do
+            knife('upload /').should_succeed ''
+            api.get('association_requests').map { |a| a['username'] }.should == [ 'foo' ]
+            api.get('users').map { |a| a['user']['username'] }.should == [ 'bar' ]
+          end
+        end
+      end
+
+      context 'and has invited bar and foo' do
+        org_invite 'bar', 'foo'
+
+        when_the_repository 'wants to invite foo and bar (different order)' do
+          before do
+            file 'invitations.json', [ 'foo', 'bar' ]
+          end
+
+          it 'knife upload / does nothing' do
+            knife('upload /').should_succeed ''
+            api.get('association_requests').map { |a| a['username'] }.should == [ 'bar', 'foo' ]
+            api.get('users').map { |a| a['user']['username'] }.should == [ ]
+          end
+        end
+      end
+
+      context 'and has already added bar and foo as members of the org' do
+        org_member 'bar', 'foo'
+
+        when_the_repository 'wants to add foo and bar (different order)' do
+          before do
+            file 'members.json', [ 'foo', 'bar' ]
+          end
+
+          it 'knife upload / does nothing' do
+            knife('upload /').should_succeed ''
+            api.get('association_requests').map { |a| a['username'] }.should == [ ]
+            api.get('users').map { |a| a['user']['username'] }.should == [ 'bar', 'foo' ]
+          end
+        end
+      end
+    end
+  end
 end

data/spec/support/pedant/run_pedant.rb

@@ -25,7 +25,6 @@ def start_server(chef_repo_path)
   Chef::Config.versioned_cookbooks = true
   chef_fs = Chef::ChefFS::Config.new.local_fs
   data_store = Chef::ChefFS::ChefFSDataStore.new(chef_fs)
-  data_store = ChefZero::DataStore::V1ToV2Adapter.new(data_store, 'chef', :org_defaults => ChefZero::DataStore::V1ToV2Adapter::ORG_DEFAULTS)
   server = ChefZero::Server.new(:port => 8889.upto(9999), :data_store => data_store)#, :log_level => :debug)
   server.start_background
   server

data/spec/support/shared/functional/http.rb

@@ -155,6 +155,14 @@ module ChefHTTPShared
       }
     )
 
+    @api.post('/posty', 200, 'Hi!')
+
+    #
+    # 400 with an error
+    #
+    @api.get('/bad_request', 400, '{ "error": [ "Your request is just terrible." ] }')
+    @api.post('/bad_request', 400, '{ "error": [ "Your request is just terrible." ] }')
+
   end
 
   def stop_tiny_server
@@ -239,4 +247,3 @@ shared_examples_for "downloading all the things" do
     it_behaves_like "a 403 after a successful request when reusing the request object"
   end
 end
-

data/spec/support/shared/integration/integration_helper.rb

@@ -20,33 +20,23 @@
 require 'tmpdir'
 require 'fileutils'
 require 'chef/config'
-
-# Temporarily use our own copy of chef-zero rspec integration.
-# See support/shared/integration/chef_zero_support for details
-#require 'chef_zero/rspec'
-require 'support/shared/integration/chef_zero_support'
-
 require 'chef/json_compat'
+require 'chef/server_api'
+require 'chef_zero/rspec'
 require 'support/shared/integration/knife_support'
 require 'support/shared/integration/app_server_support'
 require 'spec_helper'
 
 module IntegrationSupport
-  include ChefZeroSupport
+  include ChefZero::RSpec
 
   module ClassMethods
-
-    def when_the_chef_server(desc, *tags, &block)
-      context("when the chef server #{desc}", *tags) do
-        #include ChefZero::RSpec::Fixtures
-        include_context "With chef-zero running"
-        module_eval(&block)
-      end
-    end
+    include ChefZero::RSpec
 
     def when_the_repository(desc, *tags, &block)
       context("when the chef repo #{desc}", *tags) do
         include_context "with a chef repo"
+
         module_eval(&block)
       end
     end
@@ -63,6 +53,10 @@ module IntegrationSupport
     includer_class.extend(ClassMethods)
   end
 
+  def api
+    Chef::ServerAPI.new
+  end
+
   def directory(relative_path, &block)
     old_parent_path = @parent_path
     @parent_path = path_to(relative_path)
@@ -77,10 +71,8 @@ module IntegrationSupport
     FileUtils.mkdir_p(dir) unless dir == '.'
     File.open(filename, 'w') do |file|
       raw = case contents
-            when Hash
+            when Hash, Array
               JSON.pretty_generate(contents)
-            when Array
-              contents.join("\n")
             else
               contents
             end
@@ -101,7 +93,7 @@ module IntegrationSupport
   end
 
   def cb_metadata(name, version, extra_text="")
-    "name '#{name}'; version '#{version}'#{extra_text}"
+    "name #{name.inspect}; version #{version.inspect}#{extra_text}"
   end
 
   def cwd(relative_path)

data/spec/support/shared/unit/platform_introspector.rb

@@ -29,6 +29,10 @@ shared_examples_for "a platform introspector" do
     end
     @platform_hash["debian"] = {["5", "6"] => "debian-5/6", "default" => "debian"}
     @platform_hash["default"] = "default"
+    # The following @platform_hash keys are used for testing version constraints
+    @platform_hash['exact_match'] = { '1.2.3' => 'exact', '>= 1.0' => 'not exact'}
+    @platform_hash['multiple_matches'] = { '~> 2.3.4' => 'matched ~> 2.3.4', '>= 2.3' => 'matched >=2.3' }
+    @platform_hash['successful_matches'] = { '< 3.0' => 'matched < 3.0', '>= 3.0' => 'matched >= 3.0' }
 
     @platform_family_hash = {
       "debian" => "debian value",
@@ -79,6 +83,24 @@ shared_examples_for "a platform introspector" do
     platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
   end
 
+  it 'returns the exact match' do
+    node.automatic_attrs[:platform] = 'exact_match'
+    node.automatic_attrs[:platform_version] = '1.2.3'
+    platform_introspector.value_for_platform(@platform_hash).should == 'exact'
+  end
+
+  it 'raises RuntimeError' do
+    node.automatic_attrs[:platform] = 'multiple_matches'
+    node.automatic_attrs[:platform_version] = '2.3.4'
+    expect {platform_introspector.value_for_platform(@platform_hash)}.to raise_error(RuntimeError)
+  end
+
+  it 'should return the value for that match' do
+    node.automatic_attrs[:platform] = 'successful_matches'
+    node.automatic_attrs[:platform_version] = '2.9'
+    platform_introspector.value_for_platform(@platform_hash).should == 'matched < 3.0'
+  end
+
   describe "when platform versions is an array" do
     it "returns a version-specific value based on the current platform" do
       node.automatic_attrs[:platform] = "debian"

data/spec/unit/application/apply.rb

@@ -20,7 +20,7 @@ require 'spec_helper'
 describe Chef::Application::Apply do
 
   before do
-    @app = Chef::Application::Recipe.new
+    @app = Chef::Application::Apply.new
     @app.stub(:configure_logging).and_return(true)
     @recipe_text = "package 'nyancat'"
     Chef::Config[:solo] = true
@@ -73,4 +73,14 @@ describe Chef::Application::Apply do
       @recipe_fh.path.should == @app.instance_variable_get(:@recipe_filename)
     end
   end
+  describe "recipe_file_arg" do
+    before do
+      ARGV.clear
+    end
+    it "should exit and log message" do
+      Chef::Log.should_receive(:debug).with(/^No recipe file provided/)
+      lambda { @app.run }.should raise_error(SystemExit) { |e| e.status.should == 1 }
+    end
+
+  end
 end

data/spec/unit/application/solo_spec.rb

@@ -49,7 +49,6 @@ describe Chef::Application::Solo do
     end
 
     describe "when the json_attribs configuration option is specified" do
-
       let(:json_attribs) { {"a" => "b"} }
       let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
       let(:json_source) { "https://foo.com/foo.json" }
@@ -66,8 +65,6 @@ describe Chef::Application::Solo do
       end
     end
 
-
-
     describe "when the recipe_url configuration option is specified" do
       before do
         Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
@@ -104,6 +101,25 @@ describe Chef::Application::Solo do
     end
   end
 
+  describe "when the json_attribs and recipe_url configuration options are both specified" do
+    let(:json_attribs) { {"a" => "b"} }
+    let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
+    let(:json_source) { "https://foo.com/foo.json" }
+
+    before do
+      Chef::Config[:json_attribs] = json_source
+      Chef::Config[:recipe_url] = "http://icanhas.cheezburger.com/lolcats"
+      Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
+      FileUtils.stub(:mkdir_p).and_return(true)
+      Chef::Mixin::Command.stub(:run_command).and_return(true)
+    end
+
+    it "should fetch the recipe_url first" do
+      @app.should_receive(:fetch_recipe_tarball).ordered
+      Chef::ConfigFetcher.should_receive(:new).ordered.and_return(config_fetcher)
+      @app.reconfigure
+    end
+  end
 
   describe "after the application has been configured" do
     before do

data/spec/unit/chef_fs/config_spec.rb

@@ -0,0 +1,58 @@
+#
+# Author:: Jess Mink (<jmink@getchef.com>)
+# Copyright:: Copyright (c) 2014 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'
+require 'chef/exceptions'
+require 'lib/chef/chef_fs/config.rb'
+
+describe Chef::ChefFS::Config do
+  describe "initialize" do
+    it "warns when hosted setups use 'everything'" do
+      base_config = Hash.new()
+      base_config[:repo_mode] = 'everything'
+      base_config[:chef_server_url] = 'http://foo.com/organizations/fake_org/'
+
+      ui = double("ui")
+      expect(ui).to receive(:warn)
+
+      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
+    end
+
+    it "doesn't warn when hosted setups use 'hosted_everything'" do
+      base_config = Hash.new()
+      base_config[:repo_mode] = 'hosted_everything'
+      base_config[:chef_server_url] = 'http://foo.com/organizations/fake_org/'
+
+      ui = double("ui")
+      expect(ui).to receive(:warn).exactly(0).times
+
+      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
+    end
+
+    it "doesn't warn when non-hosted setups use 'everything'" do
+      base_config = Hash.new()
+      base_config[:repo_mode] = 'everything'
+      base_config[:chef_server_url] = 'http://foo.com/'
+
+      ui = double("ui")
+      expect(ui).to receive(:warn).exactly(0).times
+
+      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
+    end
+  end
+end

data/spec/unit/config_fetcher_spec.rb

@@ -8,9 +8,7 @@ describe Chef::ConfigFetcher do
   let(:config_location_regex) { Regexp.escape(config_location) }
   let(:invalid_json_error_regex) { %r[Could not parse the provided JSON file \(#{config_location_regex}\)] }
 
-  let(:config_jail_path) { nil }
-
-  let(:fetcher) { Chef::ConfigFetcher.new(config_location, config_jail_path) }
+  let(:fetcher) { Chef::ConfigFetcher.new(config_location) }
 
   context "when loading a local file" do
     let(:config_location) { "/etc/chef/client.rb" }

data/spec/unit/config_spec.rb

@@ -19,6 +19,7 @@
 
 require 'spec_helper'
 require 'chef/exceptions'
+require 'chef/util/path_helper'
 
 describe Chef::Config do
   describe "config attribute writer: chef_server_url" do
@@ -117,278 +118,304 @@ describe Chef::Config do
 
   end
 
-  describe "class method: plaform_specific_path" do
-    it "should return given path on non-windows systems" do
-      platform_mock :unix do
-        path = "/etc/chef/cookbooks"
-        Chef::Config.platform_specific_path(path).should == "/etc/chef/cookbooks"
-      end
-    end
+  [ false, true ].each do |is_windows|
 
-    it "should return a windows path on windows systems" do
-      platform_mock :windows do
-        path = "/etc/chef/cookbooks"
-        Chef::Config.stub(:env).and_return({ 'SYSTEMDRIVE' => 'C:' })
-        # match on a regex that looks for the base path with an optional
-        # system drive at the beginning (c:)
-        # system drive is not hardcoded b/c it can change and b/c it is not present on linux systems
-        Chef::Config.platform_specific_path(path).should == "C:\\chef\\cookbooks"
+    context "On #{is_windows ? 'Windows' : 'Unix'}" do
+      def to_platform(*args)
+        Chef::Config.platform_specific_path(*args)
       end
-    end
-  end
 
-  describe "default values" do
-    def primary_cache_path
-      if windows?
-        "#{Chef::Config.env['SYSTEMDRIVE']}\\chef"
-      else
-        "/var/chef"
+      before :each do
+        Chef::Platform.stub(:windows?).and_return(is_windows)
       end
-    end
 
-    def secondary_cache_path
-      if windows?
-        "#{Chef::Config[:user_home]}\\.chef"
-      else
-        "#{Chef::Config[:user_home]}/.chef"
+      describe "class method: platform_specific_path" do
+        if is_windows
+          it "should return a windows path on windows systems" do
+            path = "/etc/chef/cookbooks"
+            Chef::Config.stub(:env).and_return({ 'SYSTEMDRIVE' => 'C:' })
+            # match on a regex that looks for the base path with an optional
+            # system drive at the beginning (c:)
+            # system drive is not hardcoded b/c it can change and b/c it is not present on linux systems
+            Chef::Config.platform_specific_path(path).should == "C:\\chef\\cookbooks"
+          end
+        else
+          it "should return given path on non-windows systems" do
+            path = "/etc/chef/cookbooks"
+            Chef::Config.platform_specific_path(path).should == "/etc/chef/cookbooks"
+          end
+        end
       end
-    end
 
-    before do
-      if windows?
-        Chef::Config.stub(:env).and_return({ 'SYSTEMDRIVE' => 'C:' })
-        Chef::Config[:user_home] = 'C:\Users\charlie'
-      else
-        Chef::Config[:user_home] = '/Users/charlie'
-      end
+      describe "default values" do
+        let :primary_cache_path do
+          if is_windows
+            "#{Chef::Config.env['SYSTEMDRIVE']}\\chef"
+          else
+            "/var/chef"
+          end
+        end
 
-      Chef::Config.stub(:path_accessible?).and_return(false)
-    end
+        let :secondary_cache_path do
+          if is_windows
+            "#{Chef::Config[:user_home]}\\.chef"
+          else
+            "#{Chef::Config[:user_home]}/.chef"
+          end
+        end
 
-    describe "Chef::Config[:cache_path]" do
-      context "when /var/chef exists and is accessible" do
-        it "defaults to /var/chef" do
-          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
-          Chef::Config[:cache_path].should == primary_cache_path
+        before do
+          if is_windows
+            Chef::Config.stub(:env).and_return({ 'SYSTEMDRIVE' => 'C:' })
+            Chef::Config[:user_home] = 'C:\Users\charlie'
+          else
+            Chef::Config[:user_home] = '/Users/charlie'
+          end
+
+          Chef::Config.stub(:path_accessible?).and_return(false)
         end
-      end
 
-      context "when /var/chef does not exist and /var is accessible" do
-        it "defaults to /var/chef" do
-          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
-          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var")).and_return(true)
-          Chef::Config[:cache_path].should == primary_cache_path
+        describe "Chef::Config[:cache_path]" do
+          context "when /var/chef exists and is accessible" do
+            it "defaults to /var/chef" do
+              Chef::Config.stub(:path_accessible?).with(to_platform("/var/chef")).and_return(true)
+              Chef::Config[:cache_path].should == primary_cache_path
+            end
+          end
+
+          context "when /var/chef does not exist and /var is accessible" do
+            it "defaults to /var/chef" do
+              File.stub(:exists?).with(to_platform("/var/chef")).and_return(false)
+              Chef::Config.stub(:path_accessible?).with(to_platform("/var")).and_return(true)
+              Chef::Config[:cache_path].should == primary_cache_path
+            end
+          end
+
+          context "when /var/chef does not exist and /var is not accessible" do
+            it "defaults to $HOME/.chef" do
+              File.stub(:exists?).with(to_platform("/var/chef")).and_return(false)
+              Chef::Config.stub(:path_accessible?).with(to_platform("/var")).and_return(false)
+              Chef::Config[:cache_path].should == secondary_cache_path
+            end
+          end
+
+          context "when /var/chef exists and is not accessible" do
+            it "defaults to $HOME/.chef" do
+              File.stub(:exists?).with(to_platform("/var/chef")).and_return(true)
+              File.stub(:readable?).with(to_platform("/var/chef")).and_return(true)
+              File.stub(:writable?).with(to_platform("/var/chef")).and_return(false)
+
+              Chef::Config[:cache_path].should == secondary_cache_path
+            end
+          end
+
+          context "when chef is running in local mode" do
+            before do
+              Chef::Config.local_mode = true
+            end
+
+            context "and config_dir is /a/b/c" do
+              before do
+                Chef::Config.config_dir to_platform('/a/b/c')
+              end
+
+              it "cache_path is /a/b/c/local-mode-cache" do
+                Chef::Config.cache_path.should == to_platform('/a/b/c/local-mode-cache')
+              end
+            end
+
+            context "and config_dir is /a/b/c/" do
+              before do
+                Chef::Config.config_dir to_platform('/a/b/c/')
+              end
+
+              it "cache_path is /a/b/c/local-mode-cache" do
+                Chef::Config.cache_path.should == to_platform('/a/b/c/local-mode-cache')
+              end
+            end
+          end
         end
-      end
 
-      context "when /var/chef does not exist and /var is not accessible" do
-        it "defaults to $HOME/.chef" do
-          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
-          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var")).and_return(false)
-          Chef::Config[:cache_path].should == secondary_cache_path
+        it "Chef::Config[:file_backup_path] defaults to /var/chef/backup" do
+          Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+          backup_path = is_windows ? "#{primary_cache_path}\\backup" : "#{primary_cache_path}/backup"
+          Chef::Config[:file_backup_path].should == backup_path
         end
-      end
 
-      context "when /var/chef exists and is not accessible" do
-        it "defaults to $HOME/.chef" do
-          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
-          File.stub(:readable?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
-          File.stub(:writable?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
+        it "Chef::Config[:ssl_verify_mode] defaults to :verify_none" do
+          Chef::Config[:ssl_verify_mode].should == :verify_none
+        end
 
-          Chef::Config[:cache_path].should == secondary_cache_path
+        it "Chef::Config[:ssl_ca_path] defaults to nil" do
+          Chef::Config[:ssl_ca_path].should be_nil
         end
-      end
-    end
 
-    it "Chef::Config[:file_backup_path] defaults to /var/chef/backup" do
-      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
-      backup_path = windows? ? "#{primary_cache_path}\\backup" : "#{primary_cache_path}/backup"
-      Chef::Config[:file_backup_path].should == backup_path
-    end
+        # TODO can this be removed?
+        if !is_windows
+          it "Chef::Config[:ssl_ca_file] defaults to nil" do
+            Chef::Config[:ssl_ca_file].should be_nil
+          end
+        end
 
-    it "Chef::Config[:ssl_verify_mode] defaults to :verify_none" do
-      Chef::Config[:ssl_verify_mode].should == :verify_none
-    end
+        it "Chef::Config[:data_bag_path] defaults to /var/chef/data_bags" do
+          Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+          data_bag_path = is_windows ? "#{primary_cache_path}\\data_bags" : "#{primary_cache_path}/data_bags"
+          Chef::Config[:data_bag_path].should == data_bag_path
+        end
 
-    it "Chef::Config[:ssl_ca_path] defaults to nil" do
-      Chef::Config[:ssl_ca_path].should be_nil
-    end
+        it "Chef::Config[:environment_path] defaults to /var/chef/environments" do
+          Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+          environment_path = is_windows ? "#{primary_cache_path}\\environments" : "#{primary_cache_path}/environments"
+          Chef::Config[:environment_path].should == environment_path
+        end
 
-    describe "when on UNIX" do
-      before do
-        Chef::Config.stub(:on_windows?).and_return(false)
-      end
+        describe "setting the config dir" do
 
-      it "Chef::Config[:ssl_ca_file] defaults to nil" do
-        Chef::Config[:ssl_ca_file].should be_nil
-      end
-    end
+          context "when the config file is /etc/chef/client.rb" do
 
-    it "Chef::Config[:data_bag_path] defaults to /var/chef/data_bags" do
-      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
-      data_bag_path = windows? ? "#{primary_cache_path}\\data_bags" : "#{primary_cache_path}/data_bags"
-      Chef::Config[:data_bag_path].should == data_bag_path
-    end
+            before do
+              Chef::Config.config_file = to_platform("/etc/chef/client.rb")
+            end
 
-    it "Chef::Config[:environment_path] defaults to /var/chef/environments" do
-      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
-      environment_path = windows? ? "#{primary_cache_path}\\environments" : "#{primary_cache_path}/environments"
-      Chef::Config[:environment_path].should == environment_path
-    end
+            it "config_dir is /etc/chef" do
+              Chef::Config.config_dir.should == to_platform("/etc/chef")
+            end
 
-    describe "joining platform specific paths" do
+            context "and chef is running in local mode" do
+              before do
+                Chef::Config.local_mode = true
+              end
 
-      context "on UNIX" do
-        before do
-          Chef::Config.stub(:on_windows?).and_return(false)
-        end
+              it "config_dir is /etc/chef" do
+                Chef::Config.config_dir.should == to_platform("/etc/chef")
+              end
+            end
 
-        it "joins components when some end with separators" do
-          Chef::Config.path_join("/foo/", "bar", "baz").should == "/foo/bar/baz"
-        end
+            context "when config_dir is set to /other/config/dir/" do
+              before do
+                Chef::Config.config_dir = to_platform("/other/config/dir/")
+              end
 
-        it "joins components that don't end in separators" do
-          Chef::Config.path_join("/foo", "bar", "baz").should == "/foo/bar/baz"
-        end
+              it "yields the explicit value" do
+                Chef::Config.config_dir.should == to_platform("/other/config/dir/")
+              end
+            end
 
-      end
+          end
 
-      context "on Windows" do
-        before do
-          Chef::Config.stub(:on_windows?).and_return(true)
-        end
+          context "when the user's home dir is /home/charlie/" do
+            before do
+              Chef::Config.user_home = to_platform("/home/charlie")
+            end
 
-        it "joins components with the windows separator" do
-          Chef::Config.path_join('c:\\foo\\', 'bar', "baz").should == 'c:\\foo\\bar\\baz'
-        end
-      end
-    end
+            it "config_dir is /home/charlie/.chef/" do
+              Chef::Config.config_dir.should == Chef::Util::PathHelper.join(to_platform("/home/charlie/.chef"), '')
+            end
 
-    describe "setting the config dir" do
+            context "and chef is running in local mode" do
+              before do
+                Chef::Config.local_mode = true
+              end
 
-      before do
-        Chef::Config.stub(:on_windows?).and_return(false)
-        Chef::Config.config_file = "/etc/chef/client.rb"
-      end
+              it "config_dir is /home/charlie/.chef/" do
+                Chef::Config.config_dir.should == Chef::Util::PathHelper.join(to_platform("/home/charlie/.chef"), '')
+              end
+            end
+          end
 
-      context "by default" do
-        it "is the parent dir of the config file" do
-          Chef::Config.config_dir.should == "/etc/chef"
-        end
-      end
-
-      context "when chef is running in local mode" do
-        before do
-          Chef::Config.local_mode = true
-          Chef::Config.user_home = "/home/charlie"
         end
 
-        it "is in the user's home dir" do
-          Chef::Config.config_dir.should == "/home/charlie/.chef/"
+        if is_windows
+          describe "finding the windows embedded dir" do
+            let(:default_config_location) { "c:/opscode/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
+            let(:alternate_install_location) { "c:/my/alternate/install/place/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
+            let(:non_omnibus_location) { "c:/my/dev/stuff/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
+
+            let(:default_ca_file) { "c:/opscode/chef/embedded/ssl/certs/cacert.pem" }
+
+            it "finds the embedded dir in the default location" do
+              Chef::Config.stub(:_this_file).and_return(default_config_location)
+              Chef::Config.embedded_dir.should == "c:/opscode/chef/embedded"
+            end
+
+            it "finds the embedded dir in a custom install location" do
+              Chef::Config.stub(:_this_file).and_return(alternate_install_location)
+              Chef::Config.embedded_dir.should == "c:/my/alternate/install/place/chef/embedded"
+            end
+
+            it "doesn't error when not in an omnibus install" do
+              Chef::Config.stub(:_this_file).and_return(non_omnibus_location)
+              Chef::Config.embedded_dir.should be_nil
+            end
+
+            it "sets the ssl_ca_cert path if the cert file is available" do
+              Chef::Config.stub(:_this_file).and_return(default_config_location)
+              File.stub(:exist?).with(default_ca_file).and_return(true)
+              Chef::Config.ssl_ca_file.should == default_ca_file
+            end
+          end
         end
       end
 
-      context "when explicitly set" do
-        before do
-          Chef::Config.config_dir = "/other/config/dir/"
+      describe "Chef::Config[:user_home]" do
+        it "should set when HOME is provided" do
+          expected = to_platform("/home/kitten")
+          Chef::Config.stub(:env).and_return({ 'HOME' => expected })
+          Chef::Config[:user_home].should == expected
         end
 
-        it "uses the explicit value" do
-          Chef::Config.config_dir.should == "/other/config/dir/"
+        it "should be set when only USERPROFILE is provided" do
+          expected = to_platform("/users/kitten")
+          Chef::Config.stub(:env).and_return({ 'USERPROFILE' => expected })
+          Chef::Config[:user_home].should == expected
         end
-      end
 
-    end
-
-    describe "finding the windows embedded dir" do
-      let(:default_config_location) { "c:/opscode/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
-      let(:alternate_install_location) { "c:/my/alternate/install/place/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
-      let(:non_omnibus_location) { "c:/my/dev/stuff/lib/ruby/gems/1.9.1/gems/chef-11.6.0/lib/chef/config.rb" }
-
-      let(:default_ca_file) { "c:/opscode/chef/embedded/ssl/certs/cacert.pem" }
-
-      it "finds the embedded dir in the default location" do
-        Chef::Config.stub(:_this_file).and_return(default_config_location)
-        Chef::Config.embedded_dir.should == "c:/opscode/chef/embedded"
-      end
-
-      it "finds the embedded dir in a custom install location" do
-        Chef::Config.stub(:_this_file).and_return(alternate_install_location)
-        Chef::Config.embedded_dir.should == "c:/my/alternate/install/place/chef/embedded"
-      end
-
-      it "doesn't error when not in an omnibus install" do
-        Chef::Config.stub(:_this_file).and_return(non_omnibus_location)
-        Chef::Config.embedded_dir.should be_nil
-      end
-
-      it "sets the ssl_ca_cert path if the cert file is available" do
-        Chef::Config.stub(:_this_file).and_return(default_config_location)
-        Chef::Config.stub(:on_windows?).and_return(true)
-        File.stub(:exist?).with(default_ca_file).and_return(true)
-        Chef::Config.ssl_ca_file.should == default_ca_file
+        it "falls back to the current working directory when HOME and USERPROFILE is not set" do
+          Chef::Config.stub(:env).and_return({})
+          Chef::Config[:user_home].should == Dir.pwd
+        end
       end
-    end
-  end
-
-  describe "Chef::Config[:user_home]" do
-    it "should set when HOME is provided" do
-      Chef::Config.stub(:env).and_return({ 'HOME' => "/home/kitten" })
-      Chef::Config[:user_home].should == "/home/kitten"
-    end
 
-    it "should be set when only USERPROFILE is provided" do
-      Chef::Config.stub(:env).and_return({ 'USERPROFILE' => "/users/kitten" })
-      Chef::Config[:user_home].should == "/users/kitten"
-    end
-
-    it "falls back to the current working directory when HOME and USERPROFILE is not set" do
-      Chef::Config.stub(:env).and_return({})
-      Chef::Config[:user_home].should == Dir.pwd
-    end
-  end
-
-  describe "Chef::Config[:encrypted_data_bag_secret]" do
-    db_secret_default_path =
-      Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+      describe "Chef::Config[:encrypted_data_bag_secret]" do
+        let(:db_secret_default_path){ to_platform("/etc/chef/encrypted_data_bag_secret") }
 
-    let(:db_secret_default_path){ db_secret_default_path }
+        before do
+          File.stub(:exist?).with(db_secret_default_path).and_return(secret_exists)
+        end
 
-    before do
-      File.stub(:exist?).with(db_secret_default_path).and_return(secret_exists)
-    end
+        context "/etc/chef/encrypted_data_bag_secret exists" do
+          let(:secret_exists) { true }
+          it "sets the value to /etc/chef/encrypted_data_bag_secret" do
+            Chef::Config[:encrypted_data_bag_secret].should eq db_secret_default_path
+          end
+        end
 
-    context "#{db_secret_default_path} exists" do
-      let(:secret_exists) { true }
-      it "sets the value to #{db_secret_default_path}" do
-        Chef::Config[:encrypted_data_bag_secret].should eq db_secret_default_path
+        context "/etc/chef/encrypted_data_bag_secret does not exist" do
+          let(:secret_exists) { false }
+          it "sets the value to nil" do
+            Chef::Config[:encrypted_data_bag_secret].should be_nil
+          end
+        end
       end
-    end
 
-    context "#{db_secret_default_path} does not exist" do
-      let(:secret_exists) { false }
-      it "sets the value to nil" do
-        Chef::Config[:encrypted_data_bag_secret].should be_nil
+      describe "Chef::Config[:event_handlers]" do
+        it "sets a event_handlers to an empty array by default" do
+          Chef::Config[:event_handlers].should eq([])
+        end
+        it "should be able to add custom handlers" do
+          o = Object.new
+          Chef::Config[:event_handlers] << o
+          Chef::Config[:event_handlers].should be_include(o)
+        end
       end
-    end
-  end
 
-  describe "Chef::Config[:event_handlers]" do
-    it "sets a event_handlers to an empty array by default" do
-      Chef::Config[:event_handlers].should eq([])
-    end
-    it "should be able to add custom handlers" do
-      o = Object.new
-      Chef::Config[:event_handlers] << o
-      Chef::Config[:event_handlers].should be_include(o)
-    end
-  end
-
-  describe "Chef::Config[:user_valid_regex]" do
-    context "on a platform that is not Windows" do
-      it "allows one letter usernames" do
-        any_match = Chef::Config[:user_valid_regex].any? { |regex| regex.match('a') }
-        expect(any_match).to be_true
+      describe "Chef::Config[:user_valid_regex]" do
+        context "on a platform that is not Windows" do
+          it "allows one letter usernames" do
+            any_match = Chef::Config[:user_valid_regex].any? { |regex| regex.match('a') }
+            expect(any_match).to be_true
+          end
+        end
       end
     end
   end