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

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

@@ -47,31 +47,31 @@ describe Chef::Provider::RemoteFile::Content do
 
   describe "when the checksum of the current_resource matches the checksum set on the resource" do
     before do
-      new_resource.stub(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      current_resource.stub(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      allow(new_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
     end
 
     it "should return nil for the tempfile" do
-      content.tempfile.should be_nil
+      expect(content.tempfile).to be_nil
     end
 
     it "should not call any fetcher" do
-      Chef::Provider::RemoteFile::Fetcher.should_not_receive(:for_resource)
+      expect(Chef::Provider::RemoteFile::Fetcher).not_to receive(:for_resource)
     end
   end
 
   describe "when the checksum of the current_resource is a partial match for the checksum set on the resource" do
     before do
-      new_resource.stub(:checksum).and_return("0fd012fd")
-      current_resource.stub(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      allow(new_resource).to receive(:checksum).and_return("0fd012fd")
+      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
     end
 
     it "should return nil for the tempfile" do
-      content.tempfile.should be_nil
+      expect(content.tempfile).to be_nil
     end
 
     it "should not call any fetcher" do
-      Chef::Provider::RemoteFile::Fetcher.should_not_receive(:for_resource)
+      expect(Chef::Provider::RemoteFile::Fetcher).not_to receive(:for_resource)
     end
   end
 
@@ -79,17 +79,17 @@ describe Chef::Provider::RemoteFile::Content do
     before do
       # FIXME: test one or the other nil, test both not nil and not equal, abuse the regexp a little
       @uri = double("URI")
-      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri)
+      expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri)
     end
 
     describe "when the fetcher returns nil for the tempfile" do
       before do
         http_fetcher = double("Chef::Provider::RemoteFile::HTTP", :fetch => nil)
-        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+        expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
       end
 
       it "should return nil for the tempfile" do
-        content.tempfile.should be_nil
+        expect(content.tempfile).to be_nil
       end
     end
 
@@ -100,43 +100,43 @@ describe Chef::Provider::RemoteFile::Content do
       let(:http_fetcher) { double("Chef::Provider::RemoteFile::HTTP", :fetch => tempfile) }
 
       before do
-        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+        expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
       end
 
       it "should return the tempfile object to the caller" do
-        content.tempfile.should == tempfile
+        expect(content.tempfile).to eq(tempfile)
       end
 
     end
   end
   describe "when the checksum are both nil" do
     before do
-      new_resource.checksum.should be_nil
-      current_resource.checksum.should be_nil
+      expect(new_resource.checksum).to be_nil
+      expect(current_resource.checksum).to be_nil
     end
     it_behaves_like "the resource needs fetching"
   end
 
   describe "when the current_resource checksum is nil" do
     before do
-      new_resource.stub(:checksum).and_return("fd012fd")
-      current_resource.stub(:checksum).and_return(nil)
+      allow(new_resource).to receive(:checksum).and_return("fd012fd")
+      allow(current_resource).to receive(:checksum).and_return(nil)
     end
     it_behaves_like "the resource needs fetching"
   end
 
   describe "when the new_resource checksum is nil" do
     before do
-      new_resource.stub(:checksum).and_return(nil)
-      current_resource.stub(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      allow(new_resource).to receive(:checksum).and_return(nil)
+      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
     end
     it_behaves_like "the resource needs fetching"
   end
 
   describe "when the checksums are a partial match, but not to the leading portion" do
     before do
-      new_resource.stub(:checksum).and_return("fd012fd")
-      current_resource.stub(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      allow(new_resource).to receive(:checksum).and_return("fd012fd")
+      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
     end
     it_behaves_like "the resource needs fetching"
   end
@@ -144,17 +144,17 @@ describe Chef::Provider::RemoteFile::Content do
 
   describe "when the fetcher throws an exception" do
     before do
-      new_resource.stub(:checksum).and_return(nil)
-      current_resource.stub(:checksum).and_return(nil)
+      allow(new_resource).to receive(:checksum).and_return(nil)
+      allow(current_resource).to receive(:checksum).and_return(nil)
       @uri = double("URI")
-      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri)
+      expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri)
       http_fetcher = double("Chef::Provider::RemoteFile::HTTP")
-      http_fetcher.should_receive(:fetch).and_raise(Errno::ECONNREFUSED)
-      Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+      expect(http_fetcher).to receive(:fetch).and_raise(Errno::ECONNREFUSED)
+      expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
     end
 
     it "should propagate the error back to the caller" do
-      lambda { content.tempfile }.should raise_error(Errno::ECONNREFUSED)
+      expect { content.tempfile }.to raise_error(Errno::ECONNREFUSED)
     end
   end
 
@@ -184,15 +184,15 @@ describe Chef::Provider::RemoteFile::Content do
     ].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)
+          allow(new_resource).to receive(:checksum).and_return(nil)
+          allow(current_resource).to receive(: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)
+          expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri0)
+          expect(URI).to 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)
+          expect(@http_fetcher_throws_exception).to receive(:fetch).at_least(:once).and_raise(create_exception(exception))
+          expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
         end
 
         describe "the second url should succeed" do
@@ -200,26 +200,26 @@ describe Chef::Provider::RemoteFile::Content 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)
+            expect(Chef::Provider::RemoteFile::Fetcher).to 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
+            expect(content.tempfile).to eq(@tempfile)
           end
 
           it "should not mutate the new_resource" do
             content.tempfile
-            new_resource.source.length.should == 2
+            expect(new_resource.source.length).to eq(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)
+            expect(Chef::Provider::RemoteFile::Fetcher).to 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)
+            expect { content.tempfile }.to raise_error(exception)
           end
         end
       end
@@ -229,24 +229,24 @@ describe Chef::Provider::RemoteFile::Content do
   describe "when there is an array of sources and the first succeeds" 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)
+      allow(new_resource).to receive(:checksum).and_return(nil)
+      allow(current_resource).to receive(:checksum).and_return(nil)
       @uri0 = double("URI0")
-      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri0)
-      URI.should_not_receive(:parse).with(new_resource.source[1])
+      expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri0)
+      expect(URI).not_to receive(:parse).with(new_resource.source[1])
       @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(@uri0, new_resource, current_resource).and_return(http_fetcher_works)
+      expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(http_fetcher_works)
     end
 
     it "should return a valid tempfile" do
-      content.tempfile.should == @tempfile
+      expect(content.tempfile).to eq(@tempfile)
     end
 
     it "should not mutate the new_resource" do
       content.tempfile
-      new_resource.source.length.should == 2
+      expect(new_resource.source.length).to eq(2)
     end
   end
 

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

@@ -27,47 +27,47 @@ describe Chef::Provider::RemoteFile::Fetcher do
   describe "when passed an http url" do
     let(:uri) { double("uri", :scheme => "http" ) }
     before do
-      Chef::Provider::RemoteFile::HTTP.should_receive(:new).and_return(fetcher_instance)
+      expect(Chef::Provider::RemoteFile::HTTP).to receive(:new).and_return(fetcher_instance)
     end
     it "returns an http fetcher" do
-      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
     end
   end
 
   describe "when passed an https url" do
     let(:uri) { double("uri", :scheme => "https" ) }
     before do
-      Chef::Provider::RemoteFile::HTTP.should_receive(:new).and_return(fetcher_instance)
+      expect(Chef::Provider::RemoteFile::HTTP).to receive(:new).and_return(fetcher_instance)
     end
     it "returns an http fetcher" do
-      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
     end
   end
 
   describe "when passed an ftp url" do
     let(:uri) { double("uri", :scheme => "ftp" ) }
     before do
-      Chef::Provider::RemoteFile::FTP.should_receive(:new).and_return(fetcher_instance)
+      expect(Chef::Provider::RemoteFile::FTP).to receive(:new).and_return(fetcher_instance)
     end
     it "returns an ftp fetcher" do
-      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
     end
   end
 
   describe "when passed a file url" do
     let(:uri) { double("uri", :scheme => "file" ) }
     before do
-      Chef::Provider::RemoteFile::LocalFile.should_receive(:new).and_return(fetcher_instance)
+      expect(Chef::Provider::RemoteFile::LocalFile).to receive(:new).and_return(fetcher_instance)
     end
     it "returns a localfile fetcher" do
-      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
     end
   end
 
   describe "when passed a url we do not recognize" do
     let(:uri) { double("uri", :scheme => "xyzzy" ) }
     it "throws an ArgumentError exception" do
-      lambda { described_class.for_resource(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+      expect { described_class.for_resource(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
     end
   end
 

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

@@ -39,13 +39,13 @@ describe Chef::Provider::RemoteFile::FTP do
 
   let(:ftp) do
     ftp = double(Net::FTP, { })
-    ftp.stub(:connect)
-    ftp.stub(:login)
-    ftp.stub(:voidcmd)
-    ftp.stub(:mtime).and_return(Time.now)
-    ftp.stub(:getbinaryfile)
-    ftp.stub(:close)
-    ftp.stub(:passive=)
+    allow(ftp).to receive(:connect)
+    allow(ftp).to receive(:login)
+    allow(ftp).to receive(:voidcmd)
+    allow(ftp).to receive(:mtime).and_return(Time.now)
+    allow(ftp).to receive(:getbinaryfile)
+    allow(ftp).to receive(:close)
+    allow(ftp).to receive(:passive=)
     ftp
   end
 
@@ -53,49 +53,49 @@ describe Chef::Provider::RemoteFile::FTP do
 
   let(:tempfile) do
     t = StringIO.new
-    t.stub(:path).and_return(tempfile_path)
+    allow(t).to receive(:path).and_return(tempfile_path)
     t
   end
 
   let(:uri) { URI.parse("ftp://opscode.com/seattle.txt") }
 
   before(:each) do
-    Net::FTP.stub(:new).with().and_return(ftp)
-    Tempfile.stub(:new).and_return(tempfile)
+    allow(Net::FTP).to receive(:new).with().and_return(ftp)
+    allow(Tempfile).to receive(:new).and_return(tempfile)
   end
 
   describe "when first created" do
 
     it "throws an argument exception when no path is given" do
       uri.path = ""
-      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
     end
 
     it "throws an argument exception when only a / is given" do
       uri.path = "/"
-      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
     end
 
     it "throws an argument exception when no filename is given" do
       uri.path = "/the/whole/path/"
-      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
     end
 
     it "throws an argument exception when the typecode is invalid" do
       uri.typecode = "d"
-      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
     end
 
     it "does not use passive mode when new_resource sets ftp_active_mode to true" do
       new_resource.ftp_active_mode(true)
       fetcher = Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource)
-      fetcher.use_passive_mode?.should be_false
+      expect(fetcher.use_passive_mode?).to be_false
     end
 
     it "uses passive mode when new_resource sets ftp_active_mode to false" do
       new_resource.ftp_active_mode(false)
       fetcher = Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource)
-      fetcher.use_passive_mode?.should be_true
+      expect(fetcher.use_passive_mode?).to be_true
     end
   end
 
@@ -112,24 +112,24 @@ describe Chef::Provider::RemoteFile::FTP do
     end
 
     it "should connect to the host from the uri on the default port 21" do
-      ftp.should_receive(:connect).with("opscode.com", 21)
+      expect(ftp).to receive(:connect).with("opscode.com", 21)
       fetcher.fetch
     end
 
     it "should set passive true when ftp_active_mode is false" do
       new_resource.ftp_active_mode(false)
-      ftp.should_receive(:passive=).with(true)
+      expect(ftp).to receive(:passive=).with(true)
       fetcher.fetch
     end
 
     it "should set passive false when ftp_active_mode is false" do
       new_resource.ftp_active_mode(true)
-      ftp.should_receive(:passive=).with(false)
+      expect(ftp).to receive(:passive=).with(false)
       fetcher.fetch
     end
 
     it "should use anonymous ftp when no userinfo is provided" do
-      ftp.should_receive(:login).with("anonymous", nil)
+      expect(ftp).to receive(:login).with("anonymous", nil)
       fetcher.fetch
     end
 
@@ -138,7 +138,7 @@ describe Chef::Provider::RemoteFile::FTP do
 
       it "should connect on an alternate port when one is provided" do
         uri = URI.parse("ftp://opscode.com:8021/seattle.txt")
-        ftp.should_receive(:connect).with("opscode.com", 8021)
+        expect(ftp).to receive(:connect).with("opscode.com", 8021)
         fetcher.fetch
       end
 
@@ -148,7 +148,7 @@ describe Chef::Provider::RemoteFile::FTP do
       let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt") }
 
       it "should use authenticated ftp when userinfo is provided" do
-        ftp.should_receive(:login).with("the_user", "the_password")
+        expect(ftp).to receive(:login).with("the_user", "the_password")
         fetcher.fetch
       end
     end
@@ -157,7 +157,7 @@ describe Chef::Provider::RemoteFile::FTP do
       let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt;type=a") }
 
       it "fetches the file with ascii typecode set" do
-        ftp.should_receive(:voidcmd).with("TYPE A").once
+        expect(ftp).to receive(:voidcmd).with("TYPE A").once
         fetcher.fetch
       end
 
@@ -167,7 +167,7 @@ describe Chef::Provider::RemoteFile::FTP do
       let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt;type=i") }
 
       it "should accept image for the typecode" do
-        ftp.should_receive(:voidcmd).with("TYPE I").once
+        expect(ftp).to receive(:voidcmd).with("TYPE I").once
         fetcher.fetch
       end
 
@@ -177,10 +177,10 @@ describe Chef::Provider::RemoteFile::FTP do
       let(:uri) { URI.parse("ftp://opscode.com/the/whole/path/seattle.txt") }
 
       it "should fetch the file from the correct path" do
-        ftp.should_receive(:voidcmd).with("CWD the").once
-        ftp.should_receive(:voidcmd).with("CWD whole").once
-        ftp.should_receive(:voidcmd).with("CWD path").once
-        ftp.should_receive(:getbinaryfile).with("seattle.txt", tempfile.path)
+        expect(ftp).to receive(:voidcmd).with("CWD the").once
+        expect(ftp).to receive(:voidcmd).with("CWD whole").once
+        expect(ftp).to receive(:voidcmd).with("CWD path").once
+        expect(ftp).to receive(:getbinaryfile).with("seattle.txt", tempfile.path)
         fetcher.fetch
       end
 
@@ -193,7 +193,7 @@ describe Chef::Provider::RemoteFile::FTP do
 
       it "should return a tempfile in the result" do
         result = fetcher.fetch
-        result.should equal(tempfile)
+        expect(result).to equal(tempfile)
       end
 
     end
@@ -207,10 +207,10 @@ describe Chef::Provider::RemoteFile::FTP do
 
       it "fetches the file via the proxy" do
         current_socks_server = ENV["SOCKS_SERVER"]
-        ENV.should_receive(:[]=).with("SOCKS_SERVER", "socks5://bill:ted@socks.example.com:5000").ordered
-        ENV.should_receive(:[]=).with("SOCKS_SERVER", current_socks_server).ordered
+        expect(ENV).to receive(:[]=).with("SOCKS_SERVER", "socks5://bill:ted@socks.example.com:5000").ordered
+        expect(ENV).to receive(:[]=).with("SOCKS_SERVER", current_socks_server).ordered
         result = fetcher.fetch
-        result.should equal(tempfile)
+        expect(result).to equal(tempfile)
       end
 
     end