garner 0.5.0 → 0.5.1

data/spec/garner/strategies/context/key/jsonp_spec.rb

@@ -6,7 +6,7 @@ describe Garner::Strategies::Context::Key::Jsonp do
     @request = Rack::Request.new('REQUEST_METHOD' => 'GET', 'QUERY_STRING' => 'callback=jQuery21435&_=34234')
 
     @mock_context = double('object')
-    @mock_context.stub(:request) { @request }
+    allow(@mock_context).to receive(:request) { @request }
   end
 
   subject { Garner::Strategies::Context::Key::Jsonp }
@@ -17,6 +17,6 @@ describe Garner::Strategies::Context::Key::Jsonp do
     request_get = Garner::Strategies::Context::Key::RequestGet
     applied_identity = request_get.apply(@cache_identity, @mock_context)
     subject.apply(applied_identity, @mock_context)
-    @cache_identity.key_hash[:request_params].should eq({})
+    expect(@cache_identity.key_hash[:request_params]).to eq({})
   end
 end

data/spec/garner/strategies/context/key/request_get_spec.rb

@@ -9,7 +9,7 @@ describe Garner::Strategies::Context::Key::RequestGet do
         @request = Rack::Request.new('REQUEST_METHOD' => method, 'QUERY_STRING' => 'foo=bar')
 
         @mock_context = double('object')
-        @mock_context.stub(:request) { @request }
+        allow(@mock_context).to receive(:request) { @request }
       end
 
       subject { Garner::Strategies::Context::Key::RequestGet }
@@ -18,12 +18,12 @@ describe Garner::Strategies::Context::Key::RequestGet do
 
       it 'adds :request_params to the key' do
         subject.apply(@cache_identity, @mock_context)
-        @cache_identity.key_hash[:request_params].should eq('foo' => 'bar')
+        expect(@cache_identity.key_hash[:request_params]).to eq('foo' => 'bar')
       end
 
       it 'appends to an existing key hash' do
         @cache_identity.key(x: :y)
-        subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+        expect(subject.apply(@cache_identity, @mock_context).key_hash).to eq(
           x: :y,
           request_params: { 'foo' => 'bar' }
         )

data/spec/garner/strategies/context/key/request_path_spec.rb

@@ -6,7 +6,7 @@ describe Garner::Strategies::Context::Key::RequestPath do
     @request = Rack::Request.new('PATH_INFO' => '/foo')
 
     @mock_context = double('object')
-    @mock_context.stub(:request) { @request }
+    allow(@mock_context).to receive(:request) { @request }
   end
 
   subject { Garner::Strategies::Context::Key::RequestPath }
@@ -15,12 +15,12 @@ describe Garner::Strategies::Context::Key::RequestPath do
 
   it 'adds :request_params to the key' do
     subject.apply(@cache_identity, @mock_context)
-    @cache_identity.key_hash[:request_path].should eq '/foo'
+    expect(@cache_identity.key_hash[:request_path]).to eq '/foo'
   end
 
   it 'appends to an existing key hash' do
     @cache_identity.key(x: :y)
-    subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+    expect(subject.apply(@cache_identity, @mock_context).key_hash).to eq(
       x: :y,
       request_path: '/foo'
     )

data/spec/garner/strategies/context/key/request_post_spec.rb

@@ -12,7 +12,7 @@ describe Garner::Strategies::Context::Key::RequestPost do
     )
 
     @mock_context = double('object')
-    @mock_context.stub(:request) { @request }
+    allow(@mock_context).to receive(:request) { @request }
   end
 
   subject { Garner::Strategies::Context::Key::RequestPost }
@@ -21,12 +21,12 @@ describe Garner::Strategies::Context::Key::RequestPost do
 
   it 'adds :request_params to the key' do
     subject.apply(@cache_identity, @mock_context)
-    @cache_identity.key_hash[:request_params].should eq('foo' => 'bar')
+    expect(@cache_identity.key_hash[:request_params]).to eq('foo' => 'bar')
   end
 
   it 'appends to an existing key hash' do
     @cache_identity.key(x: :y)
-    subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+    expect(subject.apply(@cache_identity, @mock_context).key_hash).to eq(
       x: :y,
       request_params: { 'foo' => 'bar' }
     )

data/spec/garner/version_spec.rb

@@ -5,7 +5,7 @@ describe Garner::VERSION do
     Garner::VERSION
   end
   it 'is valid' do
-    subject.should_not be_nil
-    (!!Gem::Version.correct?(subject)).should be_truthy
+    expect(subject).not_to be_nil
+    expect(!!Gem::Version.correct?(subject)).to be_truthy
   end
 end

data/spec/integration/active_record_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'ActiveRecord integration' do
+describe 'ActiveRecord integration', type: :request do
   context 'using the Garner::Strategies::Binding::Key::CacheKey strategy' do
 
     describe 'cache key generation' do
@@ -13,12 +13,12 @@ describe 'ActiveRecord integration' do
 
       it "returns the object's cache key, or nil" do
         new_activist = Activist.new
-        subject.apply(new_activist).should eq 'activists/new'
+        expect(subject.apply(new_activist)).to eq 'activists/new'
 
         persisted_activist = Activist.create
         timestamp = persisted_activist.updated_at.utc.to_s(persisted_activist.cache_timestamp_format)
         expected_key = "activists/#{persisted_activist.id}-#{timestamp}"
-        subject.apply(persisted_activist).should eq expected_key
+        expect(subject.apply(persisted_activist)).to eq expected_key
       end
     end
 
@@ -27,7 +27,7 @@ describe 'ActiveRecord integration' do
         subject { Activist.create }
 
         it 'returns a non-nil cache_key' do
-          subject.garner_cache_key.should_not be_nil
+          expect(subject.garner_cache_key).not_to be_nil
         end
       end
 

data/spec/integration/grape_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'garner/mixins/rack'
 require 'grape'
 
-describe 'Grape integration' do
+describe 'Grape integration', type: :request do
   class TestCachebuster < Grape::Middleware::Base
     def after
       @app_response[1]['Expires'] = Time.at(0).utc.to_s

data/spec/integration/mongoid_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'garner/mixins/mongoid'
 
-describe 'Mongoid integration' do
+describe 'Mongoid integration', type: :request do
   before(:each) do
     @app = Class.new.tap do |app|
       app.send(:extend, Garner::Cache::Context)
@@ -34,42 +34,42 @@ describe 'Mongoid integration' do
             end
 
             it 'caches one copy across all callers' do
-              Monger.stub(:find) { @object }
-              Monger.should_receive(:find).once
+              allow(Monger).to receive(:find) { @object }
+              expect(Monger).to receive(:find).once
               2.times { Monger.garnered_find('m1') }
             end
 
             it 'returns the instance requested' do
-              Monger.garnered_find('m1').should eq @object
+              expect(Monger.garnered_find('m1')).to eq @object
             end
 
             it 'can be called with an array of one object, and will return an array' do
-              Monger.garnered_find(['m1']).should eq [@object]
+              expect(Monger.garnered_find(['m1'])).to eq [@object]
             end
 
             it 'is invalidated on changing identity field' do
-              Monger.garnered_find('m1').name.should eq 'M1'
+              expect(Monger.garnered_find('m1').name).to eq 'M1'
               @object.update_attributes!(name: 'M2')
-              Monger.garnered_find('m1').name.should eq 'M2'
+              expect(Monger.garnered_find('m1').name).to eq 'M2'
             end
 
             it 'is invalidated on destruction' do
-              Monger.garnered_find('m1').name.should eq 'M1'
+              expect(Monger.garnered_find('m1').name).to eq 'M1'
               @object.destroy
-              Monger.garnered_find('m1').should be_nil
+              expect(Monger.garnered_find('m1')).to be_nil
             end
 
             context 'with case-insensitive find' do
               before(:each) do
                 find_method = Monger.method(:find)
-                Monger.stub(:find) do |param|
+                allow(Monger).to receive(:find) do |param|
                   find_method.call(param.to_s.downcase)
                 end
               end
 
               it 'does not cache a nil identity' do
-                Monger.garnered_find('M1').should eq @object
-                Monger.garnered_find('foobar').should be_nil
+                expect(Monger.garnered_find('M1')).to eq @object
+                expect(Monger.garnered_find('foobar')).to be_nil
               end
             end
 
@@ -79,50 +79,50 @@ describe 'Mongoid integration' do
               end
 
               it 'returns the instances requested' do
-                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+                expect(Monger.garnered_find('m1', 'm2')).to eq [@object, @object2]
               end
 
               it 'can take an array' do
-                Monger.garnered_find(%w(m1 m2)).should eq [@object, @object2]
+                expect(Monger.garnered_find(%w(m1 m2))).to eq [@object, @object2]
               end
 
               it 'is invalidated when one of the objects is changed' do
-                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+                expect(Monger.garnered_find('m1', 'm2')).to eq [@object, @object2]
                 @object2.update_attributes!(name: 'M3')
-                Monger.garnered_find('m1', 'm2').last.name.should eq 'M3'
+                expect(Monger.garnered_find('m1', 'm2').last.name).to eq 'M3'
               end
 
               it 'is invalidated when one of the objects is changed, passed as an array' do
-                Monger.garnered_find(%w(m1 m2)).should eq [@object, @object2]
+                expect(Monger.garnered_find(%w(m1 m2))).to eq [@object, @object2]
                 @object2.update_attributes!(name: 'M3')
-                Monger.garnered_find(%w(m1 m2)).last.name.should eq 'M3'
+                expect(Monger.garnered_find(%w(m1 m2)).last.name).to eq 'M3'
               end
 
               it 'does not return a match when the objects cannot be found' do
-                Monger.garnered_find('m3').should be_nil
-                Monger.garnered_find('m3', 'm4').should eq []
-                Monger.garnered_find(%w(m3 m4)).should eq []
+                expect(Monger.garnered_find('m3')).to be_nil
+                expect(Monger.garnered_find('m3', 'm4')).to eq []
+                expect(Monger.garnered_find(%w(m3 m4))).to eq []
               end
 
               it 'does not return a match when some of the objects cannot be found, and returns those that can' do
-                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+                expect(Monger.garnered_find('m1', 'm2')).to eq [@object, @object2]
                 @object2.destroy
-                Monger.garnered_find('m1', 'm2').should eq [@object]
+                expect(Monger.garnered_find('m1', 'm2')).to eq [@object]
               end
 
               it 'correctly returns a single object when first asked for a single object as an array' do
-                Monger.garnered_find(['m1']).should eq [@object]
-                Monger.garnered_find('m1').should eq @object
+                expect(Monger.garnered_find(['m1'])).to eq [@object]
+                expect(Monger.garnered_find('m1')).to eq @object
               end
 
               it 'correctly returns an array of a single object, when first asked for a single object' do
-                Monger.garnered_find('m1').should eq @object
-                Monger.garnered_find(['m1']).should eq [@object]
+                expect(Monger.garnered_find('m1')).to eq @object
+                expect(Monger.garnered_find(['m1'])).to eq [@object]
               end
 
               it 'caches properly when called with an array' do
-                Monger.stub(:find) { @object }
-                Monger.should_receive(:find).once
+                allow(Monger).to receive(:find) { @object }
+                expect(Monger).to receive(:find).once
                 2.times { Monger.garnered_find(%w(m1 m2)) }
               end
 
@@ -140,30 +140,30 @@ describe 'Mongoid integration' do
               end
 
               it 'invalidates on update' do
-                cached_object_namer.call.should eq 'M1'
+                expect(cached_object_namer.call).to eq 'M1'
                 @object.update_attributes!(name: 'M2')
-                cached_object_namer.call.should eq 'M2'
+                expect(cached_object_namer.call).to eq 'M2'
               end
 
               it 'invalidates on destroy' do
-                cached_object_namer.call.should eq 'M1'
+                expect(cached_object_namer.call).to eq 'M1'
                 @object.destroy
-                cached_object_namer.should raise_error
+                expect(cached_object_namer).to raise_error
               end
 
               it 'invalidates by explicit call to invalidate_garner_caches' do
-                cached_object_namer.call.should eq 'M1'
+                expect(cached_object_namer.call).to eq 'M1'
                 if Mongoid.mongoid3?
                   @object.set(:name, 'M2')
                 else
                   @object.set(name: 'M2')
                 end
                 @object.invalidate_garner_caches
-                cached_object_namer.call.should eq 'M2'
+                expect(cached_object_namer.call).to eq 'M2'
               end
 
               it 'does not invalidate results for other like-classed objects' do
-                cached_object_namer.call.should eq 'M1'
+                expect(cached_object_namer.call).to eq 'M1'
                 if Mongoid.mongoid3?
                   @object.set(:name, 'M2')
                 else
@@ -173,7 +173,7 @@ describe 'Mongoid integration' do
                 new_monger.update_attributes!(name: 'M4')
                 new_monger.destroy
 
-                cached_object_namer.call.should eq 'M1'
+                expect(cached_object_namer.call).to eq 'M1'
               end
 
               context 'with racing destruction' do
@@ -192,7 +192,7 @@ describe 'Mongoid integration' do
                   end
                   @monger1.destroy
                   @monger2.save
-                  cached_object_namer.should raise_error
+                  expect(cached_object_namer).to raise_error
                 end
 
                 it 'invalidates caches properly (Type II)' do
@@ -205,7 +205,7 @@ describe 'Mongoid integration' do
                   @monger1.remove
                   @monger2.save
                   @monger1.destroy
-                  cached_object_namer.should raise_error
+                  expect(cached_object_namer).to raise_error
                 end
               end
 
@@ -224,9 +224,9 @@ describe 'Mongoid integration' do
                 end
 
                 it 'binds to the correct object' do
-                  cached_object_namer.call.should eq 'Swiss'
+                  expect(cached_object_namer.call).to eq 'Swiss'
                   @object.update_attributes!(name: 'Havarti')
-                  cached_object_namer.call.should eq 'Havarti'
+                  expect(cached_object_namer.call).to eq 'Havarti'
                 end
               end
 
@@ -244,9 +244,9 @@ describe 'Mongoid integration' do
                 end
 
                 it 'binds to the correct object' do
-                  cached_object_namer.call.should eq 'Trout'
+                  expect(cached_object_namer.call).to eq 'Trout'
                   @fish.update_attributes!(name: 'Sockeye')
-                  cached_object_namer.call.should eq 'Sockeye'
+                  expect(cached_object_namer.call).to eq 'Sockeye'
                 end
 
                 context 'with :invalidate_mongoid_root = true' do
@@ -264,9 +264,9 @@ describe 'Mongoid integration' do
                   end
 
                   it 'invalidates the root document' do
-                    root_cached_object_namer.call.should eq 'Trout'
+                    expect(root_cached_object_namer.call).to eq 'Trout'
                     @fish.update_attributes!(name: 'Sockeye')
-                    root_cached_object_namer.call.should eq 'Sockeye'
+                    expect(root_cached_object_namer.call).to eq 'Sockeye'
                   end
                 end
               end
@@ -287,11 +287,11 @@ describe 'Mongoid integration' do
                 end
 
                 it 'invalidates all identities' do
-                  cached_object_namer.call.should eq 'M1'
-                  cached_object_namer_by_slug.call('m1').should eq 'M1'
+                  expect(cached_object_namer.call).to eq 'M1'
+                  expect(cached_object_namer_by_slug.call('m1')).to eq 'M1'
                   @object.update_attributes!(name: 'M2')
-                  cached_object_namer.call.should eq 'M2'
-                  cached_object_namer_by_slug.call('m1').should eq 'M2'
+                  expect(cached_object_namer.call).to eq 'M2'
+                  expect(cached_object_namer_by_slug.call('m1')).to eq 'M2'
                 end
               end
             end
@@ -313,38 +313,38 @@ describe 'Mongoid integration' do
 
               it 'invalidates on create' do
                 Cheese.create(name: 'M1')
-                cached_object_name_concatenator.call.should eq 'M1'
+                expect(cached_object_name_concatenator.call).to eq 'M1'
                 Cheese.create(name: 'M3')
-                cached_object_name_concatenator.call.should eq 'M1, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M1, M3'
               end
 
               it 'invalidates on update' do
                 m1 = Cheese.create(name: 'M1')
                 Cheese.create(name: 'M3')
-                cached_object_name_concatenator.call.should eq 'M1, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M1, M3'
                 m1.update_attributes(name: 'M2')
-                cached_object_name_concatenator.call.should eq 'M2, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M2, M3'
               end
 
               it 'invalidates on destroy' do
                 m1 = Cheese.create(name: 'M1')
                 Cheese.create(name: 'M3')
-                cached_object_name_concatenator.call.should eq 'M1, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M1, M3'
                 m1.destroy
-                cached_object_name_concatenator.call.should eq 'M3'
+                expect(cached_object_name_concatenator.call).to eq 'M3'
               end
 
               it 'invalidates by explicit call to invalidate_garner_caches' do
                 m1 = Cheese.create(name: 'M1')
                 Cheese.create(name: 'M3')
-                cached_object_name_concatenator.call.should eq 'M1, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M1, M3'
                 if Mongoid.mongoid3?
                   m1.set(:name, 'M2')
                 else
                   m1.set(name: 'M2')
                 end
                 klass.invalidate_garner_caches
-                cached_object_name_concatenator.call.should eq 'M2, M3'
+                expect(cached_object_name_concatenator.call).to eq 'M2, M3'
               end
             end
           end

data/spec/integration/rack_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'garner/mixins/rack'
 require 'securerandom'
 
-describe 'Rack integration' do
+describe 'Rack integration', type: :request do
   include Rack::Test::Methods
 
   let(:app) do
@@ -37,18 +37,18 @@ describe 'Rack integration' do
       response1 = JSON.parse(last_response.body)[0]
       get '/foo?q=2'
       response2 = JSON.parse(last_response.body)[0]
-      response1.should eq response2
+      expect(response1).to eq response2
     end
   end
 
   context 'with default configuration' do
     it 'bypasses cache if cache_enabled? returns false' do
-      TestRackApp.any_instance.stub(:cache_enabled?) { false }
+      allow_any_instance_of(TestRackApp).to receive(:cache_enabled?) { false }
       get '/'
       response1 = JSON.parse(last_response.body)[0]
       get '/'
       response2 = JSON.parse(last_response.body)[0]
-      response1.should_not == response2
+      expect(response1).not_to eq(response2)
     end
 
     it 'caches different results for different paths' do
@@ -56,7 +56,7 @@ describe 'Rack integration' do
       response1 = JSON.parse(last_response.body)[0]
       get '/bar'
       response2 = JSON.parse(last_response.body)[0]
-      response1.should_not == response2
+      expect(response1).not_to eq(response2)
     end
 
     it 'caches different results for different query strings' do
@@ -64,14 +64,14 @@ describe 'Rack integration' do
       response1 = JSON.parse(last_response.body)[0]
       get '/foo?q=2'
       response2 = JSON.parse(last_response.body)[0]
-      response1.should_not == response2
+      expect(response1).not_to eq(response2)
     end
 
     it 'caches multiple blocks separately within an endpoint' do
       get '/'
       random1 = JSON.parse(last_response.body)[0]
       random2 = JSON.parse(last_response.body)[1]
-      random1.should_not == random2
+      expect(random1).not_to eq(random2)
     end
   end
 end