protobuffy 3.1.0

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

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

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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 ]
+          ::Test::ResourceFindRequest.encode(:name => 'resource', :widgets => frozen_strings)
+        }.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 ]
+          ::Test::ResourceFindRequest.encode(:name => 'resource', :widget_bytes => frozen_strings)
+        }.not_to raise_error
+      end
+    end
+
+    it 'does not alter string values after encoding multiple times' do
+      source_string = "foo"
+      proto = ::Test::Resource.new(:name => source_string)
+      proto.encode
+      proto.name.should eq source_string
+      proto.encode
+      proto.name.should 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
+      proto.encode
+      proto.name.should eq source_string
+    end
+  end
+
+
+end

data/spec/lib/protobuf/field_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+require 'protobuf/field'
+
+describe ::Protobuf::Field do
+
+  describe '.build' do
+    pending
+  end
+
+  describe '.field_class' do
+    context 'when type is an enum class' do
+      it 'returns an enum field' do
+        expect(subject.field_class(::Test::EnumTestType)).to eq(::Protobuf::Field::EnumField)
+        expect(subject.field_type(::Test::EnumTestType)).to eq(::Test::EnumTestType)
+      end
+    end
+
+    context 'when type is a message class' do
+      it 'returns a message field' do
+        expect(subject.field_class(::Test::Resource)).to eq(::Protobuf::Field::MessageField)
+        expect(subject.field_type(::Test::Resource)).to eq(::Test::Resource)
+      end
+    end
+
+    context 'when type is a base field class' do
+      it 'returns that class' do
+        expect(subject.field_class(::Protobuf::Field::BoolField)).to eq(::Protobuf::Field::BoolField)
+      end
+    end
+
+    context 'when type is a double field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::DoubleField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:double)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:double)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a float field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::FloatField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:float)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:float)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed64)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a string field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::StringField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:string)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:string)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a bytes field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BytesField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bytes)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bytes)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a bool field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BoolField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bool)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bool)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is not mapped' do
+      it 'raises an ArgumentError' do
+        expect {
+          subject.field_class("boom")
+        }.to raise_error
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/base'
+
+describe ::Protobuf::Generators::Base do
+
+  subject { described_class.new(double) }
+
+  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' }
+  end
+
+  describe '#run_once' do
+    it 'protects the block from being entered more than once' do
+      foo = 0
+      bar = 0
+
+      test_run_once = lambda do
+        bar += 1
+        subject.run_once(:foo_test) do
+          foo += 1
+        end
+      end
+
+      10.times { test_run_once.call }
+      expect(foo).to eq(1)
+      expect(bar).to eq(10)
+    end
+
+    it 'always returns the same object' do
+      rv = subject.run_once(:foo_test) do
+        "foo bar"
+      end
+      expect(rv).to eq("foo bar")
+
+      rv = subject.run_once(:foo_test) do
+        "baz quux"
+      end
+      expect(rv).to eq("foo bar")
+    end
+  end
+
+  describe '#to_s' do
+    before do
+      class ToStringTest < ::Protobuf::Generators::Base
+        def compile
+          run_once(:compile) do
+            puts "this is a test"
+          end
+        end
+      end
+    end
+
+    subject { ToStringTest.new(double) }
+
+    it 'compiles and returns the contents' do
+      10.times do
+        expect(subject.to_s).to eq("this is a test\n")
+      end
+    end
+  end
+
+  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/)
+
+        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/)
+        described_class.validate_tags("FooBar", [1,2,4,5])
+      end
+    end
+  end
+
+end
+

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+require 'protobuf/generators/enum_generator'
+
+describe ::Protobuf::Generators::EnumGenerator do
+
+  let(:values) {
+    [
+      { :name => 'FOO', :number => 1 },
+      { :name => 'BAR', :number => 2 },
+      { :name => 'BAZ', :number => 3 }
+    ]
+  }
+  let(:options) { nil }
+  let(:enum_fields) { { :name => 'TestEnum',
+                        :value => values,
+                        :options => options } }
+
+  let(:enum) { ::Google::Protobuf::EnumDescriptorProto.new(enum_fields) }
+
+  subject { described_class.new(enum) }
+
+  describe '#compile' do
+    let(:compiled) {
+      %q{class TestEnum < ::Protobuf::Enum
+  define :FOO, 1
+  define :BAR, 2
+  define :BAZ, 3
+end
+
+}
+    }
+
+    it 'compiles the enum and it\'s field values' do
+      subject.compile
+      subject.to_s.should eq(compiled)
+    end
+
+    context 'when allow_alias option is set' do
+      let(:compiled) {
+        %q{class TestEnum < ::Protobuf::Enum
+  set_option :allow_alias
+
+  define :FOO, 1
+  define :BAR, 2
+  define :BAZ, 3
+end
+
+}
+    }
+
+      let(:options) { { :allow_alias => true } }
+
+      it 'sets the allow_alias option' do
+        subject.compile
+        subject.to_s.should 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")
+    end
+  end
+
+end
+

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/extension_generator'
+
+describe ::Protobuf::Generators::ExtensionGenerator do
+
+  let(:field_descriptors) {
+    [
+      double('field descriptor 1', :to_s => "  field 1\n"),
+      double('field descriptor 2', :to_s => "  field 2\n"),
+      double('field descriptor 3', :to_s => "  field 3\n")
+    ]
+  }
+  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])
+  end
+
+  subject { described_class.new(message_type, field_descriptors, 0) }
+
+  describe '#compile' do
+    let(:compiled) {
+      %q{class FooBar < ::Protobuf::Message
+  field 1
+  field 2
+  field 3
+end
+
+}
+    }
+
+    it 'compiles the a class with the extension fields' do
+      subject.compile
+      subject.to_s.should eq(compiled)
+    end
+  end
+
+end
+