protobuf 3.0.4 → 3.0.5

data/spec/lib/protobuf/code_generator_spec.rb

@@ -27,13 +27,13 @@ describe ::Protobuf::CodeGenerator do
     end
 
     before do
-      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file1).and_return(file_generator1)
-      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file2).and_return(file_generator2)
+      expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file1).and_return(file_generator1)
+      expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file2).and_return(file_generator2)
     end
 
     it 'returns the serialized CodeGeneratorResponse which contains the generated file contents' do
       generator = described_class.new(request_bytes)
-      generator.response_bytes.should eq expected_response_bytes
+      expect(generator.response_bytes).to eq expected_response_bytes
     end
   end
 
@@ -51,7 +51,7 @@ describe ::Protobuf::CodeGenerator do
 
     describe '.warn' do
       it 'prints a warning to stderr' do
-        STDERR.should_receive(:puts).with("[WARN] a warning")
+        expect(STDERR).to receive(:puts).with("[WARN] a warning")
         described_class.warn("a warning")
       end
     end

data/spec/lib/protobuf/enum_spec.rb

@@ -22,7 +22,7 @@ describe Protobuf::Enum do
 
     describe '.aliases_allowed?' do
       it 'is false when the option is not set' do
-        expect(Test::EnumTestType.aliases_allowed?).to be_false
+        expect(Test::EnumTestType.aliases_allowed?).to be_falsey
       end
     end
 
@@ -155,15 +155,15 @@ describe Protobuf::Enum do
 
     describe '.valid_tag?' do
       context 'when tag is defined' do
-        specify { expect(Test::EnumTestType.valid_tag?(tag)).to be_true }
+        specify { expect(Test::EnumTestType.valid_tag?(tag)).to be_truthy }
       end
 
       context 'when tag is not defined' do
-        specify { expect(Test::EnumTestType.valid_tag?(300)).to be_false }
+        specify { expect(Test::EnumTestType.valid_tag?(300)).to be_falsey }
       end
 
       context 'is true for aliased enums' do
-        specify { expect(EnumAliasTest.valid_tag?(1)).to be_true }
+        specify { expect(EnumAliasTest.valid_tag?(1)).to be_truthy }
       end
     end
 
@@ -201,31 +201,31 @@ describe Protobuf::Enum do
   end
 
 	subject { Test::EnumTestType::ONE }
-  its(:class) { should eq(Fixnum) }
-  its(:parent_class) { should eq(Test::EnumTestType) }
-	its(:name) { should eq(:ONE) }
-	its(:tag) { should eq(1) }
-	its(:value) { should eq(1) }
-	its(:to_hash_value) { should eq(1) }
-	its(:to_s) { should eq("1") }
-	its(:inspect) { should eq('#<Protobuf::Enum(Test::EnumTestType)::ONE=1>') }
-  specify { subject.to_s(:tag).should eq("1") }
-  specify { subject.to_s(:name).should eq("ONE") }
+  specify { expect(subject.class).to eq(Fixnum) }
+  specify { expect(subject.parent_class).to eq(Test::EnumTestType) }
+	specify { expect(subject.name).to eq(:ONE) }
+	specify { expect(subject.tag).to eq(1) }
+	specify { expect(subject.value).to eq(1) }
+	specify { expect(subject.to_hash_value).to eq(1) }
+	specify { expect(subject.to_s).to eq("1") }
+	specify { expect(subject.inspect).to eq('#<Protobuf::Enum(Test::EnumTestType)::ONE=1>') }
+  specify { expect(subject.to_s(:tag)).to eq("1") }
+  specify { expect(subject.to_s(:name)).to eq("ONE") }
 
   it "can be used as the index to an array" do
     array = [0, 1, 2, 3]
-    array[::Test::EnumTestType::ONE].should eq(1)
+    expect(array[::Test::EnumTestType::ONE]).to eq(1)
   end
 
   describe '#try' do
-    specify { subject.try(:parent_class).should eq(subject.parent_class) }
-    specify { subject.try(:class).should eq(subject.class) }
-    specify { subject.try(:name).should eq(subject.name) }
-    specify { subject.try(:tag).should eq(subject.tag) }
-    specify { subject.try(:value).should eq(subject.value) }
-    specify { subject.try(:to_i).should eq(subject.to_i) }
-    specify { subject.try(:to_int).should eq(subject.to_int) }
-    specify { subject.try { |yielded| yielded.should eq(subject) } }
+    specify { expect(subject.try(:parent_class)).to eq(subject.parent_class) }
+    specify { expect(subject.try(:class)).to eq(subject.class) }
+    specify { expect(subject.try(:name)).to eq(subject.name) }
+    specify { expect(subject.try(:tag)).to eq(subject.tag) }
+    specify { expect(subject.try(:value)).to eq(subject.value) }
+    specify { expect(subject.try(:to_i)).to eq(subject.to_i) }
+    specify { expect(subject.try(:to_int)).to eq(subject.to_int) }
+    specify { subject.try { |yielded| expect(yielded).to eq(subject) } }
   end
 
   context 'when coercing from enum' do

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Protobuf::Field::FloatField do
+
+  class SomeFloatMessage < ::Protobuf::Message
+    optional :float, :some_float, 1
+  end
+
+  let(:instance) { SomeFloatMessage.new }
+
+  describe '#define_setter' 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
+
+end

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

@@ -27,18 +27,18 @@ 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
 

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

@@ -10,8 +10,8 @@ describe ::Protobuf::Generators::Base do
   context 'namespaces' do
     let(:descriptor) { double(:name => 'Baz') }
     subject { described_class.new(descriptor, 0, :namespace => [ :foo, :bar ]) }
-    its(:type_namespace) { should eq [ :foo, :bar, 'Baz' ] }
-    its(:fully_qualified_type_namespace) { should eq '.foo.bar.Baz' }
+    specify { expect(subject.type_namespace).to eq([ :foo, :bar, 'Baz' ]) }
+    specify { expect(subject.fully_qualified_type_namespace).to eq('.foo.bar.Baz') }
   end
 
   describe '#run_once' do
@@ -67,17 +67,14 @@ describe ::Protobuf::Generators::Base do
   describe '#validate_tags' do
     context 'when tags are duplicated' do
       it 'fails with a GeneratorFatalError' do
-        ::Protobuf::CodeGenerator.should_receive(:fatal)
-                                  .with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
-
+        expect(::Protobuf::CodeGenerator).to receive(:fatal).with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
         described_class.validate_tags("FooBar", [1,2,2,3])
       end
     end
 
     context 'when tags are missing in the range' do
       it 'prints a warning' do
-        ::Protobuf::CodeGenerator.should_receive(:warn)
-                                  .with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
+        expect(::Protobuf::CodeGenerator).to receive(:warn).with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
         described_class.validate_tags("FooBar", [1,2,4,5])
       end
     end

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

@@ -33,7 +33,7 @@ end
 
     it 'compiles the enum and it\'s field values' do
       subject.compile
-      subject.to_s.should eq(compiled)
+      expect(subject.to_s).to eq(compiled)
     end
 
     context 'when allow_alias option is set' do
@@ -53,14 +53,14 @@ end
 
       it 'sets the allow_alias option' do
         subject.compile
-        subject.to_s.should eq(compiled)
+        expect(subject.to_s).to eq(compiled)
       end
     end
   end
 
   describe '#build_value' do
     it 'returns a string identifying the given enum value' do
-      subject.build_value(enum.value.first).should eq("define :FOO, 1")
+      expect(subject.build_value(enum.value.first)).to eq("define :FOO, 1")
     end
   end
 

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

@@ -15,9 +15,9 @@ describe ::Protobuf::Generators::ExtensionGenerator do
   let(:message_type) { 'FooBar' }
 
   before do
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[0], 1).and_return(field_descriptors[0])
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[1], 1).and_return(field_descriptors[1])
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[2], 1).and_return(field_descriptors[2])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[0], 1).and_return(field_descriptors[0])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[1], 1).and_return(field_descriptors[1])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[2], 1).and_return(field_descriptors[2])
   end
 
   subject { described_class.new(message_type, field_descriptors, 0) }
@@ -35,7 +35,7 @@ end
 
     it 'compiles the a class with the extension fields' do
       subject.compile
-      subject.to_s.should eq(compiled)
+      expect(subject.to_s).to eq(compiled)
     end
   end
 

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

@@ -27,33 +27,33 @@ describe ::Protobuf::Generators::FieldGenerator do
   describe '#compile' do
     subject { described_class.new(field).to_s }
 
-    it { should eq "optional :string, :foo_bar, 3\n" }
+    specify { expect(subject).to eq "optional :string, :foo_bar, 3\n" }
 
     context 'when the type is another message' do
       let(:type_enum) { :TYPE_MESSAGE }
       let(:type_name) { '.foo.bar.Baz' }
 
-      it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
+      specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
     end
 
     context 'when a default value is used' do
       let(:type_enum) { :TYPE_INT32 }
       let(:default_value) { '42' }
-      it { should eq "optional :int32, :foo_bar, 3, :default => 42\n" }
+      specify { expect(subject).to eq "optional :int32, :foo_bar, 3, :default => 42\n" }
 
       context 'when type is an enum' do
         let(:type_enum) { :TYPE_ENUM }
         let(:type_name) { '.foo.bar.Baz' }
         let(:default_value) { 'QUUX' }
 
-        it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+        specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
       end
 
       context 'when the type is a string' do
         let(:type_enum) { :TYPE_STRING }
         let(:default_value) { "a default \"string\"" }
 
-        it { should eq %Q{optional :string, :foo_bar, 3, :default => "a default \"string\""\n} }
+        specify { expect(subject).to eq %Q{optional :string, :foo_bar, 3, :default => "a default \"string\""\n} }
       end
 
       context 'when float or double field type' do
@@ -61,17 +61,17 @@ describe ::Protobuf::Generators::FieldGenerator do
 
         context 'when the default value is "nan"' do
           let(:default_value) { 'nan' }
-          it { should match(/::Float::NAN/) }
+          specify { expect(subject).to match(/::Float::NAN/) }
         end
 
         context 'when the default value is "inf"' do
           let(:default_value) { 'inf' }
-          it { should match(/::Float::INFINITY/) }
+          specify { expect(subject).to match(/::Float::INFINITY/) }
         end
 
         context 'when the default value is "-inf"' do
           let(:default_value) { '-inf' }
-          it { should match(/-::Float::INFINITY/) }
+          specify { expect(subject).to match(/-::Float::INFINITY/) }
         end
       end
     end
@@ -79,19 +79,19 @@ describe ::Protobuf::Generators::FieldGenerator do
     context 'when the field is an extension' do
       let(:extendee) { 'foo.bar.Baz' }
 
-      it { should eq "optional :string, :foo_bar, 3, :extension => true\n" }
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :extension => true\n" }
     end
 
     context 'when field is packed' do
       let(:field_options) { { :packed => true } }
 
-      it { should eq "optional :string, :foo_bar, 3, :packed => true\n" }
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :packed => true\n" }
     end
 
     context 'when field is deprecated' do
       let(:field_options) { { :deprecated => true } }
 
-      it { should eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
     end
   end
 

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

@@ -9,7 +9,7 @@ describe ::Protobuf::Generators::FileGenerator do
   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
@@ -18,8 +18,8 @@ describe ::Protobuf::Generators::FileGenerator do
     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
 

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

@@ -29,13 +29,13 @@ 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
   end
 

data/spec/lib/protobuf/lifecycle_spec.rb

@@ -9,8 +9,8 @@ describe ::Protobuf::Lifecycle do
   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
@@ -26,8 +26,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 +43,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 +55,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 +69,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