protobuf-cucumber 3.10.4

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::DoubleField do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [1.0, 2.0, 3.0] }
+  end
+
+end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::EnumField do
+  let(:message) do
+    Class.new(::Protobuf::Message) do
+      enum_class = Class.new(::Protobuf::Enum) do
+        define :POSITIVE, 22
+        define :NEGATIVE, -33
+      end
+
+      optional enum_class, :enum, 1
+    end
+  end
+
+  describe '.{encode, decode}' do
+    it 'handles positive enum constants' do
+      instance = message.new(:enum => :POSITIVE)
+      expect(message.decode(instance.encode).enum).to eq(22)
+    end
+
+    it 'handles negative enum constants' do
+      instance = message.new(:enum => :NEGATIVE)
+      expect(message.decode(instance.encode).enum).to eq(-33)
+    end
+  end
+
+  # https://developers.google.com/protocol-buffers/docs/proto3#json
+  describe '.{to_json, from_json}' do
+    it 'serialises enum value as string' do
+      instance = message.new(:enum => :POSITIVE)
+      expect(instance.to_json).to eq('{"enum":"POSITIVE"}')
+    end
+
+    it 'deserialises enum value as integer' do
+      instance = message.from_json('{"enum":22}')
+      expect(instance.enum).to eq(22)
+    end
+
+    it 'deserialises enum value as string' do
+      instance = message.from_json('{"enum":"NEGATIVE"}')
+      expect(instance.enum).to eq(-33)
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FieldArray do
+
+  let(:basic_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :field, 1
+    end
+  end
+
+  let(:more_complex_message) do
+    Class.new(BasicMessage) do
+    end
+  end
+
+  let(:some_enum) do
+    Class.new(::Protobuf::Enum) do
+      define :FOO, 1
+      define :BAR, 2
+      define :BAZ, 3
+    end
+  end
+
+  let(:repeat_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :some_string, 1
+      repeated :string, :multiple_strings, 2
+      repeated BasicMessage, :multiple_basic_msgs, 3
+      repeated SomeEnum, :multiple_enums, 4
+    end
+  end
+
+  before do
+    stub_const('BasicMessage', basic_message)
+    stub_const('MoreComplexMessage', more_complex_message)
+    stub_const('SomeEnum', some_enum)
+    stub_const('SomeRepeatMessage', repeat_message)
+  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 = BasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg1)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+          basic_msg2 = BasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg2)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1, basic_msg2])
+        end
+
+        it 'fails if not adding a MessageField' do
+          expect { instance.multiple_basic_msgs.send(method, 100.0) }.to raise_error(TypeError)
+        end
+
+        it 'adds a Hash from a MessageField object' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = BasicMessage.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
+
+      context 'when applied to an EnumField field array' do
+        it 'adds an EnumField object' do
+          expect(instance.multiple_enums).to be_empty
+          instance.multiple_enums.send(method, SomeEnum::FOO)
+          expect(instance.multiple_enums).to eq([SomeEnum::FOO])
+          instance.multiple_enums.send(method, SomeEnum::BAR)
+          expect(instance.multiple_enums).to eq([SomeEnum::FOO, SomeEnum::BAR])
+        end
+
+        it 'fails if not adding an EnumField' do
+          expect { instance.multiple_basic_msgs.send(method, 100.0) }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FieldHash do
+
+  let(:basic_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :field, 1
+    end
+  end
+
+  let(:more_complex_message) do
+    Class.new(BasicMessage) do
+    end
+  end
+
+  let(:some_enum) do
+    Class.new(::Protobuf::Enum) do
+      define :FOO, 1
+      define :BAR, 2
+      define :BAZ, 3
+    end
+  end
+
+  let(:map_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :some_string, 1
+      map :int32, :string, :map_int32_to_string, 2
+      map :string, BasicMessage, :map_string_to_msg, 3
+      map :string, SomeEnum, :map_string_to_enum, 4
+    end
+  end
+
+  before do
+    stub_const('BasicMessage', basic_message)
+    stub_const('MoreComplexMessage', more_complex_message)
+    stub_const('SomeEnum', some_enum)
+    stub_const('SomeMapMessage', map_message)
+  end
+
+  let(:instance) { SomeMapMessage.new }
+
+  %w([]= store).each do |method|
+    describe "##{method}" do
+      context 'when applied to an int32->string field hash' do
+        it 'adds an int -> string entry' do
+          expect(instance.map_int32_to_string).to be_empty
+          instance.map_int32_to_string.send(method, 1, 'string 1')
+          expect(instance.map_int32_to_string).to eq(1 => 'string 1')
+          instance.map_int32_to_string.send(method, 2, 'string 2')
+          expect(instance.map_int32_to_string).to eq(1 => 'string 1', 2 => 'string 2')
+        end
+
+        it 'fails if not adding an int -> string' do
+          expect { instance.map_int32_to_string.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 'foo', 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, BasicMessage.new, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 'foo', 'bar') }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, nil, 'foo') }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 1, nil) }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when applied to a string->MessageField field hash' do
+        it 'adds a string -> MessageField entry' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = BasicMessage.new
+          instance.map_string_to_msg.send(method, 'msg1', basic_msg1)
+          expect(instance.map_string_to_msg).to eq('msg1' => basic_msg1)
+          basic_msg2 = BasicMessage.new
+          instance.map_string_to_msg.send(method, 'msg2', basic_msg2)
+          expect(instance.map_string_to_msg).to eq('msg1' => basic_msg1, 'msg2' => basic_msg2)
+        end
+
+        it 'fails if not adding a string -> MessageField entry' do
+          expect { instance.map_string_to_msg.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, 'foo', SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, SomeEnum::FOO, BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, nil, BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, 'foo', nil) }.to raise_error(TypeError)
+        end
+
+        it 'adds a Hash from a MessageField object' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = BasicMessage.new
+          basic_msg1.field = 'my value'
+          instance.map_string_to_msg.send(method, 'foo', basic_msg1.to_hash)
+          expect(instance.map_string_to_msg).to eq('foo' => basic_msg1)
+        end
+
+        it 'does not downcast a MessageField' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = MoreComplexMessage.new
+          instance.map_string_to_msg.send(method, 'foo', basic_msg1)
+          expect(instance.map_string_to_msg).to eq('foo' => basic_msg1)
+          expect(instance.map_string_to_msg['foo']).to be_a(MoreComplexMessage)
+        end
+      end
+
+      context 'when applied to a string->EnumField field hash' do
+        it 'adds a string -> EnumField entry' do
+          expect(instance.map_string_to_enum).to be_empty
+          instance.map_string_to_enum.send(method, 'msg1', SomeEnum::FOO)
+          expect(instance.map_string_to_enum).to eq('msg1' => SomeEnum::FOO)
+          instance.map_string_to_enum.send(method, 'msg2', SomeEnum::BAR)
+          expect(instance.map_string_to_enum).to eq('msg1' => SomeEnum::FOO, 'msg2' => SomeEnum::BAR)
+        end
+
+        it 'fails if not adding a string -> EnumField entry' do
+          expect { instance.map_string_to_enum.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, nil, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 1, nil) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 'foo', BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 1, SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, nil, SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 'foo', nil) }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe '#to_hash_value' do
+      context 'when applied to an int32->string field hash' do
+        before do
+          instance.map_int32_to_string[1] = 'string 1'
+          instance.map_int32_to_string[2] = 'string 2'
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_int32_to_string => {
+            1 => 'string 1',
+            2 => 'string 2',
+          })
+        end
+      end
+
+      context 'when applied to a string->MessageField field hash' do
+        before do
+          instance.map_string_to_msg['msg1'] = BasicMessage.new(:field => 'string 1')
+          instance.map_string_to_msg['msg2'] = BasicMessage.new(:field => 'string 2')
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_string_to_msg => {
+            'msg1' => {
+              :field => 'string 1',
+            },
+            'msg2' => {
+              :field => 'string 2',
+            },
+          })
+        end
+      end
+
+      context 'when applied to a string->EnumField field hash' do
+        before do
+          instance.map_string_to_enum['msg1'] = SomeEnum::FOO
+          instance.map_string_to_enum['msg2'] = SomeEnum::BAR
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_string_to_enum => {
+            'msg1' => 1,
+            'msg2' => 2,
+          })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Fixed32Field do
+
+  it_behaves_like :packable_field, described_class
+
+end

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Fixed64Field do
+
+  it_behaves_like :packable_field, described_class
+
+end

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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FloatField do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [1.0, 2.0, 3.0] }
+  end
+
+  class SomeFloatMessage < ::Protobuf::Message
+    optional :float, :some_float, 1
+  end
+
+  let(:instance) { SomeFloatMessage.new }
+
+  describe 'setting and getting field' 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(TypeError)
+      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
+
+  describe '#default_value' do
+    context 'optional and required fields' do
+      it 'returns the class default' do
+        expect(SomeFloatMessage.get_field('some_float').default).to be nil
+        expect(::Protobuf::Field::FloatField.default).to eq 0.0
+        expect(instance.some_float).to eq 0.0
+      end
+
+      context 'with field default' do
+        class AnotherFloatMessage < ::Protobuf::Message
+          optional :float, :set_float, 1, :default => 3.6
+        end
+
+        it 'returns the set default' do
+          expect(AnotherFloatMessage.get_field('set_float').default).to eq 3.6
+          expect(AnotherFloatMessage.new.set_float).to eq 3.6
+        end
+      end
+    end
+
+    context 'repeated field' do
+      class RepeatedFloatMessage < ::Protobuf::Message
+        repeated :float, :repeated_float, 1
+      end
+
+      it 'returns the set default' do
+        expect(RepeatedFloatMessage.new.repeated_float).to eq []
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,120 @@
+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 'setting and getting a field' 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
+
+  describe '#default_value' do
+    context 'optional and required fields' do
+      it 'returns the class default' do
+        expect(SomeInt32Message.get_field('some_int').default).to be nil
+        expect(::Protobuf::Field::Int32Field.default).to eq 0
+        expect(instance.some_int).to eq 0
+      end
+
+      context 'with field default' do
+        class AnotherIntMessage < ::Protobuf::Message
+          optional :int32, :set_int, 1, :default => 3
+        end
+
+        it 'returns the set default' do
+          expect(AnotherIntMessage.get_field('set_int').default).to eq 3
+          expect(AnotherIntMessage.new.set_int).to eq 3
+        end
+      end
+    end
+
+    context 'repeated field' do
+      class RepeatedIntMessage < ::Protobuf::Message
+        repeated :int32, :repeated_int, 1
+      end
+
+      it 'returns the set default' do
+        expect(RepeatedIntMessage.new.repeated_int).to eq []
+      end
+    end
+  end
+
+end