ridley 4.2.0 → 4.3.0

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
 
@@ -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

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

@@ -8,13 +8,16 @@ describe Ridley::DataBagResource do
     subject { instance.item_resource }
 
     it "returns a DataBagItemResource" do
-      subject.should be_a(Ridley::DataBagItemResource)
+      expect(subject).to be_a(Ridley::DataBagItemResource)
     end
 
-    its(:encrypted_data_bag_secret) { should eql(secret) }
+    describe '#encrypted_data_bag_secret' do
+      subject { super().encrypted_data_bag_secret }
+      it { is_expected.to eql(secret) }
+    end
   end
 
   describe "#find" do
-    pending
+    skip
   end
 end

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

@@ -28,13 +28,13 @@ describe Ridley::EnvironmentResource do
       end
 
       it "returns a Hash" do
-        should be_a(Hash)
+        is_expected.to be_a(Hash)
       end
 
       it "contains a key for each cookbook" do
-        subject.keys.should have(2).items
-        subject.should have_key("hello")
-        subject.should have_key("there")
+        expect(subject.keys.size).to eq(2)
+        expect(subject).to have_key("hello")
+        expect(subject).to have_key("there")
       end
     end
 

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

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

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

@@ -22,24 +22,24 @@ describe Ridley::SandboxResource do
     end
 
     it "returns a Ridley::SandboxObject" do
-      subject.create.should be_a(Ridley::SandboxObject)
+      expect(subject.create).to be_a(Ridley::SandboxObject)
     end
 
     it "has a value of 'false' for :is_completed" do
-      subject.create.is_completed.should be_false
+      expect(subject.create.is_completed).to be_falsey
     end
 
     it "has an empty Hash of checksums" do
-      subject.create.checksums.should be_a(Hash)
-      subject.create.checksums.should be_empty
+      expect(subject.create.checksums).to be_a(Hash)
+      expect(subject.create.checksums).to be_empty
     end
 
     it "has a value for :uri" do
-      subject.create.uri.should eql(sandbox_uri)
+      expect(subject.create.uri).to eql(sandbox_uri)
     end
 
     it "has a value for :sandbox_id" do
-      subject.create.sandbox_id.should eql(sandbox_id)
+      expect(subject.create.sandbox_id).to eql(sandbox_id)
     end
 
     context "when given an array of checksums" do
@@ -54,7 +54,7 @@ describe Ridley::SandboxResource do
       let(:checksum_array) { checksums.keys }
 
       it "has a Hash of checksums with each of the given checksum ids" do
-        subject.create(checksum_array).checksums.should have(checksum_array.length).checksums
+        expect(subject.create(checksum_array).checksums.size).to eq(checksum_array.length)
       end
     end
   end

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

@@ -11,8 +11,8 @@ describe Ridley::SearchResource do
       it "contains a 'q' key/value" do
         result = subject.build_query(query_string, options)
 
-        result.should have_key(:q)
-        result[:q].should eql(query_string)
+        expect(result).to have_key(:q)
+        expect(result[:q]).to eql(query_string)
       end
 
       context "when :sort option is set" do
@@ -21,8 +21,8 @@ describe Ridley::SearchResource do
         it "contains a 'sort' key/value" do
           result = subject.build_query(query_string, options)
 
-          result.should have_key(:sort)
-          result[:sort].should eql("DESC")
+          expect(result).to have_key(:sort)
+          expect(result[:sort]).to eql("DESC")
         end
       end
 
@@ -32,8 +32,8 @@ describe Ridley::SearchResource do
         it "contains a 'start' key/value" do
           result = subject.build_query(query_string, options)
 
-          result.should have_key(:start)
-          result[:start].should eql(1)
+          expect(result).to have_key(:start)
+          expect(result[:start]).to eql(1)
         end
       end
 
@@ -43,8 +43,8 @@ describe Ridley::SearchResource do
         it "contains a 'rows' key/value" do
           result = subject.build_query(query_string, options)
 
-          result.should have_key(:rows)
-          result[:rows].should eql(1)
+          expect(result).to have_key(:rows)
+          expect(result[:rows]).to eql(1)
         end
       end
     end
@@ -89,7 +89,7 @@ describe Ridley::SearchResource do
 
     describe "::query_uri" do
       it "returns a URI path containing the search resource path and index" do
-        subject.query_uri(:nodes).should eql("search/nodes")
+        expect(subject.query_uri(:nodes)).to eql("search/nodes")
       end
     end
   end
@@ -118,7 +118,7 @@ describe Ridley::SearchResource do
     end
 
     it "contains a key for each index" do
-      subject.indexes.should have(4).items
+      expect(subject.indexes.size).to eq(4)
     end
   end
 
@@ -179,8 +179,8 @@ describe Ridley::SearchResource do
       it "returns an array of Ridley::NodeObject" do
         result = run
 
-        result.should be_a(Array)
-        result.should each be_a(Ridley::NodeObject)
+        expect(result).to be_a(Array)
+        expect(result).to each be_a(Ridley::NodeObject)
       end
 
       context "after the search has executed and results are returned" do
@@ -188,7 +188,7 @@ describe Ridley::SearchResource do
 
         it "Ridley::NodeObject instances contain the results" do
           first_result = search_results.first
-          first_result.name.should eq("ridley-one")
+          expect(first_result.name).to eq("ridley-one")
         end
       end
     end
@@ -217,8 +217,8 @@ describe Ridley::SearchResource do
       it "returns an array of Ridley::RoleObject" do
         result = run
 
-        result.should be_a(Array)
-        result.should each be_a(Ridley::RoleObject)
+        expect(result).to be_a(Array)
+        expect(result).to each be_a(Ridley::RoleObject)
       end
 
       context "after the search has executed and results are returned" do
@@ -226,7 +226,7 @@ describe Ridley::SearchResource do
 
         it "Ridley::RoleObject instances contain the results" do
           first_result = search_results.first
-          first_result.name.should eq("ridley-role-one")
+          expect(first_result.name).to eq("ridley-role-one")
         end
       end
     end
@@ -254,8 +254,8 @@ describe Ridley::SearchResource do
       it "returns an array of Ridley::EnvironmentObject" do
         result = run
 
-        result.should be_a(Array)
-        result.should each be_a(Ridley::EnvironmentObject)
+        expect(result).to be_a(Array)
+        expect(result).to each be_a(Ridley::EnvironmentObject)
       end
 
       context "after the search has executed and results are returned" do
@@ -263,7 +263,7 @@ describe Ridley::SearchResource do
 
         it "Ridley::EnvironmentObject instances contain the results" do
           first_result = search_results.first
-          first_result.name.should eq("ridley-env-test")
+          expect(first_result.name).to eq("ridley-env-test")
         end
       end
     end
@@ -292,8 +292,8 @@ describe Ridley::SearchResource do
       it "returns an array of Ridley::ClientObject" do
         result = run
 
-        result.should be_a(Array)
-        result.should each be_a(Ridley::ClientObject)
+        expect(result).to be_a(Array)
+        expect(result).to each be_a(Ridley::ClientObject)
       end
 
       context "after the search has executed and results are returned" do
@@ -301,7 +301,7 @@ describe Ridley::SearchResource do
 
         it "Ridley::ClientObject instances contain the results" do
           first_result = search_results.first
-          first_result.name.should eq("ridley-client-test")
+          expect(first_result.name).to eq("ridley-client-test")
         end
       end
     end

data/spec/unit/ridley/sandbox_uploader_spec.rb

@@ -8,14 +8,14 @@ describe Ridley::SandboxUploader do
       let(:io) { StringIO.new("some long string") }
       subject { described_class.checksum(io) }
 
-      it { should eq("2fb66bbfb88cdf9e07a3f1d1dfad71ab") }
+      it { is_expected.to eq("2fb66bbfb88cdf9e07a3f1d1dfad71ab") }
     end
 
     describe "::checksum64" do
       let(:io) { StringIO.new("some long string") }
       subject { described_class.checksum64(io) }
 
-      it { should eq("L7Zrv7iM354Ho/HR361xqw==") }
+      it { is_expected.to eq("L7Zrv7iM354Ho/HR361xqw==") }
     end
   end
 
@@ -80,7 +80,7 @@ describe Ridley::SandboxUploader do
       end
 
       it "returns nil" do
-        subject.upload(sandbox, chk_id, path).should be_nil
+        expect(subject.upload(sandbox, chk_id, path)).to be_nil
       end
     end
 

data/spec/unit/ridley_spec.rb

@@ -9,9 +9,9 @@ describe Ridley do
     describe "::new" do
       it "creates a new Ridley::Connection" do
         client = double('client')
-        Ridley::Client.should_receive(:new).with(config).and_return(client)
+        expect(Ridley::Client).to receive(:new).with(config).and_return(client)
 
-        subject.new(config).should eql(client)
+        expect(subject.new(config)).to eql(client)
       end
     end
 
@@ -32,12 +32,12 @@ describe Ridley do
       let(:path) { tmp_path.join('config.rb').to_s }
 
       before do
-        Ridley::Client.stub(:new).and_return(client)
+        allow(Ridley::Client).to receive(:new).and_return(client)
         File.open(path, 'w') { |f| f.write(chef_config) }
       end
 
       it "creates a Ridley connection from the Chef config" do
-        Ridley::Client.should_receive(:new).with({
+        expect(Ridley::Client).to receive(:new).with({
           client_key: 'username.pem',
           client_name: 'username',
           validator_client: 'validator',
@@ -58,7 +58,7 @@ describe Ridley do
       end
 
       it "allows the user to override attributes" do
-        Ridley::Client.should_receive(:new).with({
+        expect(Ridley::Client).to receive(:new).with({
           client_key: 'bacon.pem',
           client_name: 'bacon',
           validator_client: 'validator',
@@ -88,7 +88,7 @@ describe Ridley do
         end
 
         it "does a knife.rb search" do
-          Ridley::Client.should_receive(:new).with({
+          expect(Ridley::Client).to receive(:new).with({
             client_key: 'username.pem',
             client_name: 'username',
             validator_client: 'validator',