aptible-resource 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31f491541f4e8330accd97a53c1896fe7fca26e2
-  data.tar.gz: fa2f72d22a0736be3d38d61d4731e7582ef64c78
+  metadata.gz: 077c3b938aed411e3c460ba3e0fe7f01ccf1cd52
+  data.tar.gz: 66a968ab57d1f73170cc960f9f547e9fd231dc2d
 SHA512:
-  metadata.gz: ea9ed96d16623b924cc4bbd463e128bab5d8ce1463a10451faa3de64be1b079c88aec56efad7ad079b7fea3877cd906c9bae5b24b2048d08ad99bdfa5f23a4a0
-  data.tar.gz: 406299c0d2a4cff3faca28f86c736374a27f38cde09ea6d050a127f74853e6d5916477d4bf03cc5feb228a4ee9cc7c8151151dbace303c8f44fab0a847c8333b
+  metadata.gz: 39b3ecc5f467482ea95b45f6408bb2c0e10fb8a0050ad249118d1604c9819d0349ea09c4662e18731a9e3598c2e6f7cd177049a8e9191a2ddc5fc23bd499eb31
+  data.tar.gz: 8fc0837539473ea9c07e6892f0b5748270c93ecf805d1b2ee33e54bc2eaec6572df337f5a00a86e0031f822d49a4baf5db3cf714f7747259392f6ac0cd2965c7

data/aptible-resource.gemspec

@@ -25,7 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'json'
 
   spec.add_dependency 'fridge'
-  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activesupport', '~> 4.0'
+  spec.add_dependency 'gem_config', '~> 0.3.1'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'aptible-tasks'

data/lib/aptible/resource.rb

@@ -1,7 +1,20 @@
 require 'aptible/resource/version'
 require 'aptible/resource/base'
+require 'aptible/resource/default_retry_coordinator'
+require 'gem_config'
 
 module Aptible
   module Resource
+    include GemConfig::Base
+
+    with_configuration do
+      has :retry_coordinator_class,
+          classes: [Class],
+          default: DefaultRetryCoordinator
+
+      has :user_agent,
+          classes: [String],
+          default: "aptible-resource #{Aptible::Resource::VERSION}"
+    end
   end
 end

data/lib/aptible/resource/base.rb

@@ -19,7 +19,8 @@ module Aptible
   module Resource
     # rubocop:disable ClassLength
     class Base < HyperResource
-      attr_accessor :token, :errors
+      attr_accessor :errors
+      attr_reader :token
 
       def self.get_data_type_from_response(response)
         return nil unless response && response.body
@@ -79,11 +80,8 @@ module Aptible
         # REVIEW: Should exception be raised if return type mismatch?
         new(options).find_by_url(url)
       rescue HyperResource::ClientError => e
-        if e.response.status == 404
-          return nil
-        else
-          raise e
-        end
+        return nil if e.response.status == 404
+        raise e
       end
 
       def self.create!(params = {})
@@ -146,6 +144,7 @@ module Aptible
             memoized
           elsif links[relation]
             depaginated = self.class.all(href: links[relation].base_href,
+                                         token: token,
                                          headers: headers)
             instance_variable_set("@#{relation}", depaginated)
           end
@@ -154,6 +153,7 @@ module Aptible
         define_method "each_#{relation.to_s.singularize}" do |&block|
           return if block.nil?
           self.class.each_page(href: links[relation].base_href,
+                               token: token,
                                headers: headers) do |page|
             page.each { |entry| block.call entry }
           end
@@ -225,12 +225,11 @@ module Aptible
       end
 
       def initialize(options = {})
-        if options.is_a?(Hash)
-          self.token = options[:token]
-          populate_default_options!(options)
-        end
+        return super(options) unless options.is_a?(Hash)
 
+        populate_default_options!(options)
         super(options)
+        self.token = options[:token] if options[:token]
       end
 
       def populate_default_options!(options)
@@ -238,8 +237,11 @@ module Aptible
         options[:namespace] ||= namespace
         options[:headers] ||= {}
         options[:headers]['Content-Type'] = 'application/json'
-        return unless options[:token]
-        options[:headers]['Authorization'] = "Bearer #{bearer_token}"
+      end
+
+      def token=(val)
+        @token = val
+        headers['Authorization'] = "Bearer #{bearer_token}"
       end
 
       def adapter
@@ -247,11 +249,11 @@ module Aptible
       end
 
       def namespace
-        fail 'Resource server namespace must be defined by subclass'
+        raise 'Resource server namespace must be defined by subclass'
       end
 
       def root_url
-        fail 'Resource server root URL must be defined by subclass'
+        raise 'Resource server root URL must be defined by subclass'
       end
 
       def find_by_url(url_or_href)
@@ -268,7 +270,10 @@ module Aptible
         end
       end
 
+      # rubocop:disable Style/Alias
       alias_method :_hyperresource_update, :update
+      # rubocop:enable Style/Alias
+
       def update!(params)
         _hyperresource_update(self.class.normalize_params(params))
       rescue HyperResource::ResponseError => e
@@ -288,11 +293,14 @@ module Aptible
         # HyperResource/Faraday choke on empty response bodies
         nil
       end
+
+      # rubocop:disable Style/Alias
       alias_method :destroy, :delete
+      # rubocop:enable Style/Alias
 
       # NOTE: The following does not update the object in-place
       def reload
-        self.class.find_by_url(href, headers: headers)
+        self.class.find_by_url(href, token: token, headers: headers)
       end
 
       def errors

data/lib/aptible/resource/default_retry_coordinator.rb

@@ -0,0 +1,15 @@
+module Aptible
+  module Resource
+    class DefaultRetryCoordinator
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def retry?(_error)
+        false
+      end
+    end
+  end
+end

data/lib/aptible/resource/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module Resource
-    VERSION = '0.3.6'
+    VERSION = '0.3.7'.freeze
   end
 end

data/lib/hyper_resource.rb

@@ -199,6 +199,7 @@ public
                    :headers         => self.headers,
                    :namespace       => self.namespace,
                    :faraday_options => self.faraday_options,
+                   :token           => self.token,
                    :href            => href)
   end
 

data/lib/hyper_resource/adapter/hal_json.rb

@@ -48,6 +48,7 @@ class HyperResource
             if collection.is_a? Hash
               r = rc.new(:root => rsrc.root,
                          :headers => rsrc.headers,
+                         :token => rsrc.token,
                          :namespace => rsrc.namespace)
               r.body = collection
               r = classify(collection, r)
@@ -56,6 +57,7 @@ class HyperResource
               objs[name] = collection.map do |obj|
                 r = rc.new(:root => rsrc.root,
                            :headers => rsrc.headers,
+                           :token => rsrc.token,
                            :namespace => rsrc.namespace)
                 r.body = obj
                 r = classify(obj, r)
@@ -73,8 +75,10 @@ class HyperResource
           klass = rsrc.class.namespaced_class(type_name, namespace)
 
           if klass
+            # TODO: Why does this not use klass.new(rsrc)?
             rsrc = klass.new(:root => rsrc.root,
                              :headers => rsrc.headers,
+                             :token => rsrc.token,
                              :namespace => rsrc.namespace)
             rsrc.body = resp
           end

data/lib/hyper_resource/modules/http.rb

@@ -6,13 +6,16 @@ require 'digest/md5'
 class HyperResource
   module Modules
     module HTTP
+      # A (high) limit to the number of retries a coordinator can ask for. This
+      # is to avoid breaking things if we have a buggy coordinator that retries
+      # things over and over again.
+      MAX_COORDINATOR_RETRIES = 16
 
       ## Loads and returns the resource pointed to by +href+.  The returned
       ## resource will be blessed into its "proper" class, if
       ## +self.class.namespace != nil+.
       def get
-        self.response = faraday_connection.get(self.href || '')
-        finish_up
+        execute_request { faraday_connection.get(href || '') }
       end
 
       ## By default, calls +post+ with the given arguments. Override to
@@ -23,12 +26,11 @@ class HyperResource
 
       ## POSTs the given attributes to this resource's href, and returns
       ## the response resource.
-      def post(attrs=nil)
-        attrs || self.attributes
-        self.response = faraday_connection.post do |req|
-          req.body = adapter.serialize(attrs)
+      def post(attrs = nil)
+        attrs ||= attributes
+        execute_request do
+          faraday_connection.post { |req| req.body = adapter.serialize(attrs) }
         end
-        finish_up
       end
 
       ## By default, calls +put+ with the given arguments.  Override to
@@ -40,48 +42,39 @@ class HyperResource
       ## PUTs this resource's attributes to this resource's href, and returns
       ## the response resource.  If attributes are given, +put+ uses those
       ## instead.
-      def put(attrs=nil)
-        attrs ||= self.attributes
-        self.response = faraday_connection.put do |req|
-          req.body = adapter.serialize(attrs)
+      def put(attrs = nil)
+        attrs ||= attributes
+        execute_request do
+          faraday_connection.put { |req| req.body = adapter.serialize(attrs) }
         end
-        finish_up
       end
 
       ## PATCHes this resource's changed attributes to this resource's href,
       ## and returns the response resource.  If attributes are given, +patch+
       ## uses those instead.
-      def patch(attrs=nil)
-        attrs ||= self.attributes.changed_attributes
-        self.response = faraday_connection.patch do |req|
-          req.body = adapter.serialize(attrs)
+      def patch(attrs = nil)
+        attrs ||= attributes.changed_attributes
+        execute_request do
+          faraday_connection.patch { |req| req.body = adapter.serialize(attrs) }
         end
-        finish_up
       end
 
       ## DELETEs this resource's href, and returns the response resource.
       def delete
-        self.response = faraday_connection.delete
-        finish_up
+        execute_request { faraday_connection.delete }
       end
 
       ## Returns a raw Faraday connection to this resource's URL, with proper
-      ## headers (including auth).  Threadsafe.
-      def faraday_connection(url=nil)
-        url ||= URI.join(self.root, self.href)
-        key = Digest::MD5.hexdigest({
-          'faraday_connection' => {
-            'url' => url,
-            'headers' => self.headers,
-            'ba' => self.auth[:basic]
-          }
-        }.to_json)
-        return Thread.current[key] if Thread.current[key]
-
-        fc = Faraday.new(self.faraday_options.merge(:url => url)) do |builder|
-          builder.headers.merge!('User-Agent' => "HyperResource #{HyperResource::VERSION}")
-          builder.headers.merge!(self.headers || {})
-          if (ba = self.auth[:basic])
+      ## headers (including auth).
+      def faraday_connection(url = nil)
+        url ||= URI.join(root, href)
+
+        Faraday.new(faraday_options.merge(url: url)) do |builder|
+          builder.headers.merge!(headers || {})
+          builder.headers['User-Agent'] = Aptible::Resource.configuration
+                                                           .user_agent
+
+          if (ba = auth[:basic])
             builder.basic_auth(*ba)
           end
 
@@ -89,49 +82,66 @@ class HyperResource
           builder.request :retry
           builder.adapter Faraday.default_adapter
         end
-
-        Thread.current[key] = fc
       end
 
-    private
+      private
+
+      def execute_request
+        raise 'execute_request needs a block!' unless block_given?
+        retry_coordinator = Aptible::Resource.configuration
+                                             .retry_coordinator_class.new(self)
+
+        n_retry = 0
+        begin
+          finish_up(yield)
+        rescue HyperResource::ResponseError => e
+          n_retry += 1
+          raise e if n_retry > MAX_COORDINATOR_RETRIES
+          retry if retry_coordinator.retry?(e)
+          raise e
+        end
+      end
 
-      def finish_up
+      def finish_up(response)
         begin
-          self.body = self.adapter.deserialize(self.response.body) unless self.response.body.nil?
+          body = adapter.deserialize(response.body) unless response.body.nil?
         rescue StandardError => e
           raise HyperResource::ResponseError.new(
-            "Error when deserializing response body",
-            :response => self.response,
-            :cause => e
+            'Error when deserializing response body',
+            response: response,
+            cause: e
           )
         end
 
-        self.adapter.apply(self.body, self)
-        self.loaded = true
-
-        status = self.response.status
+        status = response.status
         if status / 100 == 2
-          return to_response_class
         elsif status / 100 == 3
-          ## TODO redirect logic?
+          raise 'HyperResource does not handle redirects'
         elsif status / 100 == 4
           raise HyperResource::ClientError.new(status.to_s,
-                                               :response => self.response,
-                                               :body => self.body)
+                                               response: response,
+                                               body: body)
         elsif status / 100 == 5
           raise HyperResource::ServerError.new(status.to_s,
-                                               :response => self.response,
-                                               :body => self.body)
+                                               response: response,
+                                               body: body)
 
         else ## 1xx? really?
           raise HyperResource::ResponseError.new("Got status #{status}, wtf?",
-                                                 :response => self.response,
-                                                 :body => self.body)
+                                                 response: response,
+                                                 body: body)
 
         end
-      end
 
+        # Unfortunately, HyperResource insists on having response and body
+        # be attributes..
+        self.response = response
+        self.body = body
+        adapter.apply(body, self)
+        self.loaded = true
+
+        to_response_class
+      end
     end
   end
 end
-

data/lib/hyper_resource/modules/internal_attributes.rb

@@ -38,6 +38,7 @@ module HyperResource::Modules
           :namespace,
           :adapter,
           :faraday_options,
+          :token,
 
           :request,
           :response,

data/lib/hyper_resource/version.rb

@@ -1,4 +1,4 @@
 class HyperResource
-  VERSION = '0.2.5'
-  VERSION_DATE = '2014-04-02'
+  VERSION = '0.2.5'.freeze
+  VERSION_DATE = '2014-04-02'.freeze
 end

data/spec/aptible/resource/base_spec.rb

@@ -35,7 +35,7 @@ describe Aptible::Resource::Base do
         allow_any_instance_of(klass).to receive(:find_by_url) do |u, _|
           calls << u
           page = pages[u]
-          fail "Accessed unexpected URL #{u}" if page.nil?
+          raise "Accessed unexpected URL #{u}" if page.nil?
           page
         end
       end
@@ -146,14 +146,14 @@ describe Aptible::Resource::Base do
     end
 
     it 'should populate #errors in the event of an error' do
-      mainframes_link.stub(:create) { fail hyperresource_exception }
+      mainframes_link.stub(:create) { raise hyperresource_exception }
       mainframe = Api::Mainframe.create
       expect(mainframe.errors.messages).to eq(base: 'Forbidden')
       expect(mainframe.errors.full_messages).to eq(['Forbidden'])
     end
 
     it 'should return a Base-classed resource on error' do
-      mainframes_link.stub(:create) { fail hyperresource_exception }
+      mainframes_link.stub(:create) { raise hyperresource_exception }
       expect(Api::Mainframe.create).to be_a Api::Mainframe
     end
 
@@ -171,7 +171,7 @@ describe Aptible::Resource::Base do
     before { mainframes_link.stub(:create) { mainframe } }
 
     it 'should pass through any exceptions' do
-      mainframes_link.stub(:create) { fail hyperresource_exception }
+      mainframes_link.stub(:create) { raise hyperresource_exception }
       expect do
         Api::Mainframe.create!
       end.to raise_error HyperResource::ResponseError
@@ -224,14 +224,14 @@ describe Aptible::Resource::Base do
 
   describe '#update' do
     it 'should populate #errors in the event of an error' do
-      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
       subject.update({})
       expect(subject.errors.messages).to eq(base: 'Forbidden')
       expect(subject.errors.full_messages).to eq(['Forbidden'])
     end
 
     it 'should return false in the event of an error' do
-      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
       expect(subject.update({})).to eq false
     end
 
@@ -243,7 +243,7 @@ describe Aptible::Resource::Base do
 
   describe '#update!' do
     it 'should populate #errors in the event of an error' do
-      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
       begin
         subject.update!({})
       rescue
@@ -255,7 +255,7 @@ describe Aptible::Resource::Base do
     end
 
     it 'should pass through any exceptions' do
-      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
       expect do
         subject.update!({})
       end.to raise_error HyperResource::ResponseError
@@ -271,7 +271,6 @@ describe Aptible::Resource::Base do
     let(:mainframe) { Api::Mainframe.new }
     let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
 
-    before { Api.has_many :mainframes }
     before { subject.stub(:loaded) { true } }
     before { subject.stub(:links) { { mainframes: mainframes_link } } }
     before { mainframes_link.stub(:entries) { [mainframe] } }
@@ -279,19 +278,19 @@ describe Aptible::Resource::Base do
 
     describe '#create_#{relation}' do
       it 'should populate #errors in the event of an error' do
-        mainframes_link.stub(:create) { fail hyperresource_exception }
+        mainframes_link.stub(:create) { raise hyperresource_exception }
         mainframe = subject.create_mainframe({})
         expect(mainframe.errors.messages).to eq(base: 'Forbidden')
         expect(mainframe.errors.full_messages).to eq(['Forbidden'])
       end
 
       it 'should return a Base-classed resource on error' do
-        mainframes_link.stub(:create) { fail hyperresource_exception }
+        mainframes_link.stub(:create) { raise hyperresource_exception }
         expect(subject.create_mainframe.class).to eq Aptible::Resource::Base
       end
 
       it 'should have errors present on error' do
-        mainframes_link.stub(:create) { fail hyperresource_exception }
+        mainframes_link.stub(:create) { raise hyperresource_exception }
         expect(subject.create_mainframe.errors.any?).to be true
       end
 
@@ -308,7 +307,7 @@ describe Aptible::Resource::Base do
 
     describe '#create_#{relation}!' do
       it 'should pass through any exceptions' do
-        mainframes_link.stub(:create) { fail hyperresource_exception }
+        mainframes_link.stub(:create) { raise hyperresource_exception }
         expect do
           subject.create_mainframe!({})
         end.to raise_error HyperResource::ResponseError
@@ -387,4 +386,199 @@ describe Aptible::Resource::Base do
       expect(subject.awesome?).to be true
     end
   end
+
+  context 'configuration' do
+    subject { Api.new(root: 'http://foo.com') }
+
+    def configure_new_coordinator(&block)
+      Aptible::Resource.configure do |config|
+        config.retry_coordinator_class = \
+          Class.new(Aptible::Resource::DefaultRetryCoordinator) do
+            instance_exec(&block)
+          end
+      end
+    end
+
+    context 'retry_coordinator_class' do
+      it 'should not retry if the proc returns false' do
+        configure_new_coordinator { define_method(:retry?) { |_e| false } }
+
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401).then
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+        expect { subject.get.body }
+          .to raise_error(HyperResource::ClientError, /foo/)
+      end
+
+      it 'should retry if the proc returns true' do
+        configure_new_coordinator { define_method(:retry?) { |_e| true } }
+
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401).then
+          .to_return(body: { error: 'foo' }.to_json, status: 401).then
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+        expect(subject.get.body).to eq('status' => 'ok')
+      end
+
+      it 'should not retry if the request succeeds' do
+        failures = 0
+
+        configure_new_coordinator do
+          define_method(:retry?) { |_e| failures += 1 || true }
+        end
+
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401).then
+          .to_return(body: { status: 'ok' }.to_json, status: 200).then
+          .to_return(body: { error: 'foo' }.to_json, status: 401)
+
+        expect(subject.get.body).to eq('status' => 'ok')
+
+        expect(failures).to eq(1)
+      end
+
+      it 'should not retry with the default proc' do
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401).then
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+        expect { subject.get.body }
+          .to raise_error(HyperResource::ClientError, /foo/)
+      end
+
+      it 'should pass the resource in constructor and exception in method' do
+        resource = nil
+        exception = nil
+
+        configure_new_coordinator do
+          define_method(:initialize) { |r| resource = r }
+          define_method(:retry?) { |e| (exception = e) && false }
+        end
+
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401)
+
+        expect { subject.get.body }
+          .to raise_error(HyperResource::ClientError, /foo/)
+
+        expect(resource).to be_a(Api)
+        expect(exception).to be_a(HyperResource::ClientError)
+      end
+
+      it 'should let the coordinator change e.g. the request token' do
+        subject.token = 'foo'
+        retry_was_called = false
+
+        configure_new_coordinator do
+          define_method(:retry?) do |_e|
+            resource.token = 'bar'
+            # resource.headers['Authorization'] = 'Bearer bar'
+            retry_was_called = true
+          end
+        end
+
+        stub_request(:get, 'foo.com')
+          .with(headers: { 'Authorization' => /foo/ })
+          .to_return(body: { error: 'foo' }.to_json, status: 401)
+
+        stub_request(:get, 'foo.com')
+          .with(headers: { 'Authorization' => /bar/ })
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+        expect(subject.get.body).to eq('status' => 'ok')
+        expect(retry_was_called).to be_truthy
+      end
+
+      it 'should eventually fail even if the coordinator wants to retry' do
+        n = 0
+
+        configure_new_coordinator do
+          define_method(:retry?) { |_e| n += 1 || true }
+        end
+
+        stub_request(:get, 'foo.com')
+          .to_return(body: { error: 'foo' }.to_json, status: 401)
+
+        expect { subject.get.body }
+          .to raise_error(HyperResource::ClientError, /foo/)
+
+        expect(n).to eq(HyperResource::Modules::HTTP::MAX_COORDINATOR_RETRIES)
+      end
+    end
+
+    context 'user_agent' do
+      it 'should update the user agent' do
+        Aptible::Resource.configure do |config|
+          config.user_agent = 'foo ua'
+        end
+
+        stub_request(:get, 'foo.com')
+          .with(headers: { 'User-Agent' => 'foo ua' })
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+        expect(subject.get.body).to eq('status' => 'ok')
+      end
+    end
+  end
+
+  context 'token' do
+    subject { Api.new(root: 'http://foo.com', token: 'bar') }
+
+    before do
+      stub_request(:get, 'foo.com/')
+        .with(headers: { 'Authorization' => /Bearer (bar|foo)/ })
+        .to_return(body: {
+          _links: { some: { href: 'http://foo.com/some' },
+                    mainframes: { href: 'http://foo.com/mainframes' } },
+          _embedded: { best_mainframe: { _type: 'mainframe', status: 'ok' } }
+        }.to_json, status: 200)
+
+      stub_request(:get, 'foo.com/some')
+        .with(headers: { 'Authorization' => /Bearer (bar|foo)/ })
+        .to_return(body: { status: 'ok' }.to_json, status: 200)
+
+      stub_request(:get, 'foo.com/mainframes')
+        .with(headers: { 'Authorization' => /Bearer (bar|foo)/ })
+        .to_return(body: { _embedded: {
+          mainframes: [{ status: 'ok' }]
+        } }.to_json, status: 200)
+    end
+
+    it 'should persist the Authorization header when following links' do
+      expect(subject.some.get.body).to eq('status' => 'ok')
+    end
+
+    it 'should persist the token when following links' do
+      expect(subject.some.token).to eq('bar')
+      expect(subject.some.headers['Authorization']).to eq('Bearer bar')
+    end
+
+    it 'should set the Authorization header when setting the token' do
+      subject.token = 'foo'
+
+      expect(subject.some.token).to eq('foo')
+      expect(subject.some.headers['Authorization']).to eq('Bearer foo')
+    end
+
+    it 'should persist the token and set the Authorization header when ' \
+       'initializing from resource' do
+      subject.get
+      r = Api.new(subject)
+
+      expect(r.token).to eq('bar')
+      expect(r.headers['Authorization']).to eq('Bearer bar')
+    end
+
+    it 'should persist the token when accessing a related collection' do
+      m = subject.mainframes.first
+      expect(m.token).to eq('bar')
+    end
+
+    it 'should persist the token when accessing a named embedded object' do
+      m = subject.best_mainframe
+      expect(m.token).to eq('bar')
+    end
+  end
 end

data/spec/aptible/resource/network_spec.rb

@@ -9,12 +9,6 @@ describe Aptible::Resource::Base do
   subject { Api.new(root: "http://#{domain}") }
 
   context 'with mock connections' do
-    around do |example|
-      WebMock.disable_net_connect!
-      example.run
-      WebMock.allow_net_connect!
-    end
-
     it 'should retry timeout errors' do
       stub_request(:get, domain)
         .to_timeout.then
@@ -34,6 +28,12 @@ describe Aptible::Resource::Base do
   end
 
   context 'without connections' do
+    around do |example|
+      WebMock.allow_net_connect!
+      example.run
+      WebMock.disable_net_connect!
+    end
+
     it 'default to 10 seconds of timeout and retry 3 times' do
       # This really relies on how exactly MRI implements Net::HTTP open timeouts
       skip 'MRI implementation-specific' if RUBY_PLATFORM == 'java'

data/spec/fixtures/api.rb

@@ -1,6 +1,9 @@
 require 'aptible/resource'
 
 class Api < Aptible::Resource::Base
+  has_many :mainframes
+  embeds_one :best_mainframe
+
   def namespace
     'Api'
   end

data/spec/spec_helper.rb

@@ -15,4 +15,9 @@ require 'aptible/resource'
 
 # Webmock
 require 'webmock/rspec'
-WebMock.allow_net_connect!
+WebMock.disable_net_connect!
+
+RSpec.configure do |config|
+  config.before { Aptible::Resource.configuration.reset }
+  config.before { WebMock.reset! }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-resource
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uri_template
@@ -70,16 +70,30 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: gem_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +198,7 @@ files:
 - lib/aptible/resource/adapter.rb
 - lib/aptible/resource/base.rb
 - lib/aptible/resource/boolean.rb
+- lib/aptible/resource/default_retry_coordinator.rb
 - lib/aptible/resource/errors.rb
 - lib/aptible/resource/ext/faraday.rb
 - lib/aptible/resource/version.rb
@@ -225,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Foundation classes for Aptible resource server gems