protobuf 3.6.12 → 3.7.0.pre0

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Protobuf::Field::Int32Field do
+RSpec.describe Protobuf::Field::BoolField do
 
   class SomeBoolMessage < ::Protobuf::Message
     optional :bool, :some_bool, 1
@@ -9,7 +9,7 @@ RSpec.describe Protobuf::Field::Int32Field do
 
   let(:instance) { SomeBoolMessage.new }
 
-  describe '#define_setter' do
+  describe 'setting and getting field' do
     subject { instance.some_bool = value; instance.some_bool }
 
     [true, false].each do |val|
@@ -49,12 +49,38 @@ RSpec.describe Protobuf::Field::Int32Field do
     end
   end
 
-  describe '#define_getter' do
-    context 'when required bool field is set to false' do
-      subject { instance.required_bool = false; instance.required_bool }
+  it 'defines ? method' do
+    instance.required_bool = false
+    expect(instance.required_bool?).to be(false)
+  end
+
+  describe '#default_value' do
+    context 'optional and required fields' do
+      it 'returns the class default' do
+        expect(SomeBoolMessage.get_field('some_bool').default).to be nil
+        expect(::Protobuf::Field::BoolField.default).to be false
+        expect(instance.some_bool).to be false
+      end
+
+      context 'with field default' do
+        class AnotherBoolMessage < ::Protobuf::Message
+          optional :bool, :set_bool, 1, :default => true
+        end
+
+        it 'returns the set default' do
+          expect(AnotherBoolMessage.get_field('set_bool').default).to be true
+          expect(AnotherBoolMessage.new.set_bool).to be true
+        end
+      end
+    end
+
+    context 'repeated field' do
+      class RepeatedBoolMessage < ::Protobuf::Message
+        repeated :bool, :repeated_bool, 1
+      end
 
-      it 'returns false' do
-        expect(subject).to eq(false)
+      it 'returns the set default' do
+        expect(RepeatedBoolMessage.new.repeated_bool).to eq []
       end
     end
   end

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

@@ -0,0 +1,26 @@
+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
+end

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

@@ -8,7 +8,7 @@ RSpec.describe Protobuf::Field::FloatField do
 
   let(:instance) { SomeFloatMessage.new }
 
-  describe '#define_setter' do
+  describe 'setting and getting field' do
     subject { instance.some_float = value; instance.some_float }
 
     context 'when set with an int' do
@@ -52,4 +52,35 @@ RSpec.describe Protobuf::Field::FloatField do
     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

@@ -10,7 +10,7 @@ RSpec.describe Protobuf::Field::Int32Field do
 
   let(:instance) { SomeInt32Message.new }
 
-  describe '#define_setter' do
+  describe 'setting and getting a field' do
     subject { instance.some_int = value; instance.some_int }
 
     context 'when set with an int' do
@@ -86,4 +86,35 @@ RSpec.describe Protobuf::Field::Int32Field do
     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/message_field_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::MessageField do
+  let(:field_message) do
+    Class.new(::Protobuf::Message) do
+      optional :int32, :field, 1
+    end
+  end
+
+  let(:message) do
+    Class.new(::Protobuf::Message) do
+      optional FieldMessage, :message_field, 1
+    end
+  end
+
+  before do
+    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
+end

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

@@ -42,4 +42,38 @@ RSpec.describe ::Protobuf::Field::StringField do
     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_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'protobuf/field'
+require PROTOS_PATH.join('resource.pb')
 
 RSpec.describe ::Protobuf::Field do
 

data/spec/lib/protobuf/generators/enum_generator_spec.rb

@@ -68,6 +68,15 @@ end
     it 'returns a string identifying the given enum value' do
       expect(subject.build_value(enum.value.first)).to eq("define :FOO, 1")
     end
+
+    context 'with PB_UPCASE_ENUMS set' do
+      before { allow(ENV).to receive(:key?).with('PB_UPCASE_ENUMS').and_return(true) }
+      let(:values) { [{ :name => 'boom', :number => 1 }] }
+
+      it 'returns a string with the given enum name in ALL CAPS' do
+        expect(subject.build_value(enum.value.first)).to eq("define :BOOM, 1")
+      end
+    end
   end
 
 end

data/spec/lib/protobuf/generators/service_generator_spec.rb

@@ -41,6 +41,15 @@ end
     it 'returns a string identifying the given method descriptor' do
       expect(subject.build_method(service.method.first)).to eq("rpc :search, FooRequest, FooResponse")
     end
+
+    context 'with PB_USE_RAW_RPC_NAMES in the environemnt' do
+      before { allow(ENV).to receive(:key?).with('PB_USE_RAW_RPC_NAMES').and_return(true) }
+
+      it 'uses the raw RPC name and does not underscore it' do
+        expect(subject.build_method(service.method.first)).to eq("rpc :Search, FooRequest, FooResponse")
+        expect(subject.build_method(service.method.last)).to eq("rpc :FooBar, ::Foo::Request, ::Bar::Response")
+      end
+    end
   end
 
 end

data/spec/lib/protobuf/message_spec.rb

@@ -181,64 +181,6 @@ RSpec.describe Protobuf::Message do
       test_enum = Test::EnumTestMessage.new { |p| p.non_default_enum = 2 }
       expect(test_enum.non_default_enum).to eq(2)
     end
-
-    context 'ignoring unknown fields' do
-      around do |example|
-        orig = ::Protobuf.ignore_unknown_fields?
-        ::Protobuf.ignore_unknown_fields = true
-        example.call
-        ::Protobuf.ignore_unknown_fields = orig
-      end
-
-      context 'with valid fields' do
-        let(:values) { { :name => "Jim" } }
-
-        it "does not raise an error" do
-          expect { ::Test::Resource.new(values) }.to_not raise_error
-        end
-      end
-
-      context 'with non-existent field' do
-        let(:values) { { :name => "Jim", :othername => "invalid" } }
-
-        it "does not raise an error" do
-          expect { ::Test::Resource.new(values) }.to_not raise_error
-        end
-      end
-    end
-
-    context 'not ignoring unknown fields' do
-      around do |example|
-        orig = ::Protobuf.ignore_unknown_fields?
-        ::Protobuf.ignore_unknown_fields = false
-        example.call
-        ::Protobuf.ignore_unknown_fields = orig
-      end
-
-      context 'with valid fields' do
-        let(:values) { { :name => "Jim" } }
-
-        it "does not raise an error" do
-          expect { ::Test::Resource.new(values) }.to_not raise_error
-        end
-      end
-
-      context 'with non-existent field' do
-        let(:values) { { :name => "Jim", :othername => "invalid" } }
-
-        it "raises an error and mentions the erroneous field" do
-          expect { ::Test::Resource.new(values) }.to raise_error(::Protobuf::FieldNotDefinedError, /othername/)
-        end
-
-        context 'with a nil value' do
-          let(:values) { { :name => "Jim", :othername => nil } }
-
-          it "raises an error and mentions the erroneous field" do
-            expect { ::Test::Resource.new(values) }.to raise_error(::Protobuf::FieldNotDefinedError, /othername/)
-          end
-        end
-      end
-    end
   end
 
   describe '#encode' do
@@ -448,6 +390,29 @@ RSpec.describe Protobuf::Message do
         )
       end
     end
+
+    it 'uses simple field names as keys when possible and fully qualified names otherwise' do
+      message = Class.new(::Protobuf::Message) do
+        optional :int32, :field, 1
+        optional :int32, :colliding_field, 2
+        extensions 100...200
+        optional :int32, :".ext.normal_ext_field", 100, :extension => true
+        optional :int32, :".ext.colliding_field", 101, :extension => true
+        optional :int32, :".ext.colliding_field2", 102, :extension => true
+        optional :int32, :".ext2.colliding_field2", 103, :extension => true
+      end
+
+      hash = {
+        :field => 1,
+        :colliding_field => 2,
+        :normal_ext_field => 3,
+        :".ext.colliding_field" => 4,
+        :".ext.colliding_field2" => 5,
+        :".ext2.colliding_field2" => 6,
+      }
+      instance = message.new(hash)
+      expect(instance.to_hash).to eq(hash)
+    end
   end
 
   describe '#to_json' do
@@ -468,16 +433,40 @@ RSpec.describe Protobuf::Message do
     end
   end
 
-  describe "#define_setter" do
+  describe "#define_accessor" do
     subject { ::Test::Resource.new }
 
-    it "allows string fields to be set to nil" do
+    it 'allows string fields to be set to nil' do
       expect { subject.name = nil }.to_not raise_error
     end
 
-    it "does not allow string fields to be set to Numeric" do
+    it 'does not allow string fields to be set to Numeric' do
       expect { subject.name = 1 }.to raise_error(/name/)
     end
+
+    context '#{simple_field_name}!' do
+      it 'returns value of set field' do
+        expect(::Test::Resource.new(:name => "Joe").name!).to eq("Joe")
+      end
+
+      it 'returns value of set field with default' do
+        expect(::Test::Resource.new(:name => "").name!).to eq("")
+      end
+
+      it 'returns nil if extension field is unset' do
+        expect(subject.ext_is_searchable!).to be_nil
+      end
+
+      it 'returns value of set extension field' do
+        message = ::Test::Resource.new(:ext_is_searchable => true)
+        expect(message.ext_is_searchable!).to be(true)
+      end
+
+      it 'returns value of set extension field with default' do
+        message = ::Test::Resource.new(:ext_is_searchable => false)
+        expect(message.ext_is_searchable!).to be(false)
+      end
+    end
   end
 
   describe '.get_extension_field' do
@@ -486,12 +475,15 @@ RSpec.describe Protobuf::Message do
       expect(field).to be_a(::Protobuf::Field::BoolField)
       expect(field.tag).to eq(100)
       expect(field.name).to eq(:ext_is_searchable)
+      expect(field.fully_qualified_name).to eq(:'.test.Searchable.ext_is_searchable')
       expect(field).to be_extension
     end
 
     it 'fetches an extension field by its symbolized name' do
       expect(::Test::Resource.get_extension_field(:ext_is_searchable)).to be_a(::Protobuf::Field::BoolField)
       expect(::Test::Resource.get_extension_field('ext_is_searchable')).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_extension_field(:'.test.Searchable.ext_is_searchable')).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_extension_field('.test.Searchable.ext_is_searchable')).to be_a(::Protobuf::Field::BoolField)
     end
 
     it 'returns nil when attempting to get a non-extension field' do
@@ -504,12 +496,71 @@ RSpec.describe Protobuf::Message do
     end
   end
 
+  describe '#field?' do
+    it 'returns false for non-existent field' do
+      expect(::Test::Resource.get_field('doesnotexist')).to be_nil
+      expect(::Test::Resource.new.field?('doesnotexist')).to be(false)
+    end
+
+    it 'returns false for unset field' do
+      expect(::Test::Resource.get_field('name')).to be
+      expect(::Test::Resource.new.field?('name')).to be(false)
+    end
+
+    it 'returns false for unset field from tag' do
+      expect(::Test::Resource.get_field(1)).to be
+      expect(::Test::Resource.new.field?(1)).to be(false)
+    end
+
+    it 'returns true for set field' do
+      expect(::Test::Resource.new(:name => "Joe").field?('name')).to be(true)
+    end
+
+    it 'returns true for set field with default' do
+      expect(::Test::Resource.new(:name => "").field?('name')).to be(true)
+    end
+
+    it 'returns true from field tag value' do
+      expect(::Test::Resource.new(:name => "Joe").field?(1)).to be(true)
+    end
+
+    it 'returns false for unset extension field' do
+      ext_field = :".test.Searchable.ext_is_searchable"
+      expect(::Test::Resource.get_extension_field(ext_field)).to be
+      expect(::Test::Resource.new.field?(ext_field)).to be(false)
+    end
+
+    it 'returns false for unset extension field from tag' do
+      expect(::Test::Resource.get_extension_field(100)).to be
+      expect(::Test::Resource.new.field?(100)).to be(false)
+    end
+
+    it 'returns true for set extension field' do
+      ext_field = :".test.Searchable.ext_is_searchable"
+      message = ::Test::Resource.new(ext_field => true)
+      expect(message.field?(ext_field)).to be(true)
+    end
+
+    it 'returns true for set extension field with default' do
+      ext_field = :".test.Searchable.ext_is_searchable"
+      message = ::Test::Resource.new(ext_field => false)
+      expect(message.field?(ext_field)).to be(true)
+    end
+
+    it 'returns true for set extension field from tag' do
+      ext_field = :".test.Searchable.ext_is_searchable"
+      message = ::Test::Resource.new(ext_field => false)
+      expect(message.field?(100)).to be(true)
+    end
+  end
+
   describe '.get_field' do
     it 'fetches a non-extension field by its tag' do
       field = ::Test::Resource.get_field(1)
       expect(field).to be_a(::Protobuf::Field::StringField)
       expect(field.tag).to eq(1)
       expect(field.name).to eq(:name)
+      expect(field.fully_qualified_name).to eq(:name)
       expect(field).not_to be_extension
     end
 
@@ -520,8 +571,8 @@ RSpec.describe Protobuf::Message do
 
     it 'fetches an extension field when forced' do
       expect(::Test::Resource.get_field(100, true)).to be_a(::Protobuf::Field::BoolField)
-      expect(::Test::Resource.get_field(:ext_is_searchable, true)).to be_a(::Protobuf::Field::BoolField)
-      expect(::Test::Resource.get_field('ext_is_searchable', true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field(:'.test.Searchable.ext_is_searchable', true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field('.test.Searchable.ext_is_searchable', true)).to be_a(::Protobuf::Field::BoolField)
     end
 
     it 'returns nil when attempting to get an extension field' do
@@ -534,4 +585,218 @@ RSpec.describe Protobuf::Message do
     end
   end
 
+  describe 'defining a field' do
+    # Case 1
+    context 'single base field' do
+      let(:klass) do
+        Class.new(Protobuf::Message) do
+          optional :string, :foo, 1
+        end
+      end
+
+      it 'has an accessor for foo' do
+        message = klass.new(:foo => 'bar')
+        expect(message.foo).to eq('bar')
+        expect(message[:foo]).to eq('bar')
+        expect(message['foo']).to eq('bar')
+      end
+    end
+
+    # Case 2
+    context 'base field and extension field name collision' do
+      let(:klass) do
+        Class.new(Protobuf::Message) do
+          optional :string, :foo, 1
+          optional :string, :".boom.foo", 2, :extension => true
+        end
+      end
+
+      it 'has an accessor for foo that refers to the base field' do
+        message = klass.new(:foo => 'bar', '.boom.foo' => 'bam')
+        expect(message.foo).to eq('bar')
+        expect(message[:foo]).to eq('bar')
+        expect(message['foo']).to eq('bar')
+        expect(message[:'.boom.foo']).to eq('bam')
+        expect(message['.boom.foo']).to eq('bam')
+      end
+    end
+
+    # Case 3
+    context 'no base field with extension fields with name collision' do
+      let(:klass) do
+        Class.new(Protobuf::Message) do
+          optional :string, :".boom.foo", 2, :extension => true
+          optional :string, :".goat.foo", 3, :extension => true
+        end
+      end
+
+      it 'has an accessor for foo that refers to the extension field' do
+        message = klass.new('.boom.foo' => 'bam', '.goat.foo' => 'red')
+        expect { message.foo }.to raise_error(NoMethodError)
+        expect { message[:foo] }.to raise_error(ArgumentError)
+        expect { message['foo'] }.to raise_error(ArgumentError)
+        expect(message[:'.boom.foo']).to eq('bam')
+        expect(message['.boom.foo']).to eq('bam')
+        expect(message[:'.goat.foo']).to eq('red')
+        expect(message['.goat.foo']).to eq('red')
+      end
+    end
+
+    # Case 4
+    context 'no base field with an extension field' do
+      let(:klass) do
+        Class.new(Protobuf::Message) do
+          optional :string, :".boom.foo", 2, :extension => true
+        end
+      end
+
+      it 'has an accessor for foo that refers to the extension field' do
+        message = klass.new('.boom.foo' => 'bam')
+        expect(message.foo).to eq('bam')
+        expect(message[:foo]).to eq('bam')
+        expect(message['foo']).to eq('bam')
+        expect(message[:'.boom.foo']).to eq('bam')
+        expect(message['.boom.foo']).to eq('bam')
+      end
+    end
+  end
+
+  describe '.[]=' do
+    context 'clearing fields' do
+      it 'clears repeated fields with an empty array' do
+        instance = ::Test::Resource.new(:repeated_enum => [::Test::StatusType::ENABLED])
+        expect(instance.field?(:repeated_enum)).to be(true)
+        instance[:repeated_enum] = []
+        expect(instance.field?(:repeated_enum)).to be(false)
+      end
+
+      it 'clears optional fields with nil' do
+        instance = ::Test::Resource.new(:name => "Joe")
+        expect(instance.field?(:name)).to be(true)
+        instance[:name] = nil
+        expect(instance.field?(:name)).to be(false)
+      end
+
+      it 'clears optional extenstion fields with nil' do
+        instance = ::Test::Resource.new(:ext_is_searchable => true)
+        expect(instance.field?(:ext_is_searchable)).to be(true)
+        instance[:ext_is_searchable] = nil
+        expect(instance.field?(:ext_is_searchable)).to be(false)
+      end
+    end
+
+    context 'setting fields' do
+      let(:instance) { ::Test::Resource.new }
+
+      it 'sets and replaces repeated fields' do
+        initial = [::Test::StatusType::ENABLED, ::Test::StatusType::DISABLED]
+        instance[:repeated_enum] = initial
+        expect(instance[:repeated_enum]).to eq(initial)
+        replacement = [::Test::StatusType::DELETED]
+        instance[:repeated_enum] = replacement
+        expect(instance[:repeated_enum]).to eq(replacement)
+      end
+
+      it 'sets acceptable optional field values' do
+        instance[:name] = "Joe"
+        expect(instance[:name]).to eq("Joe")
+        instance[1] = "Tom"
+        expect(instance[:name]).to eq("Tom")
+      end
+
+      it 'sets acceptable empty string field values' do
+        instance[:name] = ""
+        expect(instance.name!).to eq("")
+      end
+
+      it 'sets acceptable empty message field values' do
+        instance = ::Test::Nested.new
+        instance[:resource] = {}
+        expect(instance.resource!).to eq(::Test::Resource.new)
+      end
+
+      it 'sets acceptable extension field values' do
+        instance[:ext_is_searchable] = true
+        expect(instance[:ext_is_searchable]).to eq(true)
+        instance[:".test.Searchable.ext_is_searchable"] = false
+        expect(instance[:ext_is_searchable]).to eq(false)
+        instance[100] = true
+        expect(instance[:ext_is_searchable]).to eq(true)
+      end
+    end
+
+    context 'throwing TypeError' do
+      let(:instance) { ::Test::Resource.new }
+
+      it 'throws when a repeated value is set with a non array' do
+        expect { instance[:repeated_enum] = "string" }.to raise_error(TypeError)
+      end
+
+      it 'throws when a repeated value is set with an array of the wrong type' do
+        expect { instance[:repeated_enum] = [true, false] }.to raise_error(TypeError)
+      end
+
+      it 'throws when an optional value is not #acceptable?' do
+        expect { instance[:name] = 1 }.to raise_error(TypeError)
+      end
+    end
+
+    context 'ignoring unknown fields' do
+      around do |example|
+        orig = ::Protobuf.ignore_unknown_fields?
+        ::Protobuf.ignore_unknown_fields = true
+        example.call
+        ::Protobuf.ignore_unknown_fields = orig
+      end
+
+      context 'with valid fields' do
+        let(:values) { { :name => "Jim" } }
+
+        it "does not raise an error" do
+          expect { ::Test::Resource.new(values) }.to_not raise_error
+        end
+      end
+
+      context 'with non-existent field' do
+        let(:values) { { :name => "Jim", :othername => "invalid" } }
+
+        it "does not raise an error" do
+          expect { ::Test::Resource.new(values) }.to_not raise_error
+        end
+      end
+    end
+
+    context 'not ignoring unknown fields' do
+      around do |example|
+        orig = ::Protobuf.ignore_unknown_fields?
+        ::Protobuf.ignore_unknown_fields = false
+        example.call
+        ::Protobuf.ignore_unknown_fields = orig
+      end
+
+      context 'with valid fields' do
+        let(:values) { { :name => "Jim" } }
+
+        it "does not raise an error" do
+          expect { ::Test::Resource.new(values) }.to_not raise_error
+        end
+      end
+
+      context 'with non-existent field' do
+        let(:values) { { :name => "Jim", :othername => "invalid" } }
+
+        it "raises an error and mentions the erroneous field" do
+          expect { ::Test::Resource.new(values) }.to raise_error(::Protobuf::FieldNotDefinedError, /othername/)
+        end
+
+        context 'with a nil value' do
+          let(:values) { { :name => "Jim", :othername => nil } }
+
+          it "raises an error and mentions the erroneous field" do
+            expect { ::Test::Resource.new(values) }.to raise_error(::Protobuf::FieldNotDefinedError, /othername/)
+          end
+        end
+      end
+    end
+  end
 end