chef 11.14.0.alpha.4 → 11.14.0.rc.2

data/spec/unit/provider/remote_file/cache_control_data_spec.rb

@@ -125,6 +125,15 @@ describe Chef::Provider::RemoteFile::CacheControlData do
         cache_control_data.etag.should be_nil
         cache_control_data.mtime.should be_nil
       end
+
+      context "and it still is valid JSON" do
+        let(:cache_json_data) { '' }
+
+        it "returns empty cache control data" do
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should be_nil
+        end
+      end
     end
   end
 
@@ -190,7 +199,7 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       it "truncates the file cache path to 102 characters" do
         normalized_cache_path = cache_control_data.send('sanitized_cache_file_basename')
 
-        Chef::FileCache.should_receive(:store).with("remote_file/" + normalized_cache_path, cache_control_data.json_data)              
+        Chef::FileCache.should_receive(:store).with("remote_file/" + normalized_cache_path, cache_control_data.json_data)
 
         cache_control_data.save
 

data/spec/unit/provider/service/solaris_smf_service_spec.rb

@@ -66,7 +66,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call '/bin/svcs -l service_name'" do
-        @provider.should_receive(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
+        @provider.should_receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
         @provider.load_current_resource
       end
 
@@ -145,7 +145,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm disable -s chef for stop_service" do
-        @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm disable -s chef")
+        @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm disable -s chef").and_return(@status)
         @provider.stop_service.should be_true
         @current_resource.enabled.should be_false
       end
@@ -164,5 +164,26 @@ describe Chef::Provider::Service::Solaris do
       end
 
     end
+
+    describe "when the service doesn't exist" do
+      before(:each) do
+        @stdout_string = ""
+        @status = double("Status", :exitstatus => 1, :stdout => @stdout)
+        @provider.current_resource = @current_resource
+      end
+
+      it "should be marked not running" do
+        @provider.should_receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
+        @provider.service_status
+        @current_resource.running.should be_false
+      end
+
+      it "should be marked not enabled" do
+        @provider.should_receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
+        @provider.service_status
+        @current_resource.enabled.should be_false
+      end
+
+    end
   end
 end

data/spec/unit/provider/service/upstart_service_spec.rb

@@ -88,6 +88,13 @@ describe Chef::Provider::Service::Upstart do
       @provider.load_current_resource
     end
 
+    it "should not change the service name when parameters are specified" do
+      @new_resource.parameters({ "OSD_ID" => "2" })
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @new_resource.service_name.should == @current_resource.service_name
+    end
+
     it "should run '/sbin/status rsyslog'" do
       @provider.should_receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
       @provider.load_current_resource

data/spec/unit/provider/service/windows_spec.rb

@@ -92,8 +92,39 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.start_service
       @new_resource.updated_by_last_action?.should be_false
     end
+
+    it "should raise an error if the service is paused" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "paused"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should wait and continue if the service is in start_pending" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "start pending"),
+        double("StatusStruct", :current_state => "start pending"),
+        double("StatusStruct", :current_state => "running"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      @provider.start_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should fail if the service is in stop_pending" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "stop pending"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
   end
 
+
   describe Chef::Provider::Service::Windows, "stop_service" do
 
     before(:each) do
@@ -130,6 +161,47 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.stop_service
       @new_resource.updated_by_last_action?.should be_false
     end
+
+    it "should raise an error if the service is paused" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "paused"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should wait and continue if the service is in stop_pending" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "stop pending"),
+        double("StatusStruct", :current_state => "stop pending"),
+        double("StatusStruct", :current_state => "stopped"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      @provider.stop_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should fail if the service is in start_pending" do
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "start pending"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should pass custom timeout to the stop command if provided" do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "running"))
+      @new_resource.timeout 1
+      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
+      Timeout.timeout(2) do
+        expect { @provider.stop_service }.to raise_error(Timeout::Error)
+      end
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
   end
 
   describe Chef::Provider::Service::Windows, "restart_service" do

data/spec/unit/provider/user/pw_spec.rb

@@ -164,10 +164,27 @@ describe Chef::Provider::User::Pw do
       @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
     end
 
-    it "should check for differences in password between the new and current resources" do
-      @current_resource.should_receive(:password)
-      @new_resource.should_receive(:password)
-      @provider.modify_password
+    describe "and the new password has not been specified" do
+      before(:each) do
+        @new_resource.stub(:password).and_return(nil)
+      end
+
+      it "logs an appropriate message" do
+        Chef::Log.should_receive(:debug).with("user[adam] no change needed to password")
+        @provider.modify_password
+      end
+    end
+
+    describe "and the new password has been specified" do
+      before(:each) do
+        @new_resource.stub(:password).and_return("abracadabra")
+      end
+
+      it "should check for differences in password between the new and current resources" do
+        @current_resource.should_receive(:password)
+        @new_resource.should_receive(:password)
+        @provider.modify_password
+      end
     end
 
     describe "and the passwords are identical" do

data/spec/unit/provider/user/useradd_spec.rb

@@ -37,4 +37,14 @@ describe Chef::Provider::User::Useradd do
   }
 
   include_examples "a useradd-based user provider", supported_useradd_options
+
+  describe "manage_user" do
+    # CHEF-5247: Chef::Provider::User::Solaris subclasses Chef::Provider::User::Useradd, but does not use usermod to change passwords.
+    # Thus, a call to Solaris#manage_user calls Solaris#manage_password and Useradd#manage_user, but the latter should be a no-op.
+    it "should not run the command if universal_options is an empty array" do
+      provider.stub(:universal_options).and_return([])
+      expect(provider).not_to receive(:shell_out!)
+      provider.manage_user
+    end
+  end
 end

data/spec/unit/resource/package_spec.rb

@@ -64,22 +64,30 @@ describe Chef::Resource::Package do
     @resource.options.should eql("something")
   end
 
- describe "when it has a package_name and version" do
-   before do
-     @resource.package_name("tomcat")
-     @resource.version("10.9.8")
-     @resource.options("-al")
-   end
-
-   it "describes its state" do
-     state = @resource.state
-     state[:version].should == "10.9.8"
-     state[:options].should == "-al"
-   end
-
-   it "returns the file path as its identity" do
-     @resource.identity.should == "tomcat"
-   end
-
- end
+  describe "when it has a package_name and version" do
+    before do
+      @resource.package_name("tomcat")
+      @resource.version("10.9.8")
+      @resource.options("-al")
+    end
+
+    it "describes its state" do
+      state = @resource.state
+      state[:version].should == "10.9.8"
+      state[:options].should == "-al"
+    end
+
+    it "returns the file path as its identity" do
+      @resource.identity.should == "tomcat"
+    end
+  end
+
+  # String, Integer
+  [ "600", 600 ].each do |val|
+    it "supports setting a timeout as a #{val.class}" do
+      @resource.timeout(val)
+      expect(@resource.timeout).to eql(val)
+    end
+  end
+
 end

data/spec/unit/resource/registry_key_spec.rb

@@ -89,6 +89,11 @@ describe Chef::Resource::RegistryKey, "values" do
     @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
   end
 
+  it "should return checksummed data if the type is unsafe" do
+    @resource.values( { :name => 'poosh', :type => :binary, :data => 255.chr * 1 })
+    @resource.values.should eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ])
+  end
+
   it "should throw an exception if the name field is missing" do
     lambda { @resource.values [ { :type => :string, :data => 'carmen' } ] }.should raise_error(ArgumentError)
   end
@@ -169,3 +174,26 @@ describe Chef::Resource::RegistryKey, "architecture" do
     lambda { @resource.architecture(100) }.should raise_error(ArgumentError)
   end
 end
+
+describe Chef::Resource::RegistryKey, ":unscrubbed_values" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should return unsafe data as-is" do
+    key_values = [ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ]
+    @resource.values(key_values)
+    @resource.unscrubbed_values.should eql(key_values)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "state" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should return scrubbed values" do
+    @resource.values([ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ])
+    @resource.state.should eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } )
+  end
+end

data/spec/unit/resource/service_spec.rb

@@ -29,6 +29,20 @@ describe Chef::Resource::Service do
     @resource.should be_a_kind_of(Chef::Resource)
     @resource.should be_a_kind_of(Chef::Resource::Service)
   end
+  
+  it "should not set a provider unless node[:init_package] is defined as systemd" do
+    @resource.provider.should == nil
+  end
+    
+  it "should set the provider to Chef::Provider::Service::Systemd if node[:init_package] is systemd" do
+    node = Chef::Node.new
+    node.set[:init_package] = "systemd"
+    cookbook_collection = Chef::CookbookCollection.new([])
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, cookbook_collection, events)
+    @resource = Chef::Resource::Service.new("chef", run_context)
+    @resource.provider.should == Chef::Provider::Service::Systemd
+  end
 
   it "should set the service_name to the first argument to new" do
     @resource.service_name.should eql("chef")

data/spec/unit/resource_reporter_spec.rb

@@ -39,7 +39,8 @@ describe Chef::ResourceReporter do
     @rest_client.stub(:post_rest).and_return(true)
     @resource_reporter = Chef::ResourceReporter.new(@rest_client)
     @new_resource      = Chef::Resource::File.new("/tmp/a-file.txt")
-    @new_resource.cookbook_name = "monkey"
+    @cookbook_name = "monkey"
+    @new_resource.cookbook_name = @cookbook_name
     @cookbook_version = double("Cookbook::Version", :version => "1.2.3")
     @new_resource.stub(:cookbook_version).and_return(@cookbook_version)
     @current_resource  = Chef::Resource::File.new("/tmp/a-file.txt")
@@ -316,8 +317,7 @@ describe Chef::ResourceReporter do
       end
     end
 
-
-    context "for a successful client run" do
+    shared_examples_for "a successful client run" do
       before do
         # TODO: add inputs to generate expected output.
 
@@ -349,10 +349,10 @@ describe Chef::ResourceReporter do
         #    "status" : "success"
         #    "data" : ""
         # }
-        @resource_reporter.resource_action_start(@new_resource, :create)
-        @resource_reporter.resource_current_state_loaded(@new_resource, :create, @current_resource)
-        @resource_reporter.resource_updated(@new_resource, :create)
-        @resource_reporter.resource_completed(@new_resource)
+        @resource_reporter.resource_action_start(new_resource, :create)
+        @resource_reporter.resource_current_state_loaded(new_resource, :create, current_resource)
+        @resource_reporter.resource_updated(new_resource, :create)
+        @resource_reporter.resource_completed(new_resource)
         @run_status.stop_clock
         @report = @resource_reporter.prepare_run_data
         @first_update_report = @report["resources"].first
@@ -371,19 +371,19 @@ describe Chef::ResourceReporter do
       end
 
       it "includes an updated resource's initial state" do
-        @first_update_report["before"].should == @current_resource.state
+        @first_update_report["before"].should == current_resource.state
       end
 
       it "includes an updated resource's final state" do
-        @first_update_report["after"].should == @new_resource.state
+        @first_update_report["after"].should == new_resource.state
       end
 
       it "includes the resource's name" do
-        @first_update_report["name"].should == @new_resource.name
+        @first_update_report["name"].should == new_resource.name
       end
 
       it "includes the resource's id attribute" do
-        @first_update_report["id"].should == @new_resource.identity
+        @first_update_report["id"].should == new_resource.identity
       end
 
       it "includes the elapsed time for the resource to converge" do
@@ -400,7 +400,7 @@ describe Chef::ResourceReporter do
 
       it "includes the cookbook name of the resource" do
         @first_update_report.should have_key("cookbook_name")
-        @first_update_report["cookbook_name"].should == "monkey"
+        @first_update_report["cookbook_name"].should == @cookbook_name
       end
 
       it "includes the cookbook version of the resource" do
@@ -430,6 +430,31 @@ describe Chef::ResourceReporter do
 
     end
 
+    context "when the resource is a File" do
+      let(:new_resource) { @new_resource }
+      let(:current_resource) { @current_resource }
+
+      it_should_behave_like "a successful client run"
+    end
+
+    context "when the resource is a RegistryKey with binary data" do
+      let(:new_resource) do
+        resource = Chef::Resource::RegistryKey.new('Wubba\Lubba\Dub\Dubs')
+        resource.values([ { :name => 'rick', :type => :binary, :data => 255.chr * 1 } ])
+        resource.stub(:cookbook_name).and_return(@cookbook_name)
+        resource.stub(:cookbook_version).and_return(@cookbook_version)
+        resource
+      end
+
+      let(:current_resource) do
+        resource = Chef::Resource::RegistryKey.new('Wubba\Lubba\Dub\Dubs')
+        resource.values([ { :name => 'rick', :type => :binary, :data => 255.chr * 1 } ])
+        resource
+      end
+
+      it_should_behave_like "a successful client run"
+    end
+
     context "for an unsuccessful run" do
 
       before do

data/spec/unit/resource_spec.rb

@@ -344,7 +344,8 @@ describe Chef::Resource do
       expected_keys = [ :allowed_actions, :params, :provider, :updated,
         :updated_by_last_action, :before, :supports,
         :noop, :ignore_failure, :name, :source_line,
-        :action, :retries, :retry_delay, :elapsed_time, :guard_interpreter]
+        :action, :retries, :retry_delay, :elapsed_time, 
+        :guard_interpreter, :sensitive ]
       (hash.keys - expected_keys).should == []
       (expected_keys - hash.keys).should == []
       hash[:name].should eql("funk")
@@ -559,12 +560,12 @@ describe Chef::Resource do
       @resource.should_skip?(:purr).should be_false
     end
 
-    it "should return false when if_only is met" do
+    it "should return false when only_if is met" do
       @resource.only_if { true }
       @resource.should_skip?(:purr).should be_false
     end
 
-    it "should return true when if_only is not met" do
+    it "should return true when only_if is not met" do
       @resource.only_if { false }
       @resource.should_skip?(:purr).should be_true
     end
@@ -574,18 +575,18 @@ describe Chef::Resource do
       @resource.should_skip?(:purr).should be_true
     end
 
-    it "should return false when if_only is not met" do
+    it "should return false when not_if is not met" do
       @resource.not_if { false }
       @resource.should_skip?(:purr).should be_false
     end
 
-    it "should return true when if_only is met but also not_if is met" do
+    it "should return true when only_if is met but also not_if is met" do
       @resource.only_if { true }
       @resource.not_if { true }
       @resource.should_skip?(:purr).should be_true
     end
 
-    it "should return true when one of multiple if_only's is not met" do
+    it "should return true when one of multiple only_if's is not met" do
       @resource.only_if { true }
       @resource.only_if { false }
       @resource.only_if { true }
@@ -781,6 +782,40 @@ describe Chef::Resource do
     end
 
   end
+
+  describe "resource sensitive attribute" do
+
+    before(:each) do
+       @resource_file = Chef::Resource::File.new("/nonexistent/CHEF-5098/file", @run_context)
+       @action = :create
+    end 
+
+    def compiled_resource_data(resource, action, err)
+      error_inspector = Chef::Formatters::ErrorInspectors::ResourceFailureInspector.new(resource, action, err)
+      description = Chef::Formatters::ErrorDescription.new("test")
+      error_inspector.add_explanation(description)
+      Chef::Log.info("descrtiption: #{description.inspect},error_inspector: #{error_inspector}")
+      description.sections[1]["Compiled Resource:"]
+    end
+
+    it "set to false by default" do
+      @resource.sensitive.should be_false
+    end
+
+    it "when set to false should show compiled resource for failed resource" do
+      expect { @resource_file.run_action(@action) }.to raise_error { |err|
+            compiled_resource_data(@resource_file, @action, err).should match 'path "/nonexistent/CHEF-5098/file"'
+          }
+    end
+
+    it "when set to true should show compiled resource for failed resource" do
+      @resource_file.sensitive true
+      expect { @resource_file.run_action(@action) }.to raise_error { |err|
+            compiled_resource_data(@resource_file, @action, err).should eql("suppressed sensitive resource output")
+          }
+    end
+
+  end
 end
 
 describe Chef::Resource::Notification do