ridley 4.0.0 → 4.3.0

data/spec/acceptance/user_resource_spec.rb

@@ -11,30 +11,30 @@ describe "User API operations", type: "wip" do
       before { chef_user("reset", admin: false) }
 
       it "returns a UserObject" do
-        connection.user.find("reset").should be_a(Ridley::UserObject)
+        expect(connection.user.find("reset")).to be_a(Ridley::UserObject)
       end
     end
 
     context "when the server does not have the user" do
       it "returns a nil value" do
-        connection.user.find("not_there").should be_nil
+        expect(connection.user.find("not_there")).to be_nil
       end
     end
   end
 
   describe "creating a user" do
     it "returns a Ridley::UserObject" do
-      connection.user.create(name: "reset").should be_a(Ridley::UserObject)
+      expect(connection.user.create(name: "reset")).to be_a(Ridley::UserObject)
     end
 
     it "adds a user to the chef server" do
       old = connection.user.all.length
       connection.user.create(name: "reset")
-      connection.user.all.should have(old + 1).items
+      expect(connection.user.all.size).to eq(old + 1)
     end
 
     it "has a value for #private_key" do
-      connection.user.create(name: "reset").private_key.should_not be_nil
+      expect(connection.user.create(name: "reset").private_key).not_to be_nil
     end
   end
 
@@ -42,13 +42,13 @@ describe "User API operations", type: "wip" do
     before { chef_user("reset", admin: false) }
 
     it "returns a Ridley::UserObject object" do
-      connection.user.delete("reset").should be_a(Ridley::UserObject)
+      expect(connection.user.delete("reset")).to be_a(Ridley::UserObject)
     end
 
     it "removes the user from the server" do
       connection.user.delete("reset")
 
-      connection.user.find("reset").should be_nil
+      expect(connection.user.find("reset")).to be_nil
     end
   end
 
@@ -59,12 +59,12 @@ describe "User API operations", type: "wip" do
     end
 
     it "returns an array of Ridley::UserObject objects" do
-      connection.user.delete_all.should each be_a(Ridley::UserObject)
+      expect(connection.user.delete_all).to each be_a(Ridley::UserObject)
     end
 
     it "deletes all users from the remote" do
       connection.user.delete_all
-      connection.user.all.should have(0).users
+      expect(connection.user.all.size).to eq(0)
     end
   end
 
@@ -75,11 +75,11 @@ describe "User API operations", type: "wip" do
     end
 
     it "returns an array of Ridley::UserObject objects" do
-      connection.user.all.should each be_a(Ridley::UserObject)
+      expect(connection.user.all).to each be_a(Ridley::UserObject)
     end
 
     it "returns all of the users on the server" do
-      connection.user.all.should have(3).items
+      expect(connection.user.all.size).to eq(3)
     end
   end
 
@@ -87,7 +87,7 @@ describe "User API operations", type: "wip" do
     before { chef_user("reset", admin: false) }
 
     it "returns a Ridley::UserObject object with a value for #private_key" do
-      connection.user.regenerate_key("reset").private_key.should match(/^-----BEGIN RSA PRIVATE KEY-----/)
+      expect(connection.user.regenerate_key("reset").private_key).to match(/^-----BEGIN RSA PRIVATE KEY-----/)
     end
   end
 
@@ -95,20 +95,20 @@ describe "User API operations", type: "wip" do
     before { chef_user('reset', password: 'swordfish') }
 
     it "returns true when given valid username & password" do
-      expect(connection.user.authenticate('reset', 'swordfish')).to be_true
+      expect(connection.user.authenticate('reset', 'swordfish')).to be_truthy
     end
 
     it "returns false when given valid username & invalid password" do
-      expect(connection.user.authenticate('reset', "not a swordfish")).to be_false
+      expect(connection.user.authenticate('reset', "not a swordfish")).to be_falsey
     end
 
     it "returns false when given invalid username & valid password" do
-      expect(connection.user.authenticate("someone-else", 'swordfish')).to be_false
+      expect(connection.user.authenticate("someone-else", 'swordfish')).to be_falsey
     end
 
     it "works also on a User object level" do
-      expect(connection.user.find('reset').authenticate('swordfish')).to be_true
-      expect(connection.user.find('reset').authenticate('not a swordfish')).to be_false
+      expect(connection.user.find('reset').authenticate('swordfish')).to be_truthy
+      expect(connection.user.find('reset').authenticate('not a swordfish')).to be_falsey
     end
   end
 
@@ -117,14 +117,14 @@ describe "User API operations", type: "wip" do
     subject { connection.user.find('reset') }
 
     it "changes the password with which user can authenticate" do
-      expect(subject.authenticate('swordfish')).to be_true
-      expect(subject.authenticate('salmon')).to be_false
+      expect(subject.authenticate('swordfish')).to be_truthy
+      expect(subject.authenticate('salmon')).to be_falsey
 
       subject.password = 'salmon'
       subject.save
 
-      expect(subject.authenticate('swordfish')).to be_false
-      expect(subject.authenticate('salmon')).to be_true
+      expect(subject.authenticate('swordfish')).to be_falsey
+      expect(subject.authenticate('salmon')).to be_truthy
     end
   end
 end

data/spec/support/each_matcher.rb

@@ -2,11 +2,11 @@ RSpec::Matchers.define :each do |check|
   match do |actual|
     actual.each_with_index do |index, o|
       @object = o
-      index.should check
+      expect(index).to check
     end
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "at[#{@object}] #{check.failure_message_for_should}"
   end
 end

data/spec/support/filepath_matchers.rb

@@ -9,11 +9,11 @@ RSpec::Matchers.define :be_relative_path do
     end
   end
 
-  failure_message_for_should do |given|
+  failure_message do |given|
     "Expected '#{given}' to be a relative path but got an absolute path."
   end
 
-  failure_message_for_should_not do |given|
+  failure_message_when_negated do |given|
     "Expected '#{given}' to not be a relative path but got an absolute path."
   end
 end

data/spec/support/shared_examples/ridley_resource.rb

@@ -9,8 +9,8 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
 
     describe "::all" do
       it "sends a get request for the class' resource_path using the given client" do
-        response.stub(:body) { Hash.new }
-        client.connection.should_receive(:get).with(subject.resource_path).and_return(response)
+        allow(response).to receive(:body) { Hash.new }
+        expect(client.connection).to receive(:get).with(subject.resource_path).and_return(response)
 
         subject.all(client)
       end
@@ -19,8 +19,8 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
     describe "::find" do
       it "sends a get request to the given client to the resource_path of the class for the given chef_id" do
         chef_id = "ridley_test"
-        response.stub(:body) { Hash.new }
-        client.connection.should_receive(:get).with("#{subject.resource_path}/#{chef_id}").and_return(response)
+        allow(response).to receive(:body) { Hash.new }
+        expect(client.connection).to receive(:get).with("#{subject.resource_path}/#{chef_id}").and_return(response)
 
         subject.find(client, chef_id)
       end
@@ -33,8 +33,8 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
           last_name: "winsor"
         }
 
-        response.stub(:body) { attrs }
-        client.connection.should_receive(:post).with(subject.resource_path, duck_type(:to_json)).and_return(response)
+        allow(response).to receive(:body) { attrs }
+        expect(client.connection).to receive(:post).with(subject.resource_path, duck_type(:to_json)).and_return(response)
 
         subject.create(client, attrs)
       end
@@ -42,17 +42,17 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
 
     describe "::delete" do
       it "sends a delete request to the given client using the includer's resource_path for the given string" do
-        response.stub(:body) { Hash.new }
-        client.connection.should_receive(:delete).with("#{subject.resource_path}/ridley-test").and_return(response)
+        allow(response).to receive(:body) { Hash.new }
+        expect(client.connection).to receive(:delete).with("#{subject.resource_path}/ridley-test").and_return(response)
 
         subject.delete(client, "ridley-test")
       end
 
       it "accepts an object that responds to 'chef_id'" do
         object = double("obj")
-        object.stub(:chef_id) { "hello" }
-        response.stub(:body) { Hash.new }
-        client.connection.should_receive(:delete).with("#{subject.resource_path}/#{object.chef_id}").and_return(response)
+        allow(object).to receive(:chef_id) { "hello" }
+        allow(response).to receive(:body) { Hash.new }
+        expect(client.connection).to receive(:delete).with("#{subject.resource_path}/#{object.chef_id}").and_return(response)
 
         subject.delete(client, object)
       end
@@ -60,17 +60,17 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
 
     describe "::delete_all" do
       it "sends a delete request for every object in the collection" do
-        pending
+        skip
       end
     end
 
     describe "::update" do
       it "sends a put request to the given client using the includer's resource_path with the given object" do
-        subject.stub(:chef_id) { :name }
+        allow(subject).to receive(:chef_id) { :name }
         subject.attribute(:name)
         object = subject.new(name: "hello")
-        response.stub(:body) { Hash.new }
-        client.connection.should_receive(:put).with("#{subject.resource_path}/#{object.chef_id}", duck_type(:to_json)).and_return(response)
+        allow(response).to receive(:body) { Hash.new }
+        expect(client.connection).to receive(:put).with("#{subject.resource_path}/#{object.chef_id}", duck_type(:to_json)).and_return(response)
 
         subject.update(client, object)
       end
@@ -81,12 +81,12 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
 
   describe "#save" do
     context "when the object is valid" do
-      before(:each) { subject.stub(:valid?).and_return(true) }
+      before(:each) { allow(subject).to receive(:valid?).and_return(true) }
 
       it "sends a create message to the implementing class" do
         updated = double('updated')
-        updated.stub(:_attributes_).and_return(Hash.new)
-        subject.class.should_receive(:create).with(client, subject).and_return(updated)
+        allow(updated).to receive(:_attributes_).and_return(Hash.new)
+        expect(subject.class).to receive(:create).with(client, subject).and_return(updated)
 
         subject.save
       end
@@ -94,10 +94,10 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
       context "when there is an HTTPConflict" do
         it "sends the update message to self" do
           updated = double('updated')
-          updated.stub(:[]).and_return(Hash.new)
-          updated.stub(:_attributes_).and_return(Hash.new)
-          subject.class.should_receive(:create).and_raise(Ridley::Errors::HTTPConflict.new(updated))
-          subject.should_receive(:update).and_return(updated)
+          allow(updated).to receive(:[]).and_return(Hash.new)
+          allow(updated).to receive(:_attributes_).and_return(Hash.new)
+          expect(subject.class).to receive(:create).and_raise(Ridley::Errors::HTTPConflict.new(updated))
+          expect(subject).to receive(:update).and_return(updated)
 
           subject.save
         end
@@ -105,12 +105,12 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
     end
 
     context "when the object is invalid" do
-      before(:each) { subject.stub(:valid?).and_return(false) }
+      before(:each) { allow(subject).to receive(:valid?).and_return(false) }
 
       it "raises an InvalidResource error" do
-        lambda {
+        expect {
           subject.save
-        }.should raise_error(Ridley::Errors::InvalidResource)
+        }.to raise_error(Ridley::Errors::InvalidResource)
       end
     end
   end
@@ -119,31 +119,31 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
     context "when the object is valid" do
       let(:updated) do
         updated = double('updated')
-        updated.stub(:[]).and_return(Hash.new)
-        updated.stub(:_attributes_).and_return(Hash.new)
+        allow(updated).to receive(:[]).and_return(Hash.new)
+        allow(updated).to receive(:_attributes_).and_return(Hash.new)
         updated
       end
 
-      before(:each) { subject.stub(:valid?).and_return(true) }
+      before(:each) { allow(subject).to receive(:valid?).and_return(true) }
 
       it "sends an update message to the implementing class" do
-        subject.class.should_receive(:update).with(anything, subject).and_return(updated)
+        expect(subject.class).to receive(:update).with(anything, subject).and_return(updated)
         subject.update
       end
 
       it "returns true" do
-        subject.class.should_receive(:update).with(anything, subject).and_return(updated)
-        subject.update.should eql(true)
+        expect(subject.class).to receive(:update).with(anything, subject).and_return(updated)
+        expect(subject.update).to eql(true)
       end
     end
 
     context "when the object is invalid" do
-      before(:each) { subject.stub(:valid?).and_return(false) }
+      before(:each) { allow(subject).to receive(:valid?).and_return(false) }
 
       it "raises an InvalidResource error" do
-        lambda {
+        expect {
           subject.update
-        }.should raise_error(Ridley::Errors::InvalidResource)
+        }.to raise_error(Ridley::Errors::InvalidResource)
       end
     end
   end
@@ -151,10 +151,10 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
   describe "#chef_id" do
     it "returns the value of the chef_id attribute" do
       subject.class.attribute(:name)
-      subject.class.stub(:chef_id) { :name }
+      allow(subject.class).to receive(:chef_id) { :name }
       subject.mass_assign(name: "reset")
 
-      subject.chef_id.should eql("reset")
+      expect(subject.chef_id).to eql("reset")
     end
   end
 
@@ -163,17 +163,17 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
 
     before(:each) do
       subject.class.attribute(:fake_attribute)
-      subject.class.stub(:find).with(client, subject).and_return(updated_subject)
+      allow(subject.class).to receive(:find).with(client, subject).and_return(updated_subject)
     end
 
     it "returns itself" do
-      subject.reload.should eql(subject)
+      expect(subject.reload).to eql(subject)
     end
 
     it "sets the attributes of self to include those of the reloaded object" do
       subject.reload
 
-      subject.get_attribute(:fake_attribute).should eql("some_value")
+      expect(subject.get_attribute(:fake_attribute)).to eql("some_value")
     end
   end
 end

data/spec/unit/ridley/chef/cookbook/metadata_spec.rb

@@ -17,36 +17,36 @@ describe Ridley::Chef::Cookbook::Metadata do
         :choice => [ "test1", "test2" ],
         :default => "test1"
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
   
       options = {
         :type => "boolean",
         :choice => [ true, false ],
         :default => true
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ 1337, 420 ],
         :default => 1337
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ true, "false" ],
         :default => false
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should raise_error
+      }.to raise_error
     end
   end
 end

data/spec/unit/ridley/chef/cookbook/syntax_check_spec.rb

@@ -12,7 +12,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
   subject { syntax_check }
 
   before(:each) do
-    subject.stub(:chefignore) { chefignore }
+    allow(subject).to receive(:chefignore) { chefignore }
   end
 
   describe "#ruby_files" do
@@ -55,7 +55,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
     it "checks if a file has already been validated" do
       valid_template_file = cookbook_dir.join("templates/default/temp.txt.erb").to_s
       subject.validated(valid_template_file)
-      expect(subject.validated?(valid_template_file)).to be_true
+      expect(subject.validated?(valid_template_file)).to be_truthy
     end
   end
 
@@ -63,7 +63,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
     let(:validated_files) { double('validated_files') }
 
     before(:each) do
-      subject.stub(:validated_files) { validated_files }
+      allow(subject).to receive(:validated_files) { validated_files }
     end
 
     it "records a file as validated" do
@@ -77,35 +77,35 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
 
   describe "#validate_ruby_files" do
     it "asks #untested_ruby_files for a list of files and calls #validate_ruby_file on each" do
-      subject.stub(:validate_ruby_file).with(anything()).exactly(9).times { true }
-      expect(subject.validate_ruby_files).to be_true
+      allow(subject).to receive(:validate_ruby_file).with(anything()).exactly(9).times { true }
+      expect(subject.validate_ruby_files).to be_truthy
     end
 
     it "marks the successfully validated ruby files" do
-      subject.stub(:validated).with(anything()).exactly(9).times
-      expect(subject.validate_ruby_files).to be_true
+      allow(subject).to receive(:validated).with(anything()).exactly(9).times
+      expect(subject.validate_ruby_files).to be_truthy
     end
 
     it "returns false if any ruby file fails to validate" do
-      subject.stub(:validate_ruby_file).with(/\.rb$/) { false }
-      expect(subject.validate_ruby_files).to be_false
+      allow(subject).to receive(:validate_ruby_file).with(/\.rb$/) { false }
+      expect(subject.validate_ruby_files).to be_falsey
     end
   end
 
   describe "#validate_templates" do
     it "asks #untested_template_files for a list of erb files and calls #validate_template on each" do
-      subject.stub(:validate_template).with(anything()).exactly(9).times { true }
-      expect(subject.validate_templates).to be_true
+      allow(subject).to receive(:validate_template).with(anything()).exactly(9).times { true }
+      expect(subject.validate_templates).to be_truthy
     end
 
     it "marks the successfully validated erb files" do
-      subject.stub(:validated).with(anything()).exactly(9).times
-      expect(subject.validate_templates).to be_true
+      allow(subject).to receive(:validated).with(anything()).exactly(9).times
+      expect(subject.validate_templates).to be_truthy
     end
 
     it "returns false if any erb file fails to validate" do
-      subject.stub(:validate_template).with(/\.erb$/) { false }
-      expect(subject.validate_templates).to be_false
+      allow(subject).to receive(:validate_template).with(/\.erb$/) { false }
+      expect(subject.validate_templates).to be_falsey
     end
   end