active_rest_client 1.0.6 → 1.0.7

data/spec/lib/caching_spec.rb

@@ -10,7 +10,7 @@ describe ActiveRestClient::Caching do
       class CachingExample1
         include ActiveRestClient::Caching
       end
-      expect(CachingExample1.perform_caching).to be_false
+      expect(CachingExample1.perform_caching).to be_falsey
     end
 
     it "should be able to have caching enabled without affecting ActiveRestClient::Base" do
@@ -18,19 +18,19 @@ describe ActiveRestClient::Caching do
         include ActiveRestClient::Caching
       end
       CachingExample2.perform_caching true
-      expect(CachingExample2.perform_caching).to be_true
-      expect(ActiveRestClient::Base.perform_caching).to be_false
+      expect(CachingExample2.perform_caching).to be_truthy
+      expect(ActiveRestClient::Base.perform_caching).to be_falsey
     end
 
     it "should be possible to enable caching for all objects" do
       class CachingExample3 < ActiveRestClient::Base ; end
       ActiveRestClient::Base._reset_caching!
 
-      expect(ActiveRestClient::Base.perform_caching).to be_false
+      expect(ActiveRestClient::Base.perform_caching).to be_falsey
 
       ActiveRestClient::Base.perform_caching = true
-      expect(ActiveRestClient::Base.perform_caching).to be_true
-      expect(CachingExample3.perform_caching).to be_true
+      expect(ActiveRestClient::Base.perform_caching).to be_truthy
+      expect(CachingExample3.perform_caching).to be_truthy
 
       ActiveRestClient::Base._reset_caching!
     end
@@ -110,8 +110,8 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         etag:@etag)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
-      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(OpenStruct.new(status:304, headers:{}))
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(OpenStruct.new(status:304, headers:{}))
       ret = Person.all
       expect(ret.first_name).to eq("Johnny")
     end
@@ -139,8 +139,8 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
-      ActiveRestClient::Connection.any_instance.should_not_receive(:get)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(ActiveRestClient::Connection).not_to receive(:get)
       ret = Person.all
       expect(ret.first_name).to eq("Johnny")
     end
@@ -150,8 +150,8 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
-      ActiveRestClient::Connection.any_instance.should_not_receive(:get)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(ActiveRestClient::Connection).not_to receive(:get)
       p = Person.new(first_name:"Billy")
       ret = p.all({})
       expect(ret.first_name).to eq("Johnny")
@@ -168,32 +168,32 @@ describe ActiveRestClient::Caching do
         result:object,
         etag:@etag,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
-      ActiveRestClient::Connection.any_instance.should_not_receive(:get)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(ActiveRestClient::Connection).not_to receive(:get)
       ret = Person.all
       expect(ret.first.first_name).to eq("Johnny")
       expect(ret._status).to eq(200)
     end
 
     it "should not write the response to the cache unless if has caching headers" do
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
-      CachingExampleCacheStore5.any_instance.should_not_receive(:write)
-      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{}))
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).not_to receive(:write)
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{}))
       ret = Person.all
     end
 
     it "should write the response to the cache if there's an etag" do
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
-      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(String), {})
-      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{etag:"1234567890"}))
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), {})
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{etag:"1234567890"}))
       Person.perform_caching true
       ret = Person.all
     end
 
     it "should write the response to the cache if there's a hard expiry" do
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
-      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
-      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:(Time.now + 30).rfc822}))
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:(Time.now + 30).rfc822}))
       Person.perform_caching = true
       ret = Person.all
     end

data/spec/lib/configuration_spec.rb

@@ -8,6 +8,8 @@ describe ActiveRestClient::Configuration do
     class ConfigurationExample
       include ActiveRestClient::Configuration
       base_url "http://www.example.com"
+      username "john"
+      password "smith"
       request_body_type :json
     end
 
@@ -20,12 +22,12 @@ describe ActiveRestClient::Configuration do
     class UnusuedConfigurationExample1
       include ActiveRestClient::Configuration
     end
-    expect(UnusuedConfigurationExample1.whiny_missing).to be_false
+    expect(UnusuedConfigurationExample1.whiny_missing).to be_falsey
   end
 
   it "should allow whiny missing methods to be enabled" do
     ConfigurationExample.whiny_missing true
-    expect(ConfigurationExample.whiny_missing).to be_true
+    expect(ConfigurationExample.whiny_missing).to be_truthy
   end
 
   it "should remember the set base_url" do
@@ -40,11 +42,13 @@ describe ActiveRestClient::Configuration do
   it "should remove a trailing slash from a globally configured base_url" do
     ActiveRestClient::Base.base_url = "http://general.example.com/"
     expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+    ActiveRestClient::Base.base_url = ""
   end
 
   it "should remember the set base_url on the base class if a more specific one hasn't been set" do
     ActiveRestClient::Base.base_url = "http://general.example.com"
     expect(ConfigurationExampleBare.base_url).to eq("http://general.example.com")
+    ActiveRestClient::Base.base_url = ""
   end
 
   it "should remove a trailing slash from a specific class configured base_url" do
@@ -55,6 +59,26 @@ describe ActiveRestClient::Configuration do
     expect(ConfigurationExample2.base_url).to eq("http://specific.example.com")
   end
 
+  it "should remember the set username" do
+    expect(ConfigurationExample.username).to eq("john")
+  end
+
+  it "should remember the set username on a class, overriding a general one" do
+    ActiveRestClient::Base.username = "bill"
+    expect(ConfigurationExample.username).to eq("john")
+    ActiveRestClient::Base.username = nil
+  end
+
+  it "should remember the set password" do
+    expect(ConfigurationExample.password).to eq("smith")
+  end
+
+  it "should remember the set password on a class, overriding a general one" do
+    ActiveRestClient::Base.password = "bloggs"
+    expect(ConfigurationExample.password).to eq("smith")
+    ActiveRestClient::Base.password = nil
+  end
+
   it "should default to a form_encoded request_body_type" do
     expect(ActiveRestClient::Base.request_body_type).to eq(:form_encoded)
   end
@@ -73,7 +97,7 @@ describe ActiveRestClient::Configuration do
     class LazyLoadingConfigurationExample1
       include ActiveRestClient::Configuration
     end
-    expect(LazyLoadingConfigurationExample1.lazy_load?).to be_false
+    expect(LazyLoadingConfigurationExample1.lazy_load?).to be_falsey
   end
 
   it "should be able to switch on lazy loading" do
@@ -81,14 +105,14 @@ describe ActiveRestClient::Configuration do
       include ActiveRestClient::Configuration
       lazy_load!
     end
-    expect(LazyLoadingConfigurationExample2.lazy_load?).to be_true
+    expect(LazyLoadingConfigurationExample2.lazy_load?).to be_truthy
   end
 
   it "should default to non-verbose loggingg" do
     class VerboseConfigurationExample1
       include ActiveRestClient::Configuration
     end
-    expect(VerboseConfigurationExample1.verbose).to be_false
+    expect(VerboseConfigurationExample1.verbose).to be_falsey
   end
 
   it "should be able to switch on verbose logging" do
@@ -100,34 +124,34 @@ describe ActiveRestClient::Configuration do
       include ActiveRestClient::Configuration
       verbose true
     end
-    expect(VerboseConfigurationExample2.verbose).to be_true
-    expect(VerboseConfigurationExample3.verbose).to be_true
+    expect(VerboseConfigurationExample2.verbose).to be_truthy
+    expect(VerboseConfigurationExample3.verbose).to be_truthy
   end
 
   it "should store a translator given" do
     expect{ ConfigurationExample.send(:translator) }.to_not raise_error
-    ConfigurationExample.send(:translator, String)
-    expect{ ConfigurationExample.translator.respond_to?(:length) }.to be_true
+    ConfigurationExample.send(:translator, String.new)
+    expect(ConfigurationExample.translator).to respond_to(:length)
   end
 
   it "should store a proxy given" do
     expect{ ConfigurationExample.send(:proxy) }.to_not raise_error
-    ConfigurationExample.send(:proxy, String)
-    expect{ ConfigurationExample.proxy.respond_to?(:length) }.to be_true
+    ConfigurationExample.send(:proxy, String.new)
+    expect(ConfigurationExample.proxy).to respond_to(:length)
   end
 
   describe "faraday_config" do
     let(:faraday_double){double(:faraday).as_null_object}
 
     it "should use default adapter if no other block set" do
-      faraday_double.should_receive(:adapter).with(:patron)
+      expect(faraday_double).to receive(:adapter).with(:patron)
       ConfigurationExample.faraday_config.call(faraday_double)
     end
 
     it "should us set adapter if no other block set" do
       ConfigurationExample.adapter = :net_http
 
-      faraday_double.should_receive(:adapter).with(:net_http)
+      expect(faraday_double).to receive(:adapter).with(:net_http)
 
       ConfigurationExample.faraday_config.call(faraday_double)
     end
@@ -135,7 +159,7 @@ describe ActiveRestClient::Configuration do
     it "should use the adapter of the passed in faraday_config block" do
       ConfigurationExample.faraday_config {|faraday| faraday.adapter(:rack)}
 
-      faraday_double.should_receive(:adapter).with(:rack)
+      expect(faraday_double).to receive(:adapter).with(:rack)
 
       ConfigurationExample.faraday_config.call(faraday_double)
     end

data/spec/lib/instrumentation_spec.rb

@@ -9,29 +9,28 @@ end
 describe ActiveRestClient::Instrumentation do
   it "should save a load hook to include the instrumentation" do
     hook_tester = double("HookTester")
-    hook_tester.should_receive(:include).with(ActiveRestClient::ControllerInstrumentation)
+    expect(hook_tester).to receive(:include).with(ActiveRestClient::ControllerInstrumentation)
     ActiveSupport.run_load_hooks(:action_controller, hook_tester)
   end
 
   it "should call ActiveSupport::Notifications.instrument when making any request" do
-    ActiveSupport::Notifications.should_receive(:instrument).with("request_call.active_rest_client", {:name=>"InstrumentationExampleClient#fake"})
+    expect(ActiveSupport::Notifications).to receive(:instrument).with("request_call.active_rest_client", {:name=>"InstrumentationExampleClient#fake"})
     InstrumentationExampleClient.fake
   end
 
   it "should call ActiveSupport::Notifications#request_call when making any request" do
-    ActiveRestClient::Instrumentation.any_instance.should_receive(:request_call).with(an_instance_of(ActiveSupport::Notifications::Event))
+    expect_any_instance_of(ActiveRestClient::Instrumentation).to receive(:request_call).with(an_instance_of(ActiveSupport::Notifications::Event))
     InstrumentationExampleClient.fake
   end
 
 
   it "should log time spent in each API call" do
-    ActiveRestClient::Connection.
-      any_instance.
-      should_receive(:get).
+    expect_any_instance_of(ActiveRestClient::Connection).
+      to receive(:get).
       with("/real", an_instance_of(Hash)).
       and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
-    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/ActiveRestClient.*ms\)/]}
-    ActiveRestClient::Logger.should_receive(:debug).at_least(:once).with(any_args)
+    expect(ActiveRestClient::Logger).to receive(:debug).with(/ActiveRestClient.*ms\)/)
+    expect(ActiveRestClient::Logger).to receive(:debug).at_least(:once).with(any_args)
     InstrumentationExampleClient.real
   end
 

data/spec/lib/lazy_association_loader_spec.rb

@@ -96,10 +96,10 @@ describe ActiveRestClient::LazyAssociationLoader do
   it "should make the request for a URL if it's accessed" do
     method_data = {options:{url:"foo"}}
     request = double("Request").as_null_object
-    request.stub(:method).and_return(method_data)
-    request.should_receive(:object).with(any_args).and_return(Array.new)
-    request.should_receive(:call).with(any_args).and_return("")
-    ActiveRestClient::Request.should_receive(:new).with(any_args).and_return(request)
+    allow(request).to receive(:method).and_return(method_data)
+    expect(request).to receive(:object).with(any_args).and_return(Array.new)
+    expect(request).to receive(:call).with(any_args).and_return("")
+    expect(ActiveRestClient::Request).to receive(:new).with(any_args).and_return(request)
     loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
     loader.length
   end
@@ -107,14 +107,14 @@ describe ActiveRestClient::LazyAssociationLoader do
   it "should proxy methods to the underlying object if the request has been made" do
     loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
     object = double("Object")
-    object.should_receive(:length).and_return(1)
+    expect(object).to receive(:length).and_return(1)
     loader.instance_variable_set(:@object, object)
     expect(loader.length).to eq(1)
   end
 
   it "should be able to iterate underlying object if it's an array" do
     loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
-    ActiveRestClient::Request.any_instance.should_receive(:call).with(any_args).and_return([1,2,3])
+    expect_any_instance_of(ActiveRestClient::Request).to receive(:call).with(any_args).and_return([1,2,3])
     test = []
     loader.each do |item|
       test << item
@@ -124,7 +124,7 @@ describe ActiveRestClient::LazyAssociationLoader do
 
   it "should be able to return the size of the underlying object if it's an array" do
     loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
-    ActiveRestClient::Request.any_instance.should_receive(:call).with(any_args).and_return([1,2,3])
+    expect_any_instance_of(ActiveRestClient::Request).to receive(:call).with(any_args).and_return([1,2,3])
     expect(loader.size).to eq(3)
   end
 

data/spec/lib/lazy_loader_spec.rb

@@ -5,21 +5,21 @@ describe ActiveRestClient::LazyLoader do
   let(:response) { double("Response") }
 
   it "should not #call the passed in request during initialisation" do
-    request.should_not_receive(:call)
+    expect(request).not_to receive(:call)
     ActiveRestClient::LazyLoader.new(request)
   end
 
   it "should #call the passed in request if you check for response to a message" do
-    request.should_receive(:call)
+    expect(request).to receive(:call)
     loader = ActiveRestClient::LazyLoader.new(request)
     loader.respond_to?(:each)
   end
 
   it "should #call the passed in request if you call a method and pass through the method" do
-    request.should_receive(:call).and_return(response)
-    response.should_receive(:valid).and_return(true)
+    expect(request).to receive(:call).and_return(response)
+    expect(response).to receive(:valid).and_return(true)
     loader = ActiveRestClient::LazyLoader.new(request)
-    expect(loader.valid).to be_true
+    expect(loader.valid).to be_truthy
   end
 
 end

data/spec/lib/logger_spec.rb

@@ -13,10 +13,10 @@ describe ActiveRestClient::Instrumentation do
     end
 
     Rails.logger = double("Logger")
-    Rails.logger.should_receive(:debug)
-    Rails.logger.should_receive(:info)
-    Rails.logger.should_receive(:warn)
-    Rails.logger.should_receive(:error)
+    expect(Rails.logger).to receive(:debug)
+    expect(Rails.logger).to receive(:info)
+    expect(Rails.logger).to receive(:warn)
+    expect(Rails.logger).to receive(:error)
     ActiveRestClient::Logger.debug("Hello world")
     ActiveRestClient::Logger.info("Hello world")
     ActiveRestClient::Logger.warn("Hello world")
@@ -27,28 +27,28 @@ describe ActiveRestClient::Instrumentation do
   it "should write to a logfile if one has been specified" do
     ActiveRestClient::Logger.logfile = "/dev/null"
     file = double('file')
-    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
-    file.should_receive(:<<).with("Hello world")
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello world")
     ActiveRestClient::Logger.debug("Hello world")
 
     file = double('file')
-    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
-    file.should_receive(:<<).with("Hello info")
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello info")
     ActiveRestClient::Logger.info("Hello info")
 
     file = double('file')
-    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
-    file.should_receive(:<<).with("Hello error")
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello error")
     ActiveRestClient::Logger.error("Hello error")
 
     file = double('file')
-    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
-    file.should_receive(:<<).with("Hello warn")
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello warn")
     ActiveRestClient::Logger.warn("Hello warn")
   end
 
   it "should append to its own messages list if neither Rails nor a logfile has been specified" do
-    File.should_not_receive(:open)
+    expect(File).not_to receive(:open)
     ActiveRestClient::Logger.debug("Hello world")
     ActiveRestClient::Logger.info("Hello info")
     ActiveRestClient::Logger.warn("Hello warn")

data/spec/lib/proxy_spec.rb

@@ -79,43 +79,43 @@ end
 
 describe ActiveRestClient::Base do
   it "allows the URL to be changed" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/getAll?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/getAll?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.all(id:1)
   end
 
   it "allows the URL to be replaced" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/new", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/new", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.old
   end
 
   it "has access to the GET params and allow them to be changed/removed/added" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/list?age=12&first_name=John", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/list?age=12&first_name=John", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.list(fname:"John", lname:"Smith")
   end
 
   it "has access to the POST params and allow them to be changed/removed/added" do
-    ActiveRestClient::Connection.any_instance.should_receive(:post).with("/create", {age:12, first_name:"John"}.to_query, instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with("/create", {age:12, first_name:"John"}.to_query, instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.create(fname:"John", lname:"Smith")
   end
 
   it "has access to raw body content for requests" do
-    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.update(fname:"John", lname:"Smith")
   end
 
   it "handles DELETE requests" do
-    ActiveRestClient::Connection.any_instance.should_receive(:delete).with("/remove", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:delete).with("/remove", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.remove
   end
 
   it "can return fake JSON data and have this parsed in the normal way" do
-    ActiveRestClient::Connection.any_instance.should_not_receive(:get).with("/fake", instance_of(Hash))
+    expect_any_instance_of(ActiveRestClient::Connection).not_to receive(:get).with("/fake", instance_of(Hash))
     ret = ProxyClientExample.fake
     expect(ret.id).to eq(1234)
   end
 
   it "can intercept the response and parse the response, alter it and pass it on during the request" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/change-format", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"fname\":\"Billy\"}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/change-format", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"fname\":\"Billy\"}", status:200, headers:{}))
     ret = ProxyClientExample.change_format
     expect(ret.first_name).to eq("Billy")
   end
@@ -128,7 +128,7 @@ describe ActiveRestClient::Base do
   end
 
   it "can continue with the request in the normal way, passing it on to the server" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/not_proxied?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/not_proxied?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     ProxyClientExample.not_proxied(id:1)
   end
 
@@ -140,12 +140,12 @@ describe ActiveRestClient::Base do
         etag:@etag)
 
     cache_store = double("CacheStore")
-    cache_store.stub(:read).with(any_args).and_return(nil)
+    allow(cache_store).to receive(:read).with(any_args).and_return(nil)
     ProxyClientExample.perform_caching true
-    ProxyClientExample.stub(:cache_store).and_return(cache_store)
+    allow(ProxyClientExample).to receive(:cache_store).and_return(cache_store)
     expiry = 10.minutes.from_now.rfc2822
-    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{"Expires" => expiry, "ETag" => "123456"}))
-    ProxyClientExample.cache_store.should_receive(:write) do |key, object, options|
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{"Expires" => expiry, "ETag" => "123456"}))
+    expect(ProxyClientExample.cache_store).to receive(:write) do |key, object, options|
       expect(key).to eq("ProxyClientExample:/update")
       expect(object).to be_an_instance_of(String)
       unmarshalled = Marshal.load(object)
@@ -162,8 +162,8 @@ describe ActiveRestClient::Base do
   end
 
   it "can force the URL from a filter without it being passed through URL replacement" do
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/hal_test/1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
-    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/this/is/a/test", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/hal_test/1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/this/is/a/test", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
     expect(ProxyClientExample.hal_test(id:1).test.result).to eq(true)
   end