protip 0.20.7 → 0.30.0

data/test/unit/protip/transformers/deprecated_transformer_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+
+require 'protip/transformers/deprecated_transformer'
+
+require 'protip/messages'
+
+describe Protip::Transformers::DeprecatedTransformer do
+  let(:transformer) { Protip::Transformers::DeprecatedTransformer.new }
+  let(:message_class) { raise NotImplementedError } # sub-sections must define
+  let(:field) do
+    field = mock.responds_like_instance_of ::Google::Protobuf::FieldDescriptor
+    field.stubs(:submsg_name).returns(message_class.descriptor.name)
+    field.stubs(:subtype).returns(message_class.descriptor)
+    field
+  end
+
+  describe '#to_object' do
+    describe 'Date' do
+      let(:message_class) { Protip::Messages::Date }
+      it 'converts dates' do
+        date = transformer.to_object(message_class.new(year: 2015, month: 2, day: 9), field)
+        assert_instance_of ::Date, date
+        assert_equal '2015-02-09', date.strftime
+      end
+    end
+
+    describe 'Range' do
+      let(:message_class) { Protip::Messages::Range }
+      it 'converts ranges' do
+        range = transformer.to_object(message_class.new(begin: 1, end: 4), field)
+        assert_instance_of ::Range, range
+        assert_equal 1..4, range
+      end
+    end
+
+    describe 'Currency' do
+      let(:message_class) { Protip::Messages::Currency }
+      it 'converts currency' do
+        currency = transformer.to_object(message_class.new(currency_code: :GBP), field)
+        assert_equal :GBP, currency
+      end
+    end
+
+    describe 'Money' do
+      let(:message_class) { Protip::Messages::Money }
+      it 'converts money' do
+        message = message_class.new amount_cents: 250,
+          currency: (Protip::Messages::Currency.new currency_code: :CAD)
+        money = transformer.to_object(message, field)
+        assert_instance_of ::Money, money
+        assert_equal ::Money::Currency.new(:CAD), money.currency
+        assert_equal 250, money.fractional
+        assert_equal ::Money.new(250, 'CAD'), money
+      end
+    end
+
+    describe 'ActiveSupport::TimeWithZone' do
+      let(:message_class) { Protip::Messages::ActiveSupport::TimeWithZone }
+      it 'converts times with zones' do
+        message = message_class.new utc_timestamp: 1451610000,
+          time_zone_name: 'America/Los_Angeles'
+        time = transformer.to_object(message, field)
+        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
+  end
+
+  describe '#to_message' do
+    describe 'Date' do
+      let(:message_class) { Protip::Messages::Date }
+      it 'converts dates' do
+        date = ::Date.new(2012, 5, 7)
+        assert_equal 7, date.day # Sanity check argument order
+        assert_equal message_class.new(year: 2012, month: 5, day: 7),
+          transformer.to_message(date, field)
+      end
+    end
+
+    describe 'Range' do
+      let(:message_class) { Protip::Messages::Range }
+      it 'converts ranges' do
+        range = -1..34
+        assert_equal message_class.new(begin: -1, end: 34),
+          transformer.to_message(range, field)
+      end
+    end
+
+    describe 'Currency' do
+      let(:message_class) { Protip::Messages::Currency }
+      it 'converts currency' do
+        currency = :HKD
+        message = transformer.to_message(currency, field)
+        assert_equal message_class.new(currency_code: currency), message
+      end
+    end
+
+    describe 'Money' do
+      let(:message_class) { Protip::Messages::Money }
+      it 'converts money' do
+        money = ::Money.new(250, 'CAD')
+        message = transformer.to_message(money, field)
+        assert_instance_of message_class, message
+        assert_equal message_class.new(
+          amount_cents: money.cents,
+          currency: Protip::Messages::Currency.new(
+            currency_code: money.currency.iso_code.to_sym
+          )),
+          message
+      end
+    end
+
+    describe 'ActiveSupport::TimeWithZone' do
+      let(:message_class) { Protip::Messages::ActiveSupport::TimeWithZone }
+      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 = transformer.to_message(time_with_zone, field)
+        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 = transformer.to_message(time, field)
+        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 = transformer.to_message(datetime, field)
+        assert_equal 1451610000, message.utc_timestamp
+        assert_equal 'UTC', message.time_zone_name
+      end
+    end
+  end
+end

data/test/unit/protip/transformers/enum_transformer_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+require 'protip/transformers/enum_transformer'
+
+require 'protip/messages'
+
+describe Protip::Transformers::EnumTransformer do
+  let(:transformer) { Protip::Transformers::EnumTransformer.new }
+  let(:pool) do
+    # See https://github.com/google/protobuf/blob/master/ruby/tests/generated_code.rb for
+    # examples of field types you can add here
+    pool = Google::Protobuf::DescriptorPool.new
+    pool.build do
+      add_enum 'number' do
+        value :ZERO, 0
+        value :ONE, 1
+      end
+    end
+    pool
+  end
+  let(:enum) { pool.lookup 'number' }
+  let(:message_class) { raise NotImplementedError } # sub-sections must define
+  let(:field) do
+    field = mock.responds_like_instance_of ::Google::Protobuf::FieldDescriptor
+    field.stubs(:submsg_name).returns(message_class.descriptor.name)
+    field.stubs(:subtype).returns(message_class.descriptor)
+    field
+  end
+
+  before do
+    Protip::Transformers::EnumTransformer.stubs(:enum_for_field).
+      returns(enum)
+  end
+
+  describe '#to_object' do
+    describe 'scalars' do
+      let(:message_class) { Protip::Messages::EnumValue }
+      it 'transforms enum values in range to symbols' do
+        message = message_class.new(value: 1)
+        assert_equal :ONE, transformer.to_object(message, field)
+      end
+      it 'transforms enum values out of range to integers' do
+        message = message_class.new(value: 5)
+        assert_equal 5, transformer.to_object(message, field)
+      end
+    end
+    describe 'arrays' do
+      let(:message_class) { Protip::Messages::RepeatedEnum }
+      it 'transforms repeated enum values in range to symbols' do
+        message = message_class.new(values: [0, 1])
+        assert_equal [:ZERO, :ONE], transformer.to_object(message, field)
+      end
+      it 'transforms repeated enum values out of range to integers' do
+        message = message_class.new(values: [3, 1, 5])
+        assert_equal [3, :ONE, 5], transformer.to_object(message, field)
+      end
+    end
+  end
+
+  describe '#to_message' do
+    %w(zero one two).each do |number| # values symbolizing as :ZERO, :ONE, :TWO
+      let number do
+        value = mock
+        value.stubs(:to_sym).returns(number.upcase.to_sym)
+        value
+      end
+    end
+
+    describe 'scalars' do
+      let(:message_class) { Protip::Messages::EnumValue }
+      it 'transforms integers to messages' do
+        assert_equal message_class.new(value: 1), transformer.to_message(1, field)
+      end
+      it 'transforms non-integers via :to_sym' do
+        assert_equal message_class.new(value: 1), transformer.to_message(one, field)
+      end
+      it 'throws an error when an out-of-range symbol is given' do
+        field.stubs(:name).returns('FOO') # The exception message contains this
+        exception = assert_raises RangeError do
+          transformer.to_message(two, field)
+        end
+        assert_match(/FOO/, exception.message)
+      end
+    end
+
+    describe 'arrays' do
+      let(:message_class) { Protip::Messages::RepeatedEnum }
+      it 'transforms integers' do
+        assert_equal message_class.new(values: [1, 4]),
+          transformer.to_message([1, 4], field)
+      end
+      it 'transforms non-integers via :to_sym' do
+        assert_equal message_class.new(values: [0, 2, 1]),
+          transformer.to_message([zero, 2, one], field)
+      end
+      it 'throws an error when an out-of-range symbol is given' do
+        field.stubs(:name).returns('FOO') # The exception message contains this
+        exception = assert_raises RangeError do
+          transformer.to_message([0, two], field)
+        end
+        assert_match(/FOO/, exception.message)
+      end
+      it 'allows assigning a scalar value' do
+        assert_equal message_class.new(values: [1]), transformer.to_message(one, field)
+      end
+    end
+
+  end
+
+  describe '.enum_for_field' do
+    # TODO pending https://github.com/google/protobuf/issues/1198
+  end
+
+  if false #describe '(functional)' do # Temp - test an actual compiled file to make sure our options hack is working
+    require 'protip/messages/test'
+    require 'protip/wrapper'
+    let(:wrapped_message) { Protip::Messages::EnumTest.new }
+    let(:wrapper) { Protip::Wrapper.new wrapped_message, transformer }
+
+    let(:value_map) do
+      {
+        :ONE => :ONE,
+        1 => :ONE,
+        2 => 2,
+      }
+    end
+
+    it 'allows setting and getting a scalar field by Ruby value' do
+      value_map.each do |value, expected|
+        wrapper.enum = value
+        assert_equal expected, wrapper.enum
+      end
+      assert_raises RangeError do
+        wrapper.enum = :TWO
+      end
+    end
+    it 'allows setting and getting a scalar field by message' do
+      wrapper.enum = ::Protip::Messages::EnumValue.new(value: 1)
+      assert_equal :ONE, wrapper.enum
+    end
+
+    it 'allows setting and getting a repeated field by Ruby value' do
+      value_map.each do |value, expected|
+        wrapper.repeated_enums = [value]
+        assert_equal [expected], wrapper.repeated_enums
+      end
+      assert_raises RangeError do
+        wrapper.repeated_enums = [:TWO]
+      end
+    end
+    it 'allows setting and geting a repeated field by message' do
+      wrapper.repeated_enums = ::Protip::Messages::RepeatedEnum.new(values: [2])
+      assert_equal [2], wrapper.repeated_enums
+    end
+  end
+
+end

data/test/unit/protip/transformers/primitives_transformer_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+require 'base64'
+
+require 'protip/transformers/primitives_transformer'
+
+require 'google/protobuf/wrappers'
+require 'protip/messages'
+
+describe ::Protip::Transformers::PrimitivesTransformer do
+  let(:transformer) { ::Protip::Transformers::PrimitivesTransformer.new }
+  let(:message_class) { raise NotImplementedError } # sub-sections must define
+  let(:field) do
+    field = mock.responds_like_instance_of ::Google::Protobuf::FieldDescriptor
+    field.stubs(:submsg_name).returns(message_class.descriptor.name)
+    field.stubs(:subtype).returns(message_class.descriptor)
+    field
+  end
+
+  INTEGER_TYPES = %w(Int64 Int32 UInt64 UInt32)
+  FLOAT_TYPES = %w(Float Double)
+  STRING_TYPES = %w(String)
+  BOOLEAN_TYPES = %w(Bool)
+  BYTES_TYPES = %w(Bytes)
+
+  BYTES_VALUE = Base64.decode64("U2VuZCByZWluZm9yY2VtZW50cw==\n")
+
+  {
+    6           => INTEGER_TYPES,
+    5.5         => FLOAT_TYPES,
+    'foo'       => STRING_TYPES,
+    true        => BOOLEAN_TYPES,
+    BYTES_VALUE => BYTES_TYPES,
+  }.each do |value, types|
+     types.each do |type|
+       describe '#to_object' do
+        describe "google.protobuf.#{type}Value" do
+          let(:message_class) { Google::Protobuf.const_get("#{type}Value") }
+          it 'converts scalar messages' do
+            assert_equal value, transformer.to_object(message_class.new(value: value), field)
+          end
+        end
+
+        describe "protip.messages.Repeated#{type}" do
+          let(:message_class) { Protip::Messages.const_get("Repeated#{type}") }
+          it 'converts repeated mesages to an immutable array' do
+            result = transformer.to_object(message_class.new(values: [value, value]), field)
+            assert_equal [value, value], result
+
+            exception = assert_raises RuntimeError do
+              result << value
+            end
+            assert_equal 'can\'t modify frozen Array', exception.message
+          end
+        end
+
+        describe '#to_message' do
+          # Keys are the actual value that should be set on the message,
+          # values are an object of a different type that should be converted.
+          # Used for testing that e.g. integer types can be set using numeric strings.
+          if INTEGER_TYPES.include?(type) || FLOAT_TYPES.include?(type)
+            let(:native_to_non_native) { {value => value.to_s} }
+          elsif STRING_TYPES.include?(type)
+            let(:native_to_non_native) { {'3' => 3} }
+          elsif BOOLEAN_TYPES.include?(type)
+            let(:native_to_non_native) { {true => 'on', false => 'off'} }
+          else
+            let(:native_to_non_native) { {} }
+          end
+
+          describe "google.protobuf.#{type}Value" do
+            let(:message_class) { Google::Protobuf.const_get("#{type}Value") }
+            it 'converts scalar types to a message' do
+              assert_equal message_class.new(value: value), transformer.to_message(value, field)
+            end
+
+            it "converts non-#{type} types to a #{type} message" do
+              native_to_non_native.each do |native, non_native|
+                assert_equal message_class.new(value: native),
+                  transformer.to_message(non_native, field)
+              end
+            end
+          end
+
+          describe "protip.messages.Repeated#{type}" do
+            let(:message_class) { Protip::Messages.const_get("Repeated#{type}") }
+
+            it 'converts repeated types when given a scalar' do
+              assert_equal message_class.new(values: [value]),
+                transformer.to_message(value, field)
+            end
+
+            it 'converts repeated types when given an array' do
+              assert_equal message_class.new(values: [value, value]),
+                transformer.to_message([value, value], field)
+            end
+
+            it "converts non-#{type} scalar types to a repeated #{type} message" do
+              native_to_non_native.each do |native, non_native|
+                assert_equal message_class.new(values: [native]),
+                  transformer.to_message(non_native, field)
+              end
+            end
+
+            it "converts non-#{type} array types to a repeated #{type} message" do
+              native_to_non_native.each do |native, non_native|
+                assert_equal message_class.new(values: [native, native]),
+                  transformer.to_message([non_native, non_native], field)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#to_message' do
+    let(:message_class) { Google::Protobuf::BoolValue }
+    it 'converts all truthy values to booleans' do
+      [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].each do |truth_value|
+        assert_equal Google::Protobuf::BoolValue.new(value: true),
+          transformer.to_message(truth_value, field)
+      end
+    end
+    it 'converts all falsey values to booleans' do
+      [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].each do |false_value|
+        assert_equal Google::Protobuf::BoolValue.new(value: false),
+          transformer.to_message(false_value, field)
+      end
+    end
+
+    it 'raises an exception if non-boolean values passed to a boolean field' do
+      [nil, 'test', Object.new, 2, {}, []].each do |bad_value|
+        assert_raises TypeError do
+          transformer.to_message(bad_value, field)
+        end
+      end
+    end
+  end
+end

data/test/unit/protip/transformers/timestamp_transformer_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'protip/transformers/timestamp_transformer'
+require 'google/protobuf/timestamp'
+
+describe Protip::Transformers::TimestampTransformer do
+  let(:transformer) { Protip::Transformers::TimestampTransformer.new }
+  let(:field) do
+    field = mock.responds_like_instance_of Google::Protobuf::FieldDescriptor
+    descriptor = Google::Protobuf::Timestamp.descriptor
+    field.stubs(:submsg_name).returns(descriptor.name)
+    field.stubs(:subtype).returns(descriptor)
+    field
+  end
+
+  describe '#to_object' do
+    it 'creates a timestamp' do
+      message = Google::Protobuf::Timestamp.new(seconds: 1415, nanos: 12345678)
+      result = transformer.to_object(message, field)
+      assert_instance_of ::Time, result
+      assert_equal 1415, result.to_i
+      assert_equal 12345678, result.nsec
+    end
+  end
+
+  describe '#to_message' do
+    let(:timestamp) do
+      ::Time.at(601, 1)
+    end
+    let(:expected_message) do
+      Google::Protobuf::Timestamp.new(
+        seconds: 601,
+        nanos: 1000,
+      )
+    end
+    it 'converts times directly' do
+      assert_equal expected_message,
+        transformer.to_message(timestamp, field)
+    end
+    it 'converts non-times via :to_time' do
+      object = mock 'object'
+      object.expects(:to_time).once.returns(timestamp)
+      assert_equal expected_message,
+        transformer.to_message(object, field)
+    end
+  end
+end