protobuf 3.10.8 → 3.10.10

data/spec/encoding/packed_decoding_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+# The protobuf spec: "Protobuf parsers must be able to parse repeated fields
+# that were compiled as packed as if they were not packed, and vice versa."
+# https://protobuf.dev/programming-guides/encoding/#packed
+#
+# proto3 encoders (Go, Java, C++, google-protobuf) pack repeated scalars by
+# default, so these fields must decode packed input although they do not
+# declare `packed`.
+RSpec.describe 'Decoding packed and unpacked repeated scalar fields' do
+  module PackedDecodingSpec
+    class Color < ::Protobuf::Enum
+      define :RED, 0
+      define :GREEN, 1
+      define :BLUE, 2
+    end
+
+    class Unpacked < ::Protobuf::Message
+      optional :string, :name, 15
+      repeated :int32, :r_i32, 21
+      repeated :int64, :r_i64, 22
+      repeated :uint32, :r_u32, 23
+      repeated :uint64, :r_u64, 24
+      repeated :sint32, :r_s32, 25
+      repeated :sint64, :r_s64, 26
+      repeated :bool, :r_b, 27
+      repeated ::PackedDecodingSpec::Color, :r_color, 28
+      repeated :fixed32, :r_f32, 29
+      repeated :fixed64, :r_f64, 30
+      repeated :sfixed32, :r_sf32, 31
+      repeated :sfixed64, :r_sf64, 32
+      repeated :float, :r_flt, 33
+      repeated :double, :r_dbl, 34
+      repeated :string, :r_str, 35
+    end
+
+    class Packed < ::Protobuf::Message
+      repeated :int32, :r_i32, 21, :packed => true
+      repeated :bool, :r_b, 27, :packed => true
+      repeated :double, :r_dbl, 34, :packed => true
+    end
+
+    class Singular < ::Protobuf::Message
+      optional :int32, :i32, 1
+      optional :bool, :b, 7
+      optional :string, :str, 15
+      map :string, :int32, :counts, 16
+    end
+  end
+
+  def tag(field, wire_type)
+    ::Protobuf::Varint.encode((field << 3) | wire_type)
+  end
+
+  def varint(value)
+    ::Protobuf::Varint.encode(value)
+  end
+
+  def len(field, bytes)
+    tag(field, ::Protobuf::WireType::LENGTH_DELIMITED) + varint(bytes.bytesize) + bytes
+  end
+
+  def unpacked_varints(field, values)
+    values.map { |v| tag(field, ::Protobuf::WireType::VARINT) + varint(v) }.join.b
+  end
+
+  # Bytes made by google-protobuf 4.36.2 (proto3, so every repeated scalar is
+  # packed) for:
+  #   r_i32: [1, -1, 300], r_i64: [5, -9_000_000_000],
+  #   r_u32: [0, 4_294_967_295], r_u64: [18_446_744_073_709_551_615],
+  #   r_s32: [-1, 2, -300], r_s64: [-5_000_000_000], r_b: [true, false, true],
+  #   r_color: [GREEN, BLUE], r_f32: [7, 4_294_967_295], r_f64: [8],
+  #   r_sf32: [-7], r_sf64: [-8], r_flt: [1.5, -2.25], r_dbl: [3.5, -0.125]
+  let(:google_protobuf_packed) do
+    hex = 'aa010d01ffffffffffffffffff01ac02b2010b0580ccbbbcdeffffffff01ba010600ffffffff0f' \
+          'c2010affffffffffffffffff01ca01040104d704d20105ffc7afa025da0103010001e201020102' \
+          'ea010807000000fffffffff201080800000000000000fa0104f9ffffff820208f8ffffffffffffff' \
+          '8a02080000c03f000010c09202100000000000000c40000000000000c0bf'
+    [hex].pack('H*')
+  end
+
+  describe 'packed input for fields that do not declare packed' do
+    subject(:message) { PackedDecodingSpec::Unpacked.decode(google_protobuf_packed) }
+
+    {
+      :r_i32 => [1, -1, 300],
+      :r_i64 => [5, -9_000_000_000],
+      :r_u32 => [0, 4_294_967_295],
+      :r_u64 => [18_446_744_073_709_551_615],
+      :r_s32 => [-1, 2, -300],
+      :r_s64 => [-5_000_000_000],
+      :r_b => [true, false, true],
+      :r_f32 => [7, 4_294_967_295],
+      :r_f64 => [8],
+      :r_sf32 => [-7],
+      :r_sf64 => [-8],
+      :r_flt => [1.5, -2.25],
+      :r_dbl => [3.5, -0.125],
+    }.each do |field, expected|
+      it "decodes #{field}" do
+        expect(message.public_send(field).to_a).to eq(expected)
+      end
+    end
+
+    it 'decodes enums' do
+      expect(message.r_color.to_a).to eq([PackedDecodingSpec::Color::GREEN, PackedDecodingSpec::Color::BLUE])
+    end
+
+    it 'decodes the report case: packed bools are not all false' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(27, "\x01".b)).r_b.to_a).to eq([true])
+      expect(PackedDecodingSpec::Unpacked.decode(len(27, "\x01\x01".b)).r_b.to_a).to eq([true, true])
+    end
+
+    it 'decodes the report case: packed int64 does not raise' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(22, "\x05\x09".b)).r_i64.to_a).to eq([5, 9])
+    end
+  end
+
+  describe 'packed records' do
+    it 'concatenates a packed run that is split over two records' do
+      bytes = len(21, "\x01\x02".b) + len(15, 'x') + len(21, "\x03".b)
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_i32.to_a).to eq([1, 2, 3])
+    end
+
+    it 'accepts packed and unpacked records for the same field' do
+      bytes = len(21, "\x01\x02".b) + unpacked_varints(21, [3])
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_i32.to_a).to eq([1, 2, 3])
+    end
+
+    it 'adds no values for an empty packed record' do
+      expect(PackedDecodingSpec::Unpacked.decode(len(21, ''.b)).r_i32.to_a).to eq([])
+    end
+
+    it 'does not change other fields' do
+      bytes = len(15, 'name') + len(21, "\x01".b) + len(35, 'a') + len(35, 'b')
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.name, message.r_i32.to_a, message.r_str.to_a]).to eq(['name', [1], %w[a b]])
+    end
+  end
+
+  describe 'unpacked input for fields that declare packed' do
+    it 'decodes varints' do
+      bytes = unpacked_varints(21, [1, 2])
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_i32.to_a).to eq([1, 2])
+    end
+
+    it 'decodes bools' do
+      bytes = unpacked_varints(27, [1, 0])
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_b.to_a).to eq([true, false])
+    end
+
+    it 'decodes fixed64 values' do
+      bytes = [3.5, -0.125].map { |v| tag(34, ::Protobuf::WireType::FIXED64) + [v].pack('E') }.join.b
+      expect(PackedDecodingSpec::Packed.decode(bytes).r_dbl.to_a).to eq([3.5, -0.125])
+    end
+  end
+
+  describe 'unchanged behavior' do
+    it 'decodes unpacked input for fields that do not declare packed' do
+      bytes = unpacked_varints(21, [1, 2]) + unpacked_varints(27, [1])
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.r_i32.to_a, message.r_b.to_a]).to eq([[1, 2], [true]])
+    end
+
+    it 'decodes packed input for fields that declare packed' do
+      expect(PackedDecodingSpec::Packed.decode(len(21, "\x01\x02".b)).r_i32.to_a).to eq([1, 2])
+    end
+
+    it 'round-trips both declarations' do
+      unpacked = PackedDecodingSpec::Unpacked.new(:r_i32 => [1, -1], :r_b => [true, false], :r_dbl => [1.5])
+      packed = PackedDecodingSpec::Packed.new(:r_i32 => [1, -1], :r_b => [true, false], :r_dbl => [1.5])
+      expect(PackedDecodingSpec::Unpacked.decode(unpacked.encode)).to eq(unpacked)
+      expect(PackedDecodingSpec::Packed.decode(packed.encode)).to eq(packed)
+    end
+
+    it 'decodes across declarations: packed writer, unpacked reader and back' do
+      packed = PackedDecodingSpec::Packed.new(:r_i32 => [1, 300], :r_b => [true, false], :r_dbl => [1.5, 2.5])
+      unpacked = PackedDecodingSpec::Unpacked.decode(packed.encode)
+      expect([unpacked.r_i32.to_a, unpacked.r_b.to_a, unpacked.r_dbl.to_a]).to eq([[1, 300], [true, false], [1.5, 2.5]])
+
+      back = PackedDecodingSpec::Packed.decode(unpacked.encode)
+      expect(back).to eq(packed)
+    end
+
+    it 'does not change encoding' do
+      message = PackedDecodingSpec::Unpacked.new(:r_i32 => [1, 2])
+      expect(message.encode).to eq(unpacked_varints(21, [1, 2]))
+    end
+  end
+
+  describe 'a record with the wrong wire type for a known field' do
+    it 'is skipped for a singular scalar field' do
+      bytes = len(1, 'xx') + len(7, "\x01".b) + len(15, 'ok')
+      message = PackedDecodingSpec::Singular.decode(bytes)
+      expect([message.i32, message.field?(:i32), message.b, message.field?(:b), message.str]).to eq([0, false, false, false, 'ok'])
+    end
+
+    it 'is skipped for a repeated scalar field' do
+      bytes = tag(29, ::Protobuf::WireType::VARINT) + varint(5) + len(21, "\x01".b)
+      message = PackedDecodingSpec::Unpacked.decode(bytes)
+      expect([message.r_f32.to_a, message.r_i32.to_a]).to eq([[], [1]])
+    end
+
+    it 'is skipped for a repeated string field' do
+      bytes = tag(35, ::Protobuf::WireType::VARINT) + varint(5) + len(35, 'ok')
+      expect(PackedDecodingSpec::Unpacked.decode(bytes).r_str.to_a).to eq(['ok'])
+    end
+
+    it 'is skipped for a map field' do
+      entry = len(1, 'a') + tag(2, ::Protobuf::WireType::VARINT) + varint(3)
+      bytes = tag(16, ::Protobuf::WireType::VARINT) + varint(5) + len(16, entry)
+      expect(PackedDecodingSpec::Singular.decode(bytes).counts.to_h).to eq('a' => 3)
+    end
+  end
+
+  describe 'callers that do not know the wire type' do
+    it 'Decoder.decode_each_field still works with a two-argument block' do
+      seen = []
+      ::Protobuf::Decoder.decode_each_field(StringIO.new(unpacked_varints(21, [7]))) { |tag, bytes| seen << [tag, bytes] }
+      expect(seen).to eq([[21, 7]])
+    end
+
+    it 'BaseField#set without a wire type uses the field declaration' do
+      message = PackedDecodingSpec::Packed.new
+      PackedDecodingSpec::Packed.get_field(:r_i32).set(message, "\x01\x02".b)
+      expect(message.r_i32.to_a).to eq([1, 2])
+
+      unpacked = PackedDecodingSpec::Unpacked.new
+      PackedDecodingSpec::Unpacked.get_field(:r_i32).set(unpacked, 3)
+      expect(unpacked.r_i32.to_a).to eq([3])
+    end
+  end
+end

data/spec/encoding/wire_compat_decoding_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+# Input that other protobuf implementations decode, but that made this gem
+# raise for the whole message.
+RSpec.describe 'Decoding input from other protobuf implementations' do
+  module WireCompatDecodingSpec
+    class Message < ::Protobuf::Message
+      optional :int32, :i32, 1
+      optional :uint32, :u32, 2
+      optional :sint32, :s32, 3
+      repeated :int32, :r_i32, 4
+      optional :int64, :i64, 5
+      optional :string, :str, 15
+    end
+  end
+
+  def tag(field, wire_type)
+    ::Protobuf::Varint.encode((field << 3) | wire_type)
+  end
+
+  def varint(field, value)
+    tag(field, ::Protobuf::WireType::VARINT) + ::Protobuf::Varint.encode(value)
+  end
+
+  def len(field, bytes)
+    tag(field, ::Protobuf::WireType::LENGTH_DELIMITED) + ::Protobuf::Varint.encode(bytes.bytesize) + bytes
+  end
+
+  def decode(bytes)
+    WireCompatDecodingSpec::Message.decode(bytes.b)
+  end
+
+  # The language guide calls int32, uint32, int64, and uint64 compatible: a
+  # parser keeps the low 32 bits, as in a C++ cast.
+  describe 'a 32-bit field that gets a wider varint' do
+    it 'keeps the low 32 bits of an int32' do
+      expect(decode(varint(1, 0xffff_ffff)).i32).to eq(-1)
+      expect(decode(varint(1, 0x1_0000_0005)).i32).to eq(5)
+      expect(decode(varint(1, 0xffff_ffff_8000_0000)).i32).to eq(-2_147_483_648)
+    end
+
+    it 'keeps the low 32 bits of a uint32' do
+      expect(decode(varint(2, 0x1_0000_0001)).u32).to eq(1)
+    end
+
+    it 'keeps the low 32 bits of a sint32 before the zigzag decode' do
+      # zigzag(-2) is 3; the bits above 32 are dropped.
+      expect(decode(varint(3, 0x4_0000_0003)).s32).to eq(-2)
+    end
+
+    it 'keeps the low 32 bits in a packed run' do
+      run = ::Protobuf::Varint.encode(0x1_0000_0007) + ::Protobuf::Varint.encode(1)
+      expect(decode(len(4, run)).r_i32.to_a).to eq([7, 1])
+    end
+
+    it 'decodes the other fields of the message' do
+      message = decode(varint(1, 0x1_0000_0005) + len(15, 'ok'))
+      expect([message.i32, message.str]).to eq([5, 'ok'])
+    end
+
+    it 'does not change values in range' do
+      message = WireCompatDecodingSpec::Message.new(
+        :i32 => -2_147_483_648, :u32 => 4_294_967_295, :s32 => -7, :r_i32 => [-1, 2_147_483_647], :i64 => -2**40,
+      )
+      expect(WireCompatDecodingSpec::Message.decode(message.encode)).to eq(message)
+    end
+  end
+
+  # Groups (wire types 3 and 4) come from proto2 group fields and from
+  # editions DELIMITED encoding. This gem has no group fields, so it skips a
+  # group as an unknown field.
+  describe 'a group' do
+    let(:start_group) { tag(95, ::Protobuf::WireType::START_GROUP) }
+    let(:end_group) { tag(95, ::Protobuf::WireType::END_GROUP) }
+
+    it 'is skipped, with the fields inside it' do
+      bytes = start_group + varint(1, 9) + len(15, 'in') + end_group + varint(1, 5)
+      message = decode(bytes)
+      expect([message.i32, message.str]).to eq([5, ''])
+    end
+
+    it 'is skipped with every wire type inside it' do
+      inner = varint(1, 1) + tag(2, ::Protobuf::WireType::FIXED64) + ("\x00" * 8) +
+              tag(3, ::Protobuf::WireType::FIXED32) + ("\x00" * 4) + len(4, 'abc')
+      expect(decode(start_group + inner + end_group + len(15, 'ok')).str).to eq('ok')
+    end
+
+    it 'is skipped with groups inside it' do
+      inner_start = tag(7, ::Protobuf::WireType::START_GROUP)
+      inner_end = tag(7, ::Protobuf::WireType::END_GROUP)
+      bytes = start_group + inner_start + varint(1, 9) + inner_end + end_group + varint(1, 5)
+      expect(decode(bytes).i32).to eq(5)
+    end
+
+    it 'is skipped when its field number is a known field' do
+      bytes = tag(1, ::Protobuf::WireType::START_GROUP) + varint(1, 9) + tag(1, ::Protobuf::WireType::END_GROUP)
+      expect(decode(bytes).field?(:i32)).to be(false)
+    end
+
+    it 'raises when the group has no end' do
+      expect { decode(start_group + varint(1, 9)) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+
+    it 'raises when the end does not match the start' do
+      bytes = start_group + tag(96, ::Protobuf::WireType::END_GROUP)
+      expect { decode(bytes) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+
+    it 'raises for an end group without a start' do
+      expect { decode(end_group) }.to raise_error(::Protobuf::InvalidWireType)
+    end
+  end
+end

data/spec/functional/railtie_boot_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'open3'
+require 'rbconfig'
+require 'tmpdir'
+require 'fileutils'
+
+# Boots a real Rails app in a subprocess, with the load order that the
+# `rpc_server` CLI uses: protobuf loads first, then the app file loads Rails.
+RSpec.describe 'Protobuf::Railtie in a booted Rails app' do
+  let(:lib_dir) { ::File.expand_path('../../../lib', __FILE__) }
+
+  def write(root, relative_path, contents)
+    full = ::File.join(root, relative_path)
+    ::FileUtils.mkdir_p(::File.dirname(full))
+    ::File.write(full, contents)
+  end
+
+  def build_app(root, services_path)
+    config_line = services_path ? "config.protobuf.services_path = #{services_path.inspect}" : ''
+
+    write(root, 'config/environment.rb', <<-RUBY)
+      require 'rails'
+      class RailtieBootApp < Rails::Application
+        config.root = #{root.inspect}
+        config.eager_load = false
+        config.logger = Logger.new(nil)
+        config.secret_key_base = 'x' * 64
+        #{config_line}
+      end
+      Rails.application.initialize!
+    RUBY
+
+    # app/services is a Zeitwerk root, so app/services/rpc/ is the Rpc namespace.
+    write(root, 'app/services/rpc/echo_service.rb', <<-RUBY)
+      module Rpc
+        class EchoService < ::Protobuf::Rpc::ApplicationService
+          rpc :echo, ::Protobuf::Socketrpc::Request, ::Protobuf::Socketrpc::Response
+          def echo; end
+        end
+      end
+    RUBY
+
+    write(root, 'app/services/plain_object.rb', <<-RUBY)
+      class PlainObject
+        $stdout.puts 'PLAIN_OBJECT_LOADED'
+      end
+    RUBY
+  end
+
+  def boot(root)
+    script = <<-RUBY
+      require 'protobuf/socket'
+      require #{::File.join(root, 'config/environment').inspect}
+      puts "BEFORE_BIND=\#{::Protobuf::Rpc::Service.implemented_services.inspect}"
+      ::ActiveSupport::Notifications.instrument('before_server_bind')
+      puts "AFTER_BIND=\#{::Protobuf::Rpc::Service.implemented_services.inspect}"
+    RUBY
+
+    Open3.capture2e(::RbConfig.ruby, '-I', lib_dir, '-e', script, :chdir => root)
+  end
+
+  it 'loads the configured services directory when the server binds' do
+    ::Dir.mktmpdir do |root|
+      build_app(root, 'app/services/rpc')
+      output, status = boot(root)
+
+      expect(status).to be_success, output
+      expect(output).to include('BEFORE_BIND=[]')
+      expect(output).to include('AFTER_BIND=["Rpc::EchoService"]')
+      expect(output).not_to include('PLAIN_OBJECT_LOADED')
+    end
+  end
+
+  it 'loads nothing when services_path is not configured' do
+    ::Dir.mktmpdir do |root|
+      build_app(root, nil)
+      output, status = boot(root)
+
+      expect(status).to be_success, output
+      expect(output).to include('AFTER_BIND=[]')
+      expect(output).not_to include('PLAIN_OBJECT_LOADED')
+    end
+  end
+end

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

@@ -53,6 +53,27 @@ RSpec.describe Protobuf::Field::BoolField do
     end
   end
 
+  describe '#decode' do
+    subject { described_class.new(SomeBoolMessage, :optional, described_class, :b, 1, :b, {}) }
+
+    it 'decodes 0 as false' do
+      expect(subject.decode(0)).to be(false)
+    end
+
+    it 'decodes 1 as true' do
+      expect(subject.decode(1)).to be(true)
+    end
+
+    it 'decodes any other non-zero varint as true, like the reference parsers' do
+      expect(subject.decode(2)).to be(true)
+      expect(subject.decode(0xffff_ffff_ffff_ffff)).to be(true)
+    end
+  end
+
+  it 'decodes a non-canonical varint (2) on the wire as true' do
+    expect(SomeBoolMessage.decode("\x08\x02".b).some_bool).to be(true)
+  end
+
   it 'defines ? method' do
     instance.required_bool = false
     expect(instance.required_bool?).to be(false)

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

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 RSpec.describe ::Protobuf::Field::StringField do

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

@@ -95,5 +95,28 @@ EOF
         expect(subject.to_s).to eq(compiled)
       end
     end
+
+    context 'with PB_SERVICE_PARENT in the environment' do
+      let(:service_parent) { ' ::Protobuf::Rpc::ApplicationService ' }
+
+      before do
+        allow(ENV).to receive(:[]).and_call_original
+        allow(ENV).to receive(:[]).with('PB_SERVICE_PARENT').and_return(service_parent)
+      end
+
+      it 'uses the given parent class' do
+        subject.compile
+        expect(subject.to_s).to start_with("class TestService < ::Protobuf::Rpc::ApplicationService\n")
+      end
+
+      context 'when it is empty' do
+        let(:service_parent) { '' }
+
+        it 'uses ::Protobuf::Rpc::Service' do
+          subject.compile
+          expect(subject.to_s).to eq(compiled)
+        end
+      end
+    end
   end
 end

data/spec/lib/protobuf/message_spec.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'stringio'
 require 'spec_helper'
 require PROTOS_PATH.join('resource.pb')

data/spec/lib/protobuf/railtie_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'protobuf/railtie'
+
+RSpec.describe Protobuf::Railtie do
+  let(:config) do
+    double('config', :protobuf => ::ActiveSupport::OrderedOptions.new)
+  end
+
+  let(:app) { double('app', :config => config, :root => Pathname.new('/srv/app')) }
+
+  describe '.services_path' do
+    it 'is nil when not configured (opt-in)' do
+      expect(described_class.services_path(app)).to be_nil
+    end
+
+    it 'is nil when configured as an empty string' do
+      config.protobuf.services_path = ''
+      expect(described_class.services_path(app)).to be_nil
+    end
+
+    it 'honors an absolute path' do
+      config.protobuf.services_path = '/custom/services'
+      expect(described_class.services_path(app)).to eq('/custom/services')
+    end
+
+    it 'resolves a relative path against the app root' do
+      config.protobuf.services_path = 'app/services/rpc'
+      expect(described_class.services_path(app)).to eq('/srv/app/app/services/rpc')
+    end
+
+    it 'accepts a Pathname' do
+      config.protobuf.services_path = Pathname.new('/custom/services')
+      expect(described_class.services_path(app)).to eq('/custom/services')
+    end
+  end
+
+  describe '.load_services' do
+    let(:loader) { double('autoloader') }
+
+    before do
+      allow(described_class).to receive(:services_path).and_return('/svc')
+      allow(::File).to receive(:directory?).and_call_original
+      allow(::File).to receive(:directory?).with('/svc').and_return(true)
+      stub_const('Rails', double('Rails', :autoloaders => double(:main => loader)))
+    end
+
+    it 'does nothing when no path is configured' do
+      allow(described_class).to receive(:services_path).and_return(nil)
+      expect(::Protobuf::ServiceLoader).not_to receive(:load_services)
+      described_class.load_services(app)
+    end
+
+    it 'does nothing when the directory is missing' do
+      allow(::File).to receive(:directory?).with('/svc').and_return(false)
+      expect(::Protobuf::ServiceLoader).not_to receive(:load_services)
+      described_class.load_services(app)
+    end
+
+    it 'eager-loads through the autoloader when eager_load_dir is available' do
+      allow(loader).to receive(:respond_to?).with(:eager_load_dir).and_return(true)
+      expect(loader).to receive(:eager_load_dir).with('/svc')
+      expect(::Protobuf::ServiceLoader).not_to receive(:load_services)
+      described_class.load_services(app)
+    end
+
+    it 'falls back to ServiceLoader when eager_load_dir is unavailable' do
+      allow(loader).to receive(:respond_to?).with(:eager_load_dir).and_return(false)
+      expect(::Protobuf::ServiceLoader).to receive(:load_services).with('/svc')
+      described_class.load_services(app)
+    end
+
+    it 'falls back to ServiceLoader with the classic autoloader (no main loader)' do
+      stub_const('Rails', double('Rails', :autoloaders => double(:main => nil)))
+      expect(::Protobuf::ServiceLoader).to receive(:load_services).with('/svc')
+      described_class.load_services(app)
+    end
+
+    it 'falls back to ServiceLoader when the path is not autoloader-managed' do
+      stub_const('Zeitwerk::Error', Class.new(StandardError))
+      allow(loader).to receive(:respond_to?).with(:eager_load_dir).and_return(true)
+      allow(loader).to receive(:eager_load_dir).and_raise(::Zeitwerk::Error)
+      expect(::Protobuf::ServiceLoader).to receive(:load_services).with('/svc')
+      described_class.load_services(app)
+    end
+  end
+end

data/spec/lib/protobuf/rpc/application_service_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require SUPPORT_PATH.join('resource_service')
+
+RSpec.describe Protobuf::Rpc::ApplicationService do
+  it 'is a subclass of Protobuf::Rpc::Service' do
+    expect(described_class.ancestors).to include(Protobuf::Rpc::Service)
+  end
+
+  it 'inherits Service class methods (host, port, configure)' do
+    expect(described_class).to respond_to(:host, :port, :configure, :rpc, :rpcs)
+  end
+
+  describe 'integration with implemented_services' do
+    let!(:app_subclass) do
+      Class.new(described_class) do
+        def self.name
+          'ImplementedAppSubclassService'
+        end
+
+        rpc :find, Test::ResourceFindRequest, Test::Resource
+        def find; end
+      end
+    end
+
+    let!(:abstract_subclass) do
+      Class.new(described_class) do
+        def self.name
+          'AbstractAppSubclassService'
+        end
+
+        rpc :find, Test::ResourceFindRequest, Test::Resource
+        # no #find method defined -> not "implemented"
+      end
+    end
+
+    after do
+      # `descendants` holds these classes until GC, which can run late. Remove
+      # the rpc method so other specs do not see this class as implemented.
+      app_subclass.send(:remove_method, :find)
+    end
+
+    it 'is discovered by Service.implemented_services (descendants traversal)' do
+      names = Protobuf::Rpc::Service.implemented_services
+      expect(names).to include('ImplementedAppSubclassService')
+    end
+
+    it 'omits subclasses with no implemented rpc methods' do
+      names = Protobuf::Rpc::Service.implemented_services
+      expect(names).not_to include('AbstractAppSubclassService')
+    end
+
+    it 'does not list the ApplicationService base itself' do
+      names = Protobuf::Rpc::Service.implemented_services
+      expect(names).not_to include(described_class.name)
+    end
+  end
+end