protobuffy 3.6.0 → 4.0.0

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(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
+
+  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

@@ -1,7 +1,120 @@
 require 'spec_helper'
 
-describe Protobuf::Field::Int32Field do
+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

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

@@ -2,24 +2,24 @@
 
 require 'spec_helper'
 
-describe ::Protobuf::Field::StringField do
+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 {
-          frozen_strings = [ "foo".freeze, "bar".freeze, "baz".freeze ]
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
           ::Test::ResourceFindRequest.encode(:name => 'resource', :widgets => frozen_strings)
-        }.not_to raise_error
+        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 {
-          frozen_strings = [ "foo".freeze, "bar".freeze, "baz".freeze ]
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
           ::Test::ResourceFindRequest.encode(:name => 'resource', :widget_bytes => frozen_strings)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -27,20 +27,53 @@ describe ::Protobuf::Field::StringField do
       source_string = "foo"
       proto = ::Test::Resource.new(:name => source_string)
       proto.encode
-      proto.name.should eq source_string
+      expect(proto.name).to eq source_string
       proto.encode
-      proto.name.should eq source_string
+      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
-      proto.name.should eq source_string
+      expect(proto.name).to eq source_string
       proto.encode
-      proto.name.should eq source_string
+      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