protip 0.10.7 → 0.11.0

data/lib/protip/wrapper.rb

@@ -1,5 +1,4 @@
 require 'active_support/concern'
-require 'protobuf'
 
 module Protip
 
@@ -19,18 +18,18 @@ module Protip
         true
       else
         if name =~ /=$/
-          message.class.fields.any?{|field| :"#{field.name}=" == name.to_sym}
+          message.class.descriptor.any?{|field| :"#{field.name}=" == name.to_sym}
         else
-          message.class.fields.any?{|field| field.name == name.to_sym}
+          message.class.descriptor.any?{|field| field.name.to_sym == name.to_sym}
         end
       end
     end
 
     def method_missing(name, *args)
-      if (name =~ /=$/ && field = message.class.fields.detect{|field| :"#{field.name}=" == name})
+      if (name =~ /=$/ && field = message.class.descriptor.detect{|field| :"#{field.name}=" == name})
         raise ArgumentError unless args.length == 1
         set field, args[0]
-      elsif (field = message.class.fields.detect{|field| field.name == name})
+      elsif (field = message.class.descriptor.detect{|field| field.name.to_sym == name})
         raise ArgumentError unless args.length == 0
         get field
       else
@@ -62,14 +61,16 @@ module Protip
     # @return [Protip::Wrapper] The created field
     def build(field_name, attributes = {})
 
-      field = message.class.fields.detect{|field| field.name == field_name.to_sym}
-      if !field.is_a?(Protobuf::Field::MessageField)
-        raise "Not a message field: #{field_name}"
-      elsif converter.convertible?(field.type_class)
+      field = message.class.descriptor.detect{|field| field.name.to_sym == field_name.to_sym}
+      if !field
+        raise "No field named #{field_name}"
+      elsif field.type != :message
+        raise "Can only build message fields: #{field_name}"
+      elsif converter.convertible?(field.subtype.msgclass)
         raise "Cannot build a convertible field: #{field.name}"
       end
 
-      message[field_name] = field.type_class.new
+      message[field_name.to_s] = field.subtype.msgclass.new
       wrapper = get(field)
       wrapper.assign_attributes attributes
       wrapper
@@ -85,12 +86,19 @@ module Protip
     # @return [NilClass]
     def assign_attributes(attributes)
       attributes.each do |field_name, value|
-        field = message.class.fields.detect{|field| field.name == field_name.to_sym}
+        field = message.class.descriptor.detect{|field| field.name == field_name.to_s}
+        if !field
+          raise ArgumentError.new("Unrecognized field: #{field_name}")
+        end
 
-        # For inconvertible nested messages, the value should be a hash - just pass it through to the nested message
-        if field.is_a?(Protobuf::Field::MessageField) && !converter.convertible?(field.type_class)
-          wrapper = get(field) || build(field.name) # Create the field if it doesn't already exist
-          wrapper.assign_attributes value
+        # For inconvertible nested messages, the value should be either a hash or a message
+        if field.type == :message && !converter.convertible?(field.subtype.msgclass)
+          if value.is_a?(field.subtype.msgclass) # If a message, set it directly
+            set(field, value)
+          else # If a hash, pass it through to the nested message
+            wrapper = get(field) || build(field.name) # Create the field if it doesn't already exist
+            wrapper.assign_attributes value
+          end
         # Otherwise, if the field is a convertible message or a simple type, we set the value directly
         else
           set(field, value)
@@ -102,7 +110,7 @@ module Protip
 
     def as_json
       json = {}
-      message.class.fields.each do |name|
+      message.class.descriptor.map(&:name).each do |name|
         value = public_send(name)
         json[name.to_s] = value.respond_to?(:as_json) ? value.as_json : value
       end
@@ -110,17 +118,20 @@ module Protip
     end
 
     def ==(wrapper)
-      wrapper.is_a?(self.class) && message == wrapper.message && converter == wrapper.converter
+      wrapper.class == self.class &&
+        wrapper.message.class == message.class &&
+        message.class.encode(message) == wrapper.message.class.encode(wrapper.message) &&
+        converter == wrapper.converter
     end
 
     private
 
     def get(field)
-      if field.is_a?(Protobuf::Field::MessageField)
-        if message[field.name].nil?
+      if field.type == :message
+        if nil == message[field.name]
           nil
         else
-          if converter.convertible?(field.type_class)
+          if converter.convertible?(field.subtype.msgclass)
             converter.to_object message[field.name]
           else
             self.class.new message[field.name], converter
@@ -132,16 +143,27 @@ module Protip
     end
 
     def set(field, value)
-      if field.is_a?(Protobuf::Field::MessageField)
-        if value.is_a? Protobuf::Message
-          message[field.name] = value
-        elsif converter.convertible?(field.type_class)
-          message[field.name] = converter.to_message value, field.type_class
+      if field.label == :repeated
+        message[field.name].replace value.map{|v| to_protobuf_value field, v}
+      else
+        message[field.name] = to_protobuf_value(field, value)
+      end
+    end
+
+    # Helper for setting values - converts the value for the given field to one that we can set directly
+    def to_protobuf_value(field, value)
+      if field.type == :message
+        if nil == value
+          nil
+        elsif value.is_a?(field.subtype.msgclass)
+          value
+        elsif converter.convertible?(field.subtype.msgclass)
+          converter.to_message value, field.subtype.msgclass
         else
           raise ArgumentError.new "Cannot convert from Ruby object: \"#{field}\""
         end
       else
-        message[field.name] = value
+        value
       end
     end
   end

data/test/functional/protip/resource_test.rb

@@ -2,196 +2,231 @@ require 'test_helper'
 
 require 'protip'
 
-module Protip::ResourceTestFunctional # Namespace for internal constants
-  describe 'Protip::Resource (functional)' do
+describe 'Protip::Resource (functional)' do
 
-    before do
-      WebMock.disable_net_connect!
-    end
+  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 encoded but still accidentally correctly decoded.
-    class NestedMessage < ::Protobuf::Message
-      optional :string, :inconvertible_value, 1
-    end
-    class ResourceMessage < ::Protobuf::Message
-      optional :int64, :id, 2
-      optional :string, :ordered_tests, 3
-      optional NestedMessage, :nested_message, 4
-      optional Protip::Int64Value, :nested_int, 5
-    end
+  let :pool do
+    pool = Google::Protobuf::DescriptorPool.new
+    pool.build do
+      add_message 'google.protobuf.Int64Value' do # TODO: can we get this directly into the pool from the global pool?
+        optional :value, :int64, 1
+      end
 
-    class ResourceQuery < ::Protobuf::Message
-      optional :string, :param, 6
-    end
+      # Make sure none of these are structurally identical (e.g. give fields
+      # different positions), to avoid potential errors where a message is
+      # incorrectly encoded but still accidentally correctly decoded.
 
-    class NameResponse < ::Protobuf::Message
-      optional :string, :name, 7
-    end
+      add_message 'nested_message' do
+        optional :inconvertible_value, :string, 1
+      end
+      add_message 'resource_message' do
+        optional :id, :message, 2, 'google.protobuf.Int64Value'
+        optional :ordered_tests, :string, 3
+        optional :nested_message, :message, 4, 'nested_message'
+        optional :nested_int, :message, 5, 'google.protobuf.Int64Value'
+      end
 
-    class SearchRequest < ::Protobuf::Message
-      optional :string, :term, 8
-    end
+      add_message 'resource_query' do
+        optional :param, :string, 6
+      end
 
-    class SearchResponse < ::Protobuf::Message
-      repeated :string, :results, 9
-    end
+      add_message 'name_response' do
+        optional :name, :string, 7
+      end
+
+      add_message 'search_request' do
+        optional :term, :string, 8
+      end
 
-    class FetchRequest < ::Protobuf::Message
-      repeated :string, :names, 10
+      add_message 'search_response' do
+        repeated :results, :string, 9
+      end
+
+      add_message 'fetch_request' do
+        repeated :names, :string, 10
+      end
+    end
+    pool
+  end
+  %w(nested_message resource_message resource_query name_response search_request search_response fetch_request).each do |name|
+    let(:"#{name}_class") do
+      pool.lookup(name).msgclass
     end
+  end
+  let :int_message_class do
+    pool.lookup('google.protobuf.Int64Value').msgclass
+  end
 
-    class Client
+  let :client_class do
+    Class.new do
       include Protip::Client
       def base_uri
         'https://external.service'
       end
     end
+  end
 
-    class Resource
+  let :resource_class do
+    resource_class = Class.new do
       include Protip::Resource
+    end
+    resource_class.class_exec(resource_query_class, resource_message_class, name_response_class, search_request_class, search_response_class, fetch_request_class, client_class) do |resource_query_class, resource_message_class, name_response_class, search_request_class, search_response_class, fetch_request_class, client_class|
       resource actions: [:index, :show, :create, :update, :destroy],
-               query: ResourceQuery, message: ResourceMessage
+               query: resource_query_class, message: resource_message_class
 
       member action: :archive, method: Net::HTTP::Put
-      member action: :name, method: Net::HTTP::Get, response: NameResponse
+      member action: :name, method: Net::HTTP::Get, response: name_response_class
 
-      collection action: :search, method: Net::HTTP::Get, request: SearchRequest, response: SearchResponse
-      collection action: :fetch, method: Net::HTTP::Post, request: FetchRequest
+      collection action: :search, method: Net::HTTP::Get, request: search_request_class, response: search_response_class
+      collection action: :fetch, method: Net::HTTP::Post, request: fetch_request_class
 
       self.base_path = 'resources'
-      self.client = Client.new
+      self.client = client_class.new
     end
+    resource_class
+  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, nested_int: {value: index + 42}).encode
-          end)
-          stub_request(:get, 'https://external.service/resources')
-            .to_return body: response.encode
-        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|
+          message = resource_message_class.new(id: int_message_class.new(value: index), ordered_tests: name, nested_int: int_message_class.new(value: index + 42))
+          message.class.encode(message).encode('UTF-8')
+        end)
+        stub_request(:get, 'https://external.service/resources')
+          .to_return body: response.class.encode(response)
+      end
 
-        it 'requests resources from the index endpoint' do
-          results = Resource.all param: 'val'
+      it 'requests resources from the index endpoint' do
+        results = resource_class.all param: 'val'
 
-          assert_requested :get, 'https://external.service/resources',
-            times: 1, body: ResourceQuery.new(param: 'val').encode
+        assert_requested :get, 'https://external.service/resources',
+          times: 1, body: resource_query_class.encode(resource_query_class.new(param: 'val'))
 
-          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 2, results.length, 'incorrect number of resources were returned'
+        results.each { |result| assert_instance_of resource_class, result, 'incorrect type was parsed'}
 
-          assert_equal({ordered_tests: 'bilbo', id: 0, nested_message: nil, nested_int: 42},
-            results[0].attributes)
-          assert_equal({ordered_tests: 'baggins', id: 1, nested_message: nil, nested_int: 43},
-            results[1].attributes)
-        end
+        assert_equal({'ordered_tests' => 'bilbo', 'id' => 0, 'nested_message' => nil, 'nested_int' => 42},
+          results[0].attributes)
+        assert_equal({'ordered_tests' => 'baggins', 'id' => 1, 'nested_message' => nil, 'nested_int' => 43},
+          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
+      it 'allows requests without parameters' do
+        results = resource_class.all
+        assert_requested :get, 'https://external.service/resources',
+          times: 1, body: resource_query_class.encode(resource_query_class.new)
+        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
+  describe '.find' do
+    describe 'with a successful server response' do
+      before do
+        message = resource_message_class.new(id: int_message_class.new(value: 311), ordered_tests: 'i_suck_and_my_tests_are_order_dependent!')
+        response = message.class.encode(message)
+        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 'requests the resource from the show endpoint' do
+        resource = resource_class.find 311, param: 'val'
+        assert_requested :get, 'https://external.service/resources/311', times: 1,
+          body: resource_query_class.encode(resource_query_class.new(param: 'val'))
+        assert_instance_of resource_class, 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
+      it 'allows requests without parameters' do
+        resource = resource_class.find 311
+        assert_requested :get, 'https://external.service/resources/311', times: 1,
+          body: resource_query_class.encode(resource_query_class.new)
+        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, nested_int: 100
+  describe '#save' do
+    let :resource_message do
+      resource_message_class.new(id: int_message_class.new(value: 666), ordered_tests: 'yes')
+    end
+    let :errors_message do
+      Protip::Messages::Errors.new({
+        messages: ['base1', 'base2'],
+        field_errors: [
+          Protip::Messages::FieldError.new(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
+          attrs = {nested_int: 100}
+          if id
+            attrs[:id] = id
           end
+          @resource = resource_class.new attrs
+        end
 
-          describe 'with a successful server response' do
-            before do
-              stub_request(method, uri).to_return body: resource_message.encode
-            end
+        describe 'with a successful server response' do
+          before do
+            stub_request(method, uri).to_return body: resource_message.class.encode(resource_message)
+          end
 
-            it 'returns true' do
-              assert @resource.save, 'save was not successful'
-            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
+          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', nested_int: {value: 100}).encode
-              assert_equal 'yes', @resource.ordered_tests
+            attrs = {ordered_tests: 'no', nested_int: int_message_class.new(value: 100)}
+            if id
+              attrs[:id] = int_message_class.new(value: id)
             end
+            message = resource_message_class.new(attrs)
+            assert_requested method, uri,
+              times: 1, body: message.class.encode(message)
+            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
+        describe 'with a 422 server response' do
+          before do
+            stub_request(method, uri)
+              .to_return body: errors_message.class.encode(errors_message), status: 422
+          end
 
-            it 'returns false' do
-              refute @resource.save, 'save appeared successful'
-            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
+          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 '.member' do
+    # TODO
+  end
 
-    describe '.collection' do
-      # TODO
-    end
+  describe '.collection' do
+    # TODO
   end
 end