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

data/spec/unit/resource/registry_key_spec.rb

@@ -24,33 +24,33 @@ describe Chef::Resource::RegistryKey, "initialize" do
   end
 
   it "should create a new Chef::Resource::RegistryKey" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::RegistryKey)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::RegistryKey)
   end
 
   it "should set the resource_name to :registry_key" do
-    @resource.resource_name.should eql(:registry_key)
+    expect(@resource.resource_name).to eql(:registry_key)
   end
 
   it "should set the key equal to the argument to initialize" do
-    @resource.key.should eql('HKCU\Software\Raxicoricofallapatorius')
+    expect(@resource.key).to eql('HKCU\Software\Raxicoricofallapatorius')
   end
 
   it "should default recursive to false" do
-    @resource.recursive.should eql(false)
+    expect(@resource.recursive).to eql(false)
   end
 
   it "should default architecture to :machine" do
-    @resource.architecture.should eql(:machine)
+    expect(@resource.architecture).to eql(:machine)
   end
 
   it "should set action to :create" do
-    @resource.action.should eql(:create)
+    expect(@resource.action).to eql(:create)
   end
 
   %w{create create_if_missing delete delete_key}.each do |action|
     it "should allow action #{action}" do
-      @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
+      expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym)
     end
   end
 end
@@ -62,15 +62,15 @@ describe Chef::Resource::RegistryKey, "key" do
 
   it "should allow a string" do
     @resource.key 'HKCU\Software\Poosh'
-    @resource.key.should eql('HKCU\Software\Poosh')
+    expect(@resource.key).to eql('HKCU\Software\Poosh')
   end
 
   it "should not allow an integer" do
-    lambda { @resource.send(:key, 100) }.should raise_error(ArgumentError)
+    expect { @resource.send(:key, 100) }.to raise_error(ArgumentError)
   end
 
   it "should not allow a hash" do
-    lambda { @resource.send(:key, { :sonic => "screwdriver" }) }.should raise_error(ArgumentError)
+    expect { @resource.send(:key, { :sonic => "screwdriver" }) }.to raise_error(ArgumentError)
   end
 end
 
@@ -81,41 +81,41 @@ describe Chef::Resource::RegistryKey, "values" do
 
   it "should allow a single proper hash of registry values" do
     @resource.values( { :name => 'poosh', :type => :string, :data => 'carmen' } )
-    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+    expect(@resource.values).to eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
   end
 
   it "should allow an array of proper hashes of registry values" do
     @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen' } ]
-    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+    expect(@resource.values).to eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
   end
 
   it "should return checksummed data if the type is unsafe" do
     @resource.values( { :name => 'poosh', :type => :binary, :data => 255.chr * 1 })
-    @resource.values.should eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ])
+    expect(@resource.values).to eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ])
   end
 
   it "should throw an exception if the name field is missing" do
-    lambda { @resource.values [ { :type => :string, :data => 'carmen' } ] }.should raise_error(ArgumentError)
+    expect { @resource.values [ { :type => :string, :data => 'carmen' } ] }.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if the type field is missing" do
-    lambda { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.should raise_error(ArgumentError)
+    expect { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if the data field is missing" do
-    lambda { @resource.values [ { :name => 'poosh', :type => :string } ] }.should raise_error(ArgumentError)
+    expect { @resource.values [ { :name => 'poosh', :type => :string } ] }.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if extra fields are present" do
-    lambda { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.should raise_error(ArgumentError)
+    expect { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.to raise_error(ArgumentError)
   end
 
   it "should not allow a string" do
-    lambda { @resource.send(:values, 'souffle') }.should raise_error(ArgumentError)
+    expect { @resource.send(:values, 'souffle') }.to raise_error(ArgumentError)
   end
 
   it "should not allow an integer" do
-    lambda { @resource.send(:values, 100) }.should raise_error(ArgumentError)
+    expect { @resource.send(:values, 100) }.to raise_error(ArgumentError)
   end
 end
 
@@ -126,23 +126,23 @@ describe Chef::Resource::RegistryKey, "recursive" do
 
   it "should allow a boolean" do
     @resource.recursive(true)
-    @resource.recursive.should eql(true)
+    expect(@resource.recursive).to eql(true)
   end
 
   it "should not allow a hash" do
-    lambda { @resource.recursive({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+    expect { @resource.recursive({:sonic => :screwdriver}) }.to raise_error(ArgumentError)
   end
 
   it "should not allow an array" do
-    lambda { @resource.recursive([:nose, :chin]) }.should raise_error(ArgumentError)
+    expect { @resource.recursive([:nose, :chin]) }.to raise_error(ArgumentError)
   end
 
   it "should not allow a string" do
-    lambda { @resource.recursive('souffle') }.should raise_error(ArgumentError)
+    expect { @resource.recursive('souffle') }.to raise_error(ArgumentError)
   end
 
   it "should not allow an integer" do
-    lambda { @resource.recursive(100) }.should raise_error(ArgumentError)
+    expect { @resource.recursive(100) }.to raise_error(ArgumentError)
   end
 end
 
@@ -154,24 +154,24 @@ describe Chef::Resource::RegistryKey, "architecture" do
   [ :i386, :x86_64, :machine ].each do |arch|
     it "should allow #{arch} as a symbol" do
       @resource.architecture(arch)
-      @resource.architecture.should eql(arch)
+      expect(@resource.architecture).to eql(arch)
     end
   end
 
   it "should not allow a hash" do
-    lambda { @resource.architecture({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+    expect { @resource.architecture({:sonic => :screwdriver}) }.to raise_error(ArgumentError)
   end
 
   it "should not allow an array" do
-    lambda { @resource.architecture([:nose, :chin]) }.should raise_error(ArgumentError)
+    expect { @resource.architecture([:nose, :chin]) }.to raise_error(ArgumentError)
   end
 
   it "should not allow a string" do
-    lambda { @resource.architecture('souffle') }.should raise_error(ArgumentError)
+    expect { @resource.architecture('souffle') }.to raise_error(ArgumentError)
   end
 
   it "should not allow an integer" do
-    lambda { @resource.architecture(100) }.should raise_error(ArgumentError)
+    expect { @resource.architecture(100) }.to raise_error(ArgumentError)
   end
 end
 
@@ -183,7 +183,7 @@ describe Chef::Resource::RegistryKey, ":unscrubbed_values" do
   it "should return unsafe data as-is" do
     key_values = [ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ]
     @resource.values(key_values)
-    @resource.unscrubbed_values.should eql(key_values)
+    expect(@resource.unscrubbed_values).to eql(key_values)
   end
 end
 
@@ -194,6 +194,6 @@ describe Chef::Resource::RegistryKey, "state" do
 
   it "should return scrubbed values" do
     @resource.values([ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ])
-    @resource.state.should eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } )
+    expect(@resource.state).to eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } )
   end
 end

data/spec/unit/resource/remote_directory_spec.rb

@@ -25,52 +25,52 @@ describe Chef::Resource::RemoteDirectory do
   end
 
   it "should create a new Chef::Resource::RemoteDirectory" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::RemoteDirectory)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::RemoteDirectory)
   end
 
   it "should set the path to the first argument to new" do
-    @resource.path.should eql("/etc/dunk")
+    expect(@resource.path).to eql("/etc/dunk")
   end
 
   it "should accept a string for the remote directory source" do
     @resource.source "foo"
-    @resource.source.should eql("foo")
+    expect(@resource.source).to eql("foo")
   end
 
   it "should have the basename of the remote directory resource as the default source" do
-    @resource.source.should eql("dunk")
+    expect(@resource.source).to eql("dunk")
   end
 
   it "should accept a number for the remote files backup" do
     @resource.files_backup 1
-    @resource.files_backup.should eql(1)
+    expect(@resource.files_backup).to eql(1)
   end
 
   it "should accept false for the remote files backup" do
     @resource.files_backup false
-    @resource.files_backup.should eql(false)
+    expect(@resource.files_backup).to eql(false)
   end
 
   it "should accept 3 or 4 digets for the files_mode" do
     @resource.files_mode 100
-    @resource.files_mode.should eql(100)
+    expect(@resource.files_mode).to eql(100)
     @resource.files_mode 1000
-    @resource.files_mode.should eql(1000)
+    expect(@resource.files_mode).to eql(1000)
   end
 
   it "should accept a string or number for the files group" do
     @resource.files_group "heart"
-    @resource.files_group.should eql("heart")
+    expect(@resource.files_group).to eql("heart")
     @resource.files_group 1000
-    @resource.files_group.should eql(1000)
+    expect(@resource.files_group).to eql(1000)
   end
 
   it "should accept a string or number for the files owner" do
     @resource.files_owner "heart"
-    @resource.files_owner.should eql("heart")
+    expect(@resource.files_owner).to eql("heart")
     @resource.files_owner 1000
-    @resource.files_owner.should eql(1000)
+    expect(@resource.files_owner).to eql(1000)
   end
 
   describe "when it has cookbook, files owner, files mode, and source" do
@@ -85,13 +85,13 @@ describe Chef::Resource::RemoteDirectory do
 
     it "describes its state" do
       state = @resource.state
-      state[:files_owner].should == "root"
-      state[:files_group].should == "supergroup"
-      state[:files_mode].should == "0664"
+      expect(state[:files_owner]).to eq("root")
+      expect(state[:files_group]).to eq("supergroup")
+      expect(state[:files_mode]).to eq("0664")
     end
 
     it "returns the path  as its identity" do
-      @resource.identity.should == "/var/path/"
+      expect(@resource.identity).to eq("/var/path/")
     end
   end
 end

data/spec/unit/resource/remote_file_spec.rb

@@ -27,74 +27,74 @@ describe Chef::Resource::RemoteFile do
 
   describe "initialize" do
     it "should create a new Chef::Resource::RemoteFile" do
-      @resource.should be_a_kind_of(Chef::Resource)
-      @resource.should be_a_kind_of(Chef::Resource::File)
-      @resource.should be_a_kind_of(Chef::Resource::RemoteFile)
+      expect(@resource).to be_a_kind_of(Chef::Resource)
+      expect(@resource).to be_a_kind_of(Chef::Resource::File)
+      expect(@resource).to be_a_kind_of(Chef::Resource::RemoteFile)
     end
   end
 
   it "says its provider is RemoteFile when the source is an absolute URI" do
     @resource.source("http://www.google.com/robots.txt")
-    @resource.provider.should == Chef::Provider::RemoteFile
-    Chef::Platform.find_provider(:noplatform, 'noversion', @resource).should == Chef::Provider::RemoteFile
+    expect(@resource.provider).to eq(Chef::Provider::RemoteFile)
+    expect(Chef::Platform.find_provider(:noplatform, 'noversion', @resource)).to eq(Chef::Provider::RemoteFile)
   end
 
 
   describe "source" do
     it "does not have a default value for 'source'" do
-      @resource.source.should eql([])
+      expect(@resource.source).to eql([])
     end
 
     it "should accept a URI for the remote file source" do
       @resource.source "http://opscode.com/"
-      @resource.source.should eql([ "http://opscode.com/" ])
+      expect(@resource.source).to 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/" ])
+      expect(@resource.source).to 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/" ])
+      expect(@resource.source).to 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/" ])
+      expect(@resource.source).to 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/" ])
+      expect(@resource.source).to eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
     end
 
     it "should only accept a single argument if a delayed evalutor is used" do
-      lambda {
+      expect {
         @resource.source("http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"})
-      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
     it "should only accept a single array item if a delayed evalutor is used" do
-      lambda {
+      expect {
         @resource.source(["http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"}])
-      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      }.to 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)
+      expect { @resource.source("not-a-uri") }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
     it "does not accept a non-URI as the source when read from a delayed evaluator" do
-      lambda {
+      expect {
         @resource.source(Chef::DelayedEvaluator.new {"not-a-uri"})
         @resource.source
-      }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      }.to 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)
+      expect { @resource.source([]) }.to raise_error(ArgumentError)
     end
 
   end
@@ -102,51 +102,51 @@ describe Chef::Resource::RemoteFile do
   describe "checksum" do
     it "should accept a string for the checksum object" do
       @resource.checksum "asdf"
-      @resource.checksum.should eql("asdf")
+      expect(@resource.checksum).to eql("asdf")
     end
 
     it "should default to nil" do
-      @resource.checksum.should == nil
+      expect(@resource.checksum).to eq(nil)
     end
   end
 
   describe "ftp_active_mode" do
     it "should accept a boolean for the ftp_active_mode object" do
       @resource.ftp_active_mode true
-      @resource.ftp_active_mode.should be_true
+      expect(@resource.ftp_active_mode).to be_true
     end
 
     it "should default to false" do
-      @resource.ftp_active_mode.should be_false
+      expect(@resource.ftp_active_mode).to be_false
     end
   end
 
   describe "conditional get options" do
     it "defaults to using etags and last modified" do
-      @resource.use_etags.should be_true
-      @resource.use_last_modified.should be_true
+      expect(@resource.use_etags).to be_true
+      expect(@resource.use_last_modified).to be_true
     end
 
     it "enable or disables etag and last modified options as a group" do
       @resource.use_conditional_get(false)
-      @resource.use_etags.should be_false
-      @resource.use_last_modified.should be_false
+      expect(@resource.use_etags).to be_false
+      expect(@resource.use_last_modified).to be_false
 
       @resource.use_conditional_get(true)
-      @resource.use_etags.should be_true
-      @resource.use_last_modified.should be_true
+      expect(@resource.use_etags).to be_true
+      expect(@resource.use_last_modified).to be_true
     end
 
     it "disables etags indivdually" do
       @resource.use_etags(false)
-      @resource.use_etags.should be_false
-      @resource.use_last_modified.should be_true
+      expect(@resource.use_etags).to be_false
+      expect(@resource.use_last_modified).to be_true
     end
 
     it "disables last modified individually" do
       @resource.use_last_modified(false)
-      @resource.use_last_modified.should be_false
-      @resource.use_etags.should be_true
+      expect(@resource.use_last_modified).to be_false
+      expect(@resource.use_etags).to be_true
     end
 
   end
@@ -171,21 +171,21 @@ describe Chef::Resource::RemoteFile do
       state = @resource.state
       if Chef::Platform.windows?
         puts state
-        state[:rights].should == [{:permissions => :read, :principals => "Everyone"}]
-        state[:deny_rights].should == [{:permissions => :full_control, :principals => "Clumsy_Sam"}]
+        expect(state[:rights]).to eq([{:permissions => :read, :principals => "Everyone"}])
+        expect(state[:deny_rights]).to eq([{:permissions => :full_control, :principals => "Clumsy_Sam"}])
       else
-        state[:group].should == "pokemon"
-        state[:mode].should == "0664"
-        state[:owner].should == "root"
-        state[:checksum].should == "1"*26
+        expect(state[:group]).to eq("pokemon")
+        expect(state[:mode]).to eq("0664")
+        expect(state[:owner]).to eq("root")
+        expect(state[:checksum]).to eq("1"*26)
       end
     end
 
     it "returns the path as its identity" do
       if Chef::Platform.windows?
-        @resource.identity.should == "C:/temp/origin/file.txt"
+        expect(@resource.identity).to eq("C:/temp/origin/file.txt")
       else
-        @resource.identity.should == "/this/path/"
+        expect(@resource.identity).to eq("/this/path/")
       end
     end
   end