prepor-protobuf 3.5.0

data/spec/lib/protobuf/field/bool_field_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Int32Field do
+
+  class SomeBoolMessage < ::Protobuf::Message
+    optional :bool, :some_bool, 1
+  end
+
+  let(:instance) { SomeBoolMessage.new }
+
+  describe '#define_setter' do
+    subject { instance.some_bool = value; instance.some_bool }
+
+    [true, false].each do |val|
+      context "when set with #{val}" do
+        let(:value) { val }
+
+        it 'is readable as a bool' do
+          expect(subject).to eq(val)
+        end
+      end
+    end
+
+    [['true', true], ['false', false]].each do |val, expected|
+      context "when set with a string of #{val}" do
+        let(:value) { val }
+
+        it 'is readable as a bool' do
+          expect(subject).to eq(expected)
+        end
+      end
+    end
+
+    context 'when set with a non-bool string' do
+      let(:value) { "aaaa" }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with something that is not a bool' do
+      let(:value) { [1, 2, 3] }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/field/field_array_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FieldArray do
+
+  class SomeBasicMessage < ::Protobuf::Message
+    optional :string, :field, 1
+  end
+
+  class MoreComplexMessage < SomeBasicMessage
+  end
+
+  class OtherBasicMessage < ::Protobuf::Message
+    optional :string, :other_field, 1
+  end
+
+  class SomeRepeatMessage < ::Protobuf::Message
+    optional :string, :some_string, 1
+    repeated :string, :multiple_strings, 2
+    repeated SomeBasicMessage, :multiple_basic_msgs, 3
+  end
+
+  let(:instance) { SomeRepeatMessage.new }
+
+  %w(<< push).each do |method|
+    describe "\##{method}" do
+      context 'when applied to a string field array' do
+        it 'adds a string' do
+          expect(instance.multiple_strings).to be_empty
+          instance.multiple_strings.send(method, 'string 1')
+          expect(instance.multiple_strings).to eq(['string 1'])
+          instance.multiple_strings.send(method, 'string 2')
+          expect(instance.multiple_strings).to eq(['string 1', 'string 2'])
+        end
+
+        it 'fails if not adding a string' do
+          expect { instance.multiple_strings.send(method, 100.0) }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when applied to a MessageField field array' do
+        it 'adds a MessageField object' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = SomeBasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg1)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+          basic_msg2 = SomeBasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg2)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1, basic_msg2])
+        end
+
+        it 'adds a Hash from a MessageField object' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = SomeBasicMessage.new
+          basic_msg1.field = 'my value'
+          instance.multiple_basic_msgs.send(method, basic_msg1.to_hash)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+        end
+
+        it 'does not downcast a MessageField' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = MoreComplexMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg1)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+          expect(instance.multiple_basic_msgs.first).to be_a(MoreComplexMessage)
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf/field/float_field_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FloatField do
+
+  class SomeFloatMessage < ::Protobuf::Message
+    optional :float, :some_float, 1
+  end
+
+  let(:instance) { SomeFloatMessage.new }
+
+  describe '#define_setter' do
+    subject { instance.some_float = value; instance.some_float }
+
+    context 'when set with an int' do
+      let(:value) { 100 }
+
+      it 'is readable as a float' do
+        expect(subject).to eq(100.0)
+      end
+    end
+
+    context 'when set with a float' do
+      let(:value) { 100.1 }
+
+      it 'is readable as a float' do
+        expect(subject).to eq(100.1)
+      end
+    end
+
+    context 'when set with a string of a float' do
+      let(:value) { "101.1" }
+
+      it 'is readable as a float' do
+        expect(subject).to eq(101.1)
+      end
+    end
+
+    context 'when set with a non-numeric string' do
+      let(:value) { "aaaa" }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when set with something that is not a float' do
+      let(:value) { [1, 2, 3] }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/field/int32_field_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Int32Field do
+
+  it_behaves_like :packable_field, described_class
+
+  class SomeInt32Message < ::Protobuf::Message
+    optional :int32, :some_int, 1
+  end
+
+  let(:instance) { SomeInt32Message.new }
+
+  describe '#define_setter' do
+    subject { instance.some_int = value; instance.some_int }
+
+    context 'when set with an int' do
+      let(:value) { 100 }
+
+      it 'is readable as an int' do
+        expect(subject).to eq(100)
+      end
+    end
+
+    context 'when set with a float' do
+      let(:value) { 100.1 }
+
+      it 'is readable as an int' do
+        expect(subject).to eq(100)
+      end
+    end
+
+    context 'when set with a string of an int' do
+      let(:value) { "101" }
+
+      it 'is readable as an int' do
+        expect(subject).to eq(101)
+      end
+    end
+
+    context 'when set with a negative representation of an int as string' do
+      let(:value) { "-101" }
+
+      it 'is readable as a negative int' do
+        expect(subject).to eq(-101)
+      end
+    end
+
+    context 'when set with a non-numeric string' do
+      let(:value) { "aaaa" }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with a string of an int in hex format' do
+      let(:value) { "0x101" }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with a string of an int larger than int32 max' do
+      let(:value) { (described_class.max + 1).to_s }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with something that is not an int' do
+      let(:value) { [1, 2, 3] }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with a timestamp' do
+      let(:value) { Time.now }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/field/string_field_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe ::Protobuf::Field::StringField do
+
+  describe '#encode' do
+    context 'when a repeated string field contains frozen strings' do
+      it 'does not raise an encoding error' do
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
+          ::Test::ResourceFindRequest.encode(:name => 'resource', :widgets => frozen_strings)
+        end.not_to raise_error
+      end
+    end
+
+    context 'when a repeated bytes field contains frozen strings' do
+      it 'does not raise an encoding error' do
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
+          ::Test::ResourceFindRequest.encode(:name => 'resource', :widget_bytes => frozen_strings)
+        end.not_to raise_error
+      end
+    end
+
+    it 'does not alter string values after encoding multiple times' do
+      source_string = "foo"
+      proto = ::Test::Resource.new(:name => source_string)
+      proto.encode
+      expect(proto.name).to eq source_string
+      proto.encode
+      expect(proto.name).to eq source_string
+    end
+
+    it 'does not alter unicode string values after encoding multiple times' do
+      source_string = "¢"
+      proto = ::Test::Resource.new(:name => source_string)
+      proto.encode
+      expect(proto.name).to eq source_string
+      proto.encode
+      expect(proto.name).to eq source_string
+    end
+  end
+
+end

data/spec/lib/protobuf/field_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'protobuf/field'
+
+RSpec.describe ::Protobuf::Field do
+
+  describe '.build' do
+    pending
+  end
+
+  describe '.field_class' do
+    context 'when type is an enum class' do
+      it 'returns an enum field' do
+        expect(subject.field_class(::Test::EnumTestType)).to eq(::Protobuf::Field::EnumField)
+        expect(subject.field_type(::Test::EnumTestType)).to eq(::Test::EnumTestType)
+      end
+    end
+
+    context 'when type is a message class' do
+      it 'returns a message field' do
+        expect(subject.field_class(::Test::Resource)).to eq(::Protobuf::Field::MessageField)
+        expect(subject.field_type(::Test::Resource)).to eq(::Test::Resource)
+      end
+    end
+
+    context 'when type is a base field class' do
+      it 'returns that class' do
+        expect(subject.field_class(::Protobuf::Field::BoolField)).to eq(::Protobuf::Field::BoolField)
+      end
+    end
+
+    context 'when type is a double field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::DoubleField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:double)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:double)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a float field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::FloatField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:float)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:float)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a string field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::StringField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:string)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:string)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a bytes field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BytesField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bytes)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bytes)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a bool field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BoolField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bool)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bool)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is not mapped' do
+      it 'raises an ArgumentError' do
+        expect do
+          subject.field_class("boom")
+        end.to raise_error
+      end
+    end
+
+  end
+
+end