protip 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c99dbb33000837b699628b8a836790ef3f11fb2
-  data.tar.gz: 0c137bcc95256ef4c85977aaeca953e2c137a8e9
+  metadata.gz: 7c340cc60f0fd35abd3d10a61bb3e1f089a7a74f
+  data.tar.gz: b0638b042c3234a0915811aeb8b403c855cd8ce8
 SHA512:
-  metadata.gz: 79e28c350f9dd492a2d0fea1f586e5cd1c28066ab78cead4d5a3be04344803192eae92f031ea95e3532d3f6c8ac90f355d5daa4db9002e12380ed4f0552b4f6f
-  data.tar.gz: 91a2a3a68ebc88a3640c31d7fc4c6f1d8e94538fc821759bacbbcf56ec2ccdfa71fd82aff60789aaed606fa9170661e4f19da20a0e46ef9873e3783fc127b50f
+  metadata.gz: fb76ebde93c39fca443494c1505360f426f5001927ada5be9da5976db7fac15bc066491d084c0ef6963f3b519c3141a9df4d3a683eacf7f911db2ff94f0236af
+  data.tar.gz: 06d98607aacfd60d8e9ddabb9117beecc78c7b0361bad1ccf329e786593efbbc54a6e2e23f0d7256a031ecfdf0fe270d2057f4f8a1aa5cf81fa93cd7d501aab2

data/definitions/protip/messages/active_support/time_with_zone.proto

@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+package protip.messages.ActiveSupport;
+
+message TimeWithZone {
+  int64 utc_timestamp = 1;
+  string time_zone_name = 2;
+}

data/lib/protip/messages/active_support/time_with_zone.rb

@@ -0,0 +1,19 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: protip/messages/active_support/time_with_zone.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "protip.messages.ActiveSupport.TimeWithZone" do
+    optional :utc_timestamp, :int64, 1
+    optional :time_zone_name, :string, 2
+  end
+end
+
+module Protip
+  module Messages
+    module ActiveSupport
+      TimeWithZone = Google::Protobuf::DescriptorPool.generated_pool.lookup("protip.messages.ActiveSupport.TimeWithZone").msgclass
+    end
+  end
+end

data/lib/protip/resource.rb

@@ -29,6 +29,8 @@ require 'protip/resource/updateable'
 require 'protip/resource/destroyable'
 require 'protip/resource/extra_methods'
 require 'protip/resource/search_methods'
+require 'protip/resource/associations/belongs_to_association'
+require 'protip/resource/associations/belongs_to_polymorphic_association'
 
 module Protip
   module Resource
@@ -204,6 +206,40 @@ module Protip
           end
         end
       end
+
+      def belongs_to(association_name, options = {})
+        association = ::Protip::Resource::Associations::BelongsToAssociation.new(self, association_name, options)
+        association.define_accessors!
+        association
+      end
+
+      def belongs_to_polymorphic(association_name, options = {}, &block)
+        # We evaluate the block in the context of a wrapper that stores simple belongs-to associations
+        # as they're being created.
+        nested_association_creator = Class.new do
+          attr_reader :associations
+          def initialize(resource_class)
+            @resource_class = resource_class
+            @associations = []
+          end
+          def belongs_to(*args)
+            # Just forward the belongs_to call and store the result so we can pass it to the polymorphic association
+            @associations << @resource_class.send(:belongs_to, *args)
+          end
+        end.new(self)
+
+        nested_association_creator.instance_eval(&block)
+
+        association = ::Protip::Resource::Associations::BelongsToPolymorphicAssociation.new self,
+          association_name, nested_association_creator.associations, options
+        association.define_accessors!
+        association
+      end
+
+      def references_through_one_of(id_field, options = {})
+        ::Protip::Resource::Associations::ReferencesThroughOneOfAssociation.new(self, id_field, options)
+          .define_accessors!
+      end
     end
 
     def initialize(message_or_attributes = {})

data/lib/protip/resource/associations/association.rb

@@ -0,0 +1,39 @@
+# Base module for a reference that can be defined on a resource. References
+# are similar to +belongs_to+ associations in ActiveRecord.
+module Protip
+  module Resource
+    module Associations
+      module Association
+
+        def define_accessors!
+          resource_class.class_exec(self, association_name) do |association, association_name|
+            define_method(association_name) do
+              association.read(self)
+            end
+
+            define_method(:"#{association_name}=") do |value|
+              association.write(self, value)
+            end
+          end
+        end
+
+        # Individual reference classes must implement
+        def resource_class
+          raise NotImplementedError
+        end
+
+        def association_name
+          raise NotImplementedError
+        end
+
+        def read(resource)
+          raise NotImplementedError
+        end
+
+        def write(resource, value)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/protip/resource/associations/belongs_to_association.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/string/inflections' # For classifying/constantizing strings
+
+require 'protip/resource/associations/association'
+
+module Protip
+  module Resource
+    module Associations
+      class BelongsToAssociation
+
+        include Protip::Resource::Associations::Association
+
+        attr_reader :resource_class, :association_name, :id_field
+
+        def initialize(resource_class, association_name, id_field: nil, class_name: nil)
+          # The resource type that houses the association
+          @resource_class = resource_class
+
+          # The name for generating accessor methods
+          @association_name = association_name
+
+          # The field that holds the ID for the association
+          @id_field = (id_field || self.class.default_id_field(association_name)).to_sym
+
+          @class_name = (class_name || self.class.default_class_name(association_name)).to_s
+        end
+
+        def associated_resource_class
+          @associated_resource_class ||= @class_name.constantize
+        end
+
+        def read(resource)
+          id = resource.public_send(@id_field)
+          if id == nil
+            nil
+          else
+            associated_resource_class.find id
+          end
+        end
+
+        def write(resource, value)
+          if value != nil
+            unless value.is_a?(associated_resource_class)
+              raise ArgumentError.new("Cannot assign #{value.class} to #{resource_class}##{@id_field}")
+            end
+            unless value.persisted?
+              raise "Cannot assign non-persisted resource to association #{resource_class}##{association_name}"
+            end
+          end
+          resource.public_send(:"#{@id_field}=", value.try(:id))
+        end
+
+        class << self
+          def default_id_field(association_name)
+            "#{association_name}_id".to_sym
+          end
+          def default_class_name(association_name)
+            association_name.to_s.classify
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/protip/resource/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,89 @@
+require 'protip/resource/associations/association'
+require 'protip/resource/associations/belongs_to_association'
+
+module Protip
+  module Resource
+    module Associations
+      class BelongsToPolymorphicAssociation
+
+        include Protip::Resource::Associations::Association
+        attr_reader :resource_class, :association_name, :id_field
+
+        # Define a polymorphic association based on a one-of field. The options for the oneof must all be IDs with
+        # an associated +Protip::Resource::Associations::BelongsToAssociation+ that's already been created.
+        #
+        # @param [Class] resource_class The +Protip::Resource+ class that holds a reference to an associated object.
+        # @param [String] association_name The name to use when defining accessors for the associated object.
+        # @param [Array<Protip::Resource::Associations::BelongsToAssociation>] nested_associations The individual
+        #   associations corresponding to the fields within the `oneof`.
+        # @param [Symbol|String] id_field The name of the `oneof` field that holds the association ID. Defaults to
+        #   `#{association_name}_id`.
+        def initialize(resource_class, association_name, nested_associations, id_field: nil)
+          # The class where accessors will be defined
+          @resource_class = resource_class
+
+          # The name of the accessor methods
+          @association_name = association_name.to_sym
+
+          # The oneof field that holds the ID of the foreign resource
+          @id_field  = (id_field ||
+            Protip::Resource::Associations::BelongsToAssociation.default_id_field(association_name)).to_sym
+          @oneof = @resource_class.message.descriptor.lookup_oneof(@id_field.to_s)
+          raise "Invalid field name for polymorphic association: #{@id_field}" unless @oneof
+
+          # Internally, keep the nested associations indexed by ID field
+          @_nested_associations = {}
+          nested_associations.each do |association|
+            if @_nested_associations.has_key? association.id_field.to_sym
+              raise ArgumentError.new("Duplicate association for #{id_field}")
+            end
+            @_nested_associations[association.id_field.to_sym] = association
+          end
+          field_names = @oneof.map{|desc| desc.name.to_sym}
+          unless (field_names.length == @_nested_associations.length &&
+            @_nested_associations.keys.all?{|id_field| field_names.include? id_field})
+            raise ArgumentError.new(
+              'Polymorphic association requires an association to be defined for all nested fields'
+            )
+          end
+        end
+
+        def read(resource)
+          field = resource.message.public_send(id_field)
+          if field
+            @_nested_associations[field].read(resource)
+          else
+            nil
+          end
+        end
+
+        def write(resource, value)
+          if value == nil
+            @oneof.each do |field_descriptor|
+              resource.public_send(:"#{field_descriptor.name}=", nil)
+            end
+            nil
+          else
+            # Find the nested reference matching this association type
+            matching_references = @_nested_associations.select do |id_field, reference|
+              value.is_a? reference.associated_resource_class
+            end
+
+            # Make sure we found exactly one
+            if matching_references.empty?
+              raise ArgumentError.new("Could not find matching reference for value of type #{value.class}")
+            end
+            if matching_references.length > 1
+              raise ArgumentError.new(
+                      "Value of type #{value.class} matched with #{matching_references.keys.map(&:to_s).join(', ')}"
+                    )
+            end
+
+            # And forward the write operation
+            matching_references.values.first.write(resource, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protip/standard_converter.rb

@@ -1,5 +1,7 @@
 require 'money'
 
+require 'active_support/time_with_zone'
+
 require 'protip/converter'
 
 require 'protip/messages/currency'
@@ -67,8 +69,29 @@ module Protip
     conversions['google.protobuf.BoolValue'] = {
       to_object: ->(message) { message.value },
       to_message: lambda do |value, message_class|
-      message_class.new value: value_to_boolean(value)
-    end
+        message_class.new value: value_to_boolean(value)
+      end
+    }
+
+    ## ActiveSupport objects
+    conversions['protip.messages.ActiveSupport.TimeWithZone'] = {
+      to_object: ->(message) {
+        ActiveSupport::TimeWithZone.new(
+          Time.at(message.utc_timestamp).utc,
+          ActiveSupport::TimeZone.new(message.time_zone_name)
+        )
+      },
+      to_message: ->(value, message_class) {
+        if !value.is_a?(::ActiveSupport::TimeWithZone) && (value.is_a?(Time) || value.is_a?(DateTime))
+          value = ::ActiveSupport::TimeWithZone.new(value.to_time.utc, ::ActiveSupport::TimeZone.new('UTC'))
+        end
+        raise ArgumentError unless value.is_a?(::ActiveSupport::TimeWithZone)
+
+        message_class.new(
+          utc_timestamp: value.to_i,
+          time_zone_name: value.time_zone.name,
+        )
+      }
     }
 
     def convertible?(message_class)

data/test/functional/protip/resource_test.rb

@@ -28,26 +28,27 @@ describe 'Protip::Resource (functional)' do
         optional :ordered_tests, :string, 3
         optional :nested_message, :message, 4, 'nested_message'
         optional :nested_int, :message, 5, 'google.protobuf.Int64Value'
+        optional :association_id, :message, 6, 'google.protobuf.Int64Value'
       end
 
       add_message 'resource_query' do
-        optional :param, :string, 6
+        optional :param, :string, 7
       end
 
       add_message 'name_response' do
-        optional :name, :string, 7
+        optional :name, :string, 8
       end
 
       add_message 'search_request' do
-        optional :term, :string, 8
+        optional :term, :string, 9
       end
 
       add_message 'search_response' do
-        repeated :results, :string, 9
+        repeated :results, :string, 10
       end
 
       add_message 'fetch_request' do
-        repeated :names, :string, 10
+        repeated :names, :string, 11
       end
     end
     pool
@@ -112,10 +113,19 @@ describe 'Protip::Resource (functional)' do
         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)
+        assert_equal(
+          {
+            'ordered_tests' => 'bilbo', 'id' => 0, 'nested_message' => nil, 'nested_int' => 42, 'association_id' => nil
+          },
+          results[0].attributes
+        )
+        assert_equal(
+          {
+            'ordered_tests' => 'baggins', 'id' => 1, 'nested_message' => nil, 'nested_int' => 43,
+            'association_id' => nil
+          },
+          results[1].attributes
+      )
       end
 
       it 'allows requests without parameters' do
@@ -232,4 +242,41 @@ describe 'Protip::Resource (functional)' do
   describe '.collection' do
     # TODO
   end
+
+  describe '.belongs_to' do
+    before do
+      resource_class.class_eval do
+        belongs_to :association, class_name: 'ResourceClass', id_field: :association_id
+      end
+    end
+
+    it 'returns nil when no association ID has been set' do
+      Object.stub_const(:ResourceClass, resource_class) do
+        resource_class.expects(:find).never
+        assert_nil resource_class.new.association
+      end
+    end
+
+    it 'fetches the associated resource' do
+      Object.stub_const(:ResourceClass, resource_class) do
+        associated = mock
+        resource_class.expects(:find).once.with(123).returns(associated)
+        assert_equal associated, resource_class.new(association_id: 123).association
+      end
+    end
+
+    it 'allows writing the associated resource' do
+      Object.stub_const(:ResourceClass, resource_class) do
+        associated = resource_class.new
+        associated.id = 5
+        base = resource_class.new
+        base.association = associated
+        assert_equal 5, base.association_id
+      end
+    end
+  end
+
+  describe '.belongs_to_polymorphic' do
+    # TODO
+  end
 end

data/test/test_helper.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
 require 'mocha/mini_test'
 require 'webmock/minitest'
+require 'minitest/stub/const'
 
 require 'minitest/pride'

data/test/unit/protip/resource/associations/association_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+require 'google/protobuf'
+require 'protip/resource/associations/association'
+
+describe Protip::Resource::Associations::Association do
+  let :resource_class do
+    pool = Google::Protobuf::DescriptorPool.new
+    pool.build do
+      add_message 'ResourceMessage' do
+        optional :id, :string, 1
+      end
+    end
+    Class.new do
+      include Protip::Resource
+      resource actions: [], message: pool.lookup('ResourceMessage').msgclass
+    end
+  end
+
+  let :association_class do
+    Class.new do
+      include Protip::Resource::Associations::Association
+      attr_reader :resource_class, :association_name
+      def initialize(resource_class, association_name)
+        @resource_class, @association_name = resource_class, association_name
+      end
+    end
+  end
+
+  describe '#define_accessors!' do
+    let :association do
+      association_class.new(resource_class, :reference)
+    end
+
+    it 'defines read and write methods' do
+      # Sanity checks
+      refute_includes resource_class.instance_methods, :reference, 'reader already set'
+      refute_includes resource_class.instance_methods, :reference=, 'writer already set'
+
+      association.define_accessors!
+
+      assert_includes resource_class.instance_methods, :reference, 'reader not set'
+      assert_includes resource_class.instance_methods, :reference=, 'writer not set'
+    end
+
+    describe '(after invoked)' do
+      let :resource do
+        resource_class.new
+      end
+
+      before do
+        association.define_accessors!
+      end
+
+      it 'receives reader calls from resource instances' do
+        association.expects(:read).once.with(resource)
+        resource.reference
+      end
+
+      it 'receives writer calls from resource instances' do
+        association.expects(:write).once.with(resource, 'test')
+        resource.reference = 'test'
+      end
+    end
+  end
+end

data/test/unit/protip/resource/associations/belongs_to_association_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+
+require 'protip/resource/associations/belongs_to_association'
+
+describe Protip::Resource::Associations::BelongsToAssociation do
+  let :pool do
+    pool = Google::Protobuf::DescriptorPool.new
+    pool.build do
+      # Allow nil ID fields
+      add_message 'google.protobuf.StringValue' do
+        optional :value, :string, 1
+      end
+      add_message 'ResourceMessage' do
+        optional :id, :message, 1, 'google.protobuf.StringValue'
+        optional :referenced_resource_id, :message, 2, 'google.protobuf.StringValue'
+      end
+      add_message 'ReferencedResourceMessage' do
+        optional :id, :message, 1, 'google.protobuf.StringValue'
+      end
+    end
+    pool
+  end
+  let :resource_class do
+    klass = Class.new do
+      include Protip::Resource
+    end
+    klass.class_exec(pool) do |pool|
+      resource actions: [], message: pool.lookup('ResourceMessage').msgclass
+    end
+    klass
+  end
+
+  let :referenced_resource_class do
+    klass = Class.new do
+      include Protip::Resource
+    end
+    klass.class_exec(pool) do |pool|
+      resource actions: [], message: pool.lookup('ReferencedResourceMessage').msgclass
+    end
+    klass
+  end
+
+  describe '#initialize' do
+    describe '(class_name option)' do
+      # These rely on private behavior - that `associated_resource_class` gives the association class after init
+      it 'chooses a default class based on the association name' do
+        Object.stub_const 'ReferencedResource', referenced_resource_class do
+          reference = Protip::Resource::Associations::BelongsToAssociation.new resource_class,
+            :referenced_resource
+          assert_equal referenced_resource_class, reference.associated_resource_class
+        end
+      end
+      it 'allows a class name to be set' do
+        Object.stub_const 'Foo', referenced_resource_class do
+          reference = Protip::Resource::Associations::BelongsToAssociation.new resource_class,
+            :referenced_resource, class_name: 'Foo'
+          assert_equal referenced_resource_class, reference.associated_resource_class
+        end
+      end
+    end
+    describe '(id_field option)' do
+      it 'chooses a default ID field based on the association name' do
+        Object.stub_const 'ReferencedResource', referenced_resource_class do
+          reference = Protip::Resource::Associations::BelongsToAssociation.new resource_class,
+            :referenced_resource
+          assert_equal :referenced_resource_id, reference.id_field
+        end
+      end
+      it 'allows an association name to be set' do
+        Object.stub_const 'ReferencedResource', referenced_resource_class do
+          reference = Protip::Resource::Associations::BelongsToAssociation.new resource_class,
+            :referenced_resource, id_field: :foo_bar
+          assert_equal :foo_bar, reference.id_field
+        end
+      end
+    end
+  end
+
+  describe '(accessors)' do
+    let :reference do
+      reference = Protip::Resource::Associations::BelongsToAssociation.new resource_class, :referenced_resource
+      reference.stubs(:associated_resource_class).returns(referenced_resource_class) # internal behavior
+      reference
+    end
+
+    let :resource do
+      resource_class.new
+    end
+
+    describe '#read' do
+      it 'finds the association by ID' do
+        referenced_resource = mock
+        referenced_resource_class.expects(:find).once.with('asdf').returns(referenced_resource)
+        resource.referenced_resource_id = 'asdf'
+        assert_equal referenced_resource, reference.read(resource)
+      end
+
+      it 'returns nil if the resource has not been set' do
+        resource.referenced_resource_id = nil
+        referenced_resource_class.expects(:find).never
+        assert_nil reference.read(resource)
+      end
+    end
+
+    describe '#write' do
+      it 'raises an error if given the wrong resource type' do
+        assert_raises ArgumentError do
+          reference.write(resource, resource)
+        end
+      end
+
+      it 'raises an error if given a non-persisted resource' do
+        assert_raises RuntimeError do
+          reference.write(resource, referenced_resource_class.new)
+        end
+      end
+
+      it 'assigns nil if nil is given' do
+        resource.referenced_resource_id = 'asdf'
+        reference.write(resource, nil)
+        assert_nil resource.referenced_resource_id
+      end
+
+      it 'assigns the resource ID if a persisted resource of the correct type is given' do
+        reference.write(resource, referenced_resource_class.new(id: 'foo'))
+        assert_equal 'foo', resource.referenced_resource_id
+      end
+    end
+  end
+
+end

data/test/unit/protip/resource/associations/belongs_to_polymorphic_association_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+require 'protip/resource/associations/belongs_to_polymorphic_association'
+
+describe Protip::Resource::Associations::BelongsToPolymorphicAssociation do
+
+  let :resource_class do
+    pool = Google::Protobuf::DescriptorPool.new
+    pool.build do
+      add_message 'ResourceMessage' do
+        optional :id, :string, 1
+        oneof :reference_id do
+          optional :rick_ross_id, :string, 2
+          optional :fetty_wap_id, :string, 3
+        end
+        optional :other_id, :string, 4
+      end
+    end
+    Class.new do
+      include Protip::Resource
+      resource actions: [], message: pool.lookup('ResourceMessage').msgclass
+    end
+  end
+
+  let :rick_ross_association do
+    association = mock.responds_like_instance_of(Protip::Resource::Associations::BelongsToAssociation)
+    association.stubs(:id_field).returns(:rick_ross_id)
+    association
+  end
+
+  let :fetty_wap_association do
+    association = mock.responds_like_instance_of(Protip::Resource::Associations::BelongsToAssociation)
+    association.stubs(:id_field).returns(:fetty_wap_id)
+    association
+  end
+
+  let :other_association do
+    association = mock.responds_like_instance_of(Protip::Resource::Associations::BelongsToAssociation)
+    association.stubs(:id_field).returns(:other_id)
+    association
+  end
+
+  describe '#initialize' do
+    it 'raises an error unless a belongs-to association is provided for all nested fields' do
+      error = assert_raises ArgumentError do
+        Protip::Resource::Associations::BelongsToPolymorphicAssociation.new resource_class,
+          :reference, [rick_ross_association]
+      end
+      assert_match /requires an association to be defined/, error.message
+    end
+
+    it 'raises an error if a belongs-to association is provided for a field outside the oneof' do
+      error = assert_raises ArgumentError do
+        Protip::Resource::Associations::BelongsToPolymorphicAssociation.new resource_class,
+          :reference, [rick_ross_association, other_association]
+      end
+      assert_match /requires an association to be defined/, error.message
+    end
+
+    it 'raises an error if a duplicate belongs-to association is provided' do
+      error = assert_raises ArgumentError do
+        Protip::Resource::Associations::BelongsToPolymorphicAssociation.new resource_class,
+          :reference, [rick_ross_association, rick_ross_association, fetty_wap_association]
+      end
+      assert_match /Duplicate association/, error.message
+    end
+
+    it 'allows the oneof ID field to be specified' do
+     association = Protip::Resource::Associations::BelongsToPolymorphicAssociation.new resource_class,
+       :foo, [rick_ross_association, fetty_wap_association], id_field: :reference_id
+      assert_equal :reference_id, association.id_field
+    end
+  end
+
+  describe '(accessors)' do
+    let(:association) do
+      Protip::Resource::Associations::BelongsToPolymorphicAssociation.new resource_class, :reference,
+        [rick_ross_association, fetty_wap_association]
+    end
+
+    describe '#read' do
+      it 'forwards to the nested association that\'s currently been set' do
+        # Create a test instance with one of the fields set
+        resource = resource_class.new fetty_wap_id: 'test'
+
+        rick_ross_association.expects(:read).never
+        fetty_wap_association.expects(:read).once.with(resource).returns('come my way')
+
+        assert_equal 'come my way', association.read(resource)
+      end
+
+      it 'returns nil if no nested association has been set' do
+        resource = resource_class.new
+
+        rick_ross_association.expects(:read).never
+        fetty_wap_association.expects(:read).never
+
+        assert_nil association.read(resource)
+      end
+    end
+
+    describe '#write' do
+      let(:rick_ross_class) { Class.new }
+      let(:fetty_wap_class) { Class.new }
+      before do
+        rick_ross_association.stubs(:associated_resource_class).returns(rick_ross_class)
+        fetty_wap_association.stubs(:associated_resource_class).returns(fetty_wap_class)
+      end
+      it 'forwards to the nested association that matches the class being set' do
+        resource = resource_class.new
+        fetty_wap = fetty_wap_class.new
+
+        rick_ross_association.expects(:write).never
+        fetty_wap_association.expects(:write).once.with(resource, fetty_wap)
+
+        association.write(resource, fetty_wap)
+      end
+
+      # Sanity check, try out forwarding for the other type as well
+      it 'forwards to the nested association that matches the class being set, if that association comes first' do
+        resource = resource_class.new
+        rick_ross = rick_ross_class.new
+
+        rick_ross_association.expects(:write).once.with(resource, rick_ross)
+        fetty_wap_association.expects(:write).never
+
+        association.write(resource, rick_ross)
+      end
+
+      it 'wipes all associations if nil is given' do
+        resource = resource_class.new
+        resource.rick_ross_id = 'asfd'
+
+        association.write(resource, nil)
+
+        assert_nil resource.rick_ross_id
+        assert_nil resource.fetty_wap_id
+      end
+    end
+  end
+end

data/test/unit/protip/resource_test.rb

@@ -865,6 +865,101 @@ module Protip::ResourceTest # Namespace for internal constants
       describe_non_resourceful_action 'collection', 'base_path/action'
     end
 
+    # Common tests for both types of belongs_to association. Assumes a `let(:association)` statement
+    # has been provided, to give a mock of the appropriate association with `define_accessors!` stubbed out
+    # If a block is needed to run the method, it can be provided
+    def self.describe_association_method!(method, association_class, &block)
+      describe '(common behvaior)' do
+        it 'defines accessors' do
+          association_class.expects(:new).once.returns(association)
+          association.expects(:define_accessors!).once
+          resource_class.class_exec(method) { |method| send method, :association_name, &block }
+        end
+
+        it 'returns the created association' do
+          association_class.expects(:new).once.returns(association)
+          resource_class.class_exec(method) { |method |@result = send method, :association_name, &block }
+          assert_equal association, resource_class.instance_variable_get(:'@result'), 'association was not returned'
+        end
+
+        it 'raises an error on invalid options' do
+          error = assert_raises ArgumentError do
+            resource_class.class_exec(method) do |method|
+              send method, :association_name, bad_option: 'bad', &block
+            end
+          end
+          assert_match /bad_option/, error.message
+        end
+      end
+    end
+
+    describe '.belongs_to' do
+      let :association do
+        association = mock.responds_like_instance_of Protip::Resource::Associations::BelongsToAssociation
+        association.stubs(:define_accessors!)
+        association
+      end
+
+      it 'creates a belongs_to association and passes in options' do
+        Protip::Resource::Associations::BelongsToAssociation.expects(:new).once
+          .with(resource_class, :association_name, class_name: 'Foo')
+          .returns(association)
+        resource_class.class_eval { belongs_to :association_name, class_name: 'Foo' }
+      end
+
+      describe_association_method! :belongs_to, Protip::Resource::Associations::BelongsToAssociation
+    end
+
+    describe '.belongs_to_polymorphic' do
+      let :association do
+        association = mock.responds_like_instance_of Protip::Resource::Associations::BelongsToPolymorphicAssociation
+        association.stubs(:define_accessors!)
+        association
+      end
+
+      it 'creates a polymorphic belongs_to association, passing in nested associations from its yielded block' do
+        nested_association = mock.responds_like_instance_of Protip::Resource::Associations::BelongsToAssociation
+        resource_class.expects(:belongs_to).once.with(:foo).returns(nested_association)
+
+        Protip::Resource::Associations::BelongsToPolymorphicAssociation.expects(:new).once
+          .with(resource_class, :bar, [nested_association], id_field: 'field').returns(association)
+
+        resource_class.class_eval do
+          belongs_to_polymorphic :bar, id_field: 'field' do
+            belongs_to :foo
+          end
+        end
+      end
+
+      describe_association_method!(:belongs_to_polymorphic,
+        Protip::Resource::Associations::BelongsToPolymorphicAssociation) { }
+    end
+
+    # {
+    #   references_through_one_of: Protip::Resource::Associations::ReferencesThroughOneOfAssociation,
+    # }.each do |method, association_class|
+    #   describe ".#{method}" do
+    #     it 'creates an association of the correct type and defines accessors' do
+    #       association = mock.responds_like_instance_of(association_class)
+    #       association_class.expects(:new).once.with(resource_class, :some_id, {class_name: 'Foo'}).returns(association)
+    #       association.expects(:define_accessors!)
+    #       resource_class.class_exec(method) do
+    #         send(method, :some_id, class_name: 'Foo')
+    #       end
+    #     end
+    #
+    #     it 'raises an error on invalid options' do
+    #       error = assert_raises ArgumentError do
+    #         resource_class.class_exec(method) do
+    #           send(method, :some_id, bad_option: 'bad')
+    #         end
+    #       end
+    #
+    #       assert_match /bad_option/, error.message
+    #     end
+    #   end
+    # end
+
     describe '.converter' do
       describe 'default value' do
         it 'defaults to the standard converter' do

data/test/unit/protip/standard_converter_test.rb

@@ -2,6 +2,7 @@ require 'test_helper'
 require 'money'
 
 require 'google/protobuf/wrappers'
+require 'protip/messages/active_support/time_with_zone'
 require 'protip/standard_converter'
 
 describe Protip::StandardConverter do
@@ -99,6 +100,15 @@ describe Protip::StandardConverter do
       assert_equal 250, money.fractional
       assert_equal ::Money.new(250, 'CAD'), money
     end
+
+    it 'converts times with zones' do
+      message = ::Protip::Messages::ActiveSupport::TimeWithZone.new utc_timestamp: 1451610000,
+                                                                    time_zone_name: 'America/Los_Angeles'
+      time = converter.to_object(message)
+      assert_instance_of ::ActiveSupport::TimeWithZone, time
+      assert_equal 1451610000, time.to_i
+      assert_equal '2015-12-31T17:00:00-08:00', time.iso8601
+    end
   end
 
   describe '#to_message' do
@@ -166,5 +176,28 @@ describe Protip::StandardConverter do
         end
       end
     end
+
+    it 'converts times with zones' do
+      time_with_zone = ::ActiveSupport::TimeWithZone.new(Time.new(2016, 1, 1, 0, 0, 0, 0),
+        ::ActiveSupport::TimeZone.new('America/New_York'))
+      message = converter.to_message(time_with_zone, ::Protip::Messages::ActiveSupport::TimeWithZone)
+      assert_equal 1451606400, message.utc_timestamp
+      assert_equal 'America/New_York', message.time_zone_name
+    end
+
+    it 'converts times without zones' do
+      time = Time.new(2016, 1, 1, 0, 0, 0, -3600)
+      message = converter.to_message(time, ::Protip::Messages::ActiveSupport::TimeWithZone)
+      assert_equal 1451610000, message.utc_timestamp
+      assert_equal 'UTC', message.time_zone_name
+    end
+
+    it 'converts datetimes without zones' do
+      datetime = DateTime.new(2016, 1, 1, 0, 0, 0, '-1')
+      message = converter.to_message(datetime, ::Protip::Messages::ActiveSupport::TimeWithZone)
+      assert_equal 1451610000, message.utc_timestamp
+      assert_equal 'UTC', message.time_zone_name
+
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protip
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - AngelList
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -98,6 +98,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-stub-const
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +179,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - definitions/google/protobuf/wrappers.proto
+- definitions/protip/messages/active_support/time_with_zone.proto
 - definitions/protip/messages/array.proto
 - definitions/protip/messages/currency.proto
 - definitions/protip/messages/errors.proto
@@ -176,6 +191,7 @@ files:
 - lib/protip/client.rb
 - lib/protip/converter.rb
 - lib/protip/error.rb
+- lib/protip/messages/active_support/time_with_zone.rb
 - lib/protip/messages/array.rb
 - lib/protip/messages/currency.rb
 - lib/protip/messages/errors.rb
@@ -183,6 +199,9 @@ files:
 - lib/protip/messages/range.rb
 - lib/protip/messages/types.rb
 - lib/protip/resource.rb
+- lib/protip/resource/associations/association.rb
+- lib/protip/resource/associations/belongs_to_association.rb
+- lib/protip/resource/associations/belongs_to_polymorphic_association.rb
 - lib/protip/resource/creatable.rb
 - lib/protip/resource/destroyable.rb
 - lib/protip/resource/extra_methods.rb
@@ -192,6 +211,9 @@ files:
 - lib/protip/wrapper.rb
 - test/functional/protip/resource_test.rb
 - test/test_helper.rb
+- test/unit/protip/resource/associations/association_test.rb
+- test/unit/protip/resource/associations/belongs_to_association_test.rb
+- test/unit/protip/resource/associations/belongs_to_polymorphic_association_test.rb
 - test/unit/protip/resource_test.rb
 - test/unit/protip/standard_converter_test.rb
 - test/unit/protip/wrapper_test.rb