protobuffy 3.6.0 → 4.0.0

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

@@ -2,28 +2,111 @@ require 'spec_helper'
 
 require 'protobuf/generators/file_generator'
 
-describe ::Protobuf::Generators::FileGenerator do
+RSpec.describe ::Protobuf::Generators::FileGenerator do
 
   let(:base_descriptor_fields) { { :name => 'test/foo.proto' } }
   let(:descriptor_fields) { base_descriptor_fields }
   let(:file_descriptor) { ::Google::Protobuf::FileDescriptorProto.new(descriptor_fields) }
 
   subject { described_class.new(file_descriptor) }
-  its(:file_name) { should eq 'test/foo.pb.rb' }
+  specify { expect(subject.file_name).to eq('test/foo.pb.rb') }
 
   describe '#print_import_requires' do
     let(:descriptor_fields) do
-      base_descriptor_fields.merge!({ :dependency => [ 'test/bar.proto',
-                                                       'test/baz.proto' ] })
+      base_descriptor_fields.merge(
+        :dependency => [
+          'test/bar.proto',
+          'test/baz.proto',
+        ]
+      )
     end
 
     it 'prints a ruby require for each dependency' do
-      subject.should_receive(:print_require).with('test/bar.pb')
-      subject.should_receive(:print_require).with('test/baz.pb')
+      expect(subject).to receive(:print_require).with('test/bar.pb')
+      expect(subject).to receive(:print_require).with('test/baz.pb')
       subject.print_import_requires
     end
 
   end
 
+  describe '#compile' do
+    it 'generates the file contents' do
+      subject.compile
+      expect(subject.to_s).to eq <<EOF
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+EOF
+    end
+
+    it 'generates the file contents using default package name' do
+      allow(ENV).to receive(:key?).with('PB_ALLOW_DEFAULT_PACKAGE_NAME')
+        .and_return(true)
+      subject.compile
+      expect(subject.to_s).to eq <<EOF
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Foo
+  ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
 end
 
+EOF
+    end
+
+    context 'with extended messages' do
+      let(:descriptor_fields) do
+        base_descriptor_fields.merge(
+          :package => 'test.pkg.file_generator_spec',
+          :extension => [{
+            :name => 'boom',
+            :number => 20_000,
+            :label => Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL,
+            :type => Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING,
+            :extendee => '.google.protobuf.FieldOptions',
+          }]
+        )
+      end
+
+      it 'generates the file contents that include the namespaced extension name' do
+        subject.compile
+        expect(subject.to_s).to eq <<EOF
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Test
+  module Pkg
+    module File_generator_spec
+      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+
+      ##
+      # Extended Message Fields
+      #
+      class ::Google::Protobuf::FieldOptions < ::Protobuf::Message
+        optional :string, :".test.pkg.file_generator_spec.boom", 20000, :extension => true
+      end
+
+    end
+
+  end
+
+end
+
+EOF
+      end
+    end
+
+  end
+end

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

@@ -2,42 +2,54 @@ require 'spec_helper'
 
 require 'protobuf/generators/service_generator'
 
-describe ::Protobuf::Generators::ServiceGenerator do
+RSpec.describe ::Protobuf::Generators::ServiceGenerator do
 
-  let(:methods) {
+  let(:methods) do
     [
       { :name => 'Search', :input_type => 'FooRequest', :output_type => 'FooResponse' },
-      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' }
+      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' },
     ]
-  }
-  let(:service_fields) { { :name => 'TestService',
-                           :method => methods } }
+  end
+  let(:service_fields) do
+    {
+      :name => 'TestService',
+      :method => methods,
+    }
+  end
 
   let(:service) { ::Google::Protobuf::ServiceDescriptorProto.new(service_fields) }
 
   subject { described_class.new(service) }
 
   describe '#compile' do
-    let(:compiled) {
-      %q{class TestService < ::Protobuf::Rpc::Service
+    let(:compiled) do
+      'class TestService < ::Protobuf::Rpc::Service
   rpc :search, FooRequest, FooResponse
   rpc :foo_bar, ::Foo::Request, ::Bar::Response
 end
 
-}
-    }
+'
+    end
 
     it 'compiles the service and it\'s rpc methods' do
       subject.compile
-      subject.to_s.should eq(compiled)
+      expect(subject.to_s).to eq(compiled)
     end
   end
 
   describe '#build_method' do
     it 'returns a string identifying the given method descriptor' do
-      subject.build_method(service.method.first).should eq("rpc :search, FooRequest, FooResponse")
+      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/lifecycle_spec.rb

@@ -1,22 +1,27 @@
 require 'spec_helper'
 require 'protobuf/lifecycle'
 
-describe ::Protobuf::Lifecycle do
+RSpec.describe ::Protobuf::Lifecycle do
   subject { described_class }
 
-  before(:each) do
+  around do |example|
+    # this entire class is deprecated
+    ::Protobuf.deprecator.silence(&example)
+  end
+
+  before do
     ::ActiveSupport::Notifications.notifier = ::ActiveSupport::Notifications::Fanout.new
   end
 
   it "registers a string as the event_name" do
-    ::ActiveSupport::Notifications.should_receive(:subscribe).with("something")
-      subject.register("something") { true }
+    expect(::ActiveSupport::Notifications).to receive(:subscribe).with("something")
+    subject.register("something") { true }
   end
 
   it "only registers blocks for event callbacks" do
-    expect {
+    expect do
       subject.register("something")
-    }.to raise_error( /block/ )
+    end.to raise_error(/block/)
   end
 
   it "calls the registered block when triggered" do
@@ -26,8 +31,8 @@ describe ::Protobuf::Lifecycle do
     end
 
     subject.trigger("this")
-    this.should_not be_nil
-    this.should eq("not nil")
+    expect(this).to_not be_nil
+    expect(this).to eq("not nil")
   end
 
   it "calls multiple registered blocks when triggered" do
@@ -43,10 +48,10 @@ describe ::Protobuf::Lifecycle do
     end
 
     subject.trigger("this")
-    this.should_not be_nil
-    this.should eq("not nil")
-    that.should_not be_nil
-    that.should eq("not nil")
+    expect(this).to_not be_nil
+    expect(this).to eq("not nil")
+    expect(that).to_not be_nil
+    expect(that).to eq("not nil")
   end
 
   context 'when the registered block has arity' do
@@ -55,12 +60,12 @@ describe ::Protobuf::Lifecycle do
         outer_bar = nil
 
         subject.register('foo') do |bar|
-          bar.should be_nil
+          expect(bar).to be_nil
           outer_bar = 'triggered'
         end
 
         subject.trigger('foo')
-        outer_bar.should eq 'triggered'
+        expect(outer_bar).to eq 'triggered'
       end
     end
 
@@ -69,21 +74,21 @@ describe ::Protobuf::Lifecycle do
         outer_bar = nil
 
         subject.register('foo') do |bar|
-          bar.should_not be_nil
+          expect(bar).to_not be_nil
           outer_bar = bar
         end
 
         subject.trigger('foo', 'baz')
-        outer_bar.should eq 'baz'
+        expect(outer_bar).to eq 'baz'
       end
     end
   end
 
   context "normalized event names" do
-    specify { subject.normalized_event_name(:derp).should eq("derp") }
-    specify { subject.normalized_event_name(:Derp).should eq("derp") }
-    specify { subject.normalized_event_name("DERP").should eq("derp") }
-    specify { subject.normalized_event_name("derp").should eq("derp") }
+    specify { expect(subject.normalized_event_name(:derp)).to eq("derp") }
+    specify { expect(subject.normalized_event_name(:Derp)).to eq("derp") }
+    specify { expect(subject.normalized_event_name("DERP")).to eq("derp") }
+    specify { expect(subject.normalized_event_name("derp")).to eq("derp") }
   end
 
 end

data/spec/lib/protobuf/message_spec.rb

@@ -1,59 +1,132 @@
+# encoding: utf-8
+
+require 'stringio'
 require 'spec_helper'
+require PROTOS_PATH.join('resource.pb')
+require PROTOS_PATH.join('enum.pb')
 
-describe Protobuf::Message do
+RSpec.describe Protobuf::Message do
 
   describe '.decode' do
     let(:message) { ::Test::Resource.new(:name => "Jim") }
 
     it 'creates a new message object decoded from the given bytes' do
-      ::Test::Resource.decode(message.encode).should eq message
+      expect(::Test::Resource.decode(message.encode)).to eq message
+    end
+
+    context 'with a new enum value' do
+      let(:older_message) do
+        Class.new(Protobuf::Message) do
+          enum_class = Class.new(::Protobuf::Enum) do
+            define :YAY, 1
+          end
+
+          optional enum_class, :enum_field, 1
+          repeated enum_class, :enum_list, 2
+        end
+      end
+
+      let(:newer_message) do
+        Class.new(Protobuf::Message) do
+          enum_class = Class.new(::Protobuf::Enum) do
+            define :YAY, 1
+            define :HOORAY, 2
+          end
+
+          optional enum_class, :enum_field, 1
+          repeated enum_class, :enum_list, 2
+        end
+      end
+
+      context 'with a singular field' do
+        it 'treats the field as if it was unset when decoding' do
+          newer = newer_message.new(:enum_field => :HOORAY).serialize
+
+          expect(older_message.decode(newer).enum_field!).to be_nil
+        end
+
+        it 'rejects an unknown value when using the constructor' do
+          expect { older_message.new(:enum_field => :HOORAY) }.to raise_error(TypeError)
+        end
+
+        it 'rejects an unknown value when the setter' do
+          older = older_message.new
+          expect { older.enum_field = :HOORAY }.to raise_error(TypeError)
+        end
+      end
+
+      context 'with a repeated field' do
+        it 'treats the field as if it was unset when decoding' do
+          newer = newer_message.new(:enum_list => [:HOORAY]).serialize
+
+          expect(older_message.decode(newer).enum_list).to eq([])
+        end
+
+        it 'rejects an unknown value when using the constructor' do
+          expect { older_message.new(:enum_list => [:HOORAY]) }.to raise_error(TypeError)
+        end
+
+        it 'rejects an unknown value when the setter' do
+          older = older_message.new
+          expect { older.enum_field = [:HOORAY] }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  describe '.decode_from' do
+    let(:message) { ::Test::Resource.new(:name => "Jim") }
+
+    it 'creates a new message object decoded from the given byte stream' do
+      stream = ::StringIO.new(message.encode)
+      expect(::Test::Resource.decode_from(stream)).to eq message
     end
   end
 
   describe 'defining a new field' do
     context 'when defining a field with a tag that has already been used' do
       it 'raises a TagCollisionError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :bar, 1
           end
-        }.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
+        end.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
       end
     end
 
     context 'when defining an extension field with a tag that has already been used' do
       it 'raises a TagCollisionError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             extensions 100...110
             optional ::Protobuf::Field::Int32Field, :foo, 100
             optional ::Protobuf::Field::Int32Field, :bar, 100, :extension => true
           end
-        }.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
+        end.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
       end
     end
 
     context 'when defining a field with a name that has already been used' do
       it 'raises a DuplicateFieldNameError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :foo, 2
           end
-        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+        end.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
     end
 
     context 'when defining an extension field with a name that has already been used' do
       it 'raises a DuplicateFieldNameError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             extensions 100...110
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :foo, 100, :extension => true
           end
-        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+        end.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
     end
   end
@@ -62,41 +135,57 @@ describe Protobuf::Message do
     let(:values) { { :name => "Jim" } }
 
     it 'creates a new message object with the given values and returns the encoded bytes' do
-      ::Test::Resource.encode(values).should eq ::Test::Resource.new(values).encode
+      expect(::Test::Resource.encode(values)).to eq ::Test::Resource.new(values).encode
     end
   end
 
   describe '#initialize' do
-    it "initializes the enum getter to 0" do
+    it "defaults to the first value listed in the enum's type definition" do
+      test_enum = Test::EnumTestMessage.new
+      expect(test_enum.non_default_enum).to eq(Test::EnumTestType.enums.first)
+    end
+
+    it "defaults to a a value with a name" do
       test_enum = Test::EnumTestMessage.new
-      test_enum.non_default_enum.should eq(0)
+      expect(test_enum.non_default_enum.name).to eq(Test::EnumTestType.enums.first.name)
     end
 
     it "exposes the enum getter raw value through ! method" do
       test_enum = Test::EnumTestMessage.new
-      test_enum.non_default_enum!.should be_nil
+      expect(test_enum.non_default_enum!).to be_nil
     end
 
     it "exposes the enum getter raw value through ! method (when set)" do
       test_enum = Test::EnumTestMessage.new
       test_enum.non_default_enum = 1
-      test_enum.non_default_enum!.should eq(1)
+      expect(test_enum.non_default_enum!).to eq(1)
     end
 
     it "does not try to set attributes which have nil values" do
-      Test::EnumTestMessage.any_instance.should_not_receive("non_default_enum=")
+      expect_any_instance_of(Test::EnumTestMessage).not_to receive("non_default_enum=")
       Test::EnumTestMessage.new(:non_default_enum => nil)
     end
 
     it "takes a hash as an initialization argument" do
       test_enum = Test::EnumTestMessage.new(:non_default_enum => 2)
-      test_enum.non_default_enum.should eq(2)
+      expect(test_enum.non_default_enum).to eq(2)
     end
 
     it "initializes with an object that responds to #to_hash" do
       hashie_object = OpenStruct.new(:to_hash => { :non_default_enum => 2 })
       test_enum = Test::EnumTestMessage.new(hashie_object)
-      test_enum.non_default_enum.should eq(2)
+      expect(test_enum.non_default_enum).to eq(2)
+    end
+
+    it "initializes with an object with a block" do
+      test_enum = Test::EnumTestMessage.new { |p| p.non_default_enum = 2 }
+      expect(test_enum.non_default_enum).to eq(2)
+    end
+
+    # to be deprecated
+    it "allows you to pass nil to repeated fields" do
+      test = Test::Resource.new(:repeated_enum => nil)
+      expect(test.repeated_enum).to eq([])
     end
   end
 
@@ -109,21 +198,21 @@ describe Protobuf::Message do
       end
 
       it "keeps utf-8 when utf-8 is input for string fields" do
-        name = "my name\xC3"
-        name.force_encoding("UTF-8")
+        name = 'my name💩'
+        name.force_encoding(Encoding::UTF_8)
 
         message = ::Test::Resource.new(:name => name)
         new_message = ::Test::Resource.decode(message.encode)
-        (new_message.name == name).should be_true
+        expect(new_message.name == name).to be true
       end
 
       it "trims binary when binary is input for string fields" do
         name = "my name\xC3"
-        name.force_encoding("ASCII-8BIT")
+        name.force_encoding(Encoding::BINARY)
 
         message = ::Test::Resource.new(:name => name)
         new_message = ::Test::Resource.decode(message.encode)
-        (new_message.name == "my name").should be_true
+        expect(new_message.name == "my name").to be true
       end
     end
 
@@ -131,9 +220,9 @@ describe Protobuf::Message do
       let(:message) { ::Test::ResourceWithRequiredField.new }
 
       it "raises a 'message not initialized' error" do
-        expect {
+        expect do
           message.encode
-        }.to raise_error(Protobuf::SerializationError, /required/i)
+        end.to raise_error(Protobuf::SerializationError, /required/i)
       end
     end
 
@@ -141,33 +230,33 @@ describe Protobuf::Message do
       let(:message) { ::Test::Resource.new(:name => "something") }
 
       it "does not raise an error when repeated fields are []" do
-        expect {
+        expect do
           message.repeated_enum = []
           message.encode
-        }.to_not raise_error
+        end.to_not raise_error
       end
 
       it "sets the value to nil when empty array is passed" do
         message.repeated_enum = []
-        message.instance_variable_get("@values")[:repeated_enum].should be_nil
+        expect(message.instance_variable_get("@values")[:repeated_enum]).to be_nil
       end
 
       it "does not compact the edit original array" do
         a = [nil].freeze
         message.repeated_enum = a
-        message.repeated_enum.should eq([])
-        a.should eq([nil].freeze)
+        expect(message.repeated_enum).to eq([])
+        expect(a).to eq([nil].freeze)
       end
 
       it "compacts the set array" do
         message.repeated_enum = [nil]
-        message.repeated_enum.should eq([])
+        expect(message.repeated_enum).to eq([])
       end
 
       it "raises TypeError when a non-array replaces it" do
-        expect {
+        expect do
           message.repeated_enum = 2
-        }.to raise_error(/value of type/)
+        end.to raise_error(/value of type/)
       end
     end
   end
@@ -175,20 +264,20 @@ describe Protobuf::Message do
   describe "boolean predicate methods" do
     subject { Test::ResourceFindRequest.new(:name => "resource") }
 
-    it { should respond_to(:active?) }
+    it { is_expected.to respond_to(:active?) }
 
     it "sets the predicate to true when the boolean value is true" do
       subject.active = true
-      subject.active?.should be_true
+      expect(subject.active?).to be true
     end
 
     it "sets the predicate to false when the boolean value is false" do
       subject.active = false
-      subject.active?.should be_false
+      expect(subject.active?).to be false
     end
 
     it "does not put predicate methods on non-boolean fields" do
-      Test::ResourceFindRequest.new(:name => "resource").should_not respond_to(:name?)
+      expect(Test::ResourceFindRequest.new(:name => "resource")).to_not respond_to(:name?)
     end
   end
 
@@ -196,11 +285,11 @@ describe Protobuf::Message do
     subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
     it "is false when the message does not have the field" do
-      subject.respond_to_and_has?(:other_field).should be_false
+      expect(subject.respond_to_and_has?(:other_field)).to be false
     end
 
     it "is true when the message has the field" do
-      subject.respond_to_and_has?(:non_default_enum).should be_true
+      expect(subject.respond_to_and_has?(:non_default_enum)).to be true
     end
   end
 
@@ -208,106 +297,204 @@ describe Protobuf::Message do
     subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
     it "is false when the message does not have the field" do
-      subject.respond_to_and_has_and_present?(:other_field).should be_false
+      expect(subject.respond_to_and_has_and_present?(:other_field)).to be false
     end
 
     it "is false when the field is repeated and a value is not present" do
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be false
     end
 
     it "is false when the field is repeated and the value is empty array" do
       subject.repeated_enums = []
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be false
     end
 
     it "is true when the field is repeated and a value is present" do
       subject.repeated_enums = [2]
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_true
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be true
     end
 
     it "is true when the message has the field" do
-      subject.respond_to_and_has_and_present?(:non_default_enum).should be_true
+      expect(subject.respond_to_and_has_and_present?(:non_default_enum)).to be true
     end
 
     context "#API" do
       subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
-      it { should respond_to(:respond_to_and_has_and_present?) }
-      it { should respond_to(:responds_to_and_has_and_present?) }
-      it { should respond_to(:responds_to_has?) }
-      it { should respond_to(:respond_to_has?) }
-      it { should respond_to(:respond_to_has_present?) }
-      it { should respond_to(:responds_to_has_present?) }
-      it { should respond_to(:respond_to_and_has_present?) }
-      it { should respond_to(:responds_to_and_has_present?) }
+      specify { expect(subject).to respond_to(:respond_to_and_has_and_present?) }
+      specify { expect(subject).to respond_to(:responds_to_and_has_and_present?) }
+      specify { expect(subject).to respond_to(:responds_to_has?) }
+      specify { expect(subject).to respond_to(:respond_to_has?) }
+      specify { expect(subject).to respond_to(:respond_to_has_present?) }
+      specify { expect(subject).to respond_to(:responds_to_has_present?) }
+      specify { expect(subject).to respond_to(:respond_to_and_has_present?) }
+      specify { expect(subject).to respond_to(:responds_to_and_has_present?) }
     end
 
   end
 
+  describe '#inspect' do
+    let(:klass) do
+      Class.new(Protobuf::Message) do |klass|
+        enum_class = Class.new(Protobuf::Enum) do
+          define :YAY, 1
+        end
+
+        klass.const_set(:EnumKlass, enum_class)
+
+        optional :string, :name, 1
+        repeated :int32, :counts, 2
+        optional enum_class, :enum, 3
+      end
+    end
+
+    before { stub_const('MyMessage', klass) }
+
+    it 'lists the fields' do
+      proto = klass.new(:name => 'wooo', :counts => [1, 2, 3], :enum => klass::EnumKlass::YAY)
+      expect(proto.inspect).to eq('#<MyMessage name="wooo" counts=[1, 2, 3] enum=#<Protobuf::Enum(MyMessage::EnumKlass)::YAY=1>>')
+    end
+  end
+
   describe '#to_hash' do
     context 'generating values for an ENUM field' do
       it 'converts the enum to its tag representation' do
         hash = Test::EnumTestMessage.new(:non_default_enum => :TWO).to_hash
-        hash.should eq({ :non_default_enum => 2 })
+        expect(hash).to eq(:non_default_enum => 2)
       end
 
       it 'does not populate default values' do
         hash = Test::EnumTestMessage.new.to_hash
-        hash.should eq(Hash.new)
+        expect(hash).to eq({})
       end
 
       it 'converts repeated enum fields to an array of the tags' do
-        hash = Test::EnumTestMessage.new(:repeated_enums => [ :ONE, :TWO, :TWO, :ONE ]).to_hash
-        hash.should eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
+        hash = Test::EnumTestMessage.new(:repeated_enums => [:ONE, :TWO, :TWO, :ONE]).to_hash
+        expect(hash).to eq(:repeated_enums => [1, 2, 2, 1])
       end
     end
 
     context 'generating values for a Message field' do
       it 'recursively hashes field messages' do
-        hash = Test::Nested.new({ :resource => { :name => 'Nested' } }).to_hash
-        hash.should eq({ :resource => { :name => 'Nested' } })
+        hash = Test::Nested.new(:resource => { :name => 'Nested' }).to_hash
+        expect(hash).to eq(:resource => { :name => 'Nested' })
       end
 
       it 'recursively hashes a repeated set of messages' do
-        proto = Test::Nested.new(:multiple_resources => [
-          Test::Resource.new(:name => 'Resource 1'),
-          Test::Resource.new(:name => 'Resource 2')
-        ])
-
-        proto.to_hash.should eq({ :multiple_resources => [ { :name => 'Resource 1' },
-                                                           { :name => 'Resource 2' } ] })
+        proto = Test::Nested.new(
+          :multiple_resources => [
+            Test::Resource.new(:name => 'Resource 1'),
+            Test::Resource.new(:name => 'Resource 2'),
+          ]
+        )
+
+        expect(proto.to_hash).to eq(
+          :multiple_resources => [
+            { :name => 'Resource 1' },
+            { :name => 'Resource 2' },
+          ]
+        )
+      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
     subject do
-      ::Test::ResourceFindRequest.new({ :name => 'Test Name', :active => false })
+      ::Test::ResourceFindRequest.new(:name => 'Test Name', :active => false)
     end
 
-    its(:to_json) { should eq '{"name":"Test Name","active":false}' }
+    specify { expect(subject.to_json).to eq '{"name":"Test Name","active":false}' }
   end
 
   describe '.to_json' do
     it 'returns the class name of the message for use in json encoding' do
-      expect {
+      expect do
         ::Timeout.timeout(0.1) do
           expect(::Test::Resource.to_json).to eq("Test::Resource")
         end
-      }.not_to raise_error
+      end.not_to raise_error
     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
-      expect { subject.name = 1}.to raise_error(/name/)
+    it 'does not allow string fields to be set to Numeric' do
+      expect { subject.name = 1 }.to raise_error(/name/)
+    end
+
+    it 'does not allow a repeated field is set to nil' do
+      expect { subject.repeated_enum = nil }.to raise_error(TypeError)
+    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
+
+      it 'returns nil for an unset repeated field that has only be read' do
+        message = ::Test::Resource.new
+        expect(message.repeated_enum!).to be_nil
+        message.repeated_enum
+        expect(message.repeated_enum!).to be_nil
+      end
+
+      it 'returns value for an unset repeated field has been read and appended to' do
+        message = ::Test::Resource.new
+        message.repeated_enum << 1
+        expect(message.repeated_enum!).to eq([1])
+      end
+
+      it 'returns value for an unset repeated field has been explicitly set' do
+        message = ::Test::Resource.new
+        message.repeated_enum = [1]
+        expect(message.repeated_enum!).to eq([1])
+      end
     end
   end
 
@@ -317,12 +504,15 @@ 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
@@ -330,8 +520,91 @@ describe Protobuf::Message do
     end
 
     it 'returns nil when field is not found' do
-      ::Test::Resource.get_extension_field(-1).should be_nil
-      ::Test::Resource.get_extension_field(nil).should be_nil
+      expect(::Test::Resource.get_extension_field(-1)).to be_nil
+      expect(::Test::Resource.get_extension_field(nil)).to be_nil
+    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
+
+    it 'returns false for repeated field that has been read from' do
+      message = ::Test::Resource.new
+      expect(message.field?(:repeated_enum)).to be(false)
+      message.repeated_enum
+      expect(message.field?(:repeated_enum)).to be(false)
+    end
+
+    it 'returns true for a repeated field that has been read from and appended to' do
+      message = ::Test::Resource.new
+      message.repeated_enum << 1
+      expect(message.field?(:repeated_enum)).to be(true)
+    end
+
+    it 'returns true for a repeated field that has been set with the setter' do
+      message = ::Test::Resource.new
+      message.repeated_enum = [1]
+      expect(message.field?(:repeated_enum)).to be(true)
+    end
+
+    it 'returns false for a repeated field that has been replaced with []' do
+      message = ::Test::Resource.new
+      message.repeated_enum.replace([])
+      expect(message.field?(:repeated_enum)).to be(false)
     end
   end
 
@@ -341,6 +614,7 @@ describe Protobuf::Message do
       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
 
@@ -351,8 +625,8 @@ 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
@@ -360,9 +634,234 @@ describe Protobuf::Message do
     end
 
     it 'returns nil when field is not defined' do
-      ::Test::Resource.get_field(-1).should be_nil
-      ::Test::Resource.get_field(nil).should be_nil
+      expect(::Test::Resource.get_field(-1)).to be_nil
+      expect(::Test::Resource.get_field(nil)).to be_nil
+    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
+
+      # to be deprecated
+      it 'does nothing when sent an empty array' do
+        instance[:repeated_enum] = nil
+        expect(instance[:repeated_enum]).to eq([])
+        instance[:repeated_enum] = [1, 2]
+        expect(instance[:repeated_enum]).to eq([1, 2])
+        instance[:repeated_enum] = nil
+        # Yes this is very silly, but backwards compatible
+        expect(instance[:repeated_enum]).to eq([1, 2])
+      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