protip 0.9.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f3d97797f1ded3cce21e24d653a5960c292f3af
+  data.tar.gz: d1fa2cea1e89f3fdb5ebf9be570e5dde1144397a
+SHA512:
+  metadata.gz: 5775bd4b337ab6d1f31ea6de1c0fc3d2b2f07a8075dda4bdcdb0581b69dd61b5154d1dd5bffd7dbfc069e34d8bd533740411d3cb97e107657ee433d8729c35c4
+  data.tar.gz: 496f91676d206299a1ebbc4328722be7976b685d1d02988ac44a76472519e19e740896a6abb9f93d8d46a600a46aee2d9cae4ecf4dc34fb7ae45b8d8d945f688

data/lib/protip.rb

@@ -0,0 +1,7 @@
+require 'protip/client'
+require 'protip/resource'
+
+# Register the mime type with Rails, if Rails exists.
+if defined?(Mime::Type)
+  Mime::Type.register 'application/x-protobuf', :protobuf
+end

data/lib/protip/client.rb

@@ -0,0 +1,68 @@
+require 'protip/error'
+require 'net/http'
+
+module Protip
+  module Client
+    extend ActiveSupport::Concern
+
+    attr_accessor :base_uri
+
+    # Makes a request and parses the response as a message of the given type.
+    # For internal use only; use the appropriate resource to make your requests.
+    #
+    # @param path [String] the URI path (exluding the base URI)
+    # @param method [Class] the HTTP method (e.g. `::Net::HTTP::Get`, `::Net::HTTP::Post`)
+    # @param message [Protobuf::Message|nil] the message to send as the request body
+    # @param response_type [Class] the `::Protobuf::Message` subclass that should be
+    #   expected as a response
+    # @return [::Protobuf::Message] the decoded response from the server
+    def request(path:, method:, message:, response_type:)
+
+      raise RuntimeError.new('base_uri is not set') unless base_uri
+
+      uri = URI.join base_uri, path
+
+      request                 = method.new uri
+      request.body            = (message == nil ? nil : message.encode)
+      request['Accept']       = 'application/x-protobuf'
+      request.content_type    = 'application/x-protobuf'
+
+      prepare_request(request)
+
+      # TODO: Shared connection object for persisent connections.
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request request
+      end
+
+      if response.is_a?(Net::HTTPUnprocessableEntity)
+        raise ::Protip::UnprocessableEntityError.new(request, response)
+      elsif response.is_a?(Net::HTTPNotFound)
+        raise ::Protip::NotFoundError.new(request, response)
+      elsif !response.is_a?(Net::HTTPSuccess)
+        raise ::Protip::Error.new(request, response)
+      end
+
+      if response_type
+        begin
+          response_type.decode response.body
+        # NotImplementedError catches the "Group is deprecated" exception raised by protobuf on some bad inputs.
+        # We may be able to remove it if we switch to a different protobuf gem.
+        rescue StandardError, NotImplementedError => error
+          raise ::Protip::ParseError.new error, request, response
+        end
+      else
+        nil
+      end
+    end
+
+    private
+
+    # Invoked just before a request is sent to the API server. No-op by default, but
+    # implementations can override to add e.g. secret keys and user agent headers.
+    #
+    # @param request [Net::HTTPGenericRequest] the raw request object which is about to be sent
+    def prepare_request(request)
+      # No-op by default.
+    end
+  end
+end

data/lib/protip/error.rb

@@ -0,0 +1,37 @@
+# Missing dependency from the protobuf require
+require 'protobuf'
+
+require 'protip/messages/errors.pb'
+
+module Protip
+  class Error < RuntimeError
+    attr_reader :request, :response
+    def initialize(request, response)
+      @request = request
+      @response = response
+    end
+
+    def inspect
+      "[#{self.class}] #{request.uri} -> code #{response.code}"
+    end
+  end
+
+  class ParseError < Error
+    attr_reader :original_error
+    def initialize(original_error, *args)
+      super(*args)
+      @original_error = original_error
+    end
+  end
+
+  class UnprocessableEntityError < Error
+    # Get the parsed errors object from a 422 response.
+    #
+    # @return ::Protip::Messages::Errors
+    def errors
+      ::Protip::Messages::Errors.decode response.body
+    end
+  end
+
+  class NotFoundError < Error ; end
+end

data/lib/protip/messages/array.pb.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Protip
+  module Messages
+
+    ##
+    # Message Classes
+    #
+    class Array < ::Protobuf::Message; end
+
+
+    ##
+    # Message Fields
+    #
+    class Array
+      repeated :bytes, :messages, 1
+    end
+
+  end
+
+end
+

data/lib/protip/messages/errors.pb.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Protip
+  module Messages
+
+    ##
+    # Message Classes
+    #
+    class Errors < ::Protobuf::Message; end
+    class FieldError < ::Protobuf::Message; end
+
+
+    ##
+    # Message Fields
+    #
+    class Errors
+      repeated :string, :messages, 1
+      repeated ::Protip::Messages::FieldError, :field_errors, 2
+    end
+
+    class FieldError
+      optional :string, :field, 1
+      optional :string, :message, 2
+    end
+
+  end
+
+end
+

data/lib/protip/resource.rb

@@ -0,0 +1,273 @@
+# Missing dependencies from the other requires
+require 'active_model/callbacks'
+require 'active_model/validator'
+require 'active_support/callbacks'
+require 'active_support/core_ext/module/delegation'
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+require 'active_model/validations'
+require 'active_model/conversion'
+require 'active_model/naming'
+require 'active_model/translation'
+require 'active_model/errors'
+
+require 'protip/error'
+
+require 'protip/messages/array.pb'
+
+module Protip
+  module Resource
+
+    # Internal handlers for index/show actions. Never use these directly; instead, use `.all` and
+    # `.find` on the resource you're working with, since those methods will adjust their
+    # signatures to correctly parse a set of query parameters if supported.
+    module SearchMethods
+      # Fetch a list from the server at the collection's base endpoint. Expects the server response
+      # to be an array containing encoded messages that can be used to instantiate our resource.
+      #
+      # @param resource_class [Class] The resource type that we're fetching.
+      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
+      # @return [Array] The array of resources (each is an instance of the resource class we were
+      #   initialized with).
+      def self.index(resource_class, query)
+        response = resource_class.client.request path: resource_class.base_path,
+          method: Net::HTTP::Get,
+          message: query,
+          response_type: Protip::Messages::Array
+        response.messages.map do |message|
+          resource_class.new resource_class.message.decode(message)
+        end
+      end
+
+      # Fetch a single resource from the server.
+      #
+      # @param resource_class [Class] The resource type that we're fetching.
+      # @param id [String] The ID to be used in the URL to fetch the resource.
+      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
+      # @return [Protip::Resource] An instance of our resource class, created from the server
+      #   response.
+      def self.show(resource_class, id, query)
+        response = resource_class.client.request path: "#{resource_class.base_path}/#{id}",
+          method: Net::HTTP::Get,
+          message: query,
+          response_type: resource_class.message
+        resource_class.new response
+      end
+    end
+
+    # Mixin for a resource that has an active `:create` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Creatable
+      private
+      # POST the resource to the server and update our internal message. Private, since
+      # we should generally do this through the `save` method.
+      def create!
+        raise RuntimeError.new("Can't re-create a persisted object") if persisted?
+        @message = self.class.client.request path: self.class.base_path,
+          method: Net::HTTP::Post,
+          message: message,
+          response_type: self.class.message
+      end
+    end
+
+    # Mixin for a resource that has an active `:update` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Updatable
+      private
+      # PUT the resource on the server and update our internal message. Private, since
+      # we should generally do this through the `save` method.
+      def update!
+        raise RuntimeError.new("Can't update a non-persisted object") if !persisted?
+        @message = self.class.client.request path: "#{self.class.base_path}/#{id}",
+          method: Net::HTTP::Put,
+          message: message,
+          response_type: self.class.message
+      end
+    end
+
+    # Mixin for a resource that has an active `:destroy` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Destroyable
+      def destroy
+        raise RuntimeError.new("Can't destroy a non-persisted object") if !persisted?
+        @message = self.class.client.request path: "#{self.class.base_path}/#{id}",
+          method: Net::HTTP::Delete,
+          message: nil,
+          response_type: self.class.message
+      end
+    end
+
+    # Internal helpers for non-resourceful member/collection methods. Never use these directly;
+    # instead, use the instance/class methods which have been dynamically defined on the resource
+    # you're working with.
+    module ExtraMethods
+      def self.member(resource, action, method, message, response_type)
+        resource.class.client.request path: "#{resource.class.base_path}/#{resource.id}/#{action}",
+          method: method,
+          message: message,
+          response_type: response_type
+      end
+      def self.collection(resource_class, action, method, message, response_type)
+        resource_class.client.request path: "#{resource_class.base_path}/#{action}",
+          method: method,
+          message: message,
+          response_type: response_type
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    # Backport the ActiveModel::Model functionality - https://github.com/rails/rails/blob/097ca3f1f84bb9a2d3cda3f2cce7974a874efdf4/activemodel/lib/active_model/model.rb#L95
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+    module ClassMethods
+
+      attr_accessor :client
+      attr_reader :message
+
+      attr_writer :base_path
+      def base_path
+        @base_path == nil ? raise(RuntimeError.new 'Base path not yet set') : @base_path.gsub(/\/$/, '')
+      end
+
+      private
+
+      # Primary entry point for defining resourceful behavior.
+      def resource(actions:, message:, query: nil)
+        if @message
+          raise RuntimeError.new('Only one call to `resource` is allowed')
+        end
+
+        # Define attribute readers/writers
+        @message = message
+        @message.all_fields.each do |field|
+          define_method :"#{field.name}" do
+            @message.public_send field.name
+          end
+          define_method :"#{field.name}=" do |value|
+            @message.public_send :"#{field.name}=", value
+          end
+        end
+
+        # Validate arguments
+        actions.map!{|action| action.to_sym}
+        (actions - %i(show index create update destroy)).each do |action|
+          raise ArgumentError.new("Unrecognized action: #{action}")
+        end
+
+        # For index/show, we want a different number of method arguments
+        # depending on whehter a query message was provided.
+        if query
+          if actions.include?(:show)
+            define_singleton_method :find do |id, query_params = {}|
+              SearchMethods.show(self, id, query.new(query_params))
+            end
+          end
+
+          if actions.include?(:index)
+            define_singleton_method :all do |query_params = {}|
+              SearchMethods.index(self, query.new(query_params))
+            end
+          end
+        else
+          if actions.include?(:show)
+            define_singleton_method :find do |id|
+              SearchMethods.show(self, id, nil)
+            end
+          end
+
+          if actions.include?(:index)
+            define_singleton_method :all do
+              SearchMethods.index(self, nil)
+            end
+          end
+        end
+
+        include(Creatable) if actions.include?(:create)
+        include(Updatable) if actions.include?(:update)
+        include(Destroyable) if actions.include?(:destroy)
+      end
+
+      def member(action:, method:, request: nil, response: nil)
+        if request
+          define_method action do |request_params = {}|
+            ExtraMethods.member self, action, method, request.new(request_params), response
+          end
+        else
+          define_method action do
+            ExtraMethods.member self, action, method, nil, response
+          end
+        end
+      end
+
+      def collection(action:, method:, request: nil, response: nil)
+        if request
+          define_singleton_method action do |request_params = {}|
+            ExtraMethods.collection self, action, method, request.new(request_params), response
+          end
+        else
+          define_singleton_method action do
+            ExtraMethods.collection self, action, method, nil, response
+          end
+        end
+      end
+    end
+
+    attr_reader :message
+    def initialize(message_or_params = {})
+      if self.class.message == nil
+        raise RuntimeError.new('Must define a message class using `resource`')
+      end
+      if message_or_params.is_a?(self.class.message)
+        @message = message_or_params
+      else
+        @message = self.class.message.new(message_or_params)
+      end
+
+      super()
+    end
+
+    def save
+      success = true
+      begin
+        if persisted?
+          # TODO: use `ActiveModel::Dirty` to only send changed attributes?
+          update!
+        else
+          create!
+        end
+      rescue Protip::UnprocessableEntityError => error
+        success = false
+        error.errors.messages.each do |message|
+          errors.add :base, message
+        end
+        error.errors.field_errors.each do |field_error|
+          errors.add field_error.field, field_error.message
+        end
+      end
+      success
+    end
+
+    def persisted?
+      message.field?(:id)
+    end
+
+    def attributes
+      self.class.message.all_fields.map{|field| field.name}.inject({}) do |hash, attribute_name|
+        hash[attribute_name] = message.field?(attribute_name) ? public_send(attribute_name) : nil
+        hash
+      end
+    end
+
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+  end
+end

data/test/functional/protip/resource_test.rb

@@ -0,0 +1,191 @@
+require 'test_helper'
+
+require 'protip'
+
+module Protip::ResourceTestFunctional # Namespace for internal constants
+  describe 'Protip::Resource (functional)' do
+
+    before do
+      WebMock.disable_net_connect!
+    end
+
+    # Make sure none of these are structurally identical (e.g. give fields
+    # different positions), to avoid potential errors where a message is
+    # incorrectly encode. Also define them as local constants so they don't
+    # interfere with any other tests.
+    class ResourceMessage < ::Protobuf::Message
+      optional :int64, :id, 1
+      optional :string, :ordered_tests, 2
+    end
+
+    class ResourceQuery < ::Protobuf::Message
+      optional :string, :param, 3
+    end
+
+    class NameResponse < ::Protobuf::Message
+      optional :string, :name, 4
+    end
+
+    class SearchRequest < ::Protobuf::Message
+      optional :string, :term, 5
+    end
+
+    class SearchResponse < ::Protobuf::Message
+      repeated :string, :results, 6
+    end
+
+    class FetchRequest < ::Protobuf::Message
+      repeated :string, :names, 7
+    end
+
+    class Client
+      include Protip::Client
+      def base_uri
+        'https://external.service'
+      end
+    end
+
+    class Resource
+      include Protip::Resource
+      resource actions: [:index, :show, :create, :update, :destroy],
+               query: ResourceQuery, message: ResourceMessage
+
+      member action: :archive, method: Net::HTTP::Put
+      member action: :name, method: Net::HTTP::Get, response: NameResponse
+
+      collection action: :search, method: Net::HTTP::Get, request: SearchRequest, response: SearchResponse
+      collection action: :fetch, method: Net::HTTP::Post, request: FetchRequest
+
+      self.base_path = 'resources'
+      self.client = Client.new
+    end
+
+    describe '.all' do
+      describe 'with a successful server response' do
+        before do
+          response = Protip::Messages::Array.new(messages: ['bilbo', 'baggins'].each_with_index.map do |name, index|
+            ResourceMessage.new(id: index, ordered_tests: name).encode
+          end)
+          stub_request(:get, 'https://external.service/resources')
+            .to_return body: response.encode
+        end
+
+        it 'requests resources from the index endpoint' do
+          results = Resource.all param: 'val'
+
+          assert_requested :get, 'https://external.service/resources',
+            times: 1, body: ResourceQuery.new(param: 'val').encode
+
+          assert_equal 2, results.length, 'incorrect number of resources were returned'
+          results.each { |result| assert_instance_of Resource, result, 'incorrect type was parsed'}
+
+          assert_equal({ordered_tests: 'bilbo', id: 0}, results[0].attributes)
+          assert_equal({ordered_tests: 'baggins', id: 1}, results[1].attributes)
+        end
+
+        it 'allows requests without parameters' do
+          results = Resource.all
+          assert_requested :get, 'https://external.service/resources',
+            times: 1, body: ResourceQuery.new.encode
+          assert_equal 2, results.length, 'incorrect number of resources were returned'
+        end
+      end
+    end
+
+    describe '.find' do
+      describe 'with a successful server response' do
+        before do
+          response = ResourceMessage.new(id: 311, ordered_tests: 'i_suck_and_my_tests_are_order_dependent!').encode
+          stub_request(:get, 'https://external.service/resources/311').to_return body: response.encode
+        end
+
+        it 'requests the resource from the show endpoint' do
+          resource = Resource.find 311, param: 'val'
+          assert_requested :get, 'https://external.service/resources/311', times: 1,
+            body: ResourceQuery.new(param: 'val').encode
+          assert_instance_of Resource, resource
+          assert_equal 311, resource.id
+          assert_equal 'i_suck_and_my_tests_are_order_dependent!', resource.ordered_tests
+        end
+
+        it 'allows requests without parameters' do
+          resource = Resource.find 311
+          assert_requested :get, 'https://external.service/resources/311', times: 1,
+            body: ResourceQuery.new.encode
+          assert_equal 'i_suck_and_my_tests_are_order_dependent!', resource.ordered_tests
+        end
+      end
+    end
+
+    describe '#save' do
+      let :resource_message do
+        ResourceMessage.new(id: 666, ordered_tests: 'yes')
+      end
+      let :errors_message do
+        Protip::Messages::Errors.new({
+          messages: ['base1', 'base2'],
+          field_errors: [
+            {field: 'ordered_tests', message: 'are not OK'}
+          ]
+        })
+      end
+
+      # Create and update cases are similar - we just modify the ID attribute on
+      # the initial resource, the HTTP method, and the expected URL.
+      [
+        [nil, :post, 'https://external.service/resources'],
+        [666, :put, 'https://external.service/resources/666']
+      ].each do |id, method, uri|
+        describe "with a #{id ? 'persisted' : 'non-persisted'} resource" do
+          before do
+            @resource = Resource.new id: id
+          end
+
+          describe 'with a successful server response' do
+            before do
+              stub_request(method, uri).to_return body: resource_message.encode
+            end
+
+            it 'returns true' do
+              assert @resource.save, 'save was not successful'
+            end
+
+            it 'saves the resource and parses the server response' do
+              @resource.ordered_tests = 'no'
+              @resource.save
+
+              assert_requested method, uri,
+                times: 1, body: ResourceMessage.new(id: id, ordered_tests: 'no').encode
+              assert_equal 'yes', @resource.ordered_tests
+            end
+          end
+
+          describe 'with a 422 server response' do
+            before do
+              stub_request(method, uri)
+                .to_return body: errors_message.encode, status: 422
+            end
+
+            it 'returns false' do
+              refute @resource.save, 'save appeared successful'
+            end
+
+            it 'adds errors based on the server response' do
+              @resource.save
+              assert_equal ['base1', 'base2'], @resource.errors['base']
+              assert_equal ['are not OK'], @resource.errors['ordered_tests']
+            end
+          end
+        end
+      end
+    end
+
+    describe '.member' do
+      # TODO
+    end
+
+    describe '.collection' do
+      # TODO
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/autorun'
+require 'mocha/mini_test'
+require 'webmock/minitest'

data/test/unit/protip/resource_test.rb

@@ -0,0 +1,494 @@
+require 'test_helper'
+
+require 'protip/client'
+require 'protip/resource'
+
+module Protip::ResourceTest # Namespace for internal constants
+  describe Protip::Resource do
+    class ResourceMessage < ::Protobuf::Message
+      optional :int64, :id, 1
+      optional :string, :string, 2
+      optional :string, :string2, 3
+    end
+    class ResourceQuery < ::Protobuf::Message
+      optional :string, :param, 1
+    end
+
+    # Give these things a different structure than ResourceQuery,
+    # just to avoid any possibility of decoding as the incorrect
+    # type but still yielding correct results.
+    class ActionQuery < ::Protobuf::Message
+      optional :string, :param, 4
+    end
+    class ActionResponse < ::Protobuf::Message
+      optional :string, :response, 3
+    end
+
+    # Stubbed API client
+    let :client do
+      mock.responds_like_instance_of(Class.new { include Protip::Client })
+    end
+
+    # Call `resource_class` to get an empty resource type.
+    let :resource_class do
+      resource_class = Class.new do
+        include Protip::Resource
+        self.base_path = 'base_path'
+        class << self
+          attr_accessor :client
+        end
+      end
+      resource_class.client = client
+      resource_class
+    end
+
+    describe '.resource' do
+      before do
+        resource_class.class_eval do
+          resource actions: [], message: ResourceMessage
+        end
+      end
+      it 'can only be invoked once' do
+        assert_raises RuntimeError do
+          resource_class.class_eval do
+            resource actions: [], message: ResourceMessage
+          end
+        end
+      end
+
+      it 'defines accessors for the fields on its message' do
+        resource = resource_class.new
+        [:id, :id=, :string, :string=].each do |method|
+          assert_respond_to resource, method
+        end
+        refute_respond_to resource, :foo
+      end
+
+      it 'sets fields on the underlying message when setters are called' do
+        resource = resource_class.new
+        resource.string = 'intern'
+        assert_equal 'intern', resource.message.string
+        assert_equal 'intern', resource.string
+      end
+    end
+
+    describe '.all' do
+      let :response do
+        Protip::Messages::Array.new({
+          messages: [
+            ResourceMessage.new(string: 'banjo', id: 1),
+            ResourceMessage.new(string: 'kazooie', id: 2),
+          ].map(&:encode)
+        })
+      end
+
+      it 'does not exist if the resource has not been defined' do
+        refute_respond_to resource_class, :all
+      end
+
+      it 'does not exist if the resource is defined without the index action' do
+        resource_class.class_eval do
+          resource actions: [:show], message: ResourceMessage
+        end
+        refute_respond_to resource_class, :all
+      end
+
+      describe 'without a query' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:index], message: ResourceMessage
+          end
+        end
+
+        it 'requests an array from the index URL' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: 'base_path', message: nil, response_type: Protip::Messages::Array)
+            .returns(response)
+          resource_class.all
+        end
+
+        it 'fails if we try to pass in a query' do
+          assert_raises ArgumentError do
+            resource_class.all(query: 'param')
+          end
+        end
+
+        # Doesn't matter whether we have a query or not
+        it 'parses the response into an array of resources' do
+          client.stubs(:request).returns(response)
+          results = resource_class.all
+
+          assert_equal 2, results.length
+          results.each { |result| assert_instance_of resource_class, result }
+
+          assert_equal 'banjo', results[0].string
+          assert_equal 1, results[0].id
+
+          assert_equal 'kazooie', results[1].string
+          assert_equal 2, results[1].id
+        end
+
+        # Doesn't matter whether we have a query or not
+        it 'allows an empty array' do
+          client.stubs(:request).returns(Protip::Messages::Array.new)
+          results = resource_class.all
+
+          assert_equal [], results
+        end
+      end
+
+      describe 'with a query' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:index], message: ResourceMessage, query: ResourceQuery
+          end
+        end
+
+        it 'requests an array from the index URL with the query' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: 'base_path',
+              message: ResourceQuery.new(param: 'val'), response_type: Protip::Messages::Array
+            ).returns(response)
+          resource_class.all(param: 'val')
+        end
+
+        it 'allows a request with an empty query' do
+          client.expects(:request)
+            .with(method: Net::HTTP::Get, path: 'base_path',
+              message: ResourceQuery.new, response_type: Protip::Messages::Array)
+          .returns(response)
+          resource_class.all
+        end
+      end
+    end
+
+    describe '.find' do
+      let :response do
+        ResourceMessage.new(string: 'pitbull', id: 100)
+      end
+
+      it 'does not exist if the resource has not been defined' do
+        refute_respond_to resource_class, :find
+      end
+
+      it 'does not exist if the resource is defined without the show action' do
+        resource_class.class_eval do
+          resource actions: [:index], message: ResourceMessage
+        end
+        refute_respond_to resource_class, :find
+      end
+
+      describe 'without a query' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:show], message: ResourceMessage
+          end
+        end
+
+        it 'requests its message type from the show URL' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: 'base_path/3', message: nil, response_type: ResourceMessage)
+            .returns(response)
+          resource_class.find 3
+        end
+
+        it 'fails if we try to pass in a query' do
+          assert_raises ArgumentError do
+            resource_class.find 2, param: 'val'
+          end
+        end
+
+        # Doesn't matter whether we have a query or not
+        it 'parses the response message into a resource' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.find 100
+          assert_instance_of resource_class, resource
+
+          assert_equal 100, resource.id
+          assert_equal 'pitbull', resource.string
+        end
+      end
+
+      describe 'with a query' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:show], message: ResourceMessage, query: ResourceQuery
+          end
+        end
+
+        it 'requests its message type from the show URL with the query' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: 'base_path/5',
+              message: ResourceQuery.new(param: 'val'), response_type: ResourceMessage)
+            .returns(response)
+          resource_class.find 5, param: 'val'
+        end
+
+        it 'allows a request with an empty query' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: 'base_path/6',
+              message: ResourceQuery.new, response_type: ResourceMessage)
+            .returns(response)
+          resource_class.find 6
+        end
+      end
+    end
+
+    describe '#save' do
+      let :response do
+        ResourceMessage.new(string: 'pit', string2: 'bull', id: 200)
+      end
+
+      describe 'for a new record' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:create], message: ResourceMessage
+          end
+          resource_class.any_instance.stubs(:persisted?).returns(false)
+        end
+
+        it 'sends the resource to the server' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Post, path: 'base_path',
+              message: ResourceMessage.new(string: 'time', string2: 'flees'), response_type: ResourceMessage)
+            .returns(response)
+
+          # Set via initializer and direct setter
+          resource = resource_class.new(string: 'time')
+          resource.string2 = 'flees'
+          resource.save
+        end
+
+        it 'returns true' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.new string: 'flees'
+          assert resource.save, 'save returned false'
+        end
+
+        it 'updates its internal message store with the server response' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.new
+          resource.save
+          assert_equal response, resource.message
+        end
+      end
+
+      describe 'for an existing record' do
+        before do
+          resource_class.class_eval do
+            resource actions: [:update], message: ResourceMessage
+          end
+          resource_class.any_instance.stubs(:persisted?).returns(true)
+        end
+
+        it 'sends the resource to the server' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Put, path: 'base_path/4',
+              message: ResourceMessage.new(id: 4, string: 'pitbull'), response_type: ResourceMessage)
+            .returns(response)
+
+          resource = resource_class.new(id: 4, string: 'pitbull')
+          resource.save
+        end
+
+        it 'returns true' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.new id: 3
+          assert resource.save, 'save returned false'
+        end
+
+        it 'updates its internal message store with the server repsonse' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.new id: 5
+          resource.save
+          assert_equal response, resource.message
+        end
+      end
+
+      describe 'when validation errors are thrown' do
+        before do
+          # Set up an errors instance variable that we can set actual messages on
+          @errors = Protip::Messages::Errors.new
+
+          exception = Protip::UnprocessableEntityError.new mock, mock
+          exception.stubs(:errors).returns @errors
+          client.stubs(:request).raises(exception)
+
+          resource_class.class_eval do
+            resource actions: [:update, :create], message: ResourceMessage
+          end
+          @resource = resource_class.new
+        end
+
+        it 'parses base errors' do
+          @errors.messages = ['message1', 'message2']
+          @resource.save
+
+          assert_equal ['message1', 'message2'], @resource.errors['base']
+        end
+
+        it 'parses field errors' do
+          @errors.field_errors = [
+            Protip::Messages::FieldError.new(field: 'string', message: 'message1'),
+            Protip::Messages::FieldError.new(field: 'id', message: 'message2'),
+            Protip::Messages::FieldError.new(field: 'string', message: 'message3'),
+          ]
+          @resource.save
+
+          assert_equal ['message1', 'message3'], @resource.errors['string']
+          assert_equal ['message2'], @resource.errors['id']
+        end
+
+        it 'returns false' do
+          refute @resource.save, 'save returned true'
+        end
+      end
+    end
+
+    describe '#destroy' do
+      describe 'for an existing record' do
+        let :response do
+          ResourceMessage.new(id: 5, string: 'deleted')
+        end
+        before do
+          resource_class.class_eval do
+            resource actions: [:destroy], message: ResourceMessage
+          end
+          resource_class.any_instance.stubs(:persisted?).returns(true)
+        end
+
+        it 'sends a delete request to the server' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Delete, path: 'base_path/79', message: nil, response_type: ResourceMessage)
+            .returns(response)
+          resource_class.new(id: 79).destroy
+        end
+
+        it 'updates its internal message with the server response' do
+          client.stubs(:request).returns(response)
+          resource = resource_class.new(id: 80)
+
+          resource.destroy
+          assert_equal response, resource.message
+        end
+      end
+    end
+
+    # member/collection have almost the same behavior, except for the URL and the target on which they're
+    # called. We assume that a `let(:target)` block has already been defined, which will yield the receiver
+    # of the non-resourceful method to be defined (e.g. a resource instance or resource class).
+    #
+    # @param defining_method [String] member or collection, e.g. the method to call in a `class_eval` block
+    # @param path [String] the URI that the client should expect to receive for an action of this type
+    #   named 'action'
+    def self.describe_non_resourceful_action(defining_method, path)
+
+      # let(:target) is assumed to have been defined
+
+      let :response do
+        ActionResponse.new(response: 'bilbo')
+      end
+
+      before do
+        resource_class.class_eval do
+          resource actions: [], message: ResourceMessage
+        end
+      end
+      describe 'without a request or response type' do
+        before do
+          resource_class.class_eval do
+            send defining_method, action: :action, method: Net::HTTP::Put
+          end
+        end
+
+        it 'sends a request with no body and no response type to the expected endpoint' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Put, path: path, message: nil, response_type: nil)
+            .returns(nil)
+          target.action
+        end
+
+        it 'does not accept request parameters' do
+          assert_raises ArgumentError do
+            target.action param: 'val'
+          end
+        end
+
+        it 'returns nil' do
+          client.stubs(:request).returns(nil)
+          assert_nil target.action
+        end
+      end
+      describe 'with a request type' do
+        before do
+          resource_class.class_eval do
+            send defining_method, action: :action, method: Net::HTTP::Post, request: ActionQuery
+          end
+        end
+
+        it 'sends a request with a body to the expected endpoint' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Post, path: path,
+              message: ActionQuery.new(param: 'tom cruise'), response_type: nil)
+            .returns(nil)
+          target.action param: 'tom cruise'
+        end
+
+        it 'allows a request with no parameters' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Post, path: path,
+              message: ActionQuery.new, response_type: nil)
+            .returns(nil)
+          target.action
+        end
+      end
+
+      describe 'with a response type' do
+        before do
+          resource_class.class_eval do
+            send defining_method, action: :action, method: Net::HTTP::Get, response: ActionResponse
+          end
+        end
+
+        it 'sends a request with a specified response type to the expected endpoint' do
+          client.expects(:request)
+            .once
+            .with(method: Net::HTTP::Get, path: path,
+              message: nil, response_type: ActionResponse)
+            .returns(response)
+          target.action
+        end
+
+        it 'returns the server response' do
+          client.stubs(:request).returns(response)
+          assert_equal response, target.action
+        end
+      end
+    end
+
+    describe '.member' do
+      let :target do
+        resource_class.new id: 42
+      end
+      describe_non_resourceful_action 'member', 'base_path/42/action'
+    end
+
+    describe '.collection' do
+      let :target do
+        resource_class
+      end
+      describe_non_resourceful_action 'collection', 'base_path/action'
+    end
+  end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: protip
+version: !ruby/object:Gem::Version
+  version: 0.9.7
+platform: ruby
+authors:
+- AngelList
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+description: 
+email:
+- team@angel.co
+- k2@angel.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/protip.rb
+- lib/protip/client.rb
+- lib/protip/error.rb
+- lib/protip/messages/array.pb.rb
+- lib/protip/messages/errors.pb.rb
+- lib/protip/resource.rb
+- test/functional/protip/resource_test.rb
+- test/test_helper.rb
+- test/unit/protip/resource_test.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Resources backed by protobuf messages
+test_files: []