schema_registry_client 0.0.5 → 0.0.6

data/lib/schema_registry_client.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'json'
+require 'schema_registry_client/confluent_schema_registry'
+require 'schema_registry_client/cached_confluent_schema_registry'
+require 'schema_registry_client/schema/protobuf'
+require 'schema_registry_client/schema/proto_json_schema'
+require 'schema_registry_client/schema/avro'
+
+class SchemaRegistry
+  class SchemaNotFoundError < StandardError; end
+  class SchemaError < StandardError; end
+
+  # Provides a way to encode and decode messages without having to embed schemas
+  # in the encoded data. Confluent's Schema Registry[1] is used to register
+  # a schema when encoding a message -- the registry will issue a schema id that
+  # will be included in the encoded data alongside the actual message. When
+  # decoding the data, the schema id will be used to look up the writer's schema
+  # from the registry.
+  #
+  # 1: https://github.com/confluentinc/schema-registry
+  # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/serdes-protobuf.html
+  # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
+  MAGIC_BYTE = [0].pack('C').freeze
+
+  # Instantiate a new SchemaRegistry instance with the given configuration.
+  #
+  # registry             - A schema registry object that responds to all methods in the
+  #                        SchemaRegistry::ConfluentSchemaRegistry interface.
+  # registry_url         - The String URL of the schema registry that should be used.
+  # schema_context       - Schema registry context name (optional)
+  # registry_path_prefix - The String URL path prefix used to namespace schema registry requests (optional).
+  # logger               - The Logger that should be used to log information (optional).
+  # proxy                - Forward the request via  proxy (optional).
+  # user                 - User for basic auth (optional).
+  # password             - Password for basic auth (optional).
+  # ssl_ca_file          - Name of file containing CA certificate (optional).
+  # client_cert          - Name of file containing client certificate (optional).
+  # client_key           - Name of file containing client private key to go with client_cert (optional).
+  # client_key_pass      - Password to go with client_key (optional).
+  # client_cert_data     - In-memory client certificate (optional).
+  # client_key_data      - In-memory client private key to go with client_cert_data (optional).
+  # connect_timeout      - Timeout to use in the connection with the schema registry (optional).
+  # resolv_resolver      - Custom domain name resolver (optional).
+  # schema_type          - A SchemaRegistry::Schema::Base subclass.
+  def initialize( # rubocop:disable Metrics/ParameterLists
+    registry: nil,
+    registry_url: nil,
+    schema_context: nil,
+    registry_path_prefix: nil,
+    logger: nil,
+    proxy: nil,
+    user: nil,
+    password: nil,
+    ssl_ca_file: nil,
+    client_cert: nil,
+    client_key: nil,
+    client_key_pass: nil,
+    client_cert_data: nil,
+    client_key_data: nil,
+    connect_timeout: nil,
+    resolv_resolver: nil,
+    schema_type: SchemaRegistry::Schema::Protobuf
+  )
+    @logger = logger || Logger.new($stderr)
+    @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
+      SchemaRegistry::ConfluentSchemaRegistry.new(
+        registry_url,
+        schema_context: schema_context,
+        logger: @logger,
+        proxy: proxy,
+        user: user,
+        password: password,
+        ssl_ca_file: ssl_ca_file,
+        client_cert: client_cert,
+        client_key: client_key,
+        client_key_pass: client_key_pass,
+        client_cert_data: client_cert_data,
+        client_key_data: client_key_data,
+        path_prefix: registry_path_prefix,
+        connect_timeout: connect_timeout,
+        resolv_resolver: resolv_resolver
+      )
+    )
+    @schema = schema_type
+  end
+
+  class << self
+    attr_accessor :avro_schema_path
+  end
+
+  # Encodes a message using the specified schema.
+  # @param message [Object] The message that should be encoded. Must be compatible with the schema.
+  # @param subject [String] The subject name the schema should be registered under in the schema registry (optional).
+  # @param schema_name [String] the name of the schema to use for encoding (optional).
+  # @return [String] the encoded data.
+  def encode(message, subject: nil, schema_text: nil, schema_name: nil)
+    id = register_schema(message, subject, schema_text: schema_text, schema_name: schema_name)
+
+    stream = StringIO.new
+    # Always start with the magic byte.
+    stream.write(MAGIC_BYTE)
+
+    # The schema id is encoded as a 4-byte big-endian integer.
+    stream.write([id].pack('N'))
+
+    @schema.encode(message, stream, schema_name: schema_name)
+    stream.string
+  end
+
+  # Decodes data into the original message.
+  #
+  # @param data [String] a string containing encoded data.
+  # @return [Object] the decoded data.
+  def decode(data)
+    stream = StringIO.new(data)
+
+    # The first byte is MAGIC!!!
+    magic_byte = stream.read(1)
+
+    raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
+
+    # The schema id is a 4-byte big-endian integer.
+    schema_id = stream.read(4).unpack1('N')
+    schema = @registry.fetch(schema_id)
+    @schema.decode(stream, schema)
+  rescue Excon::Error::NotFound
+    raise SchemaNotFoundError, "Schema with id: #{schema_id} is not found on registry"
+  end
+
+  private
+
+  def register_schema(message, subject, schema_text: nil, schema_name: nil)
+    schema_text ||= @schema.schema_text(message, schema_name: schema_name)
+    return if @registry.registered?(schema_text, subject)
+
+    # register dependencies first
+    dependencies = @schema.dependencies(message)
+    versions = dependencies.map do |name, dependency|
+      result = register_schema(dependency, name)
+      @registry.fetch_version(result, name)
+    end
+
+    @registry.register(subject,
+                       schema_text,
+                       references: dependencies.keys.map.with_index do |dependency, i|
+                         {
+                           name: dependency,
+                           subject: dependency,
+                           version: versions[i]
+                         }
+                       end,
+                       schema_type: @schema.schema_type)
+  end
+end

data/schema_registry_client.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_registry_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'schema_registry_client'
+  spec.version = SchemaRegistry::VERSION
+  spec.authors = ['Daniel Orner']
+  spec.email = ['daniel.orner@flipp.com']
+  spec.summary = 'Confluent Schema Registry client with support for Avro and Protobuf'
+  spec.homepage = 'https://github.com/flipp-oss/schema_registry_client'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'avro'
+  spec.add_dependency 'excon'
+  spec.add_dependency 'google-protobuf'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'standardrb'
+  spec.add_development_dependency 'webmock'
+end

data/spec/decoding_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+RSpec.describe 'decoding' do
+  let(:schema_registry_client) do
+    SchemaRegistry.new(
+      registry_url: 'http://localhost:8081'
+    )
+  end
+
+  it 'should decode a simple message' do
+    schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
+           .to_return_json(body: { schema: schema })
+    msg = Simple::V1::SimpleMessage.new(name: 'my name')
+    encoded = "\u0000\u0000\u0000\u0000\u000F\u0000#{msg.to_proto}"
+    expect(schema_registry_client.decode(encoded)).to eq(msg)
+
+    # if we do it again we should not see any more requests
+    expect(schema_registry_client.decode(encoded)).to eq(msg)
+
+    expect(stub).to have_been_requested.once
+  end
+
+  it 'should decode a complex message' do
+    schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+    stub = stub_request(:get, 'http://localhost:8081/schemas/ids/20')
+           .to_return_json(body: { schema: schema })
+    msg = Referenced::V1::MessageB::MessageBA.new(
+      simple: Simple::V1::SimpleMessage.new(name: 'my name')
+    )
+    encoded = "\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg.to_proto}"
+    expect(schema_registry_client.decode(encoded)).to eq(msg)
+
+    # if we do it again we should not see any more requests
+    expect(schema_registry_client.decode(encoded)).to eq(msg)
+    expect(stub).to have_been_requested.once
+  end
+
+  describe 'with JSON' do
+    let(:schema_registry_client) do
+      SchemaRegistry.new(
+        registry_url: 'http://localhost:8081',
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+      )
+    end
+
+    it 'should decode a simple message' do
+      schema = File.read("#{__dir__}/schemas/simple/simple.json")
+      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
+             .to_return_json(body: { schema: schema })
+      encoded = "\u0000\u0000\u0000\u0000\u000F{\"name\":\"my name\"}"
+      msg = { 'name' => 'my name' }
+      expect(schema_registry_client.decode(encoded)).to eq(msg)
+
+      # if we do it again we should not see any more requests
+      expect(schema_registry_client.decode(encoded)).to eq(msg)
+
+      expect(stub).to have_been_requested.once
+    end
+  end
+
+  describe 'with Avro' do
+    let(:schema_registry_client) do
+      SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      SchemaRegistry.new(
+        registry_url: 'http://localhost:8081',
+        schema_type: SchemaRegistry::Schema::Avro
+      )
+    end
+
+    after do
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    it 'should decode a simple message' do
+      schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
+             .to_return_json(body: { schema: schema })
+
+      # Avro-encoded data: "my name" as string (length 0x0E + bytes)
+      encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
+      decoded = schema_registry_client.decode(encoded)
+
+      expect(decoded).to eq({ 'name' => 'my name' })
+
+      # if we do it again we should not see any more requests
+      expect(schema_registry_client.decode(encoded)).to eq(decoded)
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should decode a complex message with nested record' do
+      schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
+      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/20')
+             .to_return_json(body: { schema: schema })
+
+      # Avro-encoded nested record
+      encoded = "\u0000\u0000\u0000\u0000\u0014\u000Emy name"
+      decoded = schema_registry_client.decode(encoded)
+
+      expect(decoded).to eq({
+                              'simple' => {
+                                'name' => 'my name'
+                              }
+                            })
+
+      # if we do it again we should not see any more requests
+      expect(schema_registry_client.decode(encoded)).to eq(decoded)
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should decode a message with multiple fields' do
+      multi_schema = {
+        'type' => 'record',
+        'name' => 'MultiFieldMessage',
+        'namespace' => 'test.v1',
+        'fields' => [
+          { 'name' => 'name', 'type' => 'string' },
+          { 'name' => 'age', 'type' => 'int' }
+        ]
+      }
+      schema_json = JSON.generate(multi_schema)
+
+      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/25')
+             .to_return_json(body: { schema: schema_json })
+
+      # Manually encode the message for testing
+      # Alice = 0x0A (length 5*2) + "Alice" bytes
+      # age 30 = zigzag encoded as 60 (0x3C)
+      encoded = "\u0000\u0000\u0000\u0000\u0019\u000AAlice\u003C"
+      decoded = schema_registry_client.decode(encoded)
+
+      expect(decoded).to eq({ 'name' => 'Alice', 'age' => 30 })
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should handle schema evolution with reader schema' do
+      # Writer schema (what was used to encode) - has an additional field with default
+      writer_schema = {
+        'type' => 'record',
+        'name' => 'SimpleMessage',
+        'namespace' => 'simple.v1',
+        'fields' => [
+          { 'name' => 'name', 'type' => 'string' },
+          { 'name' => 'age', 'type' => 'int', 'default' => 0 }
+        ]
+      }
+
+      # Reader schema (what we have locally) - doesn't have the age field
+      # This simulates reading old data with a newer schema or vice versa
+
+      stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15')
+             .to_return_json(body: { schema: JSON.generate(writer_schema) })
+
+      # Encoded with writer schema: "my name" (0x0E + bytes) + age 25 (zigzag encoded as 50 = 0x32)
+      encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name\u0032"
+      decoded = schema_registry_client.decode(encoded)
+
+      # Decoded value should only have 'name' from reader schema, age is ignored
+      expect(decoded).to eq({ 'name' => 'my name' })
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should raise error for invalid magic byte' do
+      # Wrong magic byte (0x01 instead of 0x00)
+      encoded = "\u0001\u0000\u0000\u0000\u000F\u000Emy name"
+
+      expect do
+        schema_registry_client.decode(encoded)
+      end.to raise_error(/Expected data to begin with a magic byte/)
+    end
+
+    it 'should raise error for unknown schema id' do
+      # Schema ID 999 is not stubbed, so decoding should fail
+      encoded = "\u0000\u0000\u0000\u0003\u00E7\u000Emy name"
+
+      expect do
+        schema_registry_client.decode(encoded)
+      end.to raise_error(/Schema|not found/i)
+    end
+  end
+end

data/spec/encoding_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+RSpec.describe 'encoding' do
+  let(:schema_registry_client) do
+    SchemaRegistry.new(
+      registry_url: 'http://localhost:8081'
+    )
+  end
+
+  it 'should encode a simple message' do
+    schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
+           .with(body: { 'schemaType' => 'PROTOBUF',
+                         'references' => [],
+                         'schema' => schema }).to_return_json(body: { id: 15 })
+    msg = Simple::V1::SimpleMessage.new(name: 'my name')
+    encoded = schema_registry_client.encode(msg, subject: 'simple')
+    expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u0000#{msg.to_proto}")
+
+    # if we do it again we should not see any more requests
+    encoded2 = schema_registry_client.encode(msg, subject: 'simple')
+    expect(encoded2).to eq(encoded)
+
+    expect(stub).to have_been_requested.once
+  end
+
+  it 'should encode a complex message' do
+    schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+    dep_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+    dep_stub = stub_request(:post, 'http://localhost:8081/subjects/simple%2Fsimple.proto/versions')
+               .with(body: { 'schemaType' => 'PROTOBUF',
+                             'references' => [],
+                             'schema' => dep_schema }).to_return_json(body: { id: 15 })
+    version_stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15/versions')
+                   .to_return_json(body: [{ version: 1, subject: 'simple/simple.proto' }])
+    stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
+           .with(body: { 'schemaType' => 'PROTOBUF',
+                         'references' => [
+                           {
+                             name: 'simple/simple.proto',
+                             subject: 'simple/simple.proto',
+                             version: 1
+                           }
+                         ],
+                         'schema' => schema }).to_return_json(body: { id: 20 })
+    msg = Referenced::V1::MessageB::MessageBA.new(
+      simple: Simple::V1::SimpleMessage.new(name: 'my name')
+    )
+    encoded = schema_registry_client.encode(msg, subject: 'referenced')
+    expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg.to_proto}")
+
+    # if we do it again we should not see any more requests
+    encoded2 = schema_registry_client.encode(msg, subject: 'referenced')
+    expect(encoded2).to eq(encoded)
+    expect(stub).to have_been_requested.once
+    expect(dep_stub).to have_been_requested.once
+    expect(version_stub).to have_been_requested.once
+  end
+
+  describe 'with JSON' do
+    let(:schema_registry_client) do
+      SchemaRegistry.new(
+        registry_url: 'http://localhost:8081',
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+      )
+    end
+
+    it 'should encode a simple message' do
+      schema = File.read("#{__dir__}/schemas/simple/simple.json").strip
+      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
+             .with(body: { 'schemaType' => 'JSON',
+                           'references' => [],
+                           'schema' => schema }).to_return_json(body: { id: 15 })
+      msg = Simple::V1::SimpleMessage.new(name: 'my name')
+      encoded = schema_registry_client.encode(msg, subject: 'simple')
+      expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F{\"name\":\"my name\"}")
+
+      # if we do it again we should not see any more requests
+      encoded2 = schema_registry_client.encode(msg, subject: 'simple')
+      expect(encoded2).to eq(encoded)
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should encode a complex message' do
+      schema = File.read("#{__dir__}/schemas/referenced/referenced.json").strip
+      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
+             .with(body: { 'schemaType' => 'JSON',
+                           'references' => [],
+                           'schema' => schema }).to_return_json(body: { id: 20 })
+      msg = Referenced::V1::MessageB::MessageBA.new(
+        simple: Simple::V1::SimpleMessage.new(name: 'my name')
+      )
+      encoded = schema_registry_client.encode(msg, subject: 'referenced')
+      expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014{\"simple\":{\"name\":\"my name\"}}")
+
+      # if we do it again we should not see any more requests
+      encoded2 = schema_registry_client.encode(msg, subject: 'referenced')
+      expect(encoded2).to eq(encoded)
+      expect(stub).to have_been_requested.once
+    end
+  end
+
+  describe 'with Avro' do
+    let(:schema_registry_client) do
+      SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      SchemaRegistry.new(
+        registry_url: 'http://localhost:8081',
+        schema_type: SchemaRegistry::Schema::Avro
+      )
+    end
+
+    after do
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    it 'should encode a simple message' do
+      schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
+             .with(body: { 'schemaType' => 'AVRO',
+                           'references' => [],
+                           'schema' => schema }).to_return_json(body: { id: 15 })
+      msg = { 'name' => 'my name' }
+      encoded = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      # Avro encoding: magic byte (0x00) + schema id (4 bytes, big-endian) + Avro binary data
+      # "my name" encoded as Avro string: length (0x0E = 14) + "my name" bytes
+      expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u000Emy name")
+
+      # if we do it again we should not see any more requests
+      encoded2 = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      expect(encoded2).to eq(encoded)
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should encode a complex message with nested record' do
+      schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
+      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
+             .with(body: { 'schemaType' => 'AVRO',
+                           'references' => [],
+                           'schema' => schema }).to_return_json(body: { id: 20 })
+      msg = {
+        'simple' => {
+          'name' => 'my name'
+        }
+      }
+      encoded = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      # Avro encoding: magic byte + schema id + Avro binary for nested record
+      expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u000Emy name")
+
+      # if we do it again we should not see any more requests
+      encoded2 = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      expect(encoded2).to eq(encoded)
+      expect(stub).to have_been_requested.once
+    end
+
+    it 'should handle multiple fields' do
+      # Create a temporary schema file for testing
+      multi_schema_path = "#{__dir__}/schemas/test/v1"
+      FileUtils.mkdir_p(multi_schema_path)
+
+      multi_schema = {
+        'type' => 'record',
+        'name' => 'MultiFieldMessage',
+        'namespace' => 'test.v1',
+        'fields' => [
+          { 'name' => 'name', 'type' => 'string' },
+          { 'name' => 'age', 'type' => 'int' }
+        ]
+      }
+      schema_json = JSON.pretty_generate(multi_schema)
+      File.write("#{multi_schema_path}/MultiFieldMessage.avsc", schema_json)
+
+      stub = stub_request(:post, 'http://localhost:8081/subjects/multi/versions')
+             .with(body: { 'schemaType' => 'AVRO',
+                           'references' => [],
+                           'schema' => schema_json }).to_return_json(body: { id: 25 })
+
+      msg = { 'name' => 'Alice', 'age' => 30 }
+      encoded = schema_registry_client.encode(msg, subject: 'multi', schema_name: 'test.v1.MultiFieldMessage')
+
+      # Verify encoding starts with magic byte and schema id
+      expect(encoded[0]).to eq("\u0000")
+      expect(encoded[1..4].unpack1('N')).to eq(25)
+
+      expect(stub).to have_been_requested.once
+
+      # Clean up
+      FileUtils.rm_rf("#{__dir__}/schemas/test")
+    end
+
+    it 'should validate schema before encoding' do
+      schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+      stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
+        .with(body: { 'schemaType' => 'AVRO',
+                      'references' => [],
+                      'schema' => schema }).to_return_json(body: { id: 15 })
+
+      # Invalid message - missing required field
+      msg = { 'invalid_field' => 'value' }
+
+      expect do
+        schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      end.to raise_error(Avro::SchemaValidator::ValidationError)
+    end
+  end
+end

data/spec/gen/everything/everything_pb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: everything/everything.proto
+
+require 'google/protobuf'
+
+require 'simple/simple_pb'
+require 'google/protobuf/descriptor_pb'
+
+descriptor_data = "\n\x1b\x65verything/everything.proto\x12\reverything.v1\x1a\x13simple/simple.proto\x1a google/protobuf/descriptor.proto\"*\n\x0e\x46oreignMessage\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\"\xc0\x12\n\x0cTestAllTypes\x12\x16\n\x0eoptional_int32\x18\x01 \x01(\x05\x12\x16\n\x0eoptional_int64\x18\x02 \x01(\x03\x12\x17\n\x0foptional_uint32\x18\x03 \x01(\r\x12\x17\n\x0foptional_uint64\x18\x04 \x01(\x04\x12\x17\n\x0foptional_sint32\x18\x05 \x01(\x11\x12\x17\n\x0foptional_sint64\x18\x06 \x01(\x12\x12\x18\n\x10optional_fixed32\x18\x07 \x01(\x07\x12\x18\n\x10optional_fixed64\x18\x08 \x01(\x06\x12\x19\n\x11optional_sfixed32\x18\t \x01(\x0f\x12\x19\n\x11optional_sfixed64\x18\n \x01(\x10\x12\x16\n\x0eoptional_float\x18\x0b \x01(\x02\x12\x17\n\x0foptional_double\x18\x0c \x01(\x01\x12\x15\n\roptional_bool\x18\r \x01(\x08\x12\x17\n\x0foptional_string\x18\x0e \x01(\t\x12\x16\n\x0eoptional_bytes\x18\x0f \x01(\x0c\x12J\n\x17optional_nested_message\x18\x12 \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessage\x12?\n\x18optional_foreign_message\x18\x13 \x01(\x0b\x32\x1d.everything.v1.ForeignMessage\x12\x39\n\x17optional_import_message\x18\x14 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x12\x44\n\x14optional_nested_enum\x18\x15 \x01(\x0e\x32&.everything.v1.TestAllTypes.NestedEnum\x12\x39\n\x15optional_foreign_enum\x18\x16 \x01(\x0e\x32\x1a.everything.v1.ForeignEnum\x12\x33\n\x14optional_import_enum\x18\x17 \x01(\x0e\x32\x15.simple.v1.SimpleEnum\x12!\n\x15optional_string_piece\x18\x18 \x01(\tB\x02\x08\x02\x12\x19\n\roptional_cord\x18\x19 \x01(\tB\x02\x08\x01\x12\x1f\n\x13optional_bytes_cord\x18V \x01(\x0c\x42\x02\x08\x01\x12L\n\x15optional_lazy_message\x18\x1b \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01\x12W\n optional_unverified_lazy_message\x18\x1c \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02x\x01\x12\x16\n\x0erepeated_int32\x18\x1f \x03(\x05\x12\x16\n\x0erepeated_int64\x18  \x03(\x03\x12\x17\n\x0frepeated_uint32\x18! \x03(\r\x12\x17\n\x0frepeated_uint64\x18\" \x03(\x04\x12\x17\n\x0frepeated_sint32\x18# \x03(\x11\x12\x17\n\x0frepeated_sint64\x18$ \x03(\x12\x12\x18\n\x10repeated_fixed32\x18% \x03(\x07\x12\x18\n\x10repeated_fixed64\x18& \x03(\x06\x12\x19\n\x11repeated_sfixed32\x18' \x03(\x0f\x12\x19\n\x11repeated_sfixed64\x18( \x03(\x10\x12\x16\n\x0erepeated_float\x18) \x03(\x02\x12\x17\n\x0frepeated_double\x18* \x03(\x01\x12\x15\n\rrepeated_bool\x18+ \x03(\x08\x12\x17\n\x0frepeated_string\x18, \x03(\t\x12\x16\n\x0erepeated_bytes\x18- \x03(\x0c\x12J\n\x17repeated_nested_message\x18\x30 \x03(\x0b\x32).everything.v1.TestAllTypes.NestedMessage\x12?\n\x18repeated_foreign_message\x18\x31 \x03(\x0b\x32\x1d.everything.v1.ForeignMessage\x12\x39\n\x17repeated_import_message\x18\x32 \x03(\x0b\x32\x18.simple.v1.SimpleMessage\x12\x44\n\x14repeated_nested_enum\x18\x33 \x03(\x0e\x32&.everything.v1.TestAllTypes.NestedEnum\x12\x39\n\x15repeated_foreign_enum\x18\x34 \x03(\x0e\x32\x1a.everything.v1.ForeignEnum\x12\x33\n\x14repeated_import_enum\x18\x35 \x03(\x0e\x32\x15.simple.v1.SimpleEnum\x12!\n\x15repeated_string_piece\x18\x36 \x03(\tB\x02\x08\x02\x12\x19\n\rrepeated_cord\x18\x37 \x03(\tB\x02\x08\x01\x12L\n\x15repeated_lazy_message\x18\x39 \x03(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01\x12\x16\n\x0coneof_uint32\x18o \x01(\rH\x00\x12I\n\x14oneof_nested_message\x18p \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageH\x00\x12\x16\n\x0coneof_string\x18q \x01(\tH\x00\x12\x15\n\x0boneof_bytes\x18r \x01(\x0cH\x00\x12\x18\n\noneof_cord\x18s \x01(\tB\x02\x08\x01H\x00\x12 \n\x12oneof_string_piece\x18t \x01(\tB\x02\x08\x02H\x00\x12R\n\x19oneof_lazy_nested_message\x18u \x01(\x0b\x32).everything.v1.TestAllTypes.NestedMessageB\x02(\x01H\x00\x1a\"\n\rNestedMessage\x12\x11\n\x02\x62\x62\x18\x01 \x01(\x05\x42\x05\x90\x82\x19\xd2\t\x1a\x1a\n\rOptionalGroup\x12\t\n\x01\x61\x18\x11 \x01(\x05\x1a\x1a\n\rRepeatedGroup\x12\t\n\x01\x61\x18/ \x01(\x05\"'\n\nNestedEnum\x12\x07\n\x03\x46OO\x10\x00\x12\x07\n\x03\x42\x41R\x10\x02\x12\x07\n\x03\x42\x41Z\x10\x03\x42\r\n\x0boneof_field*/\n\x0b\x46oreignEnum\x12\x0f\n\x0b\x46OREIGN_FOO\x10\x00\x12\x0f\n\x0b\x46OREIGN_BAR\x10\x01\x32Y\n\x0bTestService\x12J\n\nTestMethod\x12\x1b.everything.v1.TestAllTypes\x1a\x1d.everything.v1.ForeignMessage\"\x00:4\n\x0bsome_option\x12\x1d.google.protobuf.FieldOptions\x18\xa2\x90\x03 \x01(\x05\x62\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Everything
+  module V1
+    ForeignMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.ForeignMessage').msgclass
+    TestAllTypes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.TestAllTypes').msgclass
+    TestAllTypes::NestedMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.TestAllTypes.NestedMessage').msgclass
+    TestAllTypes::OptionalGroup = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.TestAllTypes.OptionalGroup').msgclass
+    TestAllTypes::RepeatedGroup = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.TestAllTypes.RepeatedGroup').msgclass
+    TestAllTypes::NestedEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.TestAllTypes.NestedEnum').enummodule
+    ForeignEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('everything.v1.ForeignEnum').enummodule
+  end
+end

data/spec/gen/referenced/referer_pb.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: referenced/referer.proto
+
+require 'google/protobuf'
+
+require 'simple/simple_pb'
+
+descriptor_data = "\n\x18referenced/referer.proto\x12\rreferenced.v1\x1a\x13simple/simple.proto\"j\n\x08MessageA\x1a\x43\n\tMessageAA\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x06simple\x18\x02 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x1a\x19\n\tMessageAB\x12\x0c\n\x04name\x18\x01 \x01(\t\"j\n\x08MessageB\x1a\x43\n\tMessageBA\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x06simple\x18\x02 \x01(\x0b\x32\x18.simple.v1.SimpleMessage\x1a\x19\n\tMessageBB\x12\x0c\n\x04name\x18\x01 \x01(\tb\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Referenced
+  module V1
+    MessageA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageA').msgclass
+    MessageA::MessageAA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageA.MessageAA').msgclass
+    MessageA::MessageAB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageA.MessageAB').msgclass
+    MessageB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageB').msgclass
+    MessageB::MessageBA = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageB.MessageBA').msgclass
+    MessageB::MessageBB = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('referenced.v1.MessageB.MessageBB').msgclass
+  end
+end

data/spec/gen/simple/simple_pb.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: simple/simple.proto
+
+require 'google/protobuf'
+
+descriptor_data = "\n\x13simple/simple.proto\x12\tsimple.v1\"\x1d\n\rSimpleMessage\x12\x0c\n\x04name\x18\x01 \x01(\t*,\n\nSimpleEnum\x12\x0e\n\nSIMPLE_FOO\x10\x00\x12\x0e\n\nSIMPLE_BAR\x10\x01\x62\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Simple
+  module V1
+    SimpleMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('simple.v1.SimpleMessage').msgclass
+    SimpleEnum = ::Google::Protobuf::DescriptorPool.generated_pool.lookup('simple.v1.SimpleEnum').enummodule
+  end
+end

data/spec/json_schema_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'schema_registry_client/output/json_schema'
+
+RSpec.describe SchemaRegistry::Output::JsonSchema do
+  it 'should output as expected' do
+    output = described_class.output(Everything::V1::TestAllTypes.descriptor.to_proto)
+
+    expected = File.read("#{__dir__}/schemas/everything/everything.json")
+    expect("#{output}\n").to eq(expected)
+  end
+end