chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/chef_fs/file_system_spec.rb

@@ -0,0 +1,135 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 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/chef_fs/file_system'
+require 'chef/chef_fs/file_pattern'
+
+describe Chef::ChefFS::FileSystem do
+  include FileSystemSupport
+
+  context 'with empty filesystem' do
+    let(:fs) { memory_fs('', {}) }
+
+    context 'list' do
+      it '/' do
+        list_should_yield_paths(fs, '/', '/')
+      end
+      it '/a' do
+        list_should_yield_paths(fs, '/a', '/a')
+      end
+      it '/a/b' do
+        list_should_yield_paths(fs, '/a/b', '/a/b')
+      end
+      it '/*' do
+        list_should_yield_paths(fs, '/*', '/')
+      end
+    end
+
+    context 'resolve_path' do
+      it '/' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/').path.should == '/'
+      end
+      it 'nonexistent /a' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path.should == '/a'
+      end
+      it 'nonexistent /a/b' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/b').path.should == '/a/b'
+      end
+    end
+  end
+
+  context 'with a populated filesystem' do
+    let(:fs) {
+      memory_fs('', {
+        :a => {
+          :aa => {
+            :c => '',
+            :zz => ''
+          },
+          :ab => {
+            :c => '',
+          }
+        },
+        :x => ''
+      })
+    }
+    context 'list' do
+      it '/**' do
+        list_should_yield_paths(fs, '/**', '/', '/a', '/x', '/a/aa', '/a/aa/c', '/a/aa/zz', '/a/ab', '/a/ab/c')
+      end
+      it '/' do
+        list_should_yield_paths(fs, '/', '/')
+      end
+      it '/*' do
+        list_should_yield_paths(fs, '/*', '/', '/a', '/x')
+      end
+      it '/*/*' do
+        list_should_yield_paths(fs, '/*/*', '/a/aa', '/a/ab')
+      end
+      it '/*/*/*' do
+        list_should_yield_paths(fs, '/*/*/*', '/a/aa/c', '/a/aa/zz', '/a/ab/c')
+      end
+      it '/*/*/?' do
+        list_should_yield_paths(fs, '/*/*/?', '/a/aa/c', '/a/ab/c')
+      end
+      it '/a/*/c' do
+        list_should_yield_paths(fs, '/a/*/c', '/a/aa/c', '/a/ab/c')
+      end
+      it '/**b/c' do
+        list_should_yield_paths(fs, '/**b/c', '/a/ab/c')
+      end
+      it '/a/ab/c' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/c', '/a/ab/c')
+      end
+      it 'nonexistent /a/ab/blah' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/blah', '/a/ab/blah')
+      end
+      it 'nonexistent /a/ab/blah/bjork' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/blah/bjork', '/a/ab/blah/bjork')
+      end
+    end
+
+    context 'resolve_path' do
+      before(:each) do
+        no_blocking_calls_allowed
+      end
+      it 'resolves /' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/').path.should == '/'
+      end
+      it 'resolves /x' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/x').path.should == '/x'
+      end
+      it 'resolves /a' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path.should == '/a'
+      end
+      it 'resolves /a/aa' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa').path.should == '/a/aa'
+      end
+      it 'resolves /a/aa/zz' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa/zz').path.should == '/a/aa/zz'
+      end
+      it 'resolves nonexistent /y/x/w' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/y/x/w').path.should == '/y/x/w'
+      end
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -35,17 +35,15 @@ shared_examples_for Chef::Client do
     ohai_data = { :fqdn             => @fqdn,
                   :hostname         => @hostname,
                   :platform         => 'example-platform',
-                  :platform_version => 'example-platform',
+                  :platform_version => 'example-platform-1.0',
                   :data             => {} }
     ohai_data.stub!(:all_plugins).and_return(true)
-    ohai_data.stub!(:data).and_return(ohai_data[:data])
+    ohai_data.stub!(:data).and_return(ohai_data)
     Ohai::System.stub!(:new).and_return(ohai_data)
 
-    @node = Chef::Node.new(@hostname)
+    @node = Chef::Node.new
     @node.name(@fqdn)
     @node.chef_environment("_default")
-    @node[:platform] = "example-platform"
-    @node[:platform_version] = "example-platform-1.0"
 
     @client = Chef::Client.new
     @client.node = @node
@@ -75,6 +73,111 @@ shared_examples_for Chef::Client do
     end
   end
 
+  describe "configuring output formatters" do
+    before do
+      @original_config = Chef::Config.configuration
+    end
+
+    after do
+      Chef::Config.configuration.replace(@original_config)
+    end
+    context "when no formatter has been configured" do
+      before do
+        Chef::Config.formatters.clear
+        @client = Chef::Client.new
+      end
+
+      context "and STDOUT is a TTY" do
+        before do
+          Chef::Config[:force_formatter] = false
+          Chef::Config[:force_logger] = false
+          STDOUT.stub!(:tty?).and_return(true)
+        end
+
+        it "configures the :doc formatter" do
+          @client.formatters_for_run.should == [[:doc]]
+        end
+
+        context "and force_logger is set" do
+          before do
+            Chef::Config[:force_logger] = true
+          end
+
+          it "configures the :null formatter" do
+            Chef::Config[:force_logger].should be_true
+            @client.formatters_for_run.should == [[:null]]
+          end
+
+        end
+
+      end
+
+      context "and STDOUT is not a TTY" do
+        before do
+          Chef::Config[:force_formatter] = false
+          STDOUT.stub!(:tty?).and_return(false)
+        end
+
+        it "configures the :null formatter" do
+          @client.formatters_for_run.should == [[:null]]
+        end
+
+        context "and force_formatter is set" do
+          before do
+            Chef::Config[:force_formatter] = true
+          end
+          it "it configures the :doc formatter" do
+            @client.formatters_for_run.should == [[:doc]]
+          end
+        end
+      end
+
+    end
+
+    context "when a formatter is configured" do
+      context "with no output path" do
+        before do
+          Chef::Config.formatters.clear
+          @client = Chef::Client.new
+          Chef::Config.add_formatter(:min)
+        end
+
+        it "does not configure a default formatter" do
+          @client.formatters_for_run.should == [[:min, nil]]
+        end
+
+        it "configures the formatter for STDOUT/STDERR" do
+          configured_formatters = @client.configure_formatters
+          min_formatter = configured_formatters[0]
+          min_formatter.output.out.should == STDOUT
+          min_formatter.output.err.should == STDERR
+        end
+      end
+
+      context "with an output path" do
+        before do
+          Chef::Config.formatters.clear
+          @client = Chef::Client.new
+          @tmpout = Tempfile.open("rspec-for-client-formatter-selection-#{Process.pid}")
+          Chef::Config.add_formatter(:min, @tmpout.path)
+        end
+
+        after do
+          @tmpout.close unless @tmpout.closed?
+          @tmpout.unlink
+        end
+
+        it "configures the formatter for the file path" do
+          configured_formatters = @client.configure_formatters
+          min_formatter = configured_formatters[0]
+          min_formatter.output.out.path.should == @tmpout.path
+          min_formatter.output.err.path.should == @tmpout.path
+        end
+      end
+
+    end
+  end
+
   describe "run" do
 
     it "should identify the node and run ohai, then register the client" do
@@ -89,10 +192,8 @@ shared_examples_for Chef::Client do
       File.should_receive(:exists?).with(Chef::Config[:client_key]).exactly(1).times.and_return(false)
 
       #   Client.register will register with the validation client name.
-      Chef::REST.should_receive(:new).with(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).exactly(1).and_return(mock_chef_rest_for_client)
-      mock_chef_rest_for_client.should_receive(:register).with(@fqdn, Chef::Config[:client_key]).exactly(1).and_return(true)
+      Chef::ApiClient::Registration.any_instance.should_receive(:run)
       #   Client.register will then turn around create another
-
       #   Chef::REST object, this time with the client key it got from the
       #   previous step.
       Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url], @fqdn, Chef::Config[:client_key]).exactly(1).and_return(mock_chef_rest_for_node)
@@ -124,6 +225,9 @@ shared_examples_for Chef::Client do
       Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(mock_chef_rest_for_node_save)
       mock_chef_rest_for_node_save.should_receive(:put_rest).with("nodes/#{@fqdn}", @node).and_return(true)
 
+      Chef::RunLock.any_instance.should_receive(:acquire)
+      Chef::RunLock.any_instance.should_receive(:release)
+
       # Post conditions: check that node has been filled in correctly
       @client.should_receive(:run_started)
       @client.should_receive(:run_completed_successfully)
@@ -138,7 +242,6 @@ shared_examples_for Chef::Client do
             res.replace(string)
           end
           pipe_sim.should_receive(:gets).and_return(res)
-          Chef::CouchDB.should_receive(:new).and_return(nil)
           IO.should_receive(:pipe).and_return([pipe_sim, pipe_sim])
           IO.should_receive(:select).and_return(true)
         end
@@ -160,6 +263,25 @@ shared_examples_for Chef::Client do
       end
     end
 
+    it "should remove the run_lock on failure of #load_node" do
+      @run_lock = mock("Chef::RunLock", :acquire => true)
+      Chef::RunLock.stub!(:new).and_return(@run_lock)
+
+      @events = mock("Chef::EventDispatch::Dispatcher").as_null_object
+      Chef::EventDispatch::Dispatcher.stub!(:new).and_return(@events)
+
+      # @events is created on Chef::Client.new, so we need to recreate it after mocking
+      @client = Chef::Client.new
+      @client.stub!(:load_node).and_raise(Exception)
+      @run_lock.should_receive(:release)
+      if(Chef::Config[:client_fork] && !windows?)
+        @client.should_receive(:fork) do |&block|
+          block.call
+        end
+      end
+      lambda { @client.run }.should raise_error(Exception)
+    end
+
     describe "when notifying other objects of the status of the chef run" do
       before do
         Chef::Client.clear_notifications
@@ -232,32 +354,75 @@ shared_examples_for Chef::Client do
     end
   end
 
-  describe "should set single lettered environments correctly" do
+  describe "windows_admin_check" do
     before do
-      @original_env = Chef::Config[:environment]
+      @client = Chef::Client.new
     end
 
-    after do
-      Chef::Config[:environment] = @original_env
+    context "platform is not windows" do
+      before do
+        Chef::Platform.stub(:windows?).and_return(false)
+      end
+
+      it "shouldn't be called" do
+        @client.should_not_receive(:has_admin_privileges?)
+        @client.do_windows_admin_check
+      end
     end
 
-    it "should set the environment correctly" do
-      @node.chef_environment.should == "_default"
-      Chef::Config[:environment] = "A"
+    context "platform is windows" do
+      before do
+        Chef::Platform.stub(:windows?).and_return(true)
+      end
 
-      @client.build_node
-      
-      @node.chef_environment.should == "A"
+      it "should be called" do
+        @client.should_receive(:has_admin_privileges?)
+        @client.do_windows_admin_check
+      end
+
+      context "admin privileges exist" do
+        before do
+          @client.should_receive(:has_admin_privileges?).and_return(true)
+        end
+
+        it "should not log a warning message" do
+          Chef::Log.should_not_receive(:warn)
+          @client.do_windows_admin_check
+        end
+
+        context "fatal admin check is configured" do
+          it "should not raise an exception" do
+            @client.do_windows_admin_check.should_not raise_error(Chef::Exceptions::WindowsNotAdmin)
+          end
+        end
+      end
+
+      context "admin privileges doesn't exist" do
+        before do
+          @client.should_receive(:has_admin_privileges?).and_return(false)
+        end
+
+        it "should log a warning message" do
+          Chef::Log.should_receive(:warn)
+          @client.do_windows_admin_check
+        end
+
+        context "fatal admin check is configured" do
+          it "should raise an exception" do
+            @client.do_windows_admin_check.should_not raise_error(Chef::Exceptions::WindowsNotAdmin)
+          end
+        end
+      end
     end
   end
 
   describe "when a run list override is provided" do
     before do
-      @node = Chef::Node.new(@hostname)
+      @node = Chef::Node.new
       @node.name(@fqdn)
       @node.chef_environment("_default")
-      @node[:platform] = "example-platform"
-      @node[:platform_version] = "example-platform-1.0"
+      @node.automatic_attrs[:platform] = "example-platform"
+      @node.automatic_attrs[:platform_version] = "example-platform-1.0"
     end
 
     it "should permit spaces in overriding run list" do
@@ -302,8 +467,15 @@ describe Chef::Client do
 end
 
 describe "Chef::Client Forked" do
-  it_behaves_like Chef::Client
   before do
+    @original_config = Chef::Config.configuration
     Chef::Config[:client_fork] = true
   end
+
+  after do
+    Chef::Config.configuration.replace(@original_config)
+  end
+
+  it_behaves_like Chef::Client
+
 end

data/spec/unit/config_spec.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -17,6 +18,7 @@
 #
 
 require 'spec_helper'
+require 'chef/exceptions'
 
 describe Chef::Config do
   before(:all) do
@@ -24,50 +26,80 @@ describe Chef::Config do
     @original_env = { 'HOME' => ENV['HOME'], 'SYSTEMDRIVE' => ENV['SYSTEMDRIVE'], 'HOMEPATH' => ENV['HOMEPATH'], 'USERPROFILE' => ENV['USERPROFILE'] }
   end
 
-  shared_examples_for "server URL" do
-    it "should set the registration url" do
-      Chef::Config.registration_url.should == "https://junglist.gen.nz"
+  describe "config attribute writer: chef_server_url" do
+    before do
+      Chef::Config.chef_server_url = "https://junglist.gen.nz"
     end
 
-    it "should set the template url" do
-      Chef::Config.template_url.should == "https://junglist.gen.nz"
+    it "sets the server url" do
+      Chef::Config.chef_server_url.should == "https://junglist.gen.nz"
     end
 
-    it "should set the remotefile url" do
-      Chef::Config.remotefile_url.should == "https://junglist.gen.nz"
-    end
+    context "when the url has a leading space" do
+      before do
+        Chef::Config.chef_server_url = " https://junglist.gen.nz"
+      end
 
-    it "should set the search url" do
-      Chef::Config.search_url.should == "https://junglist.gen.nz"
-    end
+      it "strips the space from the url when setting" do
+        Chef::Config.chef_server_url.should == "https://junglist.gen.nz"
+      end
 
-    it "should set the role url" do
-      Chef::Config.role_url.should == "https://junglist.gen.nz"
     end
-  end
 
-  describe "config attribute writer: chef_server_url" do
-    before do
-      Chef::Config.chef_server_url = "https://junglist.gen.nz"
+    context "when the url is a frozen string" do
+      before do
+        Chef::Config.chef_server_url = " https://junglist.gen.nz".freeze
+      end
+
+      it "strips the space from the url when setting without raising an error" do
+        Chef::Config.chef_server_url.should == "https://junglist.gen.nz"
+      end
     end
 
-    it_behaves_like "server URL"
   end
 
-  context "when the url has a leading space" do
+  describe "when configuring formatters" do
+      # if TTY and not(force-logger)
+      #   formatter = configured formatter or default formatter
+      #   formatter goes to STDOUT/ERR
+      #   if log file is writeable
+      #     log level is configured level or info
+      #     log location is file
+      #   else
+      #     log level is warn
+      #     log location is STDERR
+      #    end
+      # elsif not(TTY) and force formatter
+      #   formatter = configured formatter or default formatter
+      #   if log_location specified
+      #     formatter goes to log_location
+      #   else
+      #     formatter goes to STDOUT/ERR
+      #   end
+      # else
+      #   formatter = "null"
+      #   log_location = configured-value or defualt
+      #   log_level = info or defualt
+      # end
+      #
     before do
-      Chef::Config.chef_server_url = " https://junglist.gen.nz"
+      @config_class = Class.new(Chef::Config)
     end
 
-    it_behaves_like "server URL"
-  end
+    it "has an empty list of formatters by default" do
+      @config_class.formatters.should == []
+    end
 
-  context "when the url is a frozen string" do
-    before do
-      Chef::Config.chef_server_url = " https://junglist.gen.nz".freeze
+    it "configures a formatter with a short name" do
+      @config_class.add_formatter(:doc)
+      @config_class.formatters.should == [[:doc, nil]]
+    end
+
+    it "configures a formatter with a file output" do
+      @config_class.add_formatter(:doc, "/var/log/formatter.log")
+      @config_class.formatters.should == [[:doc, "/var/log/formatter.log"]]
     end
 
-    it_behaves_like "server URL"
   end
 
   describe "class method: manage_secret_key" do
@@ -87,7 +119,7 @@ describe Chef::Config do
       end
 
       it "should not generate and store a chef server cookie id" do
-        Chef::FileCache.should_not_receive(:store).with("chef_server_cookie_id", /\w{40}/).and_return(true)
+        Chef::FileCache.should_not_receive(:store).with("chef_server_cookie_id", /\w{40}/)
         Chef::Config.manage_secret_key
       end
     end
@@ -121,19 +153,7 @@ describe Chef::Config do
     end
   end
 
-  describe "class method: openid_providers=" do
-    it "should not log an appropriate deprecation info message" do
-      Chef::Log.should_not_receive(:info).with("DEPRECATION: openid_providers will be removed, please use authorized_openid_providers").and_return(true)
-      Chef::Config.openid_providers = %w{opscode.com junglist.gen.nz}
-    end
-
-    it "should internally configure authorized_openid_providers with the value given" do
-      Chef::Config.should_receive(:configure).and_return(%w{opscode.com junglist.gen.nz})
-      Chef::Config.openid_providers = %w{opscode.com junglist.gen.nz}
-    end
-  end
-
-   describe "class method: plaform_specific_path" do
+  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"
@@ -186,13 +206,19 @@ describe Chef::Config do
     end
 
     it "Chef::Config[:data_bag_path] defaults to /var/chef/data_bags" do
-      data_bag_path = if windows?
-        "C:\\chef\\data_bags"
+      data_bag_path =
+        Chef::Config.platform_specific_path("/var/chef/data_bags")
+      Chef::Config[:data_bag_path].should == data_bag_path
+    end
+
+    it "Chef::Config[:environment_path] defaults to /var/chef/environments" do
+      environment_path = if windows?
+        "C:\\chef\\environments"
       else
-        "/var/chef/data_bags"
+        "/var/chef/environments"
       end
 
-      Chef::Config[:data_bag_path].should == data_bag_path
+      Chef::Config[:environment_path].should == environment_path
     end
   end
 
@@ -217,14 +243,39 @@ describe Chef::Config do
     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([])
+  describe "Chef::Config[:encrypted_data_bag_secret]" do
+    db_secret_default_path =
+      Chef::Config.platform_specific_path("/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)
+      # ugh...the only way to properly test this since the conditional
+      # is evaluated at file load/require time.
+      $LOADED_FEATURES.delete_if{|f| f =~ /chef\/config\.rb/}
+      require 'chef/config'
+    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
+      end
     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)
+
+    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
+      end
+    end
+  end
+
+  describe "Chef::Config[:log_location]" do
+    it "raises ConfigurationError when log_location directory is missing" do
+      missing_path = "/tmp/non-existing-dir/file"
+      expect{Chef::Config.log_location = missing_path}.to raise_error Chef::Exceptions::ConfigurationError
     end
   end