protobuf-core 3.5.0

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,90 @@
+require 'spec_helper'
+require 'support/packed_field'
+
+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_generator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+require 'protobuf/generators/field_generator'
+
+RSpec.describe ::Protobuf::Generators::FieldGenerator do
+
+  let(:label_enum) { :LABEL_OPTIONAL }
+  let(:name) { 'foo_bar' }
+  let(:number) { 3 }
+  let(:type_enum) { :TYPE_STRING }
+  let(:type_name) { nil }
+  let(:default_value) { nil }
+  let(:extendee) { nil }
+  let(:field_options) { {} }
+
+  let(:field_fields) do
+    {
+      :label => label_enum,
+      :name => name,
+      :number => number,
+      :type => type_enum,
+      :type_name => type_name,
+      :default_value => default_value,
+      :extendee => extendee,
+      :options => field_options,
+    }
+  end
+
+  let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
+
+  describe '#compile' do
+    subject { described_class.new(field).to_s }
+
+    specify { expect(subject).to eq "optional :string, :foo_bar, 3\n" }
+
+    context 'when the type is another message' do
+      let(:type_enum) { :TYPE_MESSAGE }
+      let(:type_name) { '.foo.bar.Baz' }
+
+      specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
+    end
+
+    context 'when a default value is used' do
+      let(:type_enum) { :TYPE_INT32 }
+      let(:default_value) { '42' }
+      specify { expect(subject).to eq "optional :int32, :foo_bar, 3, :default => 42\n" }
+
+      context 'when type is an enum' do
+        let(:type_enum) { :TYPE_ENUM }
+        let(:type_name) { '.foo.bar.Baz' }
+        let(:default_value) { 'QUUX' }
+
+        specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+      end
+
+      context 'when the type is a string' do
+        let(:type_enum) { :TYPE_STRING }
+        let(:default_value) { "a default \"string\"" }
+
+        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :default => \"a default \"string\"\"\n" }
+      end
+
+      context 'when float or double field type' do
+        let(:type_enum) { :TYPE_DOUBLE }
+
+        context 'when the default value is "nan"' do
+          let(:default_value) { 'nan' }
+          specify { expect(subject).to match(/::Float::NAN/) }
+        end
+
+        context 'when the default value is "inf"' do
+          let(:default_value) { 'inf' }
+          specify { expect(subject).to match(/::Float::INFINITY/) }
+        end
+
+        context 'when the default value is "-inf"' do
+          let(:default_value) { '-inf' }
+          specify { expect(subject).to match(/-::Float::INFINITY/) }
+        end
+      end
+    end
+
+    context 'when the field is an extension' do
+      let(:extendee) { 'foo.bar.Baz' }
+
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :extension => true\n" }
+    end
+
+    context 'when field is packed' do
+      let(:field_options) { { :packed => true } }
+
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :packed => true\n" }
+    end
+
+    context 'when field is deprecated' do
+      let(:field_options) { { :deprecated => true } }
+
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
+    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