updating resources/providers unit tests to rpsec3

mechanically generated patch using transpec 2.3.7 gem

1 files changed, 58 insertions, 58 deletions

diff --git a/spec/unit/provider/env_spec.rb b/spec/unit/provider/env_spec.rb
index f8803f9bb6..22fed4b7ac 100644
--- a/spec/unit/provider/env_spec.rb
+++ b/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(:requires_modify_or_create?).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(:requires_modify_or_create?).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(:requires_modify_or_create?).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(:requires_modify_or_create?).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(:requires_modify_or_create?).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(:requires_modify_or_create?).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,41 +183,41 @@ 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")
-        @provider.delete_element.should eql(false)
-        @new_resource.should_not be_updated  # This will be updated in action_delete
+        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")
-        @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
 
       it "should return true if none of the elements are deleted" do
         @new_resource.value("C:/notfoo/bin;C:/notbaz/bin")
-        @provider.delete_element.should eql(true)
-        @new_resource.should_not be_updated
+        expect(@provider.delete_element).to eql(true)
+        expect(@new_resource).not_to be_updated
       end
     end
   end
@@ -230,25 +230,25 @@ describe Chef::Provider::Env do
     end
 
     it "should return false if the values are equal" do
-      @provider.requires_modify_or_create?.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.requires_modify_or_create?.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.requires_modify_or_create?.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.requires_modify_or_create?.should be_true
+      expect(@provider.requires_modify_or_create?).to be_true
     end
 
     context "when new_resource's value contains the delimiter"  do
@@ -256,21 +256,21 @@ describe Chef::Provider::Env do
         @new_resource.value("C:/biz;C:/baz")
         @new_resource.delim(";")
         @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
-        @provider.requires_modify_or_create?.should be_false
+        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")
-        @provider.requires_modify_or_create?.should be_true
+        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")
@@ -283,7 +283,7 @@ 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
@@ -291,7 +291,7 @@ describe Chef::Provider::Env do
       @new_resource.delim(";")
       @current_resource.value("C:/foo/bar;C:/bar;C:/baz")
       @provider.modify_env
-      @new_resource.value.should eq("C:/foo;C:/foo/bar;C:/bar;C:/baz")
+      expect(@new_resource.value).to eq("C:/foo;C:/foo/bar;C:/bar;C:/baz")
     end
   end
 end