ridley 4.0.0 → 4.3.0

data/spec/acceptance/cookbook_resource_spec.rb

@@ -18,7 +18,7 @@ describe "Client API operations", type: "acceptance" do
       before { subject.download(name, version, destination) }
 
       it "downloads the cookbook to the destination" do
-        expect(File.exist?(destination.join("metadata.json"))).to be_true
+        expect(File.exist?(destination.join("metadata.json"))).to be_truthy
       end
     end
   end
@@ -30,23 +30,23 @@ describe "Client API operations", type: "acceptance" do
       subject.upload(path)
       cookbook = subject.find("example_cookbook", "0.1.0")
 
-      cookbook.attributes.should have(1).item
-      cookbook.definitions.should have(1).item
-      cookbook.files.should have(2).items
-      cookbook.libraries.should have(1).item
-      cookbook.providers.should have(1).item
-      cookbook.recipes.should have(1).item
-      cookbook.resources.should have(1).item
-      cookbook.templates.should have(1).item
-      cookbook.root_files.should have(1).items
+      expect(cookbook.attributes.size).to eq(1)
+      expect(cookbook.definitions.size).to eq(1)
+      expect(cookbook.files.size).to eq(2)
+      expect(cookbook.libraries.size).to eq(1)
+      expect(cookbook.providers.size).to eq(1)
+      expect(cookbook.recipes.size).to eq(1)
+      expect(cookbook.resources.size).to eq(1)
+      expect(cookbook.templates.size).to eq(1)
+      expect(cookbook.root_files.size).to eq(1)
     end
 
     it "does not contain a raw metadata.rb but does contain a compiled metadata.json" do
       subject.upload(path)
       cookbook = subject.find("example_cookbook", "0.1.0")
 
-      expect(cookbook.root_files.any? { |f| f[:name] == "metadata.json" }).to be_true
-      expect(cookbook.root_files.any? { |f| f[:name] == "metadata.rb" }).to be_false
+      expect(cookbook.root_files.any? { |f| f[:name] == "metadata.json" }).to be_truthy
+      expect(cookbook.root_files.any? { |f| f[:name] == "metadata.rb" }).to be_falsey
     end
   end
 
@@ -60,9 +60,9 @@ describe "Client API operations", type: "acceptance" do
 
     it "returns all of the cookbooks on the server" do
       all_cookbooks = subject.all
-      expect(all_cookbooks).to have(2).items
-      expect(all_cookbooks["ruby"]).to have(2).items
-      expect(all_cookbooks["elixir"]).to have(2).items
+      expect(all_cookbooks.size).to eq(2)
+      expect(all_cookbooks["ruby"].size).to eq(2)
+      expect(all_cookbooks["elixir"].size).to eq(2)
     end
   end
 end

data/spec/acceptance/data_bag_item_resource_spec.rb

@@ -14,7 +14,7 @@ describe "DataBag API operations", type: "acceptance" do
   describe "listing data bag items" do
     context "when the data bag has no items" do
       it "returns an empty array" do
-        data_bag.item.all.should have(0).items
+        expect(data_bag.item.all.size).to eq(0)
       end
     end
 
@@ -25,7 +25,7 @@ describe "DataBag API operations", type: "acceptance" do
       end
 
       it "returns an array with each item" do
-        data_bag.item.all.should have(2).items
+        expect(data_bag.item.all.size).to eq(2)
       end
     end
   end
@@ -34,7 +34,7 @@ describe "DataBag API operations", type: "acceptance" do
     it "adds a data bag item to the collection of data bag items" do
       data_bag.item.create(id: "appconfig", host: "host.local", port: 80, admin: false, servers: ["one"])
 
-      data_bag.item.all.should have(1).item
+      expect(data_bag.item.all.size).to eq(1)
     end
 
     context "when an 'id' field is missing" do
@@ -59,7 +59,7 @@ describe "DataBag API operations", type: "acceptance" do
       }
       data_bag.item.create(attributes)
 
-      data_bag.item.find("appconfig").to_hash.should eql(attributes)
+      expect(data_bag.item.find("appconfig").to_hash).to eql(attributes)
     end
   end
 
@@ -76,14 +76,14 @@ describe "DataBag API operations", type: "acceptance" do
     it "returns the deleted data bag item" do
       dbi = data_bag.item.delete(attributes["id"])
 
-      dbi.should be_a(Ridley::DataBagItemObject)
-      dbi.attributes.should eql(attributes)
+      expect(dbi).to be_a(Ridley::DataBagItemObject)
+      expect(dbi.attributes).to eql(attributes)
     end
 
     it "deletes the data bag item from the server" do
       data_bag.item.delete(attributes["id"])
 
-      data_bag.item.find(attributes["id"]).should be_nil
+      expect(data_bag.item.find(attributes["id"])).to be_nil
     end
   end
 
@@ -94,13 +94,13 @@ describe "DataBag API operations", type: "acceptance" do
     end
 
     it "returns the array of deleted data bag items" do
-      data_bag.item.delete_all.should each be_a(Ridley::DataBagItemObject)
+      expect(data_bag.item.delete_all).to each be_a(Ridley::DataBagItemObject)
     end
 
     it "removes all data bag items from the data bag" do
       data_bag.item.delete_all
 
-      data_bag.item.all.should have(0).items
+      expect(data_bag.item.all.size).to eq(0)
     end
   end
 
@@ -110,7 +110,7 @@ describe "DataBag API operations", type: "acceptance" do
     it "returns the updated data bag item" do
       dbi = data_bag.item.update(id: "one", name: "brooke")
 
-      dbi[:name].should eql("brooke")
+      expect(dbi[:name]).to eql("brooke")
     end
   end
 
@@ -120,14 +120,14 @@ describe "DataBag API operations", type: "acceptance" do
 
       it "returns true if successful" do
         dbi[:name] = "brooke"
-        dbi.save.should be_true
+        expect(dbi.save).to be_truthy
       end
 
       it "creates a new data bag item on the remote" do
         dbi[:name] = "brooke"
         dbi.save
 
-        data_bag.item.all.should have(1).item
+        expect(data_bag.item.all.size).to eq(1)
       end
     end
 
@@ -136,7 +136,7 @@ describe "DataBag API operations", type: "acceptance" do
         dbi = data_bag.item.new
 
         dbi.attributes = { id: "not-there", name: "brooke" }
-        dbi.save.should be_true
+        expect(dbi.save).to be_truthy
       end
 
       it "creates a new data bag item on the remote" do
@@ -144,7 +144,7 @@ describe "DataBag API operations", type: "acceptance" do
         dbi.attributes = { id: "not-there", name: "brooke" }
         dbi.save
 
-        data_bag.item.all.should have(1).item
+        expect(data_bag.item.all.size).to eq(1)
       end
     end
   end

data/spec/acceptance/data_bag_resource_spec.rb

@@ -9,7 +9,7 @@ describe "DataBag API operations", type: "acceptance" do
   describe "listing data bags" do
     context "when no data bags exist" do
       it "returns an empty array" do
-        connection.data_bag.all.should have(0).items
+        expect(connection.data_bag.all.size).to eq(0)
       end
     end
 
@@ -20,18 +20,18 @@ describe "DataBag API operations", type: "acceptance" do
       end
 
       it "returns an array of data bags" do
-        connection.data_bag.all.should each be_a(Ridley::DataBagObject)
+        expect(connection.data_bag.all).to each be_a(Ridley::DataBagObject)
       end
 
       it "returns all of the data bags on the server" do
-        connection.data_bag.all.should have(2).items
+        expect(connection.data_bag.all.size).to eq(2)
       end
     end
   end
 
   describe "creating a data bag" do
     it "returns a Ridley::DataBagObject" do
-      connection.data_bag.create(name: "ridley-one").should be_a(Ridley::DataBagObject)
+      expect(connection.data_bag.create(name: "ridley-one")).to be_a(Ridley::DataBagObject)
     end
   end
 end

data/spec/acceptance/environment_resource_spec.rb

@@ -10,7 +10,7 @@ describe "Environment API operations", type: "acceptance" do
     before { chef_environment("ridley-test-env") }
 
     it "returns a valid Ridley::EnvironmentObject object" do
-      connection.environment.find("ridley-test-env").should be_a(Ridley::EnvironmentObject)
+      expect(connection.environment.find("ridley-test-env")).to be_a(Ridley::EnvironmentObject)
     end
   end
 
@@ -18,13 +18,13 @@ describe "Environment API operations", type: "acceptance" do
     it "returns a valid Ridley::EnvironmentObject object" do
       obj = connection.environment.create(name: "ridley-test-env", description: "a testing env for ridley")
 
-      obj.should be_a(Ridley::EnvironmentObject)
+      expect(obj).to be_a(Ridley::EnvironmentObject)
     end
 
     it "adds an environment to the chef server" do
       old = connection.environment.all.length
       connection.environment.create(name: "ridley")
-      connection.environment.all.should have(old + 1).item
+      expect(connection.environment.all.size).to eq(old + 1)
     end
   end
 
@@ -32,19 +32,19 @@ describe "Environment API operations", type: "acceptance" do
     before { chef_environment("ridley-env") }
 
     it "returns a Ridley::EnvironmentObject object" do
-      connection.environment.delete("ridley-env").should be_a(Ridley::EnvironmentObject)
+      expect(connection.environment.delete("ridley-env")).to be_a(Ridley::EnvironmentObject)
     end
 
     it "removes the environment from the server" do
       connection.environment.delete("ridley-env")
 
-      connection.environment.find("ridley-env").should be_nil
+      expect(connection.environment.find("ridley-env")).to be_nil
     end
 
     it "raises Ridley::Errors::HTTPMethodNotAllowed when attempting to delete the '_default' environment" do
-      lambda {
+      expect {
         connection.environment.delete("_default")
-      }.should raise_error(Ridley::Errors::HTTPMethodNotAllowed)
+      }.to raise_error(Ridley::Errors::HTTPMethodNotAllowed)
     end
   end
 
@@ -55,19 +55,19 @@ describe "Environment API operations", type: "acceptance" do
     end
 
     it "returns an array of Ridley::EnvironmentObject objects" do
-      connection.environment.delete_all.should each be_a(Ridley::EnvironmentObject)
+      expect(connection.environment.delete_all).to each be_a(Ridley::EnvironmentObject)
     end
 
     it "deletes all environments but '_default' from the remote" do
       connection.environment.delete_all
 
-      connection.environment.all.should have(1).item
+      expect(connection.environment.all.size).to eq(1)
     end
   end
 
   describe "listing all environments" do
     it "should return an array of Ridley::EnvironmentObject objects" do
-      connection.environment.all.should each be_a(Ridley::EnvironmentObject)
+      expect(connection.environment.all).to each be_a(Ridley::EnvironmentObject)
     end
   end
 
@@ -79,7 +79,7 @@ describe "Environment API operations", type: "acceptance" do
       target.description = description = "ridley testing environment"
 
       connection.environment.update(target)
-      target.reload.description.should eql(description)
+      expect(target.reload.description).to eql(description)
     end
 
     it "saves a new set of 'default_attributes'" do
@@ -92,7 +92,7 @@ describe "Environment API operations", type: "acceptance" do
 
       connection.environment.update(target)
       obj = connection.environment.find(target)
-      obj.default_attributes.should eql(default_attributes)
+      expect(obj.default_attributes).to eql(default_attributes)
     end
 
     it "saves a new set of 'override_attributes'" do
@@ -105,7 +105,7 @@ describe "Environment API operations", type: "acceptance" do
 
       connection.environment.update(target)
       obj = connection.environment.find(target)
-      obj.override_attributes.should eql(override_attributes)
+      expect(obj.override_attributes).to eql(override_attributes)
     end
 
     it "saves a new set of 'cookbook_versions'" do
@@ -116,7 +116,7 @@ describe "Environment API operations", type: "acceptance" do
 
       connection.environment.update(target)
       obj = connection.environment.find(target)
-      obj.cookbook_versions.should eql(cookbook_versions)
+      expect(obj.cookbook_versions).to eql(cookbook_versions)
     end
   end
 end

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