px-service-client 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c456bfefca448cba29a988f43b0170d6f15c74e8
-  data.tar.gz: 3c8e4664102e71baa40f5be677b6e9e41e1187d4
+  metadata.gz: eed1491471134440a4e1ca1644420395f15079e4
+  data.tar.gz: 5f50c16950abc5f20cd7eb7d82deb75f5731782e
 SHA512:
-  metadata.gz: 1a96bb88370ad38d33533d624acb004f81826f66529f20e744eedb50849aaf7560c1ca2cd3d3f421fc826521bfebec12f02c952056731ac8ab90785cd90108d4
-  data.tar.gz: 1a2a252723fb795709c37c19b57076eafccc7571f27e056b1b73351ad33c9b3a8bb0a6a162ef28e0d423b4d91acabc593b6ef9cbd7894707d7dd15100f3c1f2f
+  metadata.gz: cd65c7907b1870c02add4c35a4360df9487b8974b92b9bdfc2a0af941b6f1a2e44870b8b8c409d7235c72a103bc0d64d8828038bcc54457b2949c014b02f2051
+  data.tar.gz: cf39f661fb5c27d1643b036afd7d3b28028e9dc098186775dbb461a852bd9ae3b201b629685eb364e2e6ae5b768d29c3b1edb0a35f8952123e2fb784bbfd8c02

data/lib/px/service/client/base.rb

@@ -1,6 +1,5 @@
 module Px::Service::Client
   class Base
-    include Px::Service::Client::Caching
     cattr_accessor :logger
 
     private

data/lib/px/service/client/caching/cache_entry.rb

@@ -23,8 +23,9 @@ module Px::Service::Client::Caching
       ActiveSupport::Notifications.instrument("store.caching", { url: url, policy_group: policy_group, expires_in: expires_in} ) do
         real_expiry = real_cache_expiry(expires_in, refresh_window: refresh_window)
         cache_client.multi do
-          cache_client.set(cache_key(:data), data.to_json, real_expiry)
-          cache_client.set(cache_key(:meta), metadata.to_json, real_expiry)
+          data_json = data.is_a?(Hash) ? data.to_json : data
+          cache_client.set(cache_key(:data), data_json, real_expiry)
+          cache_client.set(cache_key(:meta), metadata, real_expiry)
         end
       end
     end
@@ -59,7 +60,7 @@ module Px::Service::Client::Caching
         real_expiry = real_cache_expiry(expires_in, refresh_window: refresh_window)
 
         cache_client.touch(cache_key(:data), real_expiry)
-        cache_client.set(cache_key(:meta), metadata.to_json, real_expiry)
+        cache_client.set(cache_key(:meta), metadata, real_expiry)
       end
     end
 
@@ -70,7 +71,7 @@ module Px::Service::Client::Caching
         "url" => url,
         "pg" => policy_group,
         "expires_at" => expires_at,
-      }
+      }.to_json
     end
 
     def cache_key(type)

data/lib/px/service/client/caching.rb

@@ -20,14 +20,41 @@ module Px::Service::Client
       cattr_accessor :cache_client, :cache_logger
     end
 
-    def cache_request(url, strategy: :last_resort, expires_in: 30.seconds, **options, &block)
+    module ClassMethods
+      DefaultConfig = Struct.new(:cache_strategy, :cache_expiry, :max_page, :cache_options, :cache_client) do
+        def initialize
+          self.cache_strategy = :none
+          self.cache_expiry = 30.seconds
+          self.max_page = nil
+          self.cache_options = {}
+          self.cache_options[:policy_group] = 'general'
+          self.cache_client = nil
+        end
+      end
+
+      ##
+      # Set the caching behaviour
+      def caching(&block)
+        @cache_config ||= DefaultConfig.new
+        yield(@cache_config) if block_given?
+        @cache_config
+      end
+    end
+    
+    def config
+      @cache_config || self.class.caching
+    end
+
+    def cache_request(url, strategy: nil, **options, &block)
+      strategy ||= config.cache_strategy
+
       case strategy
       when :first_resort
-        cache_first_resort(url, expires_in: expires_in, **options, &block)
+        cache_first_resort(url, policy_group: config.cache_options[:policy_group], expires_in: config.cache_expiry, **options, &block)
       when :last_resort
-        cache_last_resort(url, expires_in: expires_in, **options, &block)
+        cache_last_resort(url, policy_group: config.cache_options[:policy_group], expires_in: config.cache_expiry, **options, &block)
       else
-        no_cache(url, &block)
+        no_cache(&block)
       end
     end
 
@@ -40,27 +67,34 @@ module Px::Service::Client
     def cache_last_resort(url, policy_group: 'general', expires_in: nil, refresh_probability: 1, &block)
       # Note we use a smaller refresh window here (technically, could even use 0)
       # since we don't really need the "expired but not really expired" behaviour when caching as a last resort.
-      begin
-        response = block.call(url)
-
-        entry = CacheEntry.new(cache_client, url, policy_group, response)
-
-        # Only store a new result if we roll a 0
-        r = rand(refresh_probability)
-        entry.store(expires_in, refresh_window: 1.minute) if r == 0
-
-        response
-      rescue Px::Service::ServiceError => ex
-        cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
-
-        entry = CacheEntry.fetch(cache_client, url, policy_group)
-        if entry.nil?
-          # Re-raise the error, no cached response
-          raise ex
+      retry_response = block.call
+
+      Future.new do
+        begin
+          if retry_response.is_a?(Future)
+            resp = retry_response.value!.options
+          else
+            resp = retry_response
+          end
+
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
+
+          # Only store a new result if we roll a 0
+          r = rand(refresh_probability)
+          entry.store(expires_in, refresh_window: 1.minute) if r == 0
+          resp
+        rescue Px::Service::ServiceError => ex
+          cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
+
+          entry = CacheEntry.fetch(config.cache_client, url, policy_group)
+          if entry.nil?
+            # Re-raise the error, no cached response
+            raise ex
+          end
+
+          entry.touch(expires_in, refresh_window: 1.minute)
+          entry.data
         end
-
-        entry.touch(expires_in, refresh_window: 1.minute)
-        entry.data
       end
     end
 
@@ -70,7 +104,7 @@ module Px::Service::Client
     # has expired (but is still present) and the request fails, the cached value is still returned, as if this was
     # cache_last_resort.
     def cache_first_resort(url, policy_group: 'general', expires_in: nil, &block)
-      entry = CacheEntry.fetch(cache_client, url, policy_group)
+      entry = CacheEntry.fetch(config.cache_client, url, policy_group)
 
       if entry
         if entry.expired?
@@ -80,33 +114,52 @@ module Px::Service::Client
           # don't also try to update the cache.
           entry.touch(expires_in)
         else
-          return entry.data
+          return Future.new { entry.data }
         end
       end
 
-      begin
-        response = block.call(url)
+      retry_response = block.call
+
+      Future.new do
+        begin
+          if retry_response.is_a?(Future)
+            resp = retry_response.value!.options
+          else
+            resp = retry_response
+          end
+          
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
+          entry.store(expires_in)
+          resp
+        rescue Px::Service::ServiceError => ex
+          cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
+
+          entry = CacheEntry.fetch(config.cache_client, url, policy_group)
+          if entry.nil?
+            # Re-raise the error, no cached response
+            raise ex
+          end
+
+          # Set the entry to be expired again (but reset the refresh window).  This allows the next call to try again
+          # (assuming the circuit breaker is reset) but keeps the value in the cache in the meantime
+          entry.touch(0.seconds)
+          entry.data
+        end
+      end
+    end
 
-        entry = CacheEntry.new(cache_client, url, policy_group, response)
-        entry.store(expires_in)
-        response
-      rescue Px::Service::ServiceError => ex
-        cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
+    def no_cache(&block)
+      retry_response = block.call
 
-        if entry.nil?
-          # Re-raise the error, no cached response
-          raise ex
+      Future.new do
+        if retry_response.is_a?(Future)
+          resp = retry_response.value!.options
+        else
+          resp = retry_response
         end
 
-        # Set the entry to be expired again (but reset the refresh window).  This allows the next call to try again
-        # (assuming the circuit breaker is reset) but keeps the value in the cache in the meantime
-        entry.touch(0.seconds)
-        entry.data
+        resp
       end
     end
-
-    def no_cache(url, &block)
-      block.call(url)
-    end
   end
 end

data/lib/px/service/client/multiplexer.rb

@@ -17,7 +17,9 @@ module Px::Service::Client
     def do(request_or_future, retries: RetriableResponseFuture::DEFAULT_RETRIES)
       response = request_or_future
       if request_or_future.is_a?(Typhoeus::Request)
-        response = RetriableResponseFuture(request_or_future, retries: retries)
+        response = RetriableResponseFuture.new(request_or_future, retries: retries)
+      elsif !request_or_future.is_a?(RetriableResponseFuture)
+        return request_or_future
       end
 
       # Will automatically queue the request on the hydra

data/lib/px/service/client/version.rb

@@ -1,7 +1,7 @@
 module Px
   module Service
     module Client
-      VERSION = "1.0.6"
+      VERSION = "1.1.0"
     end
   end
 end

data/spec/px/service/client/base_spec.rb

@@ -1,8 +1,19 @@
 require 'spec_helper'
 
 describe Px::Service::Client::Base do
-  subject { Px::Service::Client::Base.send(:new) }
-  let(:response) do
+  let(:dalli_host) { ENV['PX_MEMCACHED_HOST'] }
+  let(:dalli_options) { { :namespace => "service-client-test", expires_in: 3600, compress: false, failover: false } }
+  let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
+
+  subject {
+    Px::Service::Client::Base.include(Px::Service::Client::Caching).tap do |c|
+      c.caching do |config|
+        config.cache_client = dalli
+      end
+    end.new
+  }
+
+  let(:successful_response) do
     Typhoeus::Response.new(
       code: 200,
       body: { status: 200, message: "Success"}.to_json,
@@ -45,5 +56,234 @@ describe Px::Service::Client::Base do
         expect(resp.request.url).to include("one=a&two=b")
       end
     end
+
+    context "when the caching strategy is set" do
+      let(:multi) { Px::Service::Client::Multiplexer.new }
+      let(:request) { Typhoeus::Request.new(url, method: :get) }
+      let(:future) { Px::Service::Client::RetriableResponseFuture.new(request) }
+
+      before :each do
+        dalli.flush_all
+        Typhoeus.stub(url).and_return(response)
+      end
+
+      shared_examples_for 'a request that returns a cached response' do
+        let(:cache_entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', future, Time.now + 1.year) }
+
+        before :each do
+          Typhoeus::Expectation.clear
+          Typhoeus.stub(url).and_return(successful_response)
+
+          req = subject.send(:make_request, 'get', url)
+          subject.cache_request(req.request.url, strategy: strategy) do
+            resp = nil
+            multi.context do
+              resp = multi.do(req)
+            end.run
+            
+            resp
+          end
+        end
+
+        it 'does not return a new response' do
+          req = subject.send(:make_request, 'get', url)
+
+          expect(Px::Service::Client::RetriableResponseFuture).to_not receive(:new)
+          subject.cache_request(req.request.url, strategy: strategy) do
+            resp = nil
+            multi.context do
+              resp = multi.do(req)
+            end.run
+            
+            resp
+          end
+        end
+
+        it 'returns the cached response' do
+          Typhoeus::Expectation.clear
+          Typhoeus.stub(url).and_return(response)
+          req = subject.send(:make_request, 'get', url)
+          subject.cache_request(req.request.url, strategy: strategy) do
+            resp = nil
+
+            multi.context do
+              resp = multi.do(req)
+              expect(resp).to eq(cache_entry.data)
+            end.run
+
+            resp
+          end
+        end
+      end
+
+      context 'to first_resort' do
+        let(:strategy) { :first_resort }
+        let(:response) { successful_response }
+
+        it_behaves_like 'a request that returns a cached response'
+
+        context 'when the request fails' do
+          let(:response) do
+            Typhoeus::Response.new(
+              code: 500,
+              body: { status: 500, error: "Failed"}.to_json,
+              headers: { "Content-Type" => "application/json"} )
+          end
+
+          context 'when no response is cached' do
+            it 'makes the request' do
+              called = false
+              req = subject.send(:make_request, 'get', url)
+
+              subject.cache_request(req.request.url, strategy: strategy) do
+                resp = nil
+                multi.context do
+                  resp = multi.do(req)
+                  called = true
+                end.run
+                
+                resp
+              end
+
+              expect(called).to be_truthy
+            end
+
+            it 'returns an error' do
+              req = subject.send(:make_request, 'get', url)
+              expect {
+                subject.cache_request(req.request.url, strategy: strategy) do
+                  resp = nil
+                  multi.context do
+                    resp = multi.do(req)
+                  end.run
+                  
+                  resp
+                end.value!
+              }.to raise_error(Px::Service::ServiceError, 'Failed')
+            end
+          end
+
+          context 'when a response has been cached' do
+            it_behaves_like 'a request that returns a cached response'
+          end
+        end
+      end
+
+      context 'to last_resort' do
+        let(:strategy) { :last_resort }
+        let(:response) { successful_response }
+
+        it 'makes the request' do
+          called = false
+          req = subject.send(:make_request, 'get', url)
+
+          subject.cache_request(req.request.url, strategy: strategy) do
+            resp = nil
+            multi.context do
+              resp = multi.do(req)
+              called = true
+            end.run
+            
+            resp
+          end
+
+          expect(called).to be_truthy
+        end
+
+        context 'when the request fails' do
+          let(:response) do
+            Typhoeus::Response.new(
+              code: 500,
+              body: { status: 500, error: "Failed"}.to_json,
+              headers: { "Content-Type" => "application/json"} )
+          end
+
+          context 'when no response is cached' do
+            it 'makes the request' do
+              called = false
+              req = subject.send(:make_request, 'get', url)
+
+              subject.cache_request(req.request.url, strategy: strategy) do
+                resp = nil
+                multi.context do
+                  resp = multi.do(req)
+                  called = true
+                end.run
+                
+                resp
+              end
+
+              expect(called).to be_truthy
+            end
+
+            it 'raises an error' do
+              req = subject.send(:make_request, 'get', url)
+
+              expect {
+                subject.cache_request(req.request.url, strategy: strategy) do
+                  resp = nil
+                  multi.context do
+                    resp = multi.do(req)
+                  end.run
+                  
+                  resp
+                end.value!
+              }.to raise_error(Px::Service::ServiceError, 'Failed')
+            end
+          end
+
+          context 'when a response has been cached' do
+            before :each do
+              Typhoeus::Expectation.clear
+              Typhoeus.stub(url).and_return(successful_response)
+
+              req = subject.send(:make_request, 'get', url)
+
+              subject.cache_request(req.request.url, strategy: strategy) do
+                resp = nil
+                multi.context do
+                  resp = multi.do(req)
+                end.run
+
+                resp
+              end
+            end
+
+            it 'makes the request' do
+              called = false
+              req = subject.send(:make_request, 'get', url)
+              subject.cache_request(req.request.url, strategy: strategy) do
+                resp = nil
+                multi.context do
+                  resp = multi.do(req)
+                  called = true
+                end.run
+
+                resp
+              end
+
+              expect(called).to be_truthy
+            end
+
+            it 'returns the cached response' do
+              Typhoeus::Expectation.clear
+              Typhoeus.stub(url).and_return(response)
+              req = subject.send(:make_request, 'get', url)
+
+              expect(subject.cache_request(req.request.url, strategy: strategy) do
+                resp = nil
+                multi.context do
+                  resp = multi.do(req)
+                end.run
+                
+                resp
+              end.value!['code']).to eq(200)
+            end
+          end
+
+        end
+      end
+    end
   end
 end
+  

data/spec/px/service/client/caching/caching_spec.rb

@@ -2,32 +2,34 @@ require 'spec_helper'
 require 'dalli'
 
 describe Px::Service::Client::Caching do
+  let(:dalli_host) { ENV['PX_MEMCACHED_HOST'] }
+  let(:dalli_options) { { :namespace => "service-client-test", expires_in: 3600, compress: false, failover: false } }
+  let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
+
   subject {
     Class.new.include(Px::Service::Client::Caching).tap do |c|
       # Anonymous classes don't have a name.  Stub out :name so that things work
       allow(c).to receive(:name).and_return("Caching")
+
+      c.caching do |config|
+        config.cache_client = dalli
+      end
     end.new
   }
 
-  let(:dalli_host) { "localhost:11211" }
-  let(:dalli_options) { { :namespace => "service-client-test", expires_in: 3600, compress: false, failover: false } }
-  let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
+  let (:url) { "http://search/foo?bar=baz" }
+  let(:response) { { "response" => ["foo", "bar"], "status" => 200 } }
+  let(:entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', response) }
+  let(:strategy) { :none }
 
   before :each do
     dalli.flush_all
-    subject.cache_client = dalli
   end
 
-  let (:url) { "http://search/foo?bar=baz"}
-  let (:response) {
-    { "response" => ["foo", "bar"], "status" => 200 }
-  }
-
   shared_examples_for "a successful request" do
     it "should call the block" do
       called = false
-      subject.cache_request(url, strategy: strategy) do |u|
-        expect(u).to eq(url)
+      subject.cache_request(url, strategy: strategy) do
         called = true
       end
 
@@ -35,35 +37,35 @@ describe Px::Service::Client::Caching do
     end
 
     it "should return the block's return value" do
-      expect(subject.cache_request(url, strategy: strategy) { response }).to eq(response)
+      expect(subject.cache_request(url, strategy: strategy) do
+        response
+      end.value!).to eq(response)
     end
   end
 
   shared_examples_for "a failed uncacheable request" do
     it "should raise the exception raised by the block" do
-      expect{
+      expect {
         subject.cache_request(url, strategy: strategy) do
           # Px::Service::ServiceRequestError is not cachable
           # and does not trigger a fallback to a cached response
           raise Px::Service::ServiceRequestError.new("Error", 404)
-        end
+        end.value!
       }.to raise_error(Px::Service::ServiceRequestError)
     end
   end
 
   shared_examples_for "a request with no cached response" do
     it "raises the exception" do
-      expect {
+      expect { 
         subject.cache_request(url, strategy: strategy) do
           raise Px::Service::ServiceError.new("Error", 500)
-        end
+        end.value!
       }.to raise_error(Px::Service::ServiceError)
     end
   end
 
   context "when not caching" do
-    let(:strategy) { :none }
-
     it_behaves_like "a successful request"
     it_behaves_like "a failed uncacheable request"
   end
@@ -76,22 +78,20 @@ describe Px::Service::Client::Caching do
 
     context "when there is a cached response" do
       before :each do
-        subject.cache_request(url, strategy: strategy) do
-          response
-        end
+        Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
       end
 
       it "returns the cached response on failure" do
         expect(subject.cache_request(url, strategy: strategy) do
-          raise Px::Service::ServiceError.new("Error", 500)
-        end).to eq(response)
+          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+        end.value!).to eq(response)
       end
 
       it "does not returns the cached response on request error" do
         expect {
           subject.cache_request(url, strategy: strategy) do
-            raise Px::Service::ServiceRequestError.new("Error", 404)
-          end
+            Px::Service::Client::Future.new { raise Px::Service::ServiceRequestError.new("Error", 404) }
+          end.value!
         }.to raise_error(Px::Service::ServiceRequestError)
       end
 
@@ -99,7 +99,7 @@ describe Px::Service::Client::Caching do
         expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum))
 
         subject.cache_request(url, strategy: strategy) do
-          raise Px::Service::ServiceError.new("Error", 500)
+          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
         end
       end
     end
@@ -115,14 +115,13 @@ describe Px::Service::Client::Caching do
 
     context "when there is a cached response" do
       before :each do
-        subject.cache_request(url, strategy: strategy) do
-          response
-        end
+        Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
+        entry.expires_at = DateTime.now + 1.day
       end
 
       it "does not invoke the block" do
         called = false
-        subject.cache_request(url, strategy: strategy) do |u|
+        subject.cache_request(url, strategy: strategy) do
           called = true
         end
 
@@ -130,17 +129,16 @@ describe Px::Service::Client::Caching do
       end
 
       it "returns the response" do
-        expect(subject.cache_request(url, strategy: strategy) { nil }).to eq(response)
+        expect(subject.cache_request(url, strategy: strategy) do
+          nil
+        end.value!).to eq(response)
       end
     end
 
     context "when there is an expired cached response" do
       before :each do
-        Timecop.freeze(10.minutes.ago) do
-          subject.cache_request(url, strategy: strategy) do
-            response
-          end
-        end
+        Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
+        entry.expires_at = DateTime.now - 1.day
       end
 
       let (:response) { { "value" => "response" } }
@@ -155,7 +153,9 @@ describe Px::Service::Client::Caching do
       end
 
       it "returns the new response" do
-        expect(subject.cache_request(url, strategy: strategy) { response }).to eq(response)
+        expect(subject.cache_request(url, strategy: strategy) do
+          response
+        end.value!).to eq(response)
       end
 
       it "updates the cache entry before making the request" do
@@ -166,7 +166,9 @@ describe Px::Service::Client::Caching do
           called = false
           expect(subject.cache_request(url, strategy: strategy) do
             called = true
-          end).to eq(response)
+            response
+          end.value!).to eq(response)
+
           expect(called).to be_falsey
 
           response
@@ -178,20 +180,22 @@ describe Px::Service::Client::Caching do
           response
         end
 
-        expect(subject.cache_request(url, strategy: strategy) { nil }).to eq(response)
+        expect(subject.cache_request(url, strategy: strategy) do
+          nil
+        end.value).to eq(response)
       end
 
       it "returns the cached response on failure" do
         expect(subject.cache_request(url, strategy: strategy) do
-          raise Px::Service::ServiceError.new("Error", 500)
-        end).to eq(response)
+          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+        end.value!).to eq(response)
       end
 
       it "does not returns the cached response on request error" do
         expect {
           subject.cache_request(url, strategy: strategy) do
-            raise Px::Service::ServiceRequestError.new("Error", 404)
-          end
+            Px::Service::Client::Future.new { raise Px::Service::ServiceRequestError.new("Error", 404) }
+          end.value!
         }.to raise_error(Px::Service::ServiceRequestError)
       end
 
@@ -199,7 +203,7 @@ describe Px::Service::Client::Caching do
         expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum)).twice
 
         subject.cache_request(url, strategy: strategy) do
-          raise Px::Service::ServiceError.new("Error", 500)
+          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: px-service-client
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - Chris Micacchi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-15 00:00:00.000000000 Z
+date: 2016-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: will_paginate
@@ -283,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Common service client behaviours for Ruby applications