protobuffy 3.1.0

data/spec/lib/protobuf/cli_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+require 'protobuf/cli'
+
+describe ::Protobuf::CLI do
+
+  let(:app_file) do
+    File.expand_path('../../../support/test_app_file.rb', __FILE__)
+  end
+
+  let(:sock_runner) {
+    runner = double("SocketRunner", :register_signals => nil)
+    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
+    runner
+  }
+
+  let(:zmq_runner) {
+    runner = double "ZmqRunner", register_signals: nil
+    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
+    runner
+  }
+
+  before(:each) do
+    ::Protobuf::Rpc::SocketRunner.stub(:new) { sock_runner }
+    ::Protobuf::Rpc::ZmqRunner.stub(:new) { zmq_runner }
+  end
+
+  describe '#start' do
+    let(:base_args) { [ 'start', app_file ] }
+    let(:test_args) { [] }
+    let(:args) { base_args + test_args }
+
+    context 'host option' do
+      let(:test_args) { [ '--host=123.123.123.123' ] }
+
+      it 'sends the host option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
+          options[:host].should eq '123.123.123.123'
+        end.and_return(sock_runner)
+        described_class.start(args)
+      end
+    end
+
+    context 'port option' do
+      let(:test_args) { [ '--port=12345' ] }
+
+      it 'sends the port option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
+          options[:port].should eq 12345
+        end.and_return(sock_runner)
+        described_class.start(args)
+      end
+    end
+
+    context 'threads option' do
+      let(:test_args) { [ '--threads=500' ] }
+
+      it 'sends the threads option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
+          options[:threads].should eq 500
+        end.and_return(sock_runner)
+        described_class.start(args)
+      end
+    end
+
+    context 'backlog option' do
+      let(:test_args) { [ '--backlog=500' ] }
+
+      it 'sends the backlog option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
+          options[:backlog].should eq 500
+        end.and_return(sock_runner)
+        described_class.start(args)
+      end
+    end
+
+    context 'threshold option' do
+      let(:test_args) { [ '--threshold=500' ] }
+
+      it 'sends the backlog option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
+          options[:threshold].should eq 500
+        end.and_return(sock_runner)
+        described_class.start(args)
+      end
+    end
+
+    context 'log options' do
+      let(:test_args) { [ '--log=mylog.log', '--level=0' ] }
+
+      it 'sends the log file and level options to the runner' do
+        ::Protobuf::Logger.should_receive(:configure) do |options|
+          options[:file].should eq 'mylog.log'
+          options[:level].should eq 0
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'gc options' do
+
+      context 'when gc options are not present' do
+        let(:test_args) { [] }
+
+        it 'sets both request and serialization pausing to false' do
+          described_class.start(args)
+          ::Protobuf.should_not be_gc_pause_server_request
+        end
+      end
+
+      unless defined?(JRUBY_VERSION)
+        context 'request pausing' do
+          let(:test_args) { [ '--gc_pause_request' ] }
+
+          it 'sets the configuration option to GC pause server request' do
+            described_class.start(args)
+            ::Protobuf.should be_gc_pause_server_request
+          end
+        end
+      end
+    end
+
+    context 'deprecation options' do
+      context 'when not given' do
+        let(:test_args) { [] }
+
+        context 'when no ENV is present and no command line option' do
+          before { ENV.delete("PB_IGNORE_DEPRECATIONS") }
+
+          it 'sets the deprecation warning flag to true' do
+            described_class.start(args)
+            ::Protobuf.print_deprecation_warnings?.should be_true
+          end
+        end
+
+        context 'if ENV["PB_IGNORE_DEPRECATIONS"] is present' do
+          before { ENV["PB_IGNORE_DEPRECATIONS"] = "1" }
+          after { ENV.delete("PB_IGNORE_DEPRECATIONS") }
+
+          it 'sets the deprecation warning flag to false ' do
+            described_class.start(args)
+            ::Protobuf.print_deprecation_warnings?.should be_false
+          end
+        end
+      end
+
+      context 'when enabled' do
+        let(:test_args) { [ '--print_deprecation_warnings' ] }
+
+        it 'sets the deprecation warning flag to true' do
+          described_class.start(args)
+          ::Protobuf.print_deprecation_warnings?.should be_true
+        end
+      end
+
+      context 'when disabled' do
+        let(:test_args) { [ '--no-print_deprecation_warnings' ] }
+
+        it 'sets the deprecation warning flag to false' do
+          described_class.start(args)
+          ::Protobuf.print_deprecation_warnings?.should be_false
+        end
+      end
+    end
+
+    context 'run modes' do
+
+      context 'socket' do
+        let(:test_args) { [ '--socket' ] }
+        let(:runner) { ::Protobuf::Rpc::SocketRunner }
+
+        before do
+          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
+        end
+
+        it 'is activated by the --socket switch' do
+          runner.should_receive(:new)
+          described_class.start(args)
+        end
+
+        it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do
+          ENV['PB_SERVER_TYPE'] = "Socket"
+          runner.should_receive(:new).and_return(sock_runner)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
+
+        it 'configures the connector type to be socket' do
+          load "protobuf/socket.rb"
+          ::Protobuf.connector_type.should == :socket
+        end
+      end
+
+      context 'zmq workers only' do
+        let(:test_args) { [ '--workers_only', '--zmq' ] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+        end
+
+        it 'is activated by the --workers_only switch' do
+          runner.should_receive(:new) do |options|
+            options[:workers_only].should be_true
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+        end
+
+        it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do
+          ENV['PB_WORKERS_ONLY'] = "1"
+          runner.should_receive(:new) do |options|
+            options[:workers_only].should be_true
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+          ENV.delete('PB_WORKERS_ONLY')
+        end
+      end
+
+      context 'zmq worker port' do
+        let(:test_args) { [ '--worker_port=1234', '--zmq' ] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+        end
+
+        it 'is activated by the --worker_port switch' do
+          runner.should_receive(:new) do |options|
+            options[:worker_port].should eq(1234)
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+        end
+      end
+
+      context 'zmq' do
+        let(:test_args) { [ '--zmq' ] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+        end
+
+        it 'is activated by the --zmq switch' do
+          runner.should_receive(:new)
+          described_class.start(args)
+        end
+
+        it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do
+          ENV['PB_SERVER_TYPE'] = "Zmq"
+          runner.should_receive(:new)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
+
+        it 'configures the connector type to be zmq' do
+          load "protobuf/zmq.rb"
+          ::Protobuf.connector_type.should == :zmq
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/protobuf/code_generator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+describe ::Protobuf::CodeGenerator do
+
+  # Some constants to shorten things up
+  DESCRIPTOR = ::Google::Protobuf
+  COMPILER = ::Google::Protobuf::Compiler
+
+  describe '#response_bytes' do
+    let(:input_file1) { DESCRIPTOR::FileDescriptorProto.new(:name => 'test/foo.proto') }
+    let(:input_file2) { DESCRIPTOR::FileDescriptorProto.new(:name => 'test/bar.proto') }
+
+    let(:output_file1) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/foo.pb.rb') }
+    let(:output_file2) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/bar.pb.rb') }
+
+    let(:file_generator1) { double('file generator 1', :generate_output_file => output_file1) }
+    let(:file_generator2) { double('file generator 2', :generate_output_file => output_file2) }
+
+    let(:request_bytes) do
+      COMPILER::CodeGeneratorRequest.encode(:proto_file => [ input_file1, input_file2 ])
+    end
+
+    let(:expected_response_bytes) do
+      COMPILER::CodeGeneratorResponse.encode(:file => [ output_file1, output_file2 ])
+    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)
+    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
+    end
+  end
+
+  context 'class-level printing methods' do
+    describe '.fatal' do
+      it 'raises a CodeGeneratorFatalError error' do
+        expect {
+          described_class.fatal("something is wrong")
+        }.to raise_error(
+          ::Protobuf::CodeGenerator::CodeGeneratorFatalError,
+          "something is wrong"
+        )
+      end
+    end
+
+    describe '.warn' do
+      it 'prints a warning to stderr' do
+        STDERR.should_receive(:puts).with("[WARN] a warning")
+        described_class.warn("a warning")
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/enum_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+describe Protobuf::Enum do
+
+  describe 'class dsl' do
+    let(:name) { :THREE }
+    let(:tag)  { 3 }
+
+    before(:all) do
+      Test::EnumTestType.define(:MINUS_ONE, -1)
+      Test::EnumTestType.define(:THREE, 3)
+    end
+
+    before(:all) do
+      EnumAliasTest = ::Class.new(::Protobuf::Enum) do
+        set_option :allow_alias
+        define :FOO, 1
+        define :BAR, 1
+        define :BAZ, 2
+      end
+    end
+
+    describe '.aliases_allowed?' do
+      it 'is false when the option is not set' do
+        expect(Test::EnumTestType.aliases_allowed?).to be_false
+      end
+    end
+
+    describe '.define' do
+      it 'defines a constant enum on the parent class' do
+        expect(Test::EnumTestType.constants).to include(name)
+        expect(Test::EnumTestType::THREE).to be_a(Protobuf::Enum)
+      end
+
+      context 'when enum allows aliases' do
+        before(:all) do
+          DefineEnumAlias = ::Class.new(::Protobuf::Enum) do
+            set_option :allow_alias
+          end
+        end
+
+        it 'allows defining enums with the same tag number' do
+          expect {
+            DefineEnumAlias.define(:FOO, 1)
+            DefineEnumAlias.define(:BAR, 1)
+          }.not_to raise_error
+        end
+      end
+    end
+
+    describe '.enums' do
+      it 'provides an array of defined Enums' do
+        expect(Test::EnumTestType.enums).to eq([
+          Test::EnumTestType::ONE,
+          Test::EnumTestType::TWO,
+          Test::EnumTestType::MINUS_ONE,
+          Test::EnumTestType::THREE
+        ])
+      end
+
+      context 'when enum allows aliases' do
+        it 'treats aliased enums as valid' do
+          expect(EnumAliasTest.enums).to eq([
+            EnumAliasTest::FOO,
+            EnumAliasTest::BAR,
+            EnumAliasTest::BAZ
+          ])
+        end
+      end
+    end
+
+
+    describe '.enums_for_tag' do
+      it 'returns an array of Enums for the given tag, if any' do
+        expect(EnumAliasTest.enums_for_tag(1)).to eq([ EnumAliasTest::FOO, EnumAliasTest::BAR ])
+        expect(EnumAliasTest.enums_for_tag(2)).to eq([ EnumAliasTest::BAZ ])
+        expect(EnumAliasTest.enums_for_tag(3)).to eq([])
+      end
+    end
+
+    describe '.fetch' do
+      context 'when candidate is an Enum' do
+        it 'responds with the Enum' do
+          expect(Test::EnumTestType.fetch(Test::EnumTestType::THREE)).to eq(Test::EnumTestType::THREE)
+        end
+      end
+
+      context 'when candidate can be coerced to a symbol' do
+        it 'fetches based on the symbol name' do
+          expect(Test::EnumTestType.fetch("ONE")).to eq(Test::EnumTestType::ONE)
+          expect(Test::EnumTestType.fetch(:ONE)).to eq(Test::EnumTestType::ONE)
+        end
+      end
+
+      context 'when candidate can be coerced to an integer' do
+        it 'fetches based on the integer tag' do
+          expect(Test::EnumTestType.fetch(3.0)).to eq(Test::EnumTestType::THREE)
+          expect(Test::EnumTestType.fetch(3)).to eq(Test::EnumTestType::THREE)
+        end
+
+        context 'when enum allows aliases' do
+          it 'fetches the first defined Enum' do
+            expect(EnumAliasTest.fetch(1)).to eq(EnumAliasTest::FOO)
+          end
+        end
+      end
+
+      context 'when candidate is not an applicable type' do
+        it 'returns a nil' do
+          expect(Test::EnumTestType.fetch(EnumAliasTest::FOO)).to be_nil
+          expect(Test::EnumTestType.fetch(Test::Resource.new)).to be_nil
+          expect(Test::EnumTestType.fetch(nil)).to be_nil
+          expect(Test::EnumTestType.fetch(false)).to be_nil
+          expect(Test::EnumTestType.fetch(-10)).to be_nil
+        end
+      end
+    end
+
+    describe '.enum_for_tag' do
+      it 'gets the Enum corresponding to the given tag' do
+        expect(Test::EnumTestType.enum_for_tag(tag)).to eq(Test::EnumTestType.const_get(name))
+        expect(Test::EnumTestType.enum_for_tag(-5)).to be_nil
+      end
+    end
+
+    describe '.name_for_tag' do
+      it 'get the name of the enum given the enum' do
+        expect(Test::EnumTestType.name_for_tag(::Test::EnumTestType::THREE)).to eq(name)
+      end
+
+      it 'gets the name of the enum corresponding to the given tag' do
+        expect(Test::EnumTestType.name_for_tag(tag)).to eq(name)
+      end
+
+      it 'gets the name when the tag is coercable to an int' do
+        expect(Test::EnumTestType.name_for_tag("3")).to eq(name)
+      end
+
+      it 'returns nil when tag does not correspond to a name' do
+        expect(Test::EnumTestType.name_for_tag(12345)).to be_nil
+      end
+
+      context 'when given name is nil' do
+        it 'returns a nil' do
+          expect(Test::EnumTestType.name_for_tag(nil)).to be_nil
+        end
+      end
+
+      context 'when enum allows aliases' do
+        it 'returns the first defined name for the given tag' do
+          expect(EnumAliasTest.name_for_tag(1)).to eq(:FOO)
+        end
+      end
+    end
+
+    describe '.valid_tag?' do
+      context 'when tag is defined' do
+        specify { expect(Test::EnumTestType.valid_tag?(tag)).to be_true }
+      end
+
+      context 'when tag is not defined' do
+        specify { expect(Test::EnumTestType.valid_tag?(300)).to be_false }
+      end
+
+      context 'is true for aliased enums' do
+        specify { expect(EnumAliasTest.valid_tag?(1)).to be_true }
+      end
+    end
+
+    describe '.enum_for_name' do
+      it 'gets the Enum corresponding to the given name' do
+        expect(Test::EnumTestType.enum_for_name(name)).to eq(Test::EnumTestType::THREE)
+      end
+    end
+
+    describe '.values' do
+      it 'provides a hash of defined Enums' do
+        expect(Test::EnumTestType.values).to eq({
+          :MINUS_ONE => Test::EnumTestType::MINUS_ONE,
+          :ONE       => Test::EnumTestType::ONE,
+          :TWO       => Test::EnumTestType::TWO,
+          :THREE     => Test::EnumTestType::THREE
+        })
+      end
+
+      it 'contains aliased Enums' do
+        expect(EnumAliasTest.values).to eq({
+          :FOO => EnumAliasTest::FOO,
+          :BAR => EnumAliasTest::BAR,
+          :BAZ => EnumAliasTest::BAZ
+        })
+      end
+    end
+
+    describe '.all_tags' do
+      it 'provides a unique array of defined tags' do
+        expect(Test::EnumTestType.all_tags).to include(1, 2, -1, 3)
+        expect(EnumAliasTest.all_tags).to include(1, 2)
+      end
+    end
+  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") }
+
+  it "can be used as the index to an array" do
+    array = [0, 1, 2, 3]
+    array[::Test::EnumTestType::ONE].should 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) } }
+  end
+
+  context 'when coercing from enum' do
+    subject { Test::StatusType::PENDING }
+    it { should eq(0) }
+  end
+
+  context 'when coercing from integer' do
+    specify { expect(0).to eq(Test::StatusType::PENDING) }
+  end
+end