chef 11.12.8-x86-mingw32 → 11.14.0.alpha.2-x86-mingw32

data/spec/unit/provider/cron_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Provider::Cron do
       @node = Chef::Node.new
       @events = Chef::EventDispatch::Dispatcher.new
       @run_context = Chef::RunContext.new(@node, {}, @events)
-      
+
       @new_resource = Chef::Resource::Cron.new("cronhole some stuff", @run_context)
       @new_resource.user "root"
       @new_resource.minute "30"
@@ -32,10 +32,10 @@ describe Chef::Provider::Cron do
       @new_resource.time :reboot
       @provider = Chef::Provider::Cron.new(@new_resource, @run_context)
     end
-    
+
     context "with a matching entry in the user's crontab" do
       before :each do
-        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+        @provider.stub(:read_crontab).and_return(<<-CRONTAB)
 0 2 * * * /some/other/command
 
 # Chef Name: cronhole some stuff
@@ -46,7 +46,7 @@ describe Chef::Provider::Cron do
 # Another comment
 CRONTAB
       end
-      
+
       it "should set cron_exists" do
         @provider.load_current_resource
         @provider.cron_exists.should == true
@@ -60,7 +60,7 @@ CRONTAB
       end
 
       it "should pull env vars out" do
-        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+        @provider.stub(:read_crontab).and_return(<<-CRONTAB)
 0 2 * * * /some/other/command
 
 # Chef Name: cronhole some stuff
@@ -84,7 +84,7 @@ CRONTAB
       end
 
       it "should parse and load generic and standard environment variables from cron entry" do
-        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+        @provider.stub(:read_crontab).and_return(<<-CRONTAB)
 # Chef Name: cronhole some stuff
 MAILTO=warn@example.com
 TEST=lol
@@ -98,7 +98,7 @@ CRONTAB
       end
 
       it "should not break with variables that match the cron resource internals" do
-        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+        @provider.stub(:read_crontab).and_return(<<-CRONTAB)
 # Chef Name: cronhole some stuff
 MINUTE=40
 REBOOT=midnight
@@ -116,11 +116,11 @@ CRONTAB
         Chef::Log.should_receive(:debug).with("Found cron '#{@new_resource.name}'")
         @provider.load_current_resource
       end
-      
+
       describe "action_create" do
         before :each do
-          @provider.stub!(:write_crontab)
-          @provider.stub!(:read_crontab).and_return(nil)
+          @provider.stub(:write_crontab)
+          @provider.stub(:read_crontab).and_return(nil)
         end
 
         context "when there is no existing crontab" do
@@ -128,7 +128,7 @@ CRONTAB
             @provider.cron_exists = false
             @provider.cron_empty = true
           end
-    
+
           it "should create a crontab with the entry" do
             @provider.should_receive(:write_crontab).with(<<-ENDCRON)
 # Chef Name: cronhole some stuff
@@ -140,12 +140,12 @@ CRONTAB
       end
     end
   end
-  
+
   before do
     @node = Chef::Node.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
-    
+
     @new_resource = Chef::Resource::Cron.new("cronhole some stuff", @run_context)
     @new_resource.user "root"
     @new_resource.minute "30"
@@ -417,7 +417,7 @@ CRONTAB
       @new_resource.send(:time, :reboot)
       @provider.cron_different?.should eql(true)
     end
-    
+
     it "should return true if environment doesn't match" do
       @new_resource.environment "FOO" => "something_else"
       @provider.cron_different?.should eql(true)

data/spec/unit/provider/git_spec.rb

@@ -93,7 +93,7 @@ describe Chef::Provider::Git do
       @resource.revision "v1.0"
       @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
                  "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("503c22a5e41f5ae3193460cca044ed1435029f53")
     end
 
@@ -102,7 +102,7 @@ describe Chef::Provider::Git do
       @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
                  "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n" +
                  "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0^{}\n")
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("663c22a5e41f5ae3193460cca044ed1435029f53")
     end
 
@@ -131,7 +131,7 @@ describe Chef::Provider::Git do
     it "does not raise an error when the revision is valid and assertions are run." do
       @resource.revision "0.8-alpha"
       @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "0.8-alpha*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "\"0.8-alpha*\"", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.action = :checkout
       ::File.stub(:directory?).with("/my/deploy").and_return(true)
       @provider.define_resource_requirements
@@ -156,7 +156,7 @@ b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}
 ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package
 SHAS
       @resource.revision ''
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "HEAD", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "\"HEAD\"", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("28af684d8460ba4793eda3e7ac238c864a5d029a")
     end
   end

data/spec/unit/provider/group_spec.rb

@@ -97,7 +97,7 @@ describe Chef::Provider::User do
     end
 
     it "should coerce an integer to a string for comparison" do
-      @current_resource.stub!(:gid).and_return("500")
+      @current_resource.stub(:gid).and_return("500")
       @provider.compare_group.should be_false
     end
 

data/spec/unit/provider/ohai_spec.rb

@@ -41,8 +41,8 @@ describe Chef::Provider::Ohai do
         :newdata => "somevalue"
       }
     }
-    mock_ohai.stub!(:all_plugins).and_return(true)
-    mock_ohai.stub!(:data).and_return(mock_ohai[:data],
+    mock_ohai.stub(:all_plugins).and_return(true)
+    mock_ohai.stub(:data).and_return(mock_ohai[:data],
                                       mock_ohai[:data2])
     Ohai::System.stub(:new).and_return(mock_ohai)
     Chef::Platform.stub(:find_platform_and_version).and_return({ "platform" => @platform,

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

@@ -160,44 +160,68 @@ describe Chef::Provider::RemoteFile::Content do
 
   describe "when there is an array of sources and the first fails" do
 
-    let(:source) { [ "http://opscode.com/seattle.txt", "http://opscode.com/nyc.txt" ] }
-    before do
-      new_resource.stub(:checksum).and_return(nil)
-      current_resource.stub(:checksum).and_return(nil)
-      @uri0 = double("URI0")
-      @uri1 = double("URI1")
-      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri0)
-      URI.should_receive(:parse).with(new_resource.source[1]).and_return(@uri1)
-      @http_fetcher_throws_exception = double("Chef::Provider::RemoteFile::HTTP")
-      @http_fetcher_throws_exception.should_receive(:fetch).at_least(:once).and_raise(Errno::ECONNREFUSED)
-      Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
-    end
-
-    describe "when the second url succeeds" do
-      before do
-        @tempfile = double("Tempfile")
-        mtime = Time.now
-        http_fetcher_works = double("Chef::Provider::RemoteFile::HTTP", :fetch => @tempfile)
-        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(http_fetcher_works)
-      end
-
-      it "should return a valid tempfile" do
-        content.tempfile.should == @tempfile
-      end
-
-      it "should not mutate the new_resource" do
-        content.tempfile
-        new_resource.source.length.should == 2
+    # https://github.com/opscode/chef/pull/1358#issuecomment-40853299
+    def create_exception(exception_class)
+      if [ Net::HTTPServerException, Net::HTTPFatalError ].include? exception_class
+        exception_class.new("message", {"something" => 1})
+      else
+        exception_class.new
       end
     end
 
-    describe "when both urls fail" do
-      before do
-        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
-      end
+    let(:source) { [ "http://opscode.com/seattle.txt", "http://opscode.com/nyc.txt" ] }
 
-      it "should propagate the error back to the caller" do
-        lambda { content.tempfile }.should raise_error(Errno::ECONNREFUSED)
+    ### Test each exception we care about and make sure they all behave properly
+    [
+      SocketError,
+      Errno::ECONNREFUSED,
+      Errno::ENOENT,
+      Errno::EACCES,
+      Timeout::Error,
+      Net::HTTPServerException,
+      Net::HTTPFatalError,
+      Net::FTPError
+    ].each do |exception|
+      describe "with an exception of #{exception}" do
+        before do
+          new_resource.stub(:checksum).and_return(nil)
+          current_resource.stub(:checksum).and_return(nil)
+          @uri0 = double("URI0")
+          @uri1 = double("URI1")
+          URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri0)
+          URI.should_receive(:parse).with(new_resource.source[1]).and_return(@uri1)
+          @http_fetcher_throws_exception = double("Chef::Provider::RemoteFile::HTTP")
+          @http_fetcher_throws_exception.should_receive(:fetch).at_least(:once).and_raise(create_exception(exception))
+          Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
+        end
+
+        describe "the second url should succeed" do
+          before do
+            @tempfile = double("Tempfile")
+            mtime = Time.now
+            http_fetcher_works = double("Chef::Provider::RemoteFile::HTTP", :fetch => @tempfile)
+            Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(http_fetcher_works)
+          end
+
+          it "should return a valid tempfile" do
+            content.tempfile.should == @tempfile
+          end
+
+          it "should not mutate the new_resource" do
+            content.tempfile
+            new_resource.source.length.should == 2
+          end
+        end
+
+        describe "when both urls fail" do
+          before do
+            Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
+          end
+
+          it "should propagate the error back to the caller" do
+            lambda { content.tempfile }.should raise_error(exception)
+          end
+        end
       end
     end
   end
@@ -227,4 +251,3 @@ describe Chef::Provider::RemoteFile::Content do
   end
 
 end
-

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

@@ -25,6 +25,29 @@ describe Chef::Provider::RemoteFile::LocalFile do
   let(:new_resource) { Chef::Resource::RemoteFile.new("local file backend test (new_resource)") }
   let(:current_resource) { Chef::Resource::RemoteFile.new("local file backend test (current_resource)") }
   subject(:fetcher) { Chef::Provider::RemoteFile::LocalFile.new(uri, new_resource, current_resource) }
+  
+  context "when parsing source path" do
+    describe "when given local unix path" do
+      let(:uri) { URI.parse("file:///nyan_cat.png") }
+      it "returns a correct unix path" do
+        fetcher.fix_windows_path(uri.path).should == "/nyan_cat.png"
+      end
+    end
+
+    describe "when given local windows path" do
+      let(:uri) { URI.parse("file:///z:/windows/path/file.txt") }
+      it "returns a valid windows local path" do
+        fetcher.fix_windows_path(uri.path).should == "z:/windows/path/file.txt"
+      end
+    end
+
+    describe "when given unc windows path" do
+      let(:uri) { URI.parse("file:////server/share/windows/path/file.txt") }
+      it "returns a valid windows unc path" do
+        fetcher.fix_windows_path(uri.path).should == "//server/share/windows/path/file.txt"
+      end
+    end
+  end
 
   context "when first created" do
 

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

@@ -54,14 +54,14 @@ describe Chef::Provider::Service::Solaris do
 
     describe "when discovering the current service state" do
       it "should create a current resource with the name of the new resource" do
-        @provider.stub!(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
+        @provider.stub(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
         Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
         @provider.load_current_resource
       end
 
 
       it "should return the current resource" do
-        @provider.stub!(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
+        @provider.stub(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
         @provider.load_current_resource.should eql(@current_resource)
       end
 
@@ -71,27 +71,27 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should mark service as not running" do
-        @provider.stub!(:shell_out!).and_return(@status)
+        @provider.stub(:shell_out!).and_return(@status)
         @current_resource.should_receive(:running).with(false)
         @provider.load_current_resource
       end
 
       it "should mark service as running" do
-        @status = mock("Status", :exitstatus => 0, :stdout => 'state online')
-        @provider.stub!(:shell_out!).and_return(@status)
+        @status = double("Status", :exitstatus => 0, :stdout => 'state online')
+        @provider.stub(:shell_out!).and_return(@status)
         @current_resource.should_receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should not mark service as maintenance" do
-        @provider.stub!(:shell_out!).and_return(@status)
+        @provider.stub(:shell_out!).and_return(@status)
         @provider.load_current_resource
         @provider.maintenance.should be_false
       end
 
       it "should mark service as maintenance" do
-        @status = mock("Status", :exitstatus => 0, :stdout => 'state maintenance')
-        @provider.stub!(:shell_out!).and_return(@status)
+        @status = double("Status", :exitstatus => 0, :stdout => 'state maintenance')
+        @provider.stub(:shell_out!).and_return(@status)
         @provider.load_current_resource
         @provider.maintenance.should be_true
       end
@@ -104,7 +104,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef" do
-        @new_resource.stub!(:enable_command).and_return("#{@new_resource.enable_command}")
+        @new_resource.stub(:enable_command).and_return("#{@new_resource.enable_command}")
         @provider.should_not_receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}")
         @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
         @provider.enable_service.should be_true
@@ -112,7 +112,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef for start_service" do
-        @new_resource.stub!(:start_command).and_return("#{@new_resource.start_command}")
+        @new_resource.stub(:start_command).and_return("#{@new_resource.start_command}")
         @provider.should_not_receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}")
         @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
         @provider.start_service.should be_true
@@ -120,10 +120,10 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm clear chef for start_service when state maintenance" do
-        @status = mock("Status", :exitstatus => 0, :stdout => 'state maintenance')
-        @provider.stub!(:shell_out!).and_return(@status)
+        @status = double("Status", :exitstatus => 0, :stdout => 'state maintenance')
+        @provider.stub(:shell_out!).and_return(@status)
         @provider.load_current_resource
-        @new_resource.stub!(:enable_command).and_return("#{@new_resource.enable_command}")
+        @new_resource.stub(:enable_command).and_return("#{@new_resource.enable_command}")
         @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}").and_return(@status)
         @provider.should_receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
         @provider.enable_service.should be_true

data/spec/unit/resource/mount_spec.rb

@@ -182,7 +182,6 @@ describe Chef::Resource::Mount do
 
     it "describes its state" do
       state = @resource.state
-      puts state
       state[:mount_point].should == "T:"
       state[:username].should == "Administrator"
       state[:password].should == "Jetstream123!"

data/spec/unit/resource/remote_file_spec.rb

@@ -50,20 +50,49 @@ describe Chef::Resource::RemoteFile do
       @resource.source.should eql([ "http://opscode.com/" ])
     end
 
+    it "should accept a delayed evalutator (string) for the remote file source" do
+      @resource.source Chef::DelayedEvaluator.new {"http://opscode.com/"}
+      @resource.source.should eql([ "http://opscode.com/" ])
+    end
+
     it "should accept an array of URIs for the remote file source" do
       @resource.source([ "http://opscode.com/", "http://puppetlabs.com/" ])
       @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
     end
 
+    it "should accept a delated evaluator (array) for the remote file source" do
+      @resource.source Chef::DelayedEvaluator.new { [ "http://opscode.com/", "http://puppetlabs.com/" ] }
+      @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
+    end
+
     it "should accept an multiple URIs as arguments for the remote file source" do
       @resource.source("http://opscode.com/", "http://puppetlabs.com/")
       @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
     end
 
+    it "should only accept a single argument if a delayed evalutor is used" do
+      lambda {
+        @resource.source("http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"})
+      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+    end
+
+    it "should only accept a single array item if a delayed evalutor is used" do
+      lambda {
+        @resource.source(["http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"}])
+      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+    end
+
     it "does not accept a non-URI as the source" do
       lambda { @resource.source("not-a-uri") }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
+    it "does not accept a non-URI as the source when read from a delayed evaluator" do
+      lambda {
+        @resource.source(Chef::DelayedEvaluator.new {"not-a-uri"})
+        @resource.source
+      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+    end
+
     it "should raise an exception when source is an empty array" do
       lambda { @resource.source([]) }.should raise_error(ArgumentError)
     end

data/spec/unit/resource_spec.rb

@@ -612,7 +612,7 @@ describe Chef::Resource do
     it "should print \"skipped due to action :nothing\" message for doc formatter when action is :nothing" do
       fdoc = Chef::Formatters.new(:doc, STDOUT, STDERR)
       @run_context.stub(:events).and_return(fdoc)
-      fdoc.should_receive(:puts).with(" (skipped due to action :nothing)")
+      fdoc.should_receive(:puts).with(" (skipped due to action :nothing)", anything())
       @resource.should_skip?(:nothing)
     end