ridley 4.2.0 → 4.3.0

data/spec/acceptance/node_resource_spec.rb

@@ -11,7 +11,7 @@ describe "Node API operations", type: "acceptance" do
     before { chef_node(node_name) }
 
     it "returns a Ridley::NodeObject" do
-      connection.node.find(node_name).should be_a(Ridley::NodeObject)
+      expect(connection.node.find(node_name)).to be_a(Ridley::NodeObject)
     end
   end
 
@@ -19,13 +19,13 @@ describe "Node API operations", type: "acceptance" do
     let(:node_name) { "ridley.localhost" }
 
     it "returns a new Ridley::NodeObject object" do
-      connection.node.create(name: node_name).should be_a(Ridley::NodeObject)
+      expect(connection.node.create(name: node_name)).to be_a(Ridley::NodeObject)
     end
 
     it "adds a new node to the server" do
       connection.node.create(name: node_name)
 
-      connection.node.all.should have(1).node
+      expect(connection.node.all.size).to eq(1)
     end
   end
 
@@ -34,13 +34,13 @@ describe "Node API operations", type: "acceptance" do
     before { chef_node(node_name) }
 
     it "returns a Ridley::NodeObject" do
-      connection.node.delete(node_name).should be_a(Ridley::NodeObject)
+      expect(connection.node.delete(node_name)).to be_a(Ridley::NodeObject)
     end
 
     it "removes the node from the server" do
       connection.node.delete(node_name)
 
-      connection.node.find(node_name).should be_nil
+      expect(connection.node.find(node_name)).to be_nil
     end
   end
 
@@ -53,7 +53,7 @@ describe "Node API operations", type: "acceptance" do
     it "deletes all nodes from the remote server" do
       connection.node.delete_all
 
-      connection.node.all.should have(0).nodes
+      expect(connection.node.all.size).to eq(0)
     end
   end
 
@@ -66,8 +66,8 @@ describe "Node API operations", type: "acceptance" do
     it "returns an array of Ridley::NodeObject" do
       obj = connection.node.all
 
-      obj.should each be_a(Ridley::NodeObject)
-      obj.should have(2).nodes
+      expect(obj).to each be_a(Ridley::NodeObject)
+      expect(obj.size).to eq(2)
     end
   end
 
@@ -77,7 +77,7 @@ describe "Node API operations", type: "acceptance" do
     let(:target) { connection.node.find(node_name) }
 
     it "returns the updated node" do
-      connection.node.update(target).should eql(target)
+      expect(connection.node.update(target)).to eql(target)
     end
 
     it "saves a new set of 'normal' attributes" do
@@ -91,7 +91,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.normal.should eql(normal)
+      expect(obj.normal).to eql(normal)
     end
 
     it "saves a new set of 'default' attributes" do
@@ -105,7 +105,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.default.should eql(defaults)
+      expect(obj.default).to eql(defaults)
     end
 
     it "saves a new set of 'automatic' attributes" do
@@ -119,7 +119,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.automatic.should eql(automatics)
+      expect(obj.automatic).to eql(automatics)
     end
 
     it "saves a new set of 'override' attributes" do
@@ -133,7 +133,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.override.should eql(overrides)
+      expect(obj.override).to eql(overrides)
     end
 
     it "places a node in a new 'chef_environment'" do
@@ -142,7 +142,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.chef_environment.should eql(environment)
+      expect(obj.chef_environment).to eql(environment)
     end
 
     it "saves a new 'run_list' for the node" do
@@ -151,7 +151,7 @@ describe "Node API operations", type: "acceptance" do
       connection.node.update(target)
       obj = connection.node.find(target)
 
-      obj.run_list.should eql(run_list)
+      expect(obj.run_list).to eql(run_list)
     end
   end
 end

data/spec/acceptance/role_resource_spec.rb

@@ -11,7 +11,7 @@ describe "Role API operations", type: "acceptance" do
     before { chef_role(role_name) }
 
     it "returns a Ridley::RoleObject" do
-      connection.role.find(role_name).should be_a(Ridley::RoleObject)
+      expect(connection.role.find(role_name)).to be_a(Ridley::RoleObject)
     end
   end
 
@@ -19,12 +19,12 @@ describe "Role API operations", type: "acceptance" do
     let(:role_name) { "ridley-role" }
 
     it "returns a new Ridley::RoleObject" do
-      connection.role.create(name: role_name).should be_a(Ridley::RoleObject)
+      expect(connection.role.create(name: role_name)).to be_a(Ridley::RoleObject)
     end
 
     it "adds a new role to the server" do
       connection.role.create(name: role_name)
-      connection.role.all.should have(1).role
+      expect(connection.role.all.size).to eq(1)
     end
   end
 
@@ -33,13 +33,13 @@ describe "Role API operations", type: "acceptance" do
     before { chef_role(role_name) }
 
     it "returns the deleted Ridley::RoleObject resource" do
-      connection.role.delete(role_name).should be_a(Ridley::RoleObject)
+      expect(connection.role.delete(role_name)).to be_a(Ridley::RoleObject)
     end
 
     it "removes the role from the server" do
       connection.role.delete(role_name)
 
-      connection.role.find(role_name).should be_nil
+      expect(connection.role.find(role_name)).to be_nil
     end
   end
 
@@ -52,7 +52,7 @@ describe "Role API operations", type: "acceptance" do
     it "deletes all nodes from the remote server" do
       connection.role.delete_all
 
-      connection.role.all.should have(0).roles
+      expect(connection.role.all.size).to eq(0)
     end
   end
 
@@ -65,8 +65,8 @@ describe "Role API operations", type: "acceptance" do
     it "should return an array of Ridley::RoleObject" do
       obj = connection.role.all
 
-      obj.should have(2).roles
-      obj.should each be_a(Ridley::RoleObject)
+      expect(obj.size).to eq(2)
+      expect(obj).to each be_a(Ridley::RoleObject)
     end
   end
 
@@ -76,7 +76,7 @@ describe "Role API operations", type: "acceptance" do
     let(:target) { connection.role.find(role_name) }
 
     it "returns an updated Ridley::RoleObject object" do
-      connection.role.update(target).should eql(target)
+      expect(connection.role.update(target)).to eql(target)
     end
 
     it "saves a new run_list" do
@@ -85,7 +85,7 @@ describe "Role API operations", type: "acceptance" do
       connection.role.update(target)
       obj = connection.role.find(target)
 
-      obj.run_list.should eql(run_list)
+      expect(obj.run_list).to eql(run_list)
     end
 
     it "saves a new env_run_lists" do
@@ -97,7 +97,7 @@ describe "Role API operations", type: "acceptance" do
       connection.role.update(target)
       obj = connection.role.find(target)
 
-      obj.env_run_lists.should eql(env_run_lists)
+      expect(obj.env_run_lists).to eql(env_run_lists)
     end
 
     it "saves a new description" do
@@ -106,7 +106,7 @@ describe "Role API operations", type: "acceptance" do
       connection.role.update(target)
       obj = connection.role.find(target)
 
-      obj.description.should eql(description)
+      expect(obj.description).to eql(description)
     end
 
     it "saves a new default_attributes" do
@@ -120,7 +120,7 @@ describe "Role API operations", type: "acceptance" do
       connection.role.update(target)
       obj = connection.role.find(target)
 
-      obj.default_attributes.should eql(defaults)
+      expect(obj.default_attributes).to eql(defaults)
     end
 
     it "saves a new override_attributes" do
@@ -134,7 +134,7 @@ describe "Role API operations", type: "acceptance" do
       connection.role.update(target)
       obj = connection.role.find(target)
 
-      obj.override_attributes.should eql(overrides)
+      expect(obj.override_attributes).to eql(overrides)
     end
   end
 end

data/spec/acceptance/sandbox_resource_spec.rb

@@ -15,15 +15,15 @@ describe "Sandbox API operations", type: "acceptance" do
 
   describe "creating a new sandbox" do
     it "returns an instance of Ridley::SandboxObject" do
-      connection.sandbox.create(checksums).should be_a(Ridley::SandboxObject)
+      expect(connection.sandbox.create(checksums)).to be_a(Ridley::SandboxObject)
     end
 
     it "contains a value for sandbox_id" do
-      connection.sandbox.create(checksums).sandbox_id.should_not be_nil
+      expect(connection.sandbox.create(checksums).sandbox_id).not_to be_nil
     end
 
     it "returns an instance with the same amount of checksums given to create" do
-      connection.sandbox.create(checksums).checksums.should have(2).items
+      expect(connection.sandbox.create(checksums).checksums.size).to eq(2)
     end
   end
 end

data/spec/acceptance/search_resource_spec.rb

@@ -10,18 +10,18 @@ describe "Search API operations", type: "acceptance" do
     it "returns an array of indexes" do
       indexes = connection.search_indexes
 
-      indexes.should include("role")
-      indexes.should include("node")
-      indexes.should include("client")
-      indexes.should include("environment")
+      expect(indexes).to include("role")
+      expect(indexes).to include("node")
+      expect(indexes).to include("client")
+      expect(indexes).to include("environment")
     end
   end
 
   describe "searching an index that doesn't exist" do
     it "it raises a Ridley::Errors::HTTPNotFound error" do
-      lambda {
+      expect {
         connection.search(:notthere)
-      }.should raise_error(Ridley::Errors::HTTPNotFound)
+      }.to raise_error(Ridley::Errors::HTTPNotFound)
     end
   end
 end

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