stacker_bee 2.1.1.pre263 → 2.1.1.pre265

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGZiMGQ0YTBhNmNhMjAzM2FhOWE1NWRjMmM0MWYxNjBlNjYzMmQwZg==
+    NWM0OWQ4YTM0YTM4ZTgyMDBhZWQwNmMxZWQ2YzZiMGI1NGM3MTM0MA==
   data.tar.gz: !binary |-
-    NmMwOWM4YjdkYTk1NDJhODgzNTM4Yjg3MmIzNzcxMDg4MTA3ZWE1MQ==
+    NzZlNDg5ZTNkYjc1ZWIyMDBlMzAzMjJlNjIyMGVhZjIxMDU2YTgyNw==
 SHA512:
   metadata.gz: !binary |-
-    N2M0M2IxZTAwMTA0NzMzMDNhMTQxNjg5OWViNWM4YzVlM2E4MWYzODNmYThi
-    YmYzMzljMGI0Y2FjYzQ4MDVlNTJlNDJjYWNiMzhlODRkY2ZhYzM5MzVhMjFk
-    ODNmNmE2YTIwZTRhN2VkZWQ0NGQ5MTAxYTYyNTIwMTY3YWZlMWI=
+    YmU2YjhlY2M5ZmYzZGYwNTUxNTk1ZmZkMGRjYjViMTVmYWVhOGVlZTMwMjE0
+    OWI0NDIzYzY3MjA5YzEyNmFlMzc2ZWNkZGZlNzY2MmFkODJmODg1ZDU4MzE2
+    OThhNzU3NTQxZWJmNjM2MWQ0NWI3MmVjZGJkYzdmNTU0ODZjNmE=
   data.tar.gz: !binary |-
-    NGZkOWNiMjUzODU1YTI3MjFlOTdjYzVjNjgzN2NiMDMzYTk4ZGZkMWYyY2Qy
-    YzE3ZjU5YmM0ZTFjZDYyOTg3Y2Y1YTM4Mzk4NmFiZWIxNWI2ZWIxYTUwNzQ3
-    YTAyMmVlODU5ODNjNTQ0MjZjNTIxMWM2OTU4YjVkYjRhZWQ3ODU=
+    M2Q4Y2MxOWE4NjczMzI3NGEyYjg0MTI2M2U4MzFiYjM1ZmM2MTg2ZTc3ZmU1
+    NGQzYzExZTRhNjk3MzA3MTI2NWQ0MGRmMDFiOTNjNjBkMjE0M2Q4NDQ0Y2Ji
+    NDc4MjJmOWJjMTM5ZWFkMTczYTQ5ZDkzMWEyOGJhOTUzNWRmNDM=

data/spec/integration/request_spec.rb

@@ -19,11 +19,11 @@ describe 'A response to a request sent to the CloudStack API', :vcr do
     StackerBee::Client.new(config_hash)
   end
 
-  it { should_not be_empty }
+  it { is_expected.not_to be_empty }
 
   context 'first item' do
     subject { client.list_accounts.first }
-    it { should include 'id' }
+    it { is_expected.to include 'id' }
     its(['accounttype'])  { should be_a Numeric }
     its(['account_type']) { should be_a Numeric }
   end
@@ -41,7 +41,7 @@ describe 'A response to a request sent to the CloudStack API', :vcr do
     it 'makes request with trailing slash' do
       stub = stub_request(:get, /#{url}/).to_return(body: '{"foo": {}}')
       subject
-      stub.should have_been_requested
+      expect(stub).to have_been_requested
     end
   end
 
@@ -84,9 +84,9 @@ describe 'A response to a request sent to the CloudStack API', :vcr do
   context 'a request parameter with an Array', :regression do
     subject { client.list_hosts(params).first.keys }
     let(:params) { { page: 1, pagesize: 1, details: [:events, :stats] } }
-    it { should include 'cpuused' }
-    it { should include 'events' }
-    it { should_not include 'cpuallocated' }
+    it { is_expected.to include 'cpuused' }
+    it { is_expected.to include 'events' }
+    it { is_expected.not_to include 'cpuallocated' }
   end
 
   context 'a request parameter with a map' do
@@ -113,7 +113,7 @@ describe 'A response to a request sent to the CloudStack API', :vcr do
     end
 
     it 'can create an object' do
-      tag.should_not be_nil
+      expect(tag).not_to be_nil
     end
   end
 

data/spec/spec_helper.rb

@@ -23,7 +23,7 @@ support_files = Dir[File.join(
 support_files.each { |f| require f }
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.raise_errors_for_deprecations!
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
@@ -37,3 +37,5 @@ RSpec.configure do |config|
     StackerBee::Client.reset!
   end
 end
+
+require 'rspec/its'

data/spec/units/stacker_bee/api_spec.rb

@@ -17,8 +17,8 @@ describe StackerBee::API do
   its(['getVmPassword'])         { should be_a Hash }
   its(['getWRONG'])              { should be_nil }
 
-  it { should be_key 'get_vm_password' }
-  it { should be_key 'getvmpassword' }
-  it { should be_key 'getVMPassword' }
-  it { should be_key 'getVmPassword' }
+  it { is_expected.to be_key 'get_vm_password' }
+  it { is_expected.to be_key 'getvmpassword' }
+  it { is_expected.to be_key 'getVMPassword' }
+  it { is_expected.to be_key 'getVmPassword' }
 end

data/spec/units/stacker_bee/client_spec.rb

@@ -5,7 +5,7 @@ describe StackerBee::Client, '.api' do
   subject { described_class }
   let(:api) { double }
   before do
-    StackerBee::API.stub new: api
+    allow(StackerBee::API).to receive_messages new: api
     described_class.api_path = nil
   end
   its(:api_path) { should_not be_nil }
@@ -46,17 +46,17 @@ describe StackerBee::Client, 'calling endpoint' do
 
   describe 'responding to methods' do
     subject { client }
-    it { should respond_to endpoint_name }
+    it { is_expected.to respond_to endpoint_name }
   end
 
   describe 'via a method call' do
     subject { client.list_virtual_machines(params) }
-    it { should eq response_body }
+    it { is_expected.to eq response_body }
   end
 
   describe 'via #request' do
     subject { client.request(endpoint_name, params) }
-    it { should eq response_body }
+    it { is_expected.to eq response_body }
   end
 end
 

data/spec/units/stacker_bee/configuration_spec.rb

@@ -15,17 +15,17 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should eq true }
+      it { is_expected.to eq true }
     end
 
     context 'when set to false' do
       let(:configuration) { described_class.new(ssl_verify: false) }
-      it { should eq false }
+      it { is_expected.to eq false }
     end
 
     context 'when set to true' do
       let(:configuration) { described_class.new(ssl_verify: true) }
-      it { should eq true }
+      it { is_expected.to eq true }
     end
   end
 
@@ -34,13 +34,13 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should eq nil }
+      it { is_expected.to eq nil }
     end
 
     context 'when set' do
       let(:configuration) { described_class.new(url: setting) }
       let(:setting) { 'http://example.com' }
-      it { should eq setting }
+      it { is_expected.to eq setting }
     end
   end
 
@@ -49,13 +49,13 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should eq nil }
+      it { is_expected.to eq nil }
     end
 
     context 'when set' do
       let(:configuration) { described_class.new(secret_key: setting) }
       let(:setting) { 'qwertyuiop' }
-      it { should eq setting }
+      it { is_expected.to eq setting }
     end
   end
 
@@ -64,13 +64,13 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should eq nil }
+      it { is_expected.to eq nil }
     end
 
     context 'when set' do
       let(:configuration) { described_class.new(api_key: setting) }
       let(:setting) { 'qwertyuiop' }
-      it { should eq setting }
+      it { is_expected.to eq setting }
     end
   end
 
@@ -79,13 +79,13 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should be_a Proc }
+      it { is_expected.to be_a Proc }
     end
 
     context 'when set' do
       let(:configuration) { described_class.new(middlewares: setting) }
       let(:setting) { proc { something } }
-      it { should eq setting }
+      it { is_expected.to eq setting }
     end
   end
 
@@ -94,13 +94,13 @@ describe StackerBee::Configuration do
 
     context 'when not set' do
       let(:configuration) { described_class.new }
-      it { should be_a Proc }
+      it { is_expected.to be_a Proc }
     end
 
     context 'when set' do
       let(:configuration) { described_class.new(faraday_middlewares: setting) }
       let(:setting) { proc { something } }
-      it { should eq setting }
+      it { is_expected.to eq setting }
     end
   end
 
@@ -132,24 +132,24 @@ describe StackerBee::Configuration do
     context "when the child doesn't have an attribute set" do
       let(:child) { described_class.new }
       it 'uses the attribute of the parent' do
-        subject.url.should eq :parent_url
-        subject.api_key.should eq :parent_api_key
-        subject.secret_key.should eq :parent_secret_key
-        subject.ssl_verify?.should eq :parent_ssl_verify
-        subject.middlewares.should eq :parent_ssl_middlewares
-        subject.faraday_middlewares.should eq :parent_faraday_middlewares
+        expect(subject.url).to eq :parent_url
+        expect(subject.api_key).to eq :parent_api_key
+        expect(subject.secret_key).to eq :parent_secret_key
+        expect(subject.ssl_verify?).to eq :parent_ssl_verify
+        expect(subject.middlewares).to eq :parent_ssl_middlewares
+        expect(subject.faraday_middlewares).to eq :parent_faraday_middlewares
       end
     end
 
     context "when the parent doesn't have an attribute set" do
       let(:parent) { described_class.new }
       it 'uses the attribute of the child' do
-        subject.url.should eq :child_url
-        subject.api_key.should eq :child_api_key
-        subject.secret_key.should eq :child_secret_key
-        subject.ssl_verify?.should eq :child_ssl_verify
-        subject.middlewares.should eq :child_ssl_middlewares
-        subject.faraday_middlewares.should eq :child_faraday_middlewares
+        expect(subject.url).to eq :child_url
+        expect(subject.api_key).to eq :child_api_key
+        expect(subject.secret_key).to eq :child_secret_key
+        expect(subject.ssl_verify?).to eq :child_ssl_verify
+        expect(subject.middlewares).to eq :child_ssl_middlewares
+        expect(subject.faraday_middlewares).to eq :child_faraday_middlewares
       end
     end
 
@@ -157,12 +157,12 @@ describe StackerBee::Configuration do
       let(:child) { described_class.new }
       let(:parent) { described_class.new }
       it 'uses the defaults of the attributes of the child' do
-        subject.url.should eq nil
-        subject.api_key.should eq nil
-        subject.secret_key.should eq nil
-        subject.ssl_verify?.should eq true
-        subject.middlewares.should be_a Proc
-        subject.faraday_middlewares.should be_a Proc
+        expect(subject.url).to eq nil
+        expect(subject.api_key).to eq nil
+        expect(subject.secret_key).to eq nil
+        expect(subject.ssl_verify?).to eq true
+        expect(subject.middlewares).to be_a Proc
+        expect(subject.faraday_middlewares).to be_a Proc
       end
     end
   end

data/spec/units/stacker_bee/connection_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe StackerBee::Connection do
   subject(:get) { connection.get(path, query_params) }
-  before { Faraday.stub new: faraday }
+  before { allow(Faraday).to receive_messages new: faraday }
 
   let(:url)          { 'http://test.com:1234/foo/bar/' }
   let(:path)         { '/foo/bar' }
@@ -22,20 +22,27 @@ describe StackerBee::Connection do
 
   context 'successfully connecting' do
     before do
-      faraday.should_receive(:get).with('/foo/bar', query_params) { response }
+      expect(faraday).to receive(:get).with('/foo/bar', query_params) do
+        response
+      end
     end
-    it { should be response }
+
+    it { is_expected.to be response }
+
     it 'specifies url without path when creating connection' do
       get
-      Faraday.should have_received(:new).with(url: 'http://test.com:1234',
-                                              ssl: { verify: true })
+      expect(Faraday).to have_received(:new).with(url: 'http://test.com:1234',
+                                                  ssl: { verify: true })
     end
   end
 
   context 'failing to connect' do
     before do
-      faraday.stub(:get) { fail Faraday::Error::ConnectionFailed, 'boom' }
+      allow(faraday).to receive(:get) do
+        fail Faraday::Error::ConnectionFailed, 'boom'
+      end
     end
+
     it 'raises a helpful exception' do
       expect { get }.to raise_error StackerBee::ConnectionError, /#{url}/
     end
@@ -60,8 +67,8 @@ describe StackerBee::Connection do
     let(:ssl_verify) { false }
     it 'specifies the ssl verify option when creating a connection' do
       get
-      Faraday.should have_received(:new).with(url: 'http://test.com:1234',
-                                              ssl: { verify: false })
+      expect(Faraday).to have_received(:new).with(url: 'http://test.com:1234',
+                                                  ssl: { verify: false })
     end
   end
 end

data/spec/units/stacker_bee/middleware/adapter_spec.rb

@@ -27,28 +27,28 @@ describe StackerBee::Middleware::Adapter do
     before { middleware.call(env) }
 
     it 'makes a call via the connection' do
-      connection.should have_received(:get)
+      expect(connection).to have_received(:get)
     end
 
     it "sets the environment's raw_response" do
-      env.raw_response.should == raw_response
+      expect(env.raw_response).to eq raw_response
     end
 
     it "sets the response's mime type" do
-      env.response.content_type.should == content_type
+      expect(env.response.content_type).to eq content_type
     end
 
     it "sets the response's body to the raw response's body" do
-      env.response.body.should == response_body
+      expect(env.response.body).to eq response_body
     end
 
     it 'sorts the paramers' do
-      connection.should have_received(:get).with(path, [%w(a a), %w(z z)])
+      expect(connection).to have_received(:get).with(path, [%w(a a), %w(z z)])
     end
   end
 
   describe '#endpoint_name_for' do
     subject { middleware.endpoint_name_for('listVirtualMachines') }
-    it { should be_nil }
+    it { is_expected.to be_nil }
   end
 end

data/spec/units/stacker_bee/middleware/base_spec.rb

@@ -5,7 +5,7 @@ describe StackerBee::Middleware::Base do
   let(:params) { {} }
   let(:app) { double(:app, call: response) }
   let(:response) { double(:response) }
-  let(:content_type) { double }
+  let(:content_type) { 'content-type' }
   before { env.response.content_type = content_type }
 
   let(:middleware) { subclass.new(app: app) }
@@ -20,7 +20,7 @@ describe StackerBee::Middleware::Base do
 
     def self.it_calls_its_app_with_the_env
       it 'calls its app with the env' do
-        app.should have_received(:call).with(env)
+        expect(app).to have_received(:call).with(env)
       end
     end
 
@@ -38,7 +38,7 @@ describe StackerBee::Middleware::Base do
       it_calls_its_app_with_the_env
 
       it 'runs the before hook' do
-        env.before_was_run.should be_true
+        expect(env.before_was_run).to be true
       end
     end
 
@@ -54,7 +54,7 @@ describe StackerBee::Middleware::Base do
       it_calls_its_app_with_the_env
 
       it 'runs the after hook' do
-        env.after_was_run.should be_true
+        expect(env.after_was_run).to be true
       end
     end
 
@@ -76,14 +76,14 @@ describe StackerBee::Middleware::Base do
       context 'when it matches the content type' do
         let(:content_type) { 'text/html; uft-8' }
         it 'runs the after hook' do
-          env.after_was_run.should be_true
+          expect(env.after_was_run).to be true
         end
       end
 
       context "when it doesn't match the content type" do
         let(:content_type) { 'text/javascript; uft-8' }
         it 'runs the after hook' do
-          env.after_was_run.should be_nil
+          expect(env.after_was_run).to be_nil
         end
       end
     end
@@ -98,22 +98,22 @@ describe StackerBee::Middleware::Base do
       end
 
       it 'changes the params' do
-        env.request.params[:params_merged?].should be_true
+        expect(env.request.params[:params_merged?]).to be true
       end
     end
   end
 
   describe '#endpoint_name_for' do
-    let(:endpoint_name) { double }
-    let(:normalized_endpoint_name) { double }
+    let(:endpoint_name) { 'endpoint-name' }
+    let(:normalized_endpoint_name) { 'normalized-endpoint-name' }
 
     it 'delegates to its app' do
-      app.should_receive(:endpoint_name_for)
+      expect(app).to receive(:endpoint_name_for)
         .with(endpoint_name)
         .and_return(normalized_endpoint_name)
 
-      middleware.endpoint_name_for(endpoint_name)
-        .should == normalized_endpoint_name
+      expect(middleware.endpoint_name_for(endpoint_name))
+        .to eq normalized_endpoint_name
     end
   end
 
@@ -121,7 +121,7 @@ describe StackerBee::Middleware::Base do
     describe 'by default' do
       before { env.response.content_type = '$8^02(324' }
       it 'matches anything' do
-        middleware.matches_content_type?(env).should be_true
+        expect(middleware.matches_content_type?(env)).to be true
       end
     end
   end

data/spec/units/stacker_bee/middleware/console_access_spec.rb

@@ -13,11 +13,11 @@ describe StackerBee::Middleware::ConsoleAccess do
 
     it 'adds its path to the env' do
       middleware.before(env)
-      env.request.path.should == described_class::PATH
+      expect(env.request.path).to eq described_class::PATH
     end
 
     it 'adds cmd to the parameters' do
-      env.request.params.should_not include described_class::PARAMS
+      expect(env.request.params).not_to include described_class::PARAMS
     end
   end
 
@@ -27,31 +27,31 @@ describe StackerBee::Middleware::ConsoleAccess do
     before { middleware.before(env) }
 
     it "doesn't add it's path" do
-      env.request.path.should_not == described_class::PATH
+      expect(env.request.path).not_to eq described_class::PATH
     end
 
     it "doesn't add cmd to the parameters" do
-      env.request.params.should_not include described_class::PARAMS
+      expect(env.request.params).not_to include described_class::PARAMS
     end
   end
 
   it 'matches html content typtes' do
-    middleware.content_types.should =~ 'text/html; charset=utf-8'
+    expect(middleware.content_types).to match 'text/html; charset=utf-8'
   end
 
   describe '#endpoint_name_for' do
     context 'given names it reponds to' do
       %w(consoleAccess console_access CONSOLEACCESS).each do |name|
         subject { middleware.endpoint_name_for(name) }
-        it { should eq described_class::ENDPOINT }
+        it { is_expected.to eq described_class::ENDPOINT }
       end
     end
 
     context 'for other names' do
-      before { app.stub :endpoint_name_for, &:upcase }
+      before { allow(app).to receive :endpoint_name_for, &:upcase }
 
       it 'delegates for other names' do
-        middleware.endpoint_name_for('other-name').should == 'OTHER-NAME'
+        expect(middleware.endpoint_name_for('other-name')).to eq 'OTHER-NAME'
       end
     end
   end

data/spec/units/stacker_bee/middleware/dictionary_flattener_spec.rb

@@ -8,12 +8,12 @@ describe StackerBee::Middleware::DictionaryFlattener do
 
   describe '.detokenize' do
     subject { described_class.detokenize(tokenized_string) }
-    it { should eq string  }
+    it { is_expected.to eq string  }
   end
 
   describe '.tokenize' do
     subject { described_class.tokenize(string) }
-    it { should eq tokenized_string  }
+    it { is_expected.to eq tokenized_string  }
   end
 
   describe '.new' do
@@ -34,28 +34,28 @@ describe StackerBee::Middleware::DictionaryFlattener do
     end
 
     it 'flattens objects in the manner that cloudstack expects' do
-      subject["#{param(0)}.name"].should eq 'r2'
-      subject["#{param(0)}.key"].should eq 'r2'
-      subject["#{param(0)}.value"].should eq 'd2'
+      expect(subject["#{param(0)}.name"]).to eq 'r2'
+      expect(subject["#{param(0)}.key"]).to eq 'r2'
+      expect(subject["#{param(0)}.value"]).to eq 'd2'
     end
 
     it 'does not flatten empty hashes' do
-      subject.should_not have_key "#{param(2)}.name"
+      expect(subject).not_to have_key "#{param(2)}.name"
     end
 
     it 'handles true booleans' do
-      subject["#{param(1)}.name"].should eq 'droid'
-      subject["#{param(1)}.value"].should be_true
+      expect(subject["#{param(1)}.name"]).to eq 'droid'
+      expect(subject["#{param(1)}.value"]).to be true
     end
 
     it 'removes original map params' do
-      subject.should_not have_key 'rebels'
+      expect(subject).not_to have_key 'rebels'
     end
 
     it 'doesnt send false to CloudStack' do
       # This assumption is based on CloudStack UI behavior
-      subject.values.should_not include false
-      subject.values.should_not include 'false'
+      expect(subject.values).not_to include false
+      expect(subject.values).not_to include 'false'
     end
   end
 end

data/spec/units/stacker_bee/middleware/endpoint_normalizer_spec.rb

@@ -13,19 +13,19 @@ describe StackerBee::Middleware::EndpointNormalizer do
     let(:endpoint_name) { :some_endpoint }
 
     describe '#endpoint_name_for' do
-      before { app.stub :endpoint_name_for, &:upcase }
+      before { allow(app).to receive :endpoint_name_for, &:upcase }
 
       it 'delegates to its app' do
-        middleware.endpoint_name_for('some-name').should == 'SOME-NAME'
+        expect(middleware.endpoint_name_for('some-name')).to eq 'SOME-NAME'
       end
     end
 
     describe '#before' do
-      before { app.stub endpoint_name_for: nil }
+      before { allow(app).to receive_messages endpoint_name_for: nil }
 
       it "doesn't set the endpoint to nil", :regression do
         middleware.before env
-        env.request.endpoint_name.should == endpoint_name
+        expect(env.request.endpoint_name).to eq endpoint_name
       end
     end
   end

data/spec/units/stacker_bee/middleware/error_message_spec.rb

@@ -16,10 +16,10 @@ describe StackerBee::Middleware::ErrorMessage do
   let(:is_success?) { true }
 
   it "doesn't apply to HTML responses" do
-    middleware.content_types.should_not match('text/html; charset=utf-8')
+    expect(middleware.content_types).not_to match 'text/html; charset=utf-8'
   end
   it 'applies to JSON responses' do
-    middleware.content_types.should match('text/javascript; charset=utf-8')
+    expect(middleware.content_types).to match 'text/javascript; charset=utf-8'
   end
 
   context 'given an error' do

data/spec/units/stacker_bee/middleware/format_keys_spec.rb

@@ -10,9 +10,9 @@ describe StackerBee::Middleware::FormatKeys do
     }
   end
 
-  it { should have_key 'symbol' }
-  it { should_not have_key :symbol  }
+  it { is_expected.to have_key 'symbol' }
+  it { is_expected.not_to have_key :symbol  }
 
-  it { should have_key 'keyCase' }
-  it { should_not have_key :key_case }
+  it { is_expected.to have_key 'keyCase' }
+  it { is_expected.not_to have_key :key_case }
 end

data/spec/units/stacker_bee/middleware/http_status_spec.rb

@@ -18,7 +18,7 @@ describe StackerBee::Middleware::HTTPStatus do
     let(:success?) { false }
 
     its(:status) { should eq http_status }
-    it { should_not be_success }
+    it { is_expected.not_to be_success }
   end
 
   context 'given a success' do
@@ -26,6 +26,6 @@ describe StackerBee::Middleware::HTTPStatus do
     let(:success?) { true }
 
     its(:status) { should eq http_status }
-    it { should be_success }
+    it { is_expected.to be_success }
   end
 end

data/spec/units/stacker_bee/middleware/log_response_spec.rb

@@ -13,10 +13,10 @@ describe StackerBee::Middleware::LogResponse do
 
     shared_examples_for 'all logs' do
       it 'logs the details' do
-        logger.logs.length.should eq 1
-        logger.logs.last[:request_path].should eq env.request.path
-        logger.logs.last[:params].should eq env.request.params.to_a
-        logger.logs.last[:response_body].should eq env.raw_response[:body]
+        expect(logger.logs.length).to eq 1
+        expect(logger.logs.last[:request_path]).to eq env.request.path
+        expect(logger.logs.last[:params]).to eq env.request.params.to_a
+        expect(logger.logs.last[:response_body]).to eq env.raw_response[:body]
       end
     end
 
@@ -29,7 +29,7 @@ describe StackerBee::Middleware::LogResponse do
 
       it_should_behave_like 'all logs'
       it 'should have logged the details' do
-        logger.logs.last[:short_message].should eq \
+        expect(logger.logs.last[:short_message]).to eq \
           'some command failed: invalid request'
       end
     end
@@ -42,8 +42,8 @@ describe StackerBee::Middleware::LogResponse do
 
       it_should_behave_like 'all logs'
       it 'should have logged the details' do
-        logger.logs.length.should eq 1
-        logger.logs.last[:short_message].should eq 'some command'
+        expect(logger.logs.length).to eq 1
+        expect(logger.logs.last[:short_message]).to eq 'some command'
       end
 
     end

data/spec/units/stacker_bee/middleware/raise_on_http_errors_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe StackerBee::Middleware::RaiseOnHTTPError do
-  pending
+  skip
 end

data/spec/units/stacker_bee/middleware/remove_empty_strings_spec.rb

@@ -41,14 +41,16 @@ describe StackerBee::Middleware::RemoveEmptyStrings do
   end
 
   it 'removes empty strings from the input' do
-    params.keys.should =~ [:ok1, :ok2, :ok3, :ok4, :nested]
+    expect(params.keys).to match_array [:ok1, :ok2, :ok3, :ok4, :nested]
   end
 
   it 'removes empty strings nested in hashes' do
-    params[:nested].keys.should =~ [:ok1, :ok2, :ok3, :ok4, :nested]
+    expect(params[:nested].keys).to match_array \
+      [:ok1, :ok2, :ok3, :ok4, :nested]
   end
 
   it 'removes empty strings deeply nested in hashes' do
-    params[:nested][:nested].keys.should =~ [:ok1, :ok2, :ok3, :ok4]
+    expect(params[:nested][:nested].keys).to match_array \
+      [:ok1, :ok2, :ok3, :ok4]
   end
 end

data/spec/units/stacker_bee/middleware/remove_nils_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe StackerBee::Middleware::RemoveNils do
   it 'removes pairs with nil values from the params' do
-    subject.transform_params(something: 'something', nothing: nil)
-      .should eq something: 'something'
+    expect(subject.transform_params(something: 'something', nothing: nil))
+      .to eq something: 'something'
   end
 end

data/spec/units/stacker_bee/rash_spec.rb

@@ -32,14 +32,14 @@ describe StackerBee::Rash do
   let(:dissimilar_hash) { hash.dup.tap { |loud| loud.delete 'foo' } }
   let(:rash) { described_class.new(hash) }
 
-  it { should include 'FOO' }
+  it { is_expected.to include 'FOO' }
 
-  it { should == subject }
-  it { should == subject.dup }
-  it { should == hash }
-  it { should == described_class.new(hash) }
-  it { should == similar_hash }
-  it { should_not == dissimilar_hash }
+  it { is_expected.to eq subject }
+  it { is_expected.to eq subject.dup }
+  it { is_expected.to eq hash }
+  it { is_expected.to eq described_class.new(hash) }
+  it { is_expected.to eq similar_hash }
+  it { is_expected.not_to eq dissimilar_hash }
 
   it_behaves_like 'a Rash',
                   'FOO'  => 'foo',
@@ -68,20 +68,20 @@ describe StackerBee::Rash do
 
   describe '#select' do
     subject { rash.select { |_, value| value.is_a? String } }
-    it { should be_a described_class }
-    it { should include 'FOO' }
-    it { should_not include 'WIZ' }
+    it { is_expected.to be_a described_class }
+    it { is_expected.to include 'FOO' }
+    it { is_expected.not_to include 'WIZ' }
   end
 
   describe '#reject' do
     subject { rash.reject { |_, value| value.is_a? String } }
-    it { should be_a described_class }
-    it { should include 'WIZ' }
-    it { should_not include 'FOO' }
+    it { is_expected.to be_a described_class }
+    it { is_expected.to include 'WIZ' }
+    it { is_expected.not_to include 'FOO' }
   end
 
   describe '#values_at' do
     subject { rash.values_at 'FOO', 'WIZ', 'WRONG' }
-    it { should == ['foo', wiz, nil] }
+    it { is_expected.to eq ['foo', wiz, nil] }
   end
 end

data/spec/units/stacker_bee/request_error_spec.rb

@@ -11,15 +11,15 @@ describe 'An error occuring' do
 
     context 'HTTP status in the 400s' do
       let(:status) { 431 }
-      it { should be_a StackerBee::ClientError }
+      it { is_expected.to be_a StackerBee::ClientError }
     end
     context 'HTTP status in the 500s' do
       let(:status) { 500 }
-      it { should be_a StackerBee::ServerError }
+      it { is_expected.to be_a StackerBee::ServerError }
     end
     context 'HTTP status > 599' do
       let(:status) { 999 }
-      it { should be_a StackerBee::RequestError }
+      it { is_expected.to be_a StackerBee::RequestError }
     end
   end
 

data/spec/units/stacker_bee/utilities_spec.rb

@@ -3,28 +3,28 @@ require 'spec_helper'
 describe StackerBee::Utilities, '#uncase' do
   include StackerBee::Utilities
 
-  it { uncase('Foo Bar').should eq 'foobar' }
-  it { uncase('foo_bar').should eq 'foobar' }
-  it { uncase('foo-bar').should eq 'foobar' }
-  it { uncase('fooBar').should eq 'foobar' }
-  it { uncase('foo[0].Bar').should eq 'foo[0].bar' }
-
-  it { snake_case('Foo Bar').should eq 'foo_bar' }
-  it { snake_case('foo_bar').should eq 'foo_bar' }
-  it { snake_case('foo-bar').should eq 'foo_bar' }
-  it { snake_case('fooBar').should eq 'foo_bar' }
-
-  it { camel_case('Foo Bar').should eq 'FooBar' }
-  it { camel_case('foo_bar').should eq 'FooBar' }
-  it { camel_case('foo-bar').should eq 'FooBar' }
-  it { camel_case('fooBar').should eq 'FooBar' }
-
-  it { camel_case('Foo Bar', true).should eq 'fooBar' }
-  it { camel_case('foo_bar', true).should eq 'fooBar' }
-  it { camel_case('foo-bar', true).should eq 'fooBar' }
-  it { camel_case('fooBar', true).should eq 'fooBar' }
-  it { camel_case('fooBar', false).should eq 'FooBar' }
-  it { camel_case('foo[0].Bar', false).should eq 'Foo[0].Bar' }
+  it { expect(uncase('Foo Bar')).to eq 'foobar' }
+  it { expect(uncase('foo_bar')).to eq 'foobar' }
+  it { expect(uncase('foo-bar')).to eq 'foobar' }
+  it { expect(uncase('fooBar')).to eq 'foobar' }
+  it { expect(uncase('foo[0].Bar')).to eq 'foo[0].bar' }
+
+  it { expect(snake_case('Foo Bar')).to eq 'foo_bar' }
+  it { expect(snake_case('foo_bar')).to eq 'foo_bar' }
+  it { expect(snake_case('foo-bar')).to eq 'foo_bar' }
+  it { expect(snake_case('fooBar')).to eq 'foo_bar' }
+
+  it { expect(camel_case('Foo Bar')).to eq 'FooBar' }
+  it { expect(camel_case('foo_bar')).to eq 'FooBar' }
+  it { expect(camel_case('foo-bar')).to eq 'FooBar' }
+  it { expect(camel_case('fooBar')).to eq 'FooBar' }
+
+  it { expect(camel_case('Foo Bar', true)).to eq 'fooBar' }
+  it { expect(camel_case('foo_bar', true)).to eq 'fooBar' }
+  it { expect(camel_case('foo-bar', true)).to eq 'fooBar' }
+  it { expect(camel_case('fooBar', true)).to eq 'fooBar' }
+  it { expect(camel_case('fooBar', false)).to eq 'FooBar' }
+  it { expect(camel_case('foo[0].Bar', false)).to eq 'Foo[0].Bar' }
 
   describe '#map_a_hash' do
     let(:original) { { 1 =>  1, 2 =>  2 } }
@@ -35,7 +35,7 @@ describe StackerBee::Utilities, '#uncase' do
     end
 
     it 'maps over a hash' do
-      transformed.should eq expected
+      expect(transformed).to eq expected
     end
 
     it 'does not modify the original' do
@@ -45,10 +45,10 @@ describe StackerBee::Utilities, '#uncase' do
   end
 
   describe '.transform_hash_keys' do
-    it { transform_hash_keys({ 1 => 2 }, &:odd?).should eq true => 2 }
+    it { expect(transform_hash_keys({ 1 => 2 }, &:odd?)).to eq true => 2 }
   end
 
   describe '.transform_hash_values' do
-    it { transform_hash_values({ 1 => 2 }, &:odd?).should eq 1 => false }
+    it { expect(transform_hash_values({ 1 => 2 }, &:odd?)).to eq 1 => false }
   end
 end

data/spec/units/stacker_bee_spec.rb

@@ -2,5 +2,5 @@ require 'spec_helper'
 
 describe StackerBee, 'VERSION' do
   subject { StackerBee::VERSION }
-  it { should_not be_nil }
+  it { is_expected.not_to be_nil }
 end

data/stacker_bee.gemspec

@@ -25,11 +25,12 @@ Gem::Specification.new do |spec|
   # this is a dependency for FaradayMiddleware::Graylog
   spec.add_runtime_dependency 'faraday_middleware', '~> 0.9'
 
-  spec.add_development_dependency 'bundler',  '~> 1.3'
-  spec.add_development_dependency 'rake',     '~> 10.0'
-  spec.add_development_dependency 'rspec',    '~> 2.1'
-  spec.add_development_dependency 'webmock',  '~> 1.15'
-  spec.add_development_dependency 'vcr',      '~> 2.6'
+  spec.add_development_dependency 'bundler',   '~> 1.3'
+  spec.add_development_dependency 'rake',      '~> 10.0'
+  spec.add_development_dependency 'rspec',     '~> 3.0.0'
+  spec.add_development_dependency 'rspec-its', '~> 1.0'
+  spec.add_development_dependency 'webmock',   '~> 1.15'
+  spec.add_development_dependency 'vcr',       '~> 2.9'
   spec.add_development_dependency 'pry'
 
   # It should be consistent for Travis and all developers, since we don't check

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stacker_bee
 version: !ruby/object:Gem::Version
-  version: 2.1.1.pre263
+  version: 2.1.1.pre265
 platform: ruby
 authors:
 - Greg Sterndale
@@ -93,14 +93,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -121,14 +135,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement