chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/tiny_server.rb

@@ -22,7 +22,6 @@ require 'webrick/https'
 require 'rack'
 #require 'thin'
 require 'singleton'
-require 'chef/json_compat'
 require 'open-uri'
 require 'chef/config'
 
@@ -152,7 +151,7 @@ module TinyServer
                       :available_routes => @routes, :request => env}
         # Uncomment me for glorious debugging
         # pp :not_found => debug_info
-        [404, {'Content-Type' => 'application/json'}, [ debug_info.to_json ]]
+        [404, {'Content-Type' => 'application/json'}, [ Chef::JSONCompat.to_json(debug_info) ]]
       end
     end
 

data/spec/unit/api_client_spec.rb

@@ -123,6 +123,10 @@ describe Chef::ApiClient do
     it "does not include the private key if not present" do
       @json.should_not include("private_key")
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { @client }
+    end
   end
 
   describe "when deserializing from JSON" do
@@ -135,7 +139,7 @@ describe Chef::ApiClient do
       "validator" => true,
       "json_class" => "Chef::ApiClient"
       }
-      @client = Chef::JSONCompat.from_json(client.to_json)
+      @client = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(client))
     end
 
     it "should deserialize to a Chef::ApiClient object" do

data/spec/unit/application/{apply.rb → apply_spec.rb}

@@ -35,24 +35,32 @@ describe Chef::Application::Apply do
   describe "read_recipe_file" do
     before do
       @recipe_file_name = "foo.rb"
-      @recipe_path = File.expand_path("foo.rb")
+      @recipe_path = File.expand_path(@recipe_file_name)
       @recipe_file = double("Tempfile (mock)", :read => @recipe_text)
       @app.stub(:open).with(@recipe_path).and_return(@recipe_file)
-      File.stub(:exist?).with("foo.rb").and_return(true)
+      File.stub(:exist?).with(@recipe_path).and_return(true)
       Chef::Application.stub(:fatal!).and_return(true)
     end
+
     it "should read text properly" do
       @app.read_recipe_file(@recipe_file_name)[0].should == @recipe_text
     end
     it "should return a file_handle" do
       @app.read_recipe_file(@recipe_file_name)[1].should be_instance_of(RSpec::Mocks::Mock)
     end
+
+    describe "when recipe is nil" do
+      it "should raise a fatal with the missing filename message" do
+        Chef::Application.should_receive(:fatal!).with("No recipe file was provided", 1)
+        @app.read_recipe_file(nil)
+      end
+    end
     describe "when recipe doesn't exist" do
       before do
-        File.stub(:exist?).with(@recipe_file_name).and_return(false)
+        File.stub(:exist?).with(@recipe_path).and_return(false)
       end
-      it "should raise a fatal" do
-        Chef::Application.should_receive(:fatal!)
+      it "should raise a fatal with the file doesn't exist message" do
+        Chef::Application.should_receive(:fatal!).with(/^No file exists at/, 1)
         @app.read_recipe_file(@recipe_file_name)
       end
     end

data/spec/unit/application/client_spec.rb

@@ -39,6 +39,43 @@ describe Chef::Application::Client, "reconfigure" do
     ARGV.replace(@original_argv)
   end
 
+  describe "when configured to not fork the client process" do
+    before do
+      Chef::Config[:client_fork] = false
+      Chef::Config[:daemonize] = false
+      Chef::Config[:interval] = nil
+      Chef::Config[:splay] = nil
+    end
+
+    context "when interval is given" do
+      before do
+        Chef::Config[:interval] = 600
+      end
+
+      it "should terminate with message" do
+        Chef::Application.should_receive(:fatal!).with(
+"Unforked chef-client interval runs are disabled in Chef 12.
+Configuration settings:
+  interval  = 600 seconds
+Enable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
+        )
+        @app.reconfigure
+      end
+    end
+
+    context "when configured to run once" do
+      before do
+        Chef::Config[:once] = true
+        Chef::Config[:interval] = 1000
+      end
+
+      it "should reconfigure chef-client" do
+        @app.reconfigure
+        Chef::Config[:interval].should be_nil
+      end
+    end
+  end
+
   describe "when in daemonized mode and no interval has been set" do
     before do
       Chef::Config[:daemonize] = true
@@ -131,28 +168,80 @@ end
 
 describe Chef::Application::Client, "run_application", :unix_only do
   before(:each) do
-    Chef::Config[:daemonize] = true
-    @pipe = IO.pipe
+    Chef::Config[:specific_recipes] = [] # normally gets set in @app.reconfigure
+
     @app = Chef::Application::Client.new
+    @app.setup_signal_handlers
     # Default logger doesn't work correctly when logging from a trap handler.
     @app.configure_logging
-    Chef::Daemon.stub(:daemonize).and_return(true)
-    @app.stub(:run_chef_client) do
+
+    @pipe = IO.pipe
+    @client = Chef::Client.new
+    Chef::Client.stub(:new).and_return(@client)
+    @client.stub(:run) do
       @pipe[1].puts 'started'
       sleep 1
       @pipe[1].puts 'finished'
     end
   end
 
-  it "should exit gracefully when sent SIGTERM", :volatile_on_solaris do
-    pid = fork do
-      @app.run_application
+  context "when sent SIGTERM", :volatile_on_solaris do
+    context "when converging in forked process" do
+      before do
+        Chef::Config[:daemonize] = true
+        Chef::Daemon.stub(:daemonize).and_return(true)
+      end
+
+      it "should exit hard with exitstatus 3" do
+        pid = fork do
+          @app.run_application
+        end
+        Process.kill("TERM", pid)
+        _pid, result = Process.waitpid2(pid)
+        result.exitstatus.should == 3
+      end
+
+      it "should allow child to finish converging" do
+        pid = fork do
+          @app.run_application
+        end
+        @pipe[0].gets.should == "started\n"
+        Process.kill("TERM", pid)
+        Process.wait
+        sleep 1 # Make sure we give the converging child process enough time to finish
+        IO.select([@pipe[0]], nil, nil, 0).should_not be_nil
+        @pipe[0].gets.should == "finished\n"
+      end
+    end
+
+    context "when running unforked" do
+      before(:each) do
+        Chef::Config[:client_fork] = false
+        Chef::Config[:daemonize] = false
+      end
+
+      it "should exit gracefully when sent during converge" do
+        pid = fork do
+          @app.run_application
+        end
+        @pipe[0].gets.should == "started\n"
+        Process.kill("TERM", pid)
+        _pid, result = Process.waitpid2(pid)
+        result.exitstatus.should == 0
+        IO.select([@pipe[0]], nil, nil, 0).should_not be_nil
+        @pipe[0].gets.should == "finished\n"
+      end
+
+      it "should exit hard when sent before converge" do
+        pid = fork do
+          sleep 3
+          @app.run_application
+        end
+        Process.kill("TERM", pid)
+        _pid, result = Process.waitpid2(pid)
+        result.exitstatus.should == 3
+      end
     end
-    @pipe[0].gets.should == "started\n"
-    Process.kill("TERM", pid)
-    Process.wait
-    IO.select([@pipe[0]], nil, nil, 0).should_not be_nil
-    @pipe[0].gets.should == "finished\n"
   end
 
   describe "when splay is set" do
@@ -176,6 +265,9 @@ describe Chef::Application::Client, "run_application", :unix_only do
         # If everything is fine, sending USR1 to self should prevent
         # app to go into splay sleep forever.
         Process.kill("USR1", Process.pid)
+        # On Ruby < 2.1, we need to give the signal handlers a little
+        # more time, otherwise the test will fail because interleavings.
+        sleep 1
       end
 
       number_of_sleep_calls = 0
@@ -185,7 +277,7 @@ describe Chef::Application::Client, "run_application", :unix_only do
       # We have to do it this way because the main loop of
       # Chef::Application::Client swallows most exceptions, and we need to be
       # able to expose our expectation failures to the parent process in the test.
-      @app.stub(:sleep) do |arg|
+      @app.stub(:interval_sleep) do |arg|
         number_of_sleep_calls += 1
         if number_of_sleep_calls > 1
           exit 127
@@ -194,6 +286,7 @@ describe Chef::Application::Client, "run_application", :unix_only do
     end
 
     it "shouldn't sleep when sent USR1" do
+      @app.stub(:interval_sleep).with(0).and_call_original
       pid = fork do
         @app.run_application
       end

data/spec/unit/application/solo_spec.rb

@@ -36,6 +36,31 @@ describe Chef::Application::Solo do
       Chef::Config[:solo].should be_true
     end
 
+    describe "when configured to not fork the client process" do
+      before do
+        Chef::Config[:client_fork] = false
+        Chef::Config[:daemonize] = false
+        Chef::Config[:interval] = nil
+        Chef::Config[:splay] = nil
+      end
+
+      context "when interval is given" do
+        before do
+          Chef::Config[:interval] = 600
+        end
+
+        it "should terminate with message" do
+          Chef::Application.should_receive(:fatal!).with(
+"Unforked chef-client interval runs are disabled in Chef 12.
+Configuration settings:
+  interval  = 600 seconds
+Enable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
+          )
+          @app.reconfigure
+        end
+      end
+    end
+
     describe "when in daemonized mode and no interval has been set" do
       before do
         Chef::Config[:daemonize] = true
@@ -142,4 +167,3 @@ describe Chef::Application::Solo do
   end
 
 end
-

data/spec/unit/client_spec.rb

@@ -61,6 +61,7 @@ describe Chef::Client do
   let(:client_opts) { {} }
 
   let(:client) do
+    Chef::Config[:event_loggers] = []
     Chef::Client.new(json_attribs, client_opts).tap do |c|
       c.node = node
     end
@@ -301,25 +302,6 @@ describe Chef::Client do
       include_examples "a successful client run"
     end
 
-    describe "when running chef-client with forking enabled", :unix_only do
-      include_examples "a successful client run" do
-        let(:process_status) do
-          double("Process::Status")
-        end
-
-        let(:enable_fork) { true }
-
-        before do
-          Process.should_receive(:waitpid2).and_return([1, process_status])
-
-          process_status.should_receive(:success?).and_return(true)
-          client.should_receive(:exit).and_return(nil)
-          client.should_receive(:fork).and_yield
-        end
-      end
-
-    end
-
     describe "when the client key already exists" do
 
       let(:api_client_exists?) { true }
@@ -389,7 +371,6 @@ describe Chef::Client do
           client.run
           node.run_list.should == Chef::RunList.new(new_runlist)
         end
-
       end
     end
 
@@ -404,16 +385,10 @@ describe Chef::Client do
 
       @events = double("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
   end

data/spec/unit/config_fetcher_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'chef/config_fetcher'
+
 describe Chef::ConfigFetcher do
-  let(:valid_json) { {:a=>"b"}.to_json }
+  let(:valid_json) { Chef::JSONCompat.to_json({:a=>"b"}) }
   let(:invalid_json) { %q[{"syntax-error": "missing quote}] }
   let(:http) { double("Chef::HTTP::Simple") }
 

data/spec/unit/config_spec.rb

@@ -242,8 +242,8 @@ describe Chef::Config do
           Chef::Config[:file_backup_path].should == backup_path
         end
 
-        it "Chef::Config[:ssl_verify_mode] defaults to :verify_none" do
-          Chef::Config[:ssl_verify_mode].should == :verify_none
+        it "Chef::Config[:ssl_verify_mode] defaults to :verify_peer" do
+          Chef::Config[:ssl_verify_mode].should == :verify_peer
         end
 
         it "Chef::Config[:ssl_ca_path] defaults to nil" do
@@ -417,6 +417,95 @@ describe Chef::Config do
           end
         end
       end
+
+      describe "Chef::Config[:internal_locale]" do
+        let(:shell_out) do
+          double("Chef::Mixin::ShellOut double", :exitstatus => 0, :stdout => locales)
+        end
+
+        let(:locales) { locale_array.join("\n") }
+
+        before do
+          allow(Chef::Config).to receive(:shell_out_with_systems_locale).with("locale -a").and_return(shell_out)
+        end
+
+        shared_examples_for "a suitable locale" do
+          it "returns an English UTF-8 locale" do
+            expect(Chef::Log).to_not receive(:warn).with(/Please install an English UTF-8 locale for Chef to use/)
+            expect(Chef::Log).to_not receive(:debug).with(/Defaulting to locale en_US.UTF-8 on Windows/)
+            expect(Chef::Log).to_not receive(:debug).with(/No usable locale -a command found/)
+            expect(Chef::Config[:internal_locale]).to eq expected_locale
+          end
+        end
+
+        context "when the result includes 'C.UTF-8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { [expected_locale, "en_US.UTF-8"] }
+            let(:expected_locale) { "C.UTF-8" }
+          end
+        end
+
+        context "when the result includes 'en_US.UTF-8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { ["en_CA.UTF-8", expected_locale, "en_NZ.UTF-8"] }
+            let(:expected_locale) { "en_US.UTF-8" }
+          end
+        end
+
+        context "when the result includes 'en_US.utf8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { ["en_CA.utf8", "en_US.utf8", "en_NZ.utf8"] }
+            let(:expected_locale) { "en_US.UTF-8" }
+          end
+        end
+
+        context "when the result includes 'en.UTF-8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { ["en.ISO8859-1", expected_locale] }
+            let(:expected_locale) { "en.UTF-8" }
+          end
+        end
+
+        context "when the result includes 'en_*.UTF-8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { [expected_locale, "en_CA.UTF-8", "en_GB.UTF-8"] }
+            let(:expected_locale) { "en_AU.UTF-8" }
+          end
+        end
+
+        context "when the result includes 'en_*.utf8'" do
+          include_examples "a suitable locale" do
+            let(:locale_array) { ["en_AU.utf8", "en_CA.utf8", "en_GB.utf8"] }
+            let(:expected_locale) { "en_AU.UTF-8" }
+          end
+        end
+
+        context "when the result does not include 'en_*.UTF-8'" do
+          let(:locale_array) { ["af_ZA", "af_ZA.ISO8859-1", "af_ZA.ISO8859-15", "af_ZA.UTF-8"] }
+
+          it "should fall back to C locale" do
+            expect(Chef::Log).to receive(:warn).with("Please install an English UTF-8 locale for Chef to use, falling back to C locale and disabling UTF-8 support.")
+            expect(Chef::Config[:internal_locale]).to eq 'C'
+          end
+        end
+
+        context "on error" do
+          let(:locale_array) { [] }
+
+          before do
+            allow(Chef::Config).to receive(:shell_out_with_systems_locale).and_raise("THIS IS AN ERROR")
+          end
+
+          it "should default to 'en_US.UTF-8'" do
+            if is_windows
+              expect(Chef::Log).to receive(:debug).with("Defaulting to locale en_US.UTF-8 on Windows, until it matters that we do something else.")
+            else
+              expect(Chef::Log).to receive(:debug).with("No usable locale -a command found, assuming you have en_US.UTF-8 installed.")
+            end
+            expect(Chef::Config[:internal_locale]).to eq "en_US.UTF-8"
+          end
+        end
+      end
     end
   end
 end