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

data/spec/unit/provider/http_request_spec.rb

@@ -35,7 +35,7 @@ describe Chef::Provider::HttpRequest do
   describe "load_current_resource" do
 
     it "should set up a Chef::REST client, with no authentication" do
-      Chef::HTTP::Simple.should_receive(:new).with(@new_resource.url)
+      expect(Chef::HTTP::Simple).to receive(:new).with(@new_resource.url)
       @provider.load_current_resource
     end
   end
@@ -44,7 +44,7 @@ describe Chef::Provider::HttpRequest do
     before(:each) do
       # run_action(x) forces load_current_resource to run;
       # that would overwrite our supplied mock Chef::Rest # object
-      @provider.stub(:load_current_resource).and_return(true)
+      allow(@provider).to receive(:load_current_resource).and_return(true)
       @http = double("Chef::REST")
       @provider.http = @http
     end
@@ -53,53 +53,53 @@ describe Chef::Provider::HttpRequest do
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:get).with("http://www.opscode.com/", {})
+        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
         @provider.run_action(:get)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should run a GET request" do
-        @http.should_receive(:get).with("http://www.opscode.com/", {})
+        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
         @provider.run_action(:get)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
     end
 
     describe "action_put" do
       it "should run a PUT request with the message as the payload" do
-        @http.should_receive(:put).with("http://www.opscode.com/", @new_resource.message, {})
+        expect(@http).to receive(:put).with("http://www.opscode.com/", @new_resource.message, {})
         @provider.run_action(:put)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.stub(:message).and_return(lambda { "return" })
-        @http.should_receive(:put).with("http://www.opscode.com/", "return", {})
+        allow(@new_resource).to receive(:message).and_return(lambda { "return" })
+        expect(@http).to receive(:put).with("http://www.opscode.com/", "return", {})
         @provider.run_action(:put)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
     end
 
     describe "action_post" do
       it "should run a PUT request with the message as the payload" do
-        @http.should_receive(:post).with("http://www.opscode.com/", @new_resource.message, {})
+        expect(@http).to receive(:post).with("http://www.opscode.com/", @new_resource.message, {})
         @provider.run_action(:post)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:post).with("http://www.opscode.com/", "return", {})
+        expect(@http).to receive(:post).with("http://www.opscode.com/", "return", {})
         @provider.run_action(:post)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
     end
 
     describe "action_delete" do
       it "should run a DELETE request" do
-        @http.should_receive(:delete).with("http://www.opscode.com/", {})
+        expect(@http).to receive(:delete).with("http://www.opscode.com/", {})
         @provider.run_action(:delete)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
     end
 
@@ -112,46 +112,46 @@ describe Chef::Provider::HttpRequest do
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should run a HEAD request" do
-        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should update a HEAD request with empty string response body (CHEF-4762)" do
-        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return("")
+        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return("")
         @provider.run_action(:head)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should update a HEAD request with nil response body (CHEF-4762)" do
-        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
       it "should not update a HEAD request if a not modified response (CHEF-4762)" do
         if_modified_since = File.mtime(__FILE__).httpdate
         @new_resource.headers "If-Modified-Since" => if_modified_since
-        @http.should_receive(:head).with("http://www.opscode.com/", {"If-Modified-Since" => if_modified_since}).and_return(false)
+        expect(@http).to receive(:head).with("http://www.opscode.com/", {"If-Modified-Since" => if_modified_since}).and_return(false)
         @provider.run_action(:head)
-        @new_resource.should_not be_updated
+        expect(@new_resource).not_to be_updated
       end
 
       it "should run a HEAD request with If-Modified-Since header" do
         @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
-        @http.should_receive(:head).with("http://www.opscode.com/", @new_resource.headers)
+        expect(@http).to receive(:head).with("http://www.opscode.com/", @new_resource.headers)
         @provider.run_action(:head)
       end
 
       it "doesn't call converge_by if HEAD does not return modified" do
-        @http.should_receive(:head).and_return(false)
-        @provider.should_not_receive(:converge_by)
+        expect(@http).to receive(:head).and_return(false)
+        expect(@provider).not_to receive(:converge_by)
         @provider.run_action(:head)
       end
     end

data/spec/unit/provider/ifconfig/aix_spec.rb

@@ -50,7 +50,7 @@ IFCONFIG
   describe "#load_current_resource" do
     before do
       status = double("Status", :exitstatus => 0)
-      @provider.should_receive(:popen4).with("ifconfig -a").and_yield(@pid,@stdin,StringIO.new(@ifconfig_output),@stderr).and_return(status)
+      expect(@provider).to receive(:popen4).with("ifconfig -a").and_yield(@pid,@stdin,StringIO.new(@ifconfig_output),@stderr).and_return(status)
       @new_resource.device "en0"
     end
     it "should load given interface with attributes." do
@@ -67,21 +67,21 @@ IFCONFIG
 
     it "should add an interface if it does not exist" do
       @new_resource.device "en10"
-      @provider.stub(:load_current_resource) do
+      allow(@provider).to receive(:load_current_resource) do
         @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
         @provider.instance_variable_set("@current_resource", Chef::Resource::Ifconfig.new("10.0.0.1", @run_context))
       end
       command = "chdev -l #{@new_resource.device} -a netaddr=#{@new_resource.name}"
-      @provider.should_receive(:run_command).with(:command => command)
+      expect(@provider).to receive(:run_command).with(:command => command)
 
       @provider.run_action(:add)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should raise exception if metric attribute is set" do
       @new_resource.device "en0"
       @new_resource.metric "1"
-      @provider.stub(:load_current_resource) do
+      allow(@provider).to receive(:load_current_resource) do
         @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
         @provider.instance_variable_set("@current_resource", Chef::Resource::Ifconfig.new("10.0.0.1", @run_context))
       end
@@ -93,15 +93,15 @@ IFCONFIG
   describe "#action_enable" do
     it "should enable an interface if it does not exist" do
       @new_resource.device "en10"
-      @provider.stub(:load_current_resource) do
+      allow(@provider).to receive(:load_current_resource) do
         @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
         @provider.instance_variable_set("@current_resource", Chef::Resource::Ifconfig.new("10.0.0.1", @run_context))
       end
       command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
-      @provider.should_receive(:run_command).with(:command => command)
+      expect(@provider).to receive(:run_command).with(:command => command)
 
       @provider.run_action(:enable)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
   end
 
@@ -109,21 +109,21 @@ IFCONFIG
 
     it "should not disable an interface if it does not exist" do
       @new_resource.device "en10"
-      @provider.stub(:load_current_resource) do
+      allow(@provider).to receive(:load_current_resource) do
         @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
         @provider.instance_variable_set("@current_resource", Chef::Resource::Ifconfig.new("10.0.0.1", @run_context))
       end
 
-      @provider.should_not_receive(:run_command)
+      expect(@provider).not_to receive(:run_command)
 
       @provider.run_action(:disable)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
 
     context "interface exists" do
       before do
         @new_resource.device "en10"
-        @provider.stub(:load_current_resource) do
+        allow(@provider).to receive(:load_current_resource) do
           @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
           current_resource = Chef::Resource::Ifconfig.new("10.0.0.1", @run_context)
           current_resource.device @new_resource.device
@@ -133,10 +133,10 @@ IFCONFIG
 
       it "should disable an interface if it exists" do
         command = "ifconfig #{@new_resource.device} down"
-        @provider.should_receive(:run_command).with(:command => command)
+        expect(@provider).to receive(:run_command).with(:command => command)
 
         @provider.run_action(:disable)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
 
     end
@@ -146,21 +146,21 @@ IFCONFIG
 
     it "should not delete an interface if it does not exist" do
       @new_resource.device "en10"
-      @provider.stub(:load_current_resource) do
+      allow(@provider).to receive(:load_current_resource) do
         @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
         @provider.instance_variable_set("@current_resource", Chef::Resource::Ifconfig.new("10.0.0.1", @run_context))
       end
 
-      @provider.should_not_receive(:run_command)
+      expect(@provider).not_to receive(:run_command)
 
       @provider.run_action(:delete)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
 
     context "interface exists" do
       before do
         @new_resource.device "en10"
-        @provider.stub(:load_current_resource) do
+        allow(@provider).to receive(:load_current_resource) do
           @provider.instance_variable_set("@status", double("Status", :exitstatus => 0))
           current_resource = Chef::Resource::Ifconfig.new("10.0.0.1", @run_context)
           current_resource.device @new_resource.device
@@ -170,10 +170,10 @@ IFCONFIG
 
       it "should delete an interface if it exists" do
         command = "chdev -l #{@new_resource.device} -a state=down"
-        @provider.should_receive(:run_command).with(:command => command)
+        expect(@provider).to receive(:run_command).with(:command => command)
 
         @provider.run_action(:delete)
-        @new_resource.should be_updated
+        expect(@new_resource).to be_updated
       end
     end
   end

data/spec/unit/provider/ifconfig/debian_spec.rb

@@ -317,21 +317,37 @@ source #{tempdir_path}/*
 
   describe "delete_config for action_delete" do
 
+    let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
+
+    let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
+
+    let(:config_filename_ifcfg) { "#{tempdir_path}/ifcfg-#{new_resource.device}" }
+
+    before do
+      stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
+      stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
+      File.open(config_filename_ifcfg, "w") do |fh|
+        fh.write "arbitrary text\n"
+        fh.close
+      end
+    end
+
+    after do
+      Dir.rmdir(tempdir_path)
+    end
+
     it "should delete network-script if it exists" do
       current_resource.device new_resource.device
 
-      [:exist?, :exists?, :writable?].each do |cmd|
-        # need to stub :writable? to make why_run? happy
-        allow(File).to receive(cmd).and_call_original
-        allow(File).to receive(cmd).with(config_filename_ifcfg).and_return(true)
-      end
+      # belt and suspenders testing?
+      expect_any_instance_of(Chef::Util::Backup).to receive(:do_backup).and_call_original
 
-      # stub for Chef::Util::Backup#do_backup
-      expect(FileUtils).to receive(:cp)
-        .with(config_filename_ifcfg, /#{Chef::Config[:file_backup_path]}/, :preserve => true)
-      expect(File).to receive(:delete).with(config_filename_ifcfg)
+      # internal implementation detail of Ifconfig.
+      expect_any_instance_of(Chef::Provider::File).to receive(:action_delete).and_call_original
 
+      expect(File.exist?(config_filename_ifcfg)).to be_true
       provider.run_action(:delete)
+      expect(File.exist?(config_filename_ifcfg)).to be_false
     end
   end
 

data/spec/unit/provider/ifconfig/redhat_spec.rb

@@ -40,21 +40,21 @@ describe Chef::Provider::Ifconfig::Redhat do
 
     config_filename = "/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}"
     @config = double("chef-resource-file")
-    @provider.should_receive(:resource_for_config).with(config_filename).and_return(@config)
+    expect(@provider).to receive(:resource_for_config).with(config_filename).and_return(@config)
   end
 
   describe "generate_config for action_add" do
 
     it "should write network-script for centos" do
-      @provider.stub(:load_current_resource)
-      @provider.stub(:run_command)
-      @config.should_receive(:content) do |arg|
-        arg.should match(/^\s*DEVICE=eth0\s*$/)
-        arg.should match(/^\s*IPADDR=10\.0\.0\.1\s*$/)
-        arg.should match(/^\s*NETMASK=255\.255\.254\.0\s*$/)
+      allow(@provider).to receive(:load_current_resource)
+      allow(@provider).to receive(:run_command)
+      expect(@config).to receive(:content) do |arg|
+        expect(arg).to match(/^\s*DEVICE=eth0\s*$/)
+        expect(arg).to match(/^\s*IPADDR=10\.0\.0\.1\s*$/)
+        expect(arg).to match(/^\s*NETMASK=255\.255\.254\.0\s*$/)
       end
-      @config.should_receive(:run_action).with(:create)
-      @config.should_receive(:updated?).and_return(true)
+      expect(@config).to receive(:run_action).with(:create)
+      expect(@config).to receive(:updated?).and_return(true)
       @provider.run_action(:add)
     end
   end
@@ -63,10 +63,10 @@ describe Chef::Provider::Ifconfig::Redhat do
 
     it "should delete network-script if it exists for centos" do
       @current_resource.device @new_resource.device
-      @provider.stub(:load_current_resource)
-      @provider.stub(:run_command)
-      @config.should_receive(:run_action).with(:delete)
-      @config.should_receive(:updated?).and_return(true)
+      allow(@provider).to receive(:load_current_resource)
+      allow(@provider).to receive(:run_command)
+      expect(@config).to receive(:run_action).with(:delete)
+      expect(@config).to receive(:updated?).and_return(true)
       @provider.run_action(:delete)
     end
   end

data/spec/unit/provider/ifconfig_spec.rb

@@ -43,39 +43,39 @@ describe Chef::Provider::Ifconfig do
   describe Chef::Provider::Ifconfig, "load_current_resource" do
     before do
       status = double("Status", :exitstatus => 1)
-      @provider.should_receive(:popen4).and_return status
+      expect(@provider).to receive(:popen4).and_return status
       @provider.load_current_resource
     end
     it "should track state of ifconfig failure." do
-      @provider.instance_variable_get("@status").exitstatus.should_not == 0
+      expect(@provider.instance_variable_get("@status").exitstatus).not_to eq(0)
     end
     it "should thrown an exception when ifconfig fails" do
       @provider.define_resource_requirements
-      lambda { @provider.process_resource_requirements }.should raise_error Chef::Exceptions::Ifconfig
+      expect { @provider.process_resource_requirements }.to raise_error Chef::Exceptions::Ifconfig
     end
   end
   describe Chef::Provider::Ifconfig, "action_add" do
 
     it "should add an interface if it does not exist" do
       #@provider.stub(:run_command).and_return(true)
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       @current_resource.inet_addr nil
       command = "ifconfig eth0 10.0.0.1 netmask 255.255.254.0 metric 1 mtu 1500"
-      @provider.should_receive(:run_command).with(:command => command)
-      @provider.should_receive(:generate_config)
+      expect(@provider).to receive(:run_command).with(:command => command)
+      expect(@provider).to receive(:generate_config)
 
       @provider.run_action(:add)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not add an interface if it already exists" do
-      @provider.stub(:load_current_resource)
-      @provider.should_not_receive(:run_command)
+      allow(@provider).to receive(:load_current_resource)
+      expect(@provider).not_to receive(:run_command)
       @current_resource.inet_addr "10.0.0.1"
-      @provider.should_receive(:generate_config)
+      expect(@provider).to receive(:generate_config)
 
       @provider.run_action(:add)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
 
     #We are not testing this case with the assumption that anyone writing the cookbook would not make a typo == lo
@@ -86,95 +86,95 @@ describe Chef::Provider::Ifconfig do
   describe Chef::Provider::Ifconfig, "action_enable" do
 
     it "should enable interface if does not exist" do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       @current_resource.inet_addr nil
       command = "ifconfig eth0 10.0.0.1 netmask 255.255.254.0 metric 1 mtu 1500"
-      @provider.should_receive(:run_command).with(:command => command)
-      @provider.should_not_receive(:generate_config)
+      expect(@provider).to receive(:run_command).with(:command => command)
+      expect(@provider).not_to receive(:generate_config)
 
       @provider.run_action(:enable)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not enable interface if it already exists" do
-      @provider.stub(:load_current_resource)
-      @provider.should_not_receive(:run_command)
+      allow(@provider).to receive(:load_current_resource)
+      expect(@provider).not_to receive(:run_command)
       @current_resource.inet_addr "10.0.0.1"
-      @provider.should_not_receive(:generate_config)
+      expect(@provider).not_to receive(:generate_config)
 
       @provider.run_action(:enable)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
   end
 
   describe Chef::Provider::Ifconfig, "action_delete" do
 
     it "should delete interface if it exists" do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       @current_resource.device "eth0"
       command = "ifconfig #{@new_resource.device} down"
-      @provider.should_receive(:run_command).with(:command => command)
-      @provider.should_receive(:delete_config)
+      expect(@provider).to receive(:run_command).with(:command => command)
+      expect(@provider).to receive(:delete_config)
 
       @provider.run_action(:delete)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not delete interface if it does not exist" do
-      @provider.stub(:load_current_resource)
-      @provider.should_not_receive(:run_command)
-      @provider.should_receive(:delete_config)
+      allow(@provider).to receive(:load_current_resource)
+      expect(@provider).not_to receive(:run_command)
+      expect(@provider).to receive(:delete_config)
 
       @provider.run_action(:delete)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
   end
 
   describe Chef::Provider::Ifconfig, "action_disable" do
 
     it "should disable interface if it exists" do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       @current_resource.device "eth0"
       command = "ifconfig #{@new_resource.device} down"
-      @provider.should_receive(:run_command).with(:command => command)
-      @provider.should_not_receive(:delete_config)
+      expect(@provider).to receive(:run_command).with(:command => command)
+      expect(@provider).not_to receive(:delete_config)
 
       @provider.run_action(:disable)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not delete interface if it does not exist" do
-      @provider.stub(:load_current_resource)
-      @provider.should_not_receive(:run_command)
-      @provider.should_not_receive(:delete_config)
+      allow(@provider).to receive(:load_current_resource)
+      expect(@provider).not_to receive(:run_command)
+      expect(@provider).not_to receive(:delete_config)
 
       @provider.run_action(:disable)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
   end
 
   describe Chef::Provider::Ifconfig, "action_delete" do
 
     it "should delete interface of it exists" do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       @current_resource.device "eth0"
       command = "ifconfig #{@new_resource.device} down"
-      @provider.should_receive(:run_command).with(:command => command)
-      @provider.should_receive(:delete_config)
+      expect(@provider).to receive(:run_command).with(:command => command)
+      expect(@provider).to receive(:delete_config)
 
       @provider.run_action(:delete)
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not delete interface if it does not exist" do
       # This is so that our fake values do not get overwritten
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       # This is so that nothing actually runs
-      @provider.should_not_receive(:run_command)
-      @provider.should_receive(:delete_config)
+      expect(@provider).not_to receive(:run_command)
+      expect(@provider).to receive(:delete_config)
 
       @provider.run_action(:delete)
-      @new_resource.should_not be_updated
+      expect(@new_resource).not_to be_updated
     end
   end
 end