chef 12.0.0.alpha.2 → 12.0.0.rc.0

data/spec/unit/provider/env_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Provider::Env do
   end
 
   it "assumes the key_name exists by default" do
-    @provider.key_exists.should be_true
+    expect(@provider.key_exists).to be_true
   end
 
   describe "when loading the current status" do
@@ -38,73 +38,73 @@ describe Chef::Provider::Env do
       #@current_resource = @new_resource.clone
       #Chef::Resource::Env.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
-      @provider.stub(:env_value).with("FOO").and_return("bar")
-      @provider.stub(:env_key_exists).and_return(true)
+      allow(@provider).to receive(:env_value).with("FOO").and_return("bar")
+      allow(@provider).to receive(:env_key_exists).and_return(true)
     end
 
     it "should create a current resource with the same name as the new resource" do
       @provider.load_current_resource
-      @provider.new_resource.name.should == "FOO"
+      expect(@provider.new_resource.name).to eq("FOO")
     end
 
     it "should set the key_name to the key name of the new resource" do
       @provider.load_current_resource
-      @provider.current_resource.key_name.should == "FOO"
+      expect(@provider.current_resource.key_name).to eq("FOO")
     end
 
     it "should check if the key_name exists" do
-      @provider.should_receive(:env_key_exists).with("FOO").and_return(true)
+      expect(@provider).to receive(:env_key_exists).with("FOO").and_return(true)
       @provider.load_current_resource
-      @provider.key_exists.should be_true
+      expect(@provider.key_exists).to be_true
     end
 
     it "should flip the value of exists if the key does not exist" do
-      @provider.should_receive(:env_key_exists).with("FOO").and_return(false)
+      expect(@provider).to receive(:env_key_exists).with("FOO").and_return(false)
       @provider.load_current_resource
-      @provider.key_exists.should be_false
+      expect(@provider.key_exists).to be_false
     end
 
     it "should return the current resource" do
-      @provider.load_current_resource.should be_a_kind_of(Chef::Resource::Env)
+      expect(@provider.load_current_resource).to be_a_kind_of(Chef::Resource::Env)
     end
   end
 
   describe "action_create" do
     before do
       @provider.key_exists = false
-      @provider.stub(:create_env).and_return(true)
-      @provider.stub(:modify_env).and_return(true)
+      allow(@provider).to receive(:create_env).and_return(true)
+      allow(@provider).to receive(:modify_env).and_return(true)
     end
 
     it "should call create_env if the key does not exist" do
-      @provider.should_receive(:create_env).and_return(true)
+      expect(@provider).to receive(:create_env).and_return(true)
       @provider.action_create
     end
 
     it "should set the new_resources updated flag when it creates the key" do
       @provider.action_create
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should check to see if the values are the same if the key exists" do
       @provider.key_exists = true
-      @provider.should_receive(:compare_value).and_return(false)
+      expect(@provider).to receive(:requires_modify_or_create?).and_return(false)
       @provider.action_create
     end
 
     it "should call modify_env if the key exists and values are not equal" do
       @provider.key_exists = true
-      @provider.stub(:compare_value).and_return(true)
-      @provider.should_receive(:modify_env).and_return(true)
+      allow(@provider).to receive(:requires_modify_or_create?).and_return(true)
+      expect(@provider).to receive(:modify_env).and_return(true)
       @provider.action_create
     end
 
     it "should set the new_resources updated flag when it updates an existing value" do
       @provider.key_exists = true
-      @provider.stub(:compare_value).and_return(true)
-      @provider.stub(:modify_env).and_return(true)
+      allow(@provider).to receive(:requires_modify_or_create?).and_return(true)
+      allow(@provider).to receive(:modify_env).and_return(true)
       @provider.action_create
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
   end
 
@@ -112,30 +112,30 @@ describe Chef::Provider::Env do
     before(:each) do
       @provider.current_resource = @current_resource
       @provider.key_exists = false
-      @provider.stub(:delete_element).and_return(false)
-      @provider.stub(:delete_env).and_return(true)
+      allow(@provider).to receive(:delete_element).and_return(false)
+      allow(@provider).to receive(:delete_env).and_return(true)
     end
 
     it "should not call delete_env if the key does not exist" do
-      @provider.should_not_receive(:delete_env)
+      expect(@provider).not_to receive(:delete_env)
       @provider.action_delete
     end
 
     it "should not call delete_element if the key does not exist" do
-      @provider.should_not_receive(:delete_element)
+      expect(@provider).not_to receive(:delete_element)
       @provider.action_delete
     end
 
     it "should call delete_env if the key exists" do
       @provider.key_exists = true
-      @provider.should_receive(:delete_env)
+      expect(@provider).to receive(:delete_env)
       @provider.action_delete
     end
 
     it "should set the new_resources updated flag to true if the key is deleted" do
       @provider.key_exists = true
       @provider.action_delete
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
   end
 
@@ -143,31 +143,31 @@ describe Chef::Provider::Env do
     before(:each) do
       @provider.current_resource = @current_resource
       @provider.key_exists = true
-      @provider.stub(:modify_env).and_return(true)
+      allow(@provider).to receive(:modify_env).and_return(true)
     end
 
     it "should call modify_group if the key exists and values are not equal" do
-      @provider.should_receive(:compare_value).and_return(true)
-      @provider.should_receive(:modify_env).and_return(true)
+      expect(@provider).to receive(:requires_modify_or_create?).and_return(true)
+      expect(@provider).to receive(:modify_env).and_return(true)
       @provider.action_modify
     end
 
     it "should set the new resources updated flag to true if modify_env is called" do
-      @provider.stub(:compare_value).and_return(true)
-      @provider.stub(:modify_env).and_return(true)
+      allow(@provider).to receive(:requires_modify_or_create?).and_return(true)
+      allow(@provider).to receive(:modify_env).and_return(true)
       @provider.action_modify
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not call modify_env if the key exists but the values are equal" do
-      @provider.should_receive(:compare_value).and_return(false)
-      @provider.should_not_receive(:modify_env)
+      expect(@provider).to receive(:requires_modify_or_create?).and_return(false)
+      expect(@provider).not_to receive(:modify_env)
       @provider.action_modify
     end
 
     it "should raise a Chef::Exceptions::Env if the key doesn't exist" do
       @provider.key_exists = false
-      lambda { @provider.action_modify }.should raise_error(Chef::Exceptions::Env)
+      expect { @provider.action_modify }.to raise_error(Chef::Exceptions::Env)
     end
   end
 
@@ -183,24 +183,46 @@ describe Chef::Provider::Env do
     end
 
     it "should return true if the element is not found" do
-      @new_resource.stub(:value).and_return("C:/baz/bin")
-      @provider.delete_element.should eql(true)
+      allow(@new_resource).to receive(:value).and_return("C:/baz/bin")
+      expect(@provider.delete_element).to eql(true)
     end
 
     it "should return false if the delim not defined" do
-      @new_resource.stub(:delim).and_return(nil)
-      @provider.delete_element.should eql(false)
+      allow(@new_resource).to receive(:delim).and_return(nil)
+      expect(@provider.delete_element).to eql(false)
     end
 
     it "should return true if the element is deleted" do
       @new_resource.value("C:/foo/bin")
-      @provider.should_receive(:create_env)
-      @provider.delete_element.should eql(true)
-      @new_resource.should be_updated
+      expect(@provider).to receive(:create_env)
+      expect(@provider.delete_element).to eql(true)
+      expect(@new_resource).to be_updated
+    end
+
+    context "when new_resource's value contains the delimiter"  do
+      it "should return false if all the elements are deleted" do
+        # This indicates that the entire key needs to be deleted
+        @new_resource.value("C:/foo/bin;C:/bar/bin")
+        expect(@provider.delete_element).to eql(false)
+        expect(@new_resource).not_to be_updated  # This will be updated in action_delete
+      end
+
+      it "should return true if any, but not all, of the elements are deleted" do
+        @new_resource.value("C:/foo/bin;C:/notbaz/bin")
+        expect(@provider).to receive(:create_env)
+        expect(@provider.delete_element).to eql(true)
+        expect(@new_resource).to be_updated
+      end
+
+      it "should return true if none of the elements are deleted" do
+        @new_resource.value("C:/notfoo/bin;C:/notbaz/bin")
+        expect(@provider.delete_element).to eql(true)
+        expect(@new_resource).not_to be_updated
+      end
     end
   end
 
-  describe "compare_value" do
+  describe "requires_modify_or_create?" do
     before(:each) do
       @new_resource.value("C:/bar")
       @current_resource = @new_resource.clone
@@ -208,31 +230,47 @@ describe Chef::Provider::Env do
     end
 
     it "should return false if the values are equal" do
-      @provider.compare_value.should be_false
+      expect(@provider.requires_modify_or_create?).to be_false
     end
 
     it "should return true if the values not are equal" do
       @new_resource.value("C:/elsewhere")
-      @provider.compare_value.should be_true
+      expect(@provider.requires_modify_or_create?).to be_true
     end
 
     it "should return false if the current value contains the element" do
       @new_resource.delim(";")
       @current_resource.value("C:/bar;C:/foo;C:/baz")
 
-      @provider.compare_value.should be_false
+      expect(@provider.requires_modify_or_create?).to be_false
     end
 
     it "should return true if the current value does not contain the element" do
       @new_resource.delim(";")
       @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
-      @provider.compare_value.should be_true
+      expect(@provider.requires_modify_or_create?).to be_true
+    end
+
+    context "when new_resource's value contains the delimiter"  do
+      it "should return false if all the current values are contained" do
+        @new_resource.value("C:/biz;C:/baz")
+        @new_resource.delim(";")
+        @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
+        expect(@provider.requires_modify_or_create?).to be_false
+      end
+
+      it "should return true if any of the new values are not contained" do
+        @new_resource.value("C:/biz;C:/baz;C:/bin")
+        @new_resource.delim(";")
+        @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
+        expect(@provider.requires_modify_or_create?).to be_true
+      end
     end
   end
 
   describe "modify_env" do
     before(:each) do
-      @provider.stub(:create_env).and_return(true)
+      allow(@provider).to receive(:create_env).and_return(true)
       @new_resource.delim ";"
 
       @current_resource = Chef::Resource::Env.new("FOO")
@@ -245,7 +283,15 @@ describe Chef::Provider::Env do
       passed_value = new_value.dup
       @new_resource.value(passed_value)
       @provider.modify_env
-      passed_value.should == new_value
+      expect(passed_value).to eq(new_value)
+    end
+
+    it "should only add values not already contained when a delimiter is provided" do
+      @new_resource.value("C:/foo;C:/bar;C:/baz")
+      @new_resource.delim(";")
+      @current_resource.value("C:/foo/bar;C:/bar;C:/baz")
+      @provider.modify_env
+      expect(@new_resource.value).to eq("C:/foo;C:/foo/bar;C:/bar;C:/baz")
     end
   end
 end

data/spec/unit/provider/erl_call_spec.rb

@@ -31,7 +31,7 @@ describe Chef::Provider::ErlCall do
 
     @provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
 
-    @provider.stub(:popen4).and_return(@status)
+    allow(@provider).to receive(:popen4).and_return(@status)
     @stdin = StringIO.new
     @stdout = StringIO.new('{ok, woohoo}')
     @stderr = StringIO.new
@@ -40,11 +40,11 @@ describe Chef::Provider::ErlCall do
 
   it "should return a Chef::Provider::ErlCall object" do
     provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
-    provider.should be_a_kind_of(Chef::Provider::ErlCall)
+    expect(provider).to be_a_kind_of(Chef::Provider::ErlCall)
   end
 
   it "should return true" do
-    @provider.load_current_resource.should eql(true)
+    expect(@provider.load_current_resource).to eql(true)
   end
 
   describe "when running a distributed erl call resource" do
@@ -56,12 +56,12 @@ describe Chef::Provider::ErlCall do
 
     it "should write to stdin of the erl_call command" do
       expected_cmd = "erl_call -e -s -sname chef@localhost -c nomnomnom"
-      @provider.should_receive(:popen4).with(expected_cmd, :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
-      Process.should_receive(:wait).with(@pid)
+      expect(@provider).to receive(:popen4).with(expected_cmd, :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
+      expect(Process).to receive(:wait).with(@pid)
 
       @provider.action_run
 
-      @stdin.string.should == "#{@new_resource.code}\n"
+      expect(@stdin.string).to eq("#{@new_resource.code}\n")
     end
   end
 
@@ -73,12 +73,12 @@ describe Chef::Provider::ErlCall do
     end
 
     it "should write to stdin of the erl_call command" do
-      @provider.should_receive(:popen4).with("erl_call -e  -name chef@localhost ", :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
-      Process.should_receive(:wait).with(@pid)
+      expect(@provider).to receive(:popen4).with("erl_call -e  -name chef@localhost ", :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
+      expect(Process).to receive(:wait).with(@pid)
 
       @provider.action_run
 
-      @stdin.string.should == "#{@new_resource.code}\n"
+      expect(@stdin.string).to eq("#{@new_resource.code}\n")
     end
   end
 

data/spec/unit/provider/execute_spec.rb

@@ -33,57 +33,73 @@ describe Chef::Provider::Execute do
     @provider.current_resource = @current_resource
     Chef::Log.level = :info
     # FIXME: There should be a test for how STDOUT.tty? changes the live_stream option being passed
-    STDOUT.stub(:tty?).and_return(true)
+    allow(STDOUT).to receive(:tty?).and_return(true)
   end
 
+  let(:opts) do
+    {
+      timeout:	@new_resource.timeout,
+      returns:	@new_resource.returns,
+      log_level: :info,
+      log_tag: @new_resource.to_s,
+      live_stream: STDOUT
+    }
+  end
 
   it "should execute foo_resource" do
-    @provider.stub(:load_current_resource)
-    opts = {}
-    opts[:timeout] = @new_resource.timeout
-    opts[:returns] = @new_resource.returns
-    opts[:log_level] = :info
-    opts[:log_tag] = @new_resource.to_s
-    opts[:live_stream] = STDOUT
-    @provider.should_receive(:shell_out!).with(@new_resource.command, opts)
-    Chef::Log.should_not_receive(:warn)
+    allow(@provider).to receive(:load_current_resource)
+    expect(@provider).to receive(:shell_out!).with(@new_resource.command, opts)
+    expect(@provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+    expect(Chef::Log).not_to receive(:warn)
 
     @provider.run_action(:run)
-    @new_resource.should be_updated
+    expect(@new_resource).to be_updated
+  end
+
+  it "should honor sensitive attribute" do
+    @new_resource.sensitive true
+    @provider = Chef::Provider::Execute.new(@new_resource, @run_context)
+    allow(@provider).to receive(:load_current_resource)
+    # Since the resource is sensitive, it should not have :live_stream set
+    expect(@provider).to receive(:shell_out!).with(@new_resource.command, opts.reject { |k| k == :live_stream })
+    expect(Chef::Log).not_to receive(:warn)
+    expect(@provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+    @provider.run_action(:run)
+    expect(@new_resource).to be_updated
   end
 
   it "should do nothing if the sentinel file exists" do
-    @provider.stub(:load_current_resource)
-    File.should_receive(:exists?).with(@new_resource.creates).and_return(true)
-    @provider.should_not_receive(:shell_out!)
-    Chef::Log.should_not_receive(:warn)
+    allow(@provider).to receive(:load_current_resource)
+    expect(File).to receive(:exists?).with(@new_resource.creates).and_return(true)
+    expect(@provider).not_to receive(:shell_out!)
+    expect(Chef::Log).not_to receive(:warn)
 
     @provider.run_action(:run)
-    @new_resource.should_not be_updated
+    expect(@new_resource).not_to be_updated
   end
 
   it "should respect cwd options for 'creates'" do
     @new_resource.cwd "/tmp"
     @new_resource.creates "foo_resource"
-    @provider.stub(:load_current_resource)
-    File.should_receive(:exists?).with(@new_resource.creates).and_return(false)
-    File.should_receive(:exists?).with(File.join("/tmp", @new_resource.creates)).and_return(true)
-    Chef::Log.should_not_receive(:warn)
-    @provider.should_not_receive(:shell_out!)
+    allow(@provider).to receive(:load_current_resource)
+    expect(File).to receive(:exists?).with(@new_resource.creates).and_return(false)
+    expect(File).to receive(:exists?).with(File.join("/tmp", @new_resource.creates)).and_return(true)
+    expect(Chef::Log).not_to receive(:warn)
+    expect(@provider).not_to receive(:shell_out!)
 
     @provider.run_action(:run)
-    @new_resource.should_not be_updated
+    expect(@new_resource).not_to be_updated
   end
 
   it "should warn if user specified relative path without cwd" do
     @new_resource.creates "foo_resource"
-    @provider.stub(:load_current_resource)
-    Chef::Log.should_receive(:warn).with(/relative path/)
-    File.should_receive(:exists?).with(@new_resource.creates).and_return(true)
-    @provider.should_not_receive(:shell_out!)
+    allow(@provider).to receive(:load_current_resource)
+    expect(Chef::Log).to receive(:warn).with(/relative path/)
+    expect(File).to receive(:exists?).with(@new_resource.creates).and_return(true)
+    expect(@provider).not_to receive(:shell_out!)
 
     @provider.run_action(:run)
-    @new_resource.should_not be_updated
+    expect(@new_resource).not_to be_updated
   end
 end