ridley 4.0.0 → 4.3.0

data/spec/unit/ridley/chef_objects/sandbox_object_spec.rb

@@ -24,15 +24,15 @@ describe Ridley::SandboxObject do
     )
   end
 
-  before { subject.stub(resource: resource) }
+  before { allow(subject).to receive_messages(resource: resource) }
 
   describe "#checksums" do
-    pending
+    skip
   end
 
   describe "#commit" do
     let(:response) { { is_completed: nil} }
-    before { resource.should_receive(:commit).with(subject).and_return(response) }
+    before { expect(resource).to receive(:commit).with(subject).and_return(response) }
 
     context "when the commit is successful" do
       before { response[:is_completed] = true }
@@ -40,7 +40,7 @@ describe Ridley::SandboxObject do
       it "has an 'is_completed' value of true" do
         subject.commit
 
-        subject.is_completed.should be_true
+        expect(subject.is_completed).to be_truthy
       end
     end
 
@@ -50,7 +50,7 @@ describe Ridley::SandboxObject do
       it "has an 'is_completed' value of false" do
         subject.commit
 
-        subject.is_completed.should be_false
+        expect(subject.is_completed).to be_falsey
       end
     end
   end
@@ -58,7 +58,7 @@ describe Ridley::SandboxObject do
   describe "#upload" do
     it "delegates to resource#upload" do
       checksums = double('checksums')
-      resource.should_receive(:upload).with(subject, checksums)
+      expect(resource).to receive(:upload).with(subject, checksums)
 
       subject.upload(checksums)
     end

data/spec/unit/ridley/client_spec.rb

@@ -32,9 +32,20 @@ describe Ridley::Client do
       subject { described_class.new(options) }
 
       describe "parsing the 'server_url' option" do
-        its(:host) { should eql("api.opscode.com") }
-        its(:scheme) { should eql("https") }
-        its(:path_prefix) { should eql("/") }
+        describe '#host' do
+          subject { super().host }
+          it { is_expected.to eql("api.opscode.com") }
+        end
+
+        describe '#scheme' do
+          subject { super().scheme }
+          it { is_expected.to eql("https") }
+        end
+
+        describe '#path_prefix' do
+          subject { super().path_prefix }
+          it { is_expected.to eql("/") }
+        end
       end
 
       describe "with a server_url containing an organization" do
@@ -43,16 +54,16 @@ describe Ridley::Client do
         end
 
         it "gets the host data from the server_url" do
-          subject.host.should eql("api.opscode.com")
-          subject.scheme.should eql("https")
+          expect(subject.host).to eql("api.opscode.com")
+          expect(subject.scheme).to eql("https")
         end
 
         it "takes the organization out of the server_url and assigns it to the organization reader" do
-          subject.organization.should eql(organization)
+          expect(subject.organization).to eql(organization)
         end
 
         it "sets the 'path_prefix' of the connection the organization sub URI" do
-          subject.path_prefix.should eql("/organizations/#{organization}")
+          expect(subject.path_prefix).to eql("/organizations/#{organization}")
         end
       end
 
@@ -94,26 +105,26 @@ describe Ridley::Client do
       it "expands the path of the client_key" do
         config[:client_key] = "spec/fixtures/reset.pem"
 
-        described_class.new(config).client_key[0..4].should_not == "spec/"
+        expect(described_class.new(config).client_key[0..4]).not_to eq("spec/")
       end
 
       it "accepts a client key as a string" do
         key = File.read(fixtures_path.join("reset.pem").to_s)
         config[:client_key] = key.dup
-        described_class.new(config).client_key.should == key
+        expect(described_class.new(config).client_key).to eq(key)
       end
 
       it "assigns a 'chef_version' attribute from the given 'chef_version' option" do
-        described_class.new(config).chef_version.should eql("10.24.0-01")
+        expect(described_class.new(config).chef_version).to eql("10.24.0-01")
       end
     end
 
     describe "::open" do
       it "instantiates a new connection, yields to it, and terminates it" do
         new_instance = double(alive?: true)
-        described_class.should_receive(:new).and_return(new_instance)
-        new_instance.should_receive(:hello)
-        new_instance.should_receive(:terminate)
+        expect(described_class).to receive(:new).and_return(new_instance)
+        expect(new_instance).to receive(:hello)
+        expect(new_instance).to receive(:terminate)
 
         described_class.open do |f|
           f.hello
@@ -126,18 +137,45 @@ describe Ridley::Client do
 
   subject { instance }
 
-  its(:client) { should be_a(Ridley::ClientResource) }
-  its(:cookbook) { should be_a(Ridley::CookbookResource) }
-  its(:data_bag) { should be_a(Ridley::DataBagResource) }
-  its(:environment) { should be_a(Ridley::EnvironmentResource) }
-  its(:node) { should be_a(Ridley::NodeResource) }
-  its(:role) { should be_a(Ridley::RoleResource) }
-  its(:sandbox) { should be_a(Ridley::SandboxResource) }
+  describe '#client' do
+    subject { super().client }
+    it { is_expected.to be_a(Ridley::ClientResource) }
+  end
+
+  describe '#cookbook' do
+    subject { super().cookbook }
+    it { is_expected.to be_a(Ridley::CookbookResource) }
+  end
+
+  describe '#data_bag' do
+    subject { super().data_bag }
+    it { is_expected.to be_a(Ridley::DataBagResource) }
+  end
+
+  describe '#environment' do
+    subject { super().environment }
+    it { is_expected.to be_a(Ridley::EnvironmentResource) }
+  end
+
+  describe '#node' do
+    subject { super().node }
+    it { is_expected.to be_a(Ridley::NodeResource) }
+  end
+
+  describe '#role' do
+    subject { super().role }
+    it { is_expected.to be_a(Ridley::RoleResource) }
+  end
+
+  describe '#sandbox' do
+    subject { super().sandbox }
+    it { is_expected.to be_a(Ridley::SandboxResource) }
+  end
 
   describe "#encrypted_data_bag_secret" do
     subject { instance.encrypted_data_bag_secret }
 
-    it { should be_a(String) }
+    it { is_expected.to be_a(String) }
 
     context "when a encrypted_data_bag_secret_path is not provided" do
       before(:each) do

data/spec/unit/ridley/connection_spec.rb

@@ -18,7 +18,7 @@ describe Ridley::Connection do
       expect {
         subject.get('organizations/vialstudios')
       }.to raise_error
-      a_request(:get, "https://api.opscode.com/organizations/vialstudios").should have_been_made.times(6)
+      expect(a_request(:get, "https://api.opscode.com/organizations/vialstudios")).to have_been_made.times(6)
     end
 
     context "given a configured count of two (2) retries" do
@@ -31,7 +31,7 @@ describe Ridley::Connection do
           subject.get('organizations/vialstudios')
         }.to raise_error
 
-        a_request(:get, "https://api.opscode.com/organizations/vialstudios").should have_been_made.times(3)
+        expect(a_request(:get, "https://api.opscode.com/organizations/vialstudios")).to have_been_made.times(3)
       end
     end
   end
@@ -40,13 +40,13 @@ describe Ridley::Connection do
     it "returns :foss if the organization is not set" do
       subject.stub(:organization).and_return(nil)
 
-      subject.api_type.should eql(:foss)
+      expect(subject.api_type).to eql(:foss)
     end
 
     it "returns :hosted if the organization is set" do
       subject.stub(:organization).and_return("vialstudios")
 
-      subject.api_type.should eql(:hosted)
+      expect(subject.api_type).to eql(:hosted)
     end
   end
 
@@ -62,17 +62,17 @@ describe Ridley::Connection do
     it "creates a destination file on disk" do
       subject.stream(target, destination)
 
-      File.exist?(destination).should be_true
+      expect(File.exist?(destination)).to be_truthy
     end
 
     it "returns true when the file was copied" do
-      expect(subject.stream(target, destination)).to be_true
+      expect(subject.stream(target, destination)).to be_truthy
     end
 
     it "contains the contents of the response body" do
       subject.stream(target, destination)
 
-      File.read(destination).should include(contents)
+      expect(File.read(destination)).to include(contents)
     end
   end
 end

data/spec/unit/ridley/errors_spec.rb

@@ -18,7 +18,7 @@ describe Ridley::Errors do
         it "adds an item to the error map" do
           subject.register_error(400)
 
-          subject.error_map.should have(1).item
+          expect(subject.error_map.size).to eq(1)
         end
 
         it "adds a key of the given status code with a value of the class inheriting from HTTPError" do
@@ -26,7 +26,7 @@ describe Ridley::Errors do
             register_error(400)
           end
 
-          subject.error_map[400].should eql(RidleyTestHTTPError)
+          expect(subject.error_map[400]).to eql(RidleyTestHTTPError)
         end
       end
     end
@@ -35,7 +35,7 @@ describe Ridley::Errors do
       subject { Ridley::Errors::HTTPError.new(:body => "<html><body><h1>Redirected</h1></body></html>") }
 
       it "has an HTML body" do
-        subject.message.should eq("<html><body><h1>Redirected</h1></body></html>")
+        expect(subject.message).to eq("<html><body><h1>Redirected</h1></body></html>")
       end
     end
   end

data/spec/unit/ridley/middleware/chef_auth_spec.rb

@@ -16,7 +16,7 @@ describe Ridley::Middleware::ChefAuth do
           host: "https://api.opscode.com",
           path: "/something.file"
         }
-        subject.authentication_headers(client_name, client_key, options).should be_a(Hash)
+        expect(subject.authentication_headers(client_name, client_key, options)).to be_a(Hash)
       end
 
       context "when the :client_key is an actual key" do
@@ -28,7 +28,7 @@ describe Ridley::Middleware::ChefAuth do
             host: "https://api.opscode.com",
             path: "/something.file"
           }
-          subject.authentication_headers(client_name, client_key, options).should be_a(Hash)
+          expect(subject.authentication_headers(client_name, client_key, options)).to be_a(Hash)
         end
       end
     end

data/spec/unit/ridley/middleware/chef_response_spec.rb

@@ -11,33 +11,33 @@ describe Ridley::Middleware::ChefResponse do
 
       it "returns true if response status between 200 and 210" do
         (200..210).each do |code|
-          env.should_receive(:[]).with(:status).and_return(code)
+          expect(env).to receive(:[]).with(:status).and_return(code)
 
-          subject.success?(env).should be_true
+          expect(subject.success?(env)).to be_truthy
         end
       end
 
       it "returns false if response status is in the 300 range" do
         (300..399).each do |code|
-          env.should_receive(:[]).with(:status).and_return(code)
+          expect(env).to receive(:[]).with(:status).and_return(code)
 
-          subject.success?(env).should be_false
+          expect(subject.success?(env)).to be_falsey
         end
       end
 
       it "returns false if response status is in the 400 range" do
         (400..499).each do |code|
-          env.should_receive(:[]).with(:status).and_return(code)
+          expect(env).to receive(:[]).with(:status).and_return(code)
 
-          subject.success?(env).should be_false
+          expect(subject.success?(env)).to be_falsey
         end
       end
 
       it "returns false if response status is in the 500 range" do
         (500..599).each do |code|
-          env.should_receive(:[]).with(:status).and_return(code)
+          expect(env).to receive(:[]).with(:status).and_return(code)
 
-          subject.success?(env).should be_false
+          expect(subject.success?(env)).to be_falsey
         end
       end
     end
@@ -117,15 +117,15 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "raises a Ridley::Errors::HTTPBadRequest" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error(Ridley::Errors::HTTPBadRequest)
+      }.to raise_error(Ridley::Errors::HTTPBadRequest)
     end
 
     it "should have the body of the response as the error's message" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error("errors: '400 - Bad Request: Valid X-CHEF-VERSION header is required.'")
+      }.to raise_error("errors: '400 - Bad Request: Valid X-CHEF-VERSION header is required.'")
     end
   end
 
@@ -135,15 +135,15 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "raises a Ridley::Errors::HTTPUnauthorized" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error(Ridley::Errors::HTTPUnauthorized)
+      }.to raise_error(Ridley::Errors::HTTPUnauthorized)
     end
 
     it "should have the body of the response as the error's message" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error("errors: '401 - Unauthorized.  You must properly authenticate your API requests!'")
+      }.to raise_error("errors: '401 - Unauthorized.  You must properly authenticate your API requests!'")
     end
   end
 
@@ -153,15 +153,15 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "raises a Ridley::Errors::HTTPForbidden" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error(Ridley::Errors::HTTPForbidden)
+      }.to raise_error(Ridley::Errors::HTTPForbidden)
     end
 
     it "should have the body of the response as the error's message" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error("errors: '403 - Forbidden.'")
+      }.to raise_error("errors: '403 - Forbidden.'")
     end
   end
 
@@ -171,15 +171,15 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "raises a Ridley::Errors::HTTPNotFound" do
-      lambda {
+      expect {
         subject.get('not_existant_route')
-      }.should raise_error(Ridley::Errors::HTTPNotFound)
+      }.to raise_error(Ridley::Errors::HTTPNotFound)
     end
 
     it "should have the body of the response as the error's message" do
-      lambda {
+      expect {
         subject.get('not_existant_route')
-      }.should raise_error(Ridley::Errors::HTTPNotFound, "errors: 'No routes match the request: /organizations/vialstudios/cookbookss/not_existant'")
+      }.to raise_error(Ridley::Errors::HTTPNotFound, "errors: 'No routes match the request: /organizations/vialstudios/cookbookss/not_existant'")
     end
   end
 
@@ -189,15 +189,15 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "raises a Ridley::Errors::HTTPForbidden" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error(Ridley::Errors::HTTPConflict)
+      }.to raise_error(Ridley::Errors::HTTPConflict)
     end
 
     it "should have the body of the response as the error's message" do
-      lambda {
+      expect {
         subject.get('cookbooks')
-      }.should raise_error("errors: '409 - Conflict.'")
+      }.to raise_error("errors: '409 - Conflict.'")
     end
   end
 
@@ -207,7 +207,7 @@ describe Ridley::Middleware::ChefResponse do
     end
 
     it "returns a body containing a hash" do
-      subject.get('roles/reset').env[:body].should be_a(Hash)
+      expect(subject.get('roles/reset').env[:body]).to be_a(Hash)
     end
   end
 end

data/spec/unit/ridley/middleware/parse_json_spec.rb

@@ -9,42 +9,42 @@ describe Ridley::Middleware::ParseJson do
     describe "::response_type" do
       it "returns the first element of the response content-type" do
         env = double('env')
-        env.stub(:[]).with(:response_headers).and_return(
+        allow(env).to receive(:[]).with(:response_headers).and_return(
           'content-type' => 'text/html; charset=utf-8'
         )
 
-        subject.response_type(env).should eql("text/html")
+        expect(subject.response_type(env)).to eql("text/html")
       end
     end
 
     describe "::json_response?" do
       it "returns true if the value of content-type includes 'application/json' and the body looks like JSON" do
         env = double('env')
-        env.stub(:[]).with(:response_headers).and_return(
+        allow(env).to receive(:[]).with(:response_headers).and_return(
           'content-type' => 'application/json; charset=utf8'
         )
-        subject.should_receive(:looks_like_json?).with(env).and_return(true)
+        expect(subject).to receive(:looks_like_json?).with(env).and_return(true)
 
-        subject.json_response?(env).should be_true
+        expect(subject.json_response?(env)).to be_truthy
       end
 
       it "returns false if the value of content-type includes 'application/json' but the body does not look like JSON" do
         env = double('env')
-        env.stub(:[]).with(:response_headers).and_return(
+        allow(env).to receive(:[]).with(:response_headers).and_return(
           'content-type' => 'application/json; charset=utf8'
         )
-        subject.should_receive(:looks_like_json?).with(env).and_return(false)
+        expect(subject).to receive(:looks_like_json?).with(env).and_return(false)
 
-        subject.json_response?(env).should be_false
+        expect(subject.json_response?(env)).to be_falsey
       end
 
       it "returns false if the value of content-type does not include 'application/json'" do
         env = double('env')
-        env.stub(:[]).with(:response_headers).and_return(
+        allow(env).to receive(:[]).with(:response_headers).and_return(
           'content-type' => 'text/plain'
         )
 
-        subject.json_response?(env).should be_false
+        expect(subject.json_response?(env)).to be_falsey
       end
     end
 
@@ -52,15 +52,15 @@ describe Ridley::Middleware::ParseJson do
       let(:env) { double('env') }
 
       it "returns true if the given string contains JSON brackets" do
-        env.stub(:[]).with(:body).and_return("{\"name\":\"jamie\"}")
+        allow(env).to receive(:[]).with(:body).and_return("{\"name\":\"jamie\"}")
 
-        subject.looks_like_json?(env).should be_true
+        expect(subject.looks_like_json?(env)).to be_truthy
       end
 
       it "returns false if the given string does not contain JSON brackets" do
-        env.stub(:[]).with(:body).and_return("name")
+        allow(env).to receive(:[]).with(:body).and_return("name")
 
-        subject.looks_like_json?(env).should be_false
+        expect(subject.looks_like_json?(env)).to be_falsey
       end
     end
   end

data/spec/unit/ridley/mixins/from_file_spec.rb

@@ -7,9 +7,9 @@ module Ridley
         let(:instance) { Class.new { include Ridley::Mixin::FromFile }.new }
 
         before do
-          File.stub(:exists?).and_return(true)
-          File.stub(:readable?).and_return(true)
-          IO.stub(:read).and_return('invalid Ruby code')
+          allow(File).to receive(:exists?).and_return(true)
+          allow(File).to receive(:readable?).and_return(true)
+          allow(IO).to receive(:read).and_return('invalid Ruby code')
         end
 
         it 'raises a FromFileParserError' do

data/spec/unit/ridley/resource_spec.rb

@@ -22,7 +22,7 @@ describe Ridley::Resource do
       it "sets the resource_path attr on the class" do
         subject.set_resource_path("environments")
 
-        subject.resource_path.should eql("environments")
+        expect(subject.resource_path).to eql("environments")
       end
     end
 
@@ -31,7 +31,7 @@ describe Ridley::Resource do
         before { subject.set_resource_path(nil) }
 
         it "returns the representation's chef type" do
-          subject.resource_path.should eql(representation.chef_type)
+          expect(subject.resource_path).to eql(representation.chef_type)
         end
       end
 
@@ -40,7 +40,7 @@ describe Ridley::Resource do
         before { subject.set_resource_path(set_path) }
 
         it "returns the set value" do
-          subject.resource_path.should eql(set_path)
+          expect(subject.resource_path).to eql(set_path)
         end
       end
     end
@@ -97,7 +97,7 @@ describe Ridley::Resource do
       end
 
       it "returns nil" do
-        subject.find(id).should be_nil
+        expect(subject.find(id)).to be_nil
       end
     end
   end
@@ -135,7 +135,7 @@ describe Ridley::Resource do
 
   describe "::delete_all" do
     it "sends a delete request for every object in the collection" do
-      pending
+      skip
     end
   end
 

data/spec/unit/ridley/resources/cookbook_resource_spec.rb

@@ -42,7 +42,7 @@ describe Ridley::CookbookResource do
       end
 
       it "returns the latest version" do
-        subject.latest_version(name).should eql("3.0.0")
+        expect(subject.latest_version(name)).to eql("3.0.0")
       end
     end
   end
@@ -58,16 +58,16 @@ describe Ridley::CookbookResource do
       end
 
       it "returns an array" do
-        subject.versions(name).should be_a(Array)
+        expect(subject.versions(name)).to be_a(Array)
       end
 
       it "contains a version string for each cookbook version available" do
         result = subject.versions(name)
 
-        result.should have(3).versions
-        result.should include("1.0.0")
-        result.should include("1.1.0")
-        result.should include("1.2.0")
+        expect(result.size).to eq(3)
+        expect(result).to include("1.0.0")
+        expect(result).to include("1.1.0")
+        expect(result).to include("1.2.0")
       end
     end
 
@@ -90,11 +90,11 @@ describe Ridley::CookbookResource do
       end
 
       it "returns a CookbookObject" do
-        subject.satisfy(name, ">= 2.0.0").should be_a(Ridley::CookbookObject)
+        expect(subject.satisfy(name, ">= 2.0.0")).to be_a(Ridley::CookbookObject)
       end
 
       it "is the best solution" do
-        subject.satisfy(name, ">= 2.0.0").version.should eql("3.0.0")
+        expect(subject.satisfy(name, ">= 2.0.0").version).to eql("3.0.0")
       end
     end
 
@@ -102,7 +102,7 @@ describe Ridley::CookbookResource do
       before { chef_cookbook(name, "1.0.0") }
 
       it "returns nil" do
-        subject.satisfy(name, ">= 2.0.0").should be_nil
+        expect(subject.satisfy(name, ">= 2.0.0")).to be_nil
       end
     end
 
@@ -126,20 +126,20 @@ describe Ridley::CookbookResource do
     end
 
     it 'does not include files that are ignored' do
-      # These are the SHAs for the files. It's not possible to check that
+      # These are the MD5s for the files. It's not possible to check that
       # the ignored files weren't uploaded, so we just check that the
       # non-ignored files are the ONLY thing uploaded
       sandbox_resource.should_receive(:create).with([
-        "211a3a8798d4acd424af15ff8a2e28a5", 
-        "4f9051c3ac8031bdaff10300fa92e817", 
-        "75077ba33d2887cc1746d1ef716bf8b7", 
-        "7b1ebd2ff580ca9dc46fb27ec1653bf2", 
-        "84e12365e6f4ebe7db6a0e6a92473b16", 
-        "a39eb80def9804f4b118099697cc2cd2", 
-        "b70ba735f3af47e5d6fc71b91775b34c", 
-        "cafb6869fca13f5c36f24a60de8fb982", 
-        "dbf3a6c4ab68a86172be748aced9f46e", 
-        "dc6461b5da25775f3ef6a9cc1f6cff9f", 
+        "211a3a8798d4acd424af15ff8a2e28a5",
+        "64ac6346672c6bea4ade983e3d58cd14",
+        "75077ba33d2887cc1746d1ef716bf8b7",
+        "7b1ebd2ff580ca9dc46fb27ec1653bf2",
+        "84e12365e6f4ebe7db6a0e6a92473b16",
+        "a39eb80def9804f4b118099697cc2cd2",
+        "b70ba735f3af47e5d6fc71b91775b34c",
+        "cafb6869fca13f5c36f24a60de8fb982",
+        "dbf3a6c4ab68a86172be748aced9f46e",
+        "dc6461b5da25775f3ef6a9cc1f6cff9f",
         "e9a2e24281cfbd6be0a6b1af3b6d277e"
       ]).and_return(sandbox)
 
@@ -148,6 +148,6 @@ describe Ridley::CookbookResource do
   end
 
   describe "#update" do
-    pending
+    skip
   end
 end

data/spec/unit/ridley/resources/data_bag_item_resource_spec.rb

@@ -3,5 +3,5 @@ require 'spec_helper'
 describe Ridley::DataBagItemResource do
   subject { described_class.new(double) }
 
-  pending
+  skip
 end