aptible-resource 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e0a4813794c67cf121e6e99aacdeb6d4658de77
-  data.tar.gz: 8a30600a2fe9e4b9aa5bcf1ef616af537d30f833
+  metadata.gz: f8992244b07c1cd292461871658dd5ba0b400f9a
+  data.tar.gz: 2b16f2fb43d9f60cd0993d9ee98f9d2528a7f249
 SHA512:
-  metadata.gz: c72824d53f2a8dc4933a824c733ac82858364d349ee223f1d5c46e491b759a2550c50cce746a5e49e8e5f512ae1eda1c8733ebfb82c7a0d5f655f7511b0624ec
-  data.tar.gz: b1570c06b61d5222484c0c2198ffb5f14be4bd599e95a3f534094de0fdce252e4a7bef172fc5f6e3b0f8fde9427e2ce2deab4146bd7443372c5dc6a27ec7f181
+  metadata.gz: 28bd9df8faea54c8e263e8e85da8f3543b397c438937ddcd9383db4b346bf445cc0ddbbbf6c9919c769a6c6d04b8da4e8f65b24dc3fad323576dbca25238bdbc
+  data.tar.gz: 81df2fcbaf1c1e2b98e5b8f99ac41e59fdec11e503c90ba9e6fd8f0fa2349505a2d5554c0adb3114f1b6a12a0cbdc9233fd6e6dded91d15b1181f9c8be1362e1

data/lib/aptible/resource/base.rb

@@ -1,18 +1,18 @@
 require 'fridge'
+require 'active_support/inflector'
 
 # Require vendored HyperResource
 $LOAD_PATH.unshift File.expand_path('../..', __FILE__)
 require 'hyper_resource'
 
 require 'aptible/resource/adapter'
-require 'aptible/resource/model'
+require 'aptible/resource/errors'
 
 module Aptible
   module Resource
+    # rubocop:disable ClassLength
     class Base < HyperResource
-      include Model
-
-      attr_accessor :token
+      attr_accessor :token, :errors
 
       def self.get_data_type_from_response(response)
         return nil unless response && response.body
@@ -23,6 +23,125 @@ module Aptible
         Aptible::Resource::Adapter
       end
 
+      def self.collection_href
+        "/#{basename}"
+      end
+
+      def self.basename
+        name.split('::').last.downcase.pluralize
+      end
+
+      def self.all(options = {})
+        resource = find_by_url(collection_href, options)
+        return [] unless resource
+        resource.send(basename).entries
+      end
+
+      def self.find(id, options = {})
+        find_by_url("#{collection_href}/#{id}", options)
+      end
+
+      def self.find_by_url(url, options = {})
+        # 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
+      end
+
+      def self.create!(params = {})
+        token = params.delete(:token)
+        resource = new(token: token)
+        resource.send(basename).create(normalize_params(params))
+      end
+
+      def self.create(params = {})
+        create!(params)
+      rescue HyperResource::ResponseError => e
+        new.tap { |resource| resource.errors = Errors.from_exception(e) }
+      end
+
+      # rubocop:disable PredicateName
+      def self.has_many(relation)
+        define_has_many_getter(relation)
+        define_has_many_setter(relation)
+      end
+      # rubocop:enable PredicateName
+
+      def self.field(name, options = {})
+        define_method name do
+          self.class.cast_field(attributes[name], options[:type])
+        end
+      end
+
+      def self.belongs_to(relation)
+        define_method relation do
+          get unless loaded
+          if (memoized = instance_variable_get("@#{relation}"))
+            memoized
+          elsif links[relation]
+            instance_variable_set("@#{relation}", links[relation].get)
+          end
+        end
+      end
+
+      # rubocop:disable PredicateName
+      def self.has_one(relation)
+        # Better than class << self + alias_method?
+        belongs_to(relation)
+      end
+      # rubocop:enable PredicateName
+
+      def self.define_has_many_getter(relation)
+        define_method relation do
+          get unless loaded
+          if (memoized = instance_variable_get("@#{relation}"))
+            memoized
+          elsif links[relation]
+            instance_variable_set("@#{relation}", links[relation].entries)
+          end
+        end
+      end
+
+      # rubocop:disable MethodLength
+      def self.define_has_many_setter(relation)
+        define_method "create_#{relation.to_s.singularize}!" do |params = {}|
+          get unless loaded
+          links[relation].create(self.class.normalize_params(params))
+        end
+
+        define_method "create_#{relation.to_s.singularize}" do |params = {}|
+          begin
+            send "create_#{relation.to_s.singularize}!", params
+          rescue HyperResource::ResponseError => e
+            Base.new(root: root_url, namespace: namespace).tap do |base|
+              base.errors = Errors.from_exception(e)
+            end
+          end
+        end
+      end
+      # rubocop:enable MethodLength
+
+      def self.normalize_params(params = {})
+        params_array = params.map do |key, value|
+          value.is_a?(HyperResource) ? [key, value.href] : [key, value]
+        end
+        Hash[params_array]
+      end
+
+      def self.cast_field(value, type)
+        if type == Time
+          Time.parse(value) if value
+        elsif type == DateTime
+          DateTime.parse(value) if value
+        else
+          value
+        end
+      end
+
       def initialize(options = {})
         if options.is_a?(Hash)
           self.token = options[:token]
@@ -63,8 +182,38 @@ module Aptible
         when String then token
         end
       end
+
+      alias_method :_hyperresource_update, :update
+      def update!(params)
+        _hyperresource_update(self.class.normalize_params(params))
+      rescue HyperResource::ResponseError => e
+        self.errors = Errors.from_exception(e)
+        raise e
+      end
+
+      def update(params)
+        update!(params)
+      rescue HyperResource::ResponseError
+        false
+      end
+
+      def delete
+        super
+      rescue HyperResource::ResponseError
+        # HyperResource/Faraday choke on empty response bodies
+        nil
+      end
+      alias_method :destroy, :delete
+
+      # NOTE: The following does not update the object in-place
+      def reload
+        self.class.find_by_url(href, headers: headers)
+      end
+
+      def errors
+        @errors ||= Aptible::Resource::Errors.new
+      end
     end
+    # rubocop:enable ClassLength
   end
 end
-
-require 'aptible/resource/token'

data/lib/aptible/resource/errors.rb

@@ -0,0 +1,24 @@
+module Aptible
+  module Resource
+    class Errors
+      attr_accessor :status_code, :messages, :full_messages
+
+      def self.from_exception(exception)
+        new.tap do |errors|
+          response_json = JSON.parse(exception.response.body)
+          errors.messages = { base: response_json['message'] }
+          errors.full_messages = [response_json['message']]
+          errors.status_code = exception.response.status
+        end
+      end
+
+      def messages
+        @messages ||= {}
+      end
+
+      def full_messages
+        @full_messages ||= []
+      end
+    end
+  end
+end

data/lib/aptible/resource/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module Resource
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/spec/aptible/resource/base_spec.rb

@@ -1,8 +1,107 @@
 require 'spec_helper'
 
 describe Aptible::Resource::Base do
+  let(:hyperresource_exception) { HyperResource::ResponseError.new('403') }
+  let(:error_response) { double 'Faraday::Response' }
+  before { hyperresource_exception.stub(:response) { error_response } }
+  before do
+    error_response.stub(:body) { { message: 'Forbidden' }.to_json }
+    error_response.stub(:status) { 403 }
+  end
+
   subject { Api.new }
 
+  describe '.collection_href' do
+    it 'should use the pluralized resource name' do
+      url = Api::Mainframe.collection_href
+      expect(url).to eq '/mainframes'
+    end
+  end
+
+  describe '.find' do
+    it 'should call find_by_url' do
+      url = '/mainframes/42'
+      expect(Api::Mainframe).to receive(:find_by_url).with url, {}
+      Api::Mainframe.find(42)
+    end
+  end
+
+  describe '.all' do
+    let(:mainframe) { double 'Mainframe' }
+    let(:collection) { double 'Api' }
+
+    before do
+      collection.stub(:mainframes) { [mainframe] }
+      Api::Mainframe.any_instance.stub(:find_by_url) { collection }
+    end
+
+    it 'should be an array' do
+      expect(Api::Mainframe.all).to be_a Array
+    end
+
+    it 'should return the root collection' do
+      expect(Api::Mainframe.all).to eq [mainframe]
+    end
+
+    it 'should pass options to the HyperResource initializer' do
+      klass = Api::Mainframe
+      options = { token: 'token' }
+      expect(klass).to receive(:new).with(options).and_return klass.new
+      Api::Mainframe.all(options)
+    end
+  end
+
+  describe '.create' do
+    let(:mainframe) { Api::Mainframe.new }
+    let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
+
+    before { Api.any_instance.stub(:mainframes) { mainframes_link } }
+    before { mainframes_link.stub(:create) { mainframe } }
+
+    it 'should create a new top-level resource' do
+      mainframes_link.stub(:create) { mainframe }
+      expect(mainframes_link).to receive(:create).with(foo: 'bar')
+      Api::Mainframe.create(foo: 'bar')
+    end
+
+    it 'should populate #errors in the event of an error' do
+      mainframes_link.stub(:create) { fail 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 }
+      expect(Api::Mainframe.create).to be_a Api::Mainframe
+    end
+
+    it 'should return the object in the event of successful creation' do
+      mainframes_link.stub(:create) { mainframe }
+      expect(Api::Mainframe.create).to eq mainframe
+    end
+  end
+
+  describe '.create!' do
+    let(:mainframe) { Api::Mainframe.new }
+    let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
+
+    before { Api.any_instance.stub(:mainframes) { mainframes_link } }
+    before { mainframes_link.stub(:create) { mainframe } }
+
+    it 'should pass through any exceptions' do
+      mainframes_link.stub(:create) { fail hyperresource_exception }
+      expect do
+        Api::Mainframe.create!
+      end.to raise_error HyperResource::ResponseError
+    end
+
+    it 'should return the object in the event of successful creation' do
+      mainframes_link.stub(:create) { mainframe }
+      expect(Api::Mainframe.create!).to eq mainframe
+    end
+  end
+
   describe '#initialize' do
     it 'should be a HyperResource instance' do
       expect(subject).to be_a HyperResource
@@ -33,4 +132,124 @@ describe Aptible::Resource::Base do
       expect(subject.bearer_token).to eq 'token'
     end
   end
+
+  describe '#errors' do
+    it 'should default to an empty error' do
+      expect(subject.errors).to be_a Aptible::Resource::Errors
+      expect(subject.errors.messages).to eq({})
+      expect(subject.errors.full_messages).to eq([])
+    end
+  end
+
+  describe '#update' do
+    it 'should populate #errors in the event of an error' do
+      HyperResource.any_instance.stub(:put) { fail 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 }
+      expect(subject.update({})).to eq false
+    end
+
+    it 'should return the object in the event of a successful update' do
+      HyperResource.any_instance.stub(:put) { subject }
+      expect(subject.update({})).to eq subject
+    end
+  end
+
+  describe '#update!' do
+    it 'should populate #errors in the event of an error' do
+      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      begin
+        subject.update!({})
+      rescue
+        # Allow errors to be populated and tested
+        nil
+      end
+      expect(subject.errors.messages).to eq(base: 'Forbidden')
+      expect(subject.errors.full_messages).to eq(['Forbidden'])
+    end
+
+    it 'should pass through any exceptions' do
+      HyperResource.any_instance.stub(:put) { fail hyperresource_exception }
+      expect do
+        subject.update!({})
+      end.to raise_error HyperResource::ResponseError
+    end
+
+    it 'should return the object in the event of a successful update' do
+      HyperResource.any_instance.stub(:put) { subject }
+      expect(subject.update!({})).to eq subject
+    end
+  end
+
+  context '.has_many' 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 } } }
+
+    describe '#create_#{relation}' do
+      it 'should populate #errors in the event of an error' do
+        mainframes_link.stub(:create) { fail 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 }
+        expect(subject.create_mainframe.class).to eq Aptible::Resource::Base
+      end
+
+      it 'should return the object in the event of successful creation' do
+        mainframes_link.stub(:create) { mainframe }
+        expect(subject.create_mainframe({})).to eq mainframe
+      end
+    end
+
+    describe '#create_#{relation}!' do
+      it 'should pass through any exceptions' do
+        mainframes_link.stub(:create) { fail hyperresource_exception }
+        expect do
+          subject.create_mainframe!({})
+        end.to raise_error HyperResource::ResponseError
+      end
+
+      it 'should return the object in the event of successful creation' do
+        mainframes_link.stub(:create) { mainframe }
+        expect(subject.create_mainframe!({})).to eq mainframe
+      end
+    end
+  end
+
+  context '.field' do
+    it 'should define a method for the field' do
+      Api.field :foo, type: String
+      expect(subject.respond_to?(:foo)).to be_true
+    end
+
+    it 'should return the raw attribute' do
+      Api.field :foo, type: String
+      subject.stub(:attributes) { { foo: 'bar' } }
+      expect(subject.foo).to eq 'bar'
+    end
+
+    it 'should parse the attribute if DateTime' do
+      Api.field :created_at, type: DateTime
+      subject.stub(:attributes) { { created_at: Time.now.to_json } }
+      expect(subject.created_at).to be_a DateTime
+    end
+
+    it 'should parse the attribute if Time' do
+      Api.field :created_at, type: Time
+      subject.stub(:attributes) { { created_at: Time.now.to_json } }
+      expect(subject.created_at).to be_a Time
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-resource
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-18 00:00:00.000000000 Z
+date: 2014-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uri_template
@@ -169,8 +169,7 @@ files:
 - lib/aptible/resource.rb
 - lib/aptible/resource/adapter.rb
 - lib/aptible/resource/base.rb
-- lib/aptible/resource/model.rb
-- lib/aptible/resource/token.rb
+- lib/aptible/resource/errors.rb
 - lib/aptible/resource/version.rb
 - lib/hyper_resource.rb
 - lib/hyper_resource/adapter.rb
@@ -185,7 +184,6 @@ files:
 - lib/hyper_resource/response.rb
 - lib/hyper_resource/version.rb
 - spec/aptible/resource/base_spec.rb
-- spec/aptible/resource/model_spec.rb
 - spec/fixtures/api.rb
 - spec/fixtures/mainframe.rb
 - spec/fixtures/token.rb
@@ -217,7 +215,6 @@ specification_version: 4
 summary: Foundation classes for Aptible resource server gems
 test_files:
 - spec/aptible/resource/base_spec.rb
-- spec/aptible/resource/model_spec.rb
 - spec/fixtures/api.rb
 - spec/fixtures/mainframe.rb
 - spec/fixtures/token.rb

data/lib/aptible/resource/model.rb

@@ -1,115 +0,0 @@
-require 'active_support/inflector'
-
-module Aptible
-  module Resource
-    module Model
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def collection_href
-          "/#{basename}"
-        end
-
-        def basename
-          name.split('::').last.downcase.pluralize
-        end
-
-        def all(options = {})
-          resource = find_by_url(collection_href, options)
-          return [] unless resource
-          resource.send(basename).entries
-        end
-
-        def find(id, options = {})
-          find_by_url("#{collection_href}/#{id}", options)
-        end
-
-        def find_by_url(url, options = {})
-          # 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
-        end
-
-        def create(params)
-          token = params.delete(:token)
-          resource = new(token: token)
-          resource.send(basename).create(normalize_params(params))
-        end
-
-        # rubocop:disable PredicateName
-        def has_many(relation)
-          define_has_many_getter(relation)
-          define_has_many_setter(relation)
-        end
-        # rubocop:enable PredicateName
-
-        def belongs_to(relation)
-          define_method relation do
-            get unless loaded
-            if (memoized = instance_variable_get("@#{relation}"))
-              memoized
-            elsif links[relation]
-              instance_variable_set("@#{relation}", links[relation].get)
-            end
-          end
-        end
-
-        # rubocop:disable PredicateName
-        def has_one(relation)
-          # Better than class << self + alias_method?
-          belongs_to(relation)
-        end
-        # rubocop:enable PredicateName
-
-        def define_has_many_getter(relation)
-          define_method relation do
-            get unless loaded
-            if (memoized = instance_variable_get("@#{relation}"))
-              memoized
-            elsif links[relation]
-              instance_variable_set("@#{relation}", links[relation].entries)
-            end
-          end
-        end
-
-        def define_has_many_setter(relation)
-          define_method "create_#{relation.to_s.singularize}" do |params = {}|
-            get unless loaded
-            links[relation].create(self.class.normalize_params(params))
-          end
-        end
-
-        def normalize_params(params = {})
-          params_array = params.map do |key, value|
-            value.is_a?(HyperResource) ? [key, value.href] : [key, value]
-          end
-          Hash[params_array]
-        end
-      end
-
-      def delete
-        # HyperResource/Faraday choke on empty response bodies
-        super
-      rescue HyperResource::ResponseError
-        nil
-      end
-      alias_method :destroy, :delete
-
-      def update(params)
-        super(self.class.normalize_params(params))
-      end
-
-      # NOTE: The following does not update the object in-place
-      def reload
-        self.class.find_by_url(href, headers: headers)
-      end
-    end
-  end
-end

data/lib/aptible/resource/token.rb

@@ -1,10 +0,0 @@
-require 'aptible/resource/base'
-
-# Skeleton class for token implementations to inherit from
-module Aptible
-  module Resource
-    class Token < Base
-      attr_accessor :access_token
-    end
-  end
-end

data/spec/aptible/resource/model_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe Aptible::Resource::Model do
-  subject { Api.new }
-
-  describe '.collection_href' do
-    it 'should use the pluralized resource name' do
-      url = Api::Mainframe.collection_href
-      expect(url).to eq '/mainframes'
-    end
-  end
-
-  describe '.find' do
-    it 'should call find_by_url' do
-      url = '/mainframes/42'
-      expect(Api::Mainframe).to receive(:find_by_url).with url, {}
-      Api::Mainframe.find(42)
-    end
-  end
-
-  describe '.all' do
-    let(:mainframe) { double 'Mainframe' }
-    let(:collection) { double 'Api' }
-
-    before do
-      collection.stub(:mainframes) { [mainframe] }
-      Api::Mainframe.any_instance.stub(:find_by_url) { collection }
-    end
-
-    it 'should be an array' do
-      expect(Api::Mainframe.all).to be_a Array
-    end
-
-    it 'should return the root collection' do
-      expect(Api::Mainframe.all).to eq [mainframe]
-    end
-
-    it 'should pass options to the HyperResource initializer' do
-      klass = Api::Mainframe
-      options = { token: 'token' }
-      expect(klass).to receive(:new).with(options).and_return klass.new
-      Api::Mainframe.all(options)
-    end
-  end
-
-  describe '.create' do
-    it 'should create a new top-level resource' do
-      mainframes = double 'Api'
-      Api.stub_chain(:new, :mainframes) { mainframes }
-      expect(mainframes).to receive(:create).with(foo: 'bar')
-      Api::Mainframe.create(foo: 'bar')
-    end
-  end
-end