protobuf-cucumber 3.10.4

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

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

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

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::MessageField do
+  let(:inner_message) do
+    Class.new(::Protobuf::Message) do
+      optional :int32, :field, 0
+      optional :int32, :field2, 1
+    end
+  end
+
+  let(:field_message) do
+    Class.new(::Protobuf::Message) do
+      optional :int32, :field, 1
+      repeated :int64, :repeated_field, 2
+      optional InnerMessage, :message_field, 3
+    end
+  end
+
+  let(:message) do
+    Class.new(::Protobuf::Message) do
+      optional FieldMessage, :message_field, 1
+    end
+  end
+
+  before do
+    stub_const('InnerMessage', inner_message)
+    stub_const('FieldMessage', field_message)
+    stub_const('Message', message)
+  end
+
+  let(:instance) { message.new }
+
+  describe 'setting and getting field' do
+    context "when set with the message type" do
+      it 'is readable as a message' do
+        value = field_message.new(:field => 34)
+        instance.message_field = value
+        expect(instance.message_field).to eq(value)
+      end
+    end
+
+    context "when set with #to_proto" do
+      let(:to_proto_message) do
+        Class.new do
+          def to_proto
+            FieldMessage.new(:field => 42)
+          end
+        end
+      end
+
+      it 'is readable as a message' do
+        value = to_proto_message.new
+        instance.message_field = value
+        expect(instance.message_field).to eq(value.to_proto)
+      end
+    end
+
+    context "when set with #to_proto that returns the wrong message type" do
+      let(:to_proto_is_wrong_message) do
+        Class.new do
+          def to_proto
+            Message.new
+          end
+        end
+      end
+
+      it 'fails' do
+        value = to_proto_is_wrong_message.new
+        expect { instance.message_field = value }.to raise_error TypeError
+      end
+    end
+
+    context "when set with #to_hash" do
+      let(:to_hash_message) do
+        Class.new do
+          def to_hash
+            { :field => 989 }
+          end
+        end
+      end
+
+      it 'is readable as a message' do
+        value = to_hash_message.new
+        instance.message_field = value
+        expect(instance.message_field).to eq(field_message.new(value.to_hash))
+      end
+    end
+  end
+
+  describe '#option_set' do
+    let(:message_field) { Message.fields[0] }
+    it 'returns unless yield' do
+      # No Error thrown
+      message_field.__send__(:option_set, nil, nil, nil) { false }
+      expect do
+        message_field.__send__(:option_set, nil, nil, nil) { true }
+      end.to raise_error StandardError
+    end
+
+    it 'sets repeated fields' do
+      repeated = field_message.fields[1]
+      instance = field_message.new
+      expect(instance.repeated_field!).to eq(nil)
+      message_field.__send__(:option_set, instance, repeated, [53]) { true }
+      expect(instance.repeated_field!).to eq([53])
+      message_field.__send__(:option_set, instance, repeated, [54]) { true }
+      expect(instance.repeated_field!).to eq([53, 54])
+    end
+
+    it 'sets optional non-message fields' do
+      optional = field_message.fields[0]
+      instance = field_message.new
+      expect(instance.field!).to eq(nil)
+      message_field.__send__(:option_set, instance, optional, 53) { true }
+      expect(instance.field!).to eq(53)
+      message_field.__send__(:option_set, instance, optional, 52) { true }
+      expect(instance.field!).to eq(52)
+    end
+
+    it 'sets nested inner messages fields one at a time' do
+      inner = field_message.fields[2]
+      inner_val = InnerMessage.new(:field => 21)
+      inner_val2 = InnerMessage.new(:field2 => 9)
+      instance = field_message.new
+      expect(instance.message_field!).to eq(nil)
+      message_field.__send__(:option_set, instance, inner, inner_val) { true }
+      expect(instance.message_field!).to eq(InnerMessage.new(:field => 21))
+      message_field.__send__(:option_set, instance, inner, inner_val2) { true }
+      expect(instance.message_field!).to eq(InnerMessage.new(:field => 21, :field2 => 9))
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,79 @@
+# 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
+
+  describe '#default_value' do
+    context 'optional and required fields' do
+      it 'returns the class default' do
+        class SomeStringMessage < ::Protobuf::Message
+          optional :string, :some_string, 1
+        end
+        expect(SomeStringMessage.get_field('some_string').default).to be nil
+        expect(::Protobuf::Field::StringField.default).to eq ""
+        expect(SomeStringMessage.new.some_string).to eq ""
+      end
+
+      context 'with field default' do
+        class AnotherStringMessage < ::Protobuf::Message
+          optional :string, :set_string, 1, :default => "default value this is"
+        end
+
+        it 'returns the set default' do
+          expect(AnotherStringMessage.get_field('set_string').default).to eq "default value this is"
+          expect(AnotherStringMessage.new.set_string).to eq "default value this is"
+        end
+      end
+    end
+
+    context 'repeated field' do
+      class RepeatedStringMessage < ::Protobuf::Message
+        repeated :string, :repeated_string, 1
+      end
+
+      it 'returns the set default' do
+        expect(RepeatedStringMessage.new.repeated_string).to eq []
+      end
+    end
+  end
+
+end

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

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

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

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

data/spec/lib/protobuf/field_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'protobuf/field'
+require PROTOS_PATH.join('resource.pb')
+
+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(ArgumentError)
+      end
+    end
+
+  end
+
+end