schema_registry_client 0.0.11.pre.beta1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aa1f66862cabf744233ac1fa0dcc199b7fbaaabb448d50f8e8b3aa0fb98f273
-  data.tar.gz: 642bfb50cd4efa20bdc93fb2740ed0ec6788866b378c7d601d5e7b05e8e6a9cf
+  metadata.gz: ade8a75ca2eb7bacb07566bd5eaa2899bfd69c2ed34dd7c1bc7e186b531b055e
+  data.tar.gz: 17174e9182ce1f875006bbe302f8ad7cc9809af3d415e2a9500ccfda114ec95d
 SHA512:
-  metadata.gz: 58254805ac900a92e2b7e6418b1e1565dd2d23b257ce6c771d26a1e1dd753193de6836e417c5382c083d322ded4f0a67947898057e8656cf053f1d3b713d31b2
-  data.tar.gz: db29da6cc31f095f9f83d6c26b8b2de06a52d889d2ef1a445ba6861529f34014841dda8068cc26c2945dc016a08f884aebdd7c701ad0650f2feaf9bcb854d67b
+  metadata.gz: 4ccea73cc7df695421518ad82de2507950d7d6e300146d5210c982addea11396ad4b4ee154f58ed38aa81891a13df20b5e60f50e84a74d74e7f6cd86c39aa1cb
+  data.tar.gz: 0daa9b8085d05991b1be936e8ce0aa209ab0973a05103a8dc8368e394988ec52ef7066110d912542b891342e2842b92b4e7e24d29b8d597a3a39d315d1b8d0bc

data/.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [3.1, 3.2, 3.3, 3.4]
+        ruby: [3.2, 3.3, 3.4]
 
     steps:
     - uses: actions/checkout@v3

data/.gitignore

@@ -1 +1,2 @@
 coverage
+.claude

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 0.1.0 - 2026-06-24
+
+* Avro: register the fully-resolved (inlined) schema so schemas that reference named types defined in other `.avsc` files are valid standalone.
+
+# 0.0.11 - 2026-02-20
+
+* Fixes for caching working correctly and ensuring we don't recalculate / re-parse Avro schemas
+
 # 0.0.10 - 2026-02-11
 
 * Fix: Do not send `schemaType` or `references` if schema type is `AVRO`, for backwards compatibility with older schema registries.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schema_registry_client (0.0.11.pre.beta1)
+    schema_registry_client (0.1.0)
       avro
       excon
       google-protobuf

data/lib/schema_registry_client/avro_schema_store.rb

@@ -7,16 +7,11 @@ module SchemaRegistry
     def initialize(path: nil)
       @path = path or raise "Please specify a schema path"
       @schemas = {}
-      @schema_text = {}
       @mutex = Mutex.new
     end
 
     attr_accessor :schemas
 
-    def find_text(name)
-      @schema_text[name]
-    end
-
     # Resolves and returns a schema.
     #
     # schema_name - The String name of the schema to resolve.
@@ -64,7 +59,6 @@ module SchemaRegistry
       # we will discard it.
       schema = Avro::Schema.real_parse(schema_hash, @schemas.dup)
       @schemas[full_name] = schema
-      @schema_text[full_name] = JSON.pretty_generate(schema_hash)
 
       schema
     end
@@ -96,7 +90,6 @@ module SchemaRegistry
       # Essentially, the only schemas that should be resolvable in @schemas
       # are those that have their own .avsc files on disk.
       @schemas[fullname] = schema
-      @schema_text[fullname] = schema_text
 
       schema
     rescue ::Avro::UnknownSchemaError => e

data/lib/schema_registry_client/cached_confluent_schema_registry.rb

@@ -8,6 +8,7 @@ module SchemaRegistry
       @schemas_by_id = {}
       @ids_by_schema = {}
       @versions_by_subject_and_id = {}
+      @mutex = Mutex.new
     end
 
     # Delegate the following methods to the upstream
@@ -20,25 +21,37 @@ module SchemaRegistry
     # @param id [Integer] the schema ID to fetch
     # @return [String] the schema string stored in the registry for the given id
     def fetch(id)
-      @schemas_by_id[id] ||= @upstream.fetch(id)
+      @mutex.synchronize do
+        @schemas_by_id[id] ||= @upstream.fetch(id)
+      end
     end
 
     # @param id [Integer] the schema ID to fetch
     # @param subject [String] the subject to fetch the version for
     # @return [Integer, nil] the version of the schema for the given subject and id, or nil if not found
     def fetch_version(id, subject)
-      key = [subject, id]
-      return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
+      @mutex.synchronize do
+        key = [subject, id]
+        return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
 
-      results = @upstream.schema_subject_versions(id)
-      @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
+        results = @upstream.schema_subject_versions(id)
+        @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
+      end
     end
 
     # @param subject [String] the subject to check
     # @param schema [String] the schema text to check
     # @return [Boolean] true if we know the schema has been registered for that subject.
     def registered?(subject, schema)
-      @ids_by_schema[[subject, schema]] && !@ids_by_schema[[subject, schema]].empty?
+      @mutex.synchronize do
+        @ids_by_schema.key?([subject, schema])
+      end
+    end
+
+    def fetch_id(subject, schema)
+      @mutex.synchronize do
+        @ids_by_schema[[subject, schema]]
+      end
     end
 
     # @param subject [String] the subject to register the schema under
@@ -46,12 +59,14 @@ module SchemaRegistry
     # @param references [Array<Hash>] optional references to other schemas
     # @param schema_type [String]
     def register(subject, schema, references: [], schema_type: "PROTOBUF")
-      key = [subject, schema]
+      @mutex.synchronize do
+        key = [subject, schema]
 
-      @ids_by_schema[key] ||= @upstream.register(subject,
-        schema,
-        references: references,
-        schema_type: schema_type)
+        @ids_by_schema[key] ||= @upstream.register(subject,
+          schema,
+          references: references,
+          schema_type: schema_type)
+      end
     end
   end
 end

data/lib/schema_registry_client/confluent_schema_registry.rb

@@ -24,9 +24,6 @@ module SchemaRegistry
       resolv_resolver: nil,
       retry_limit: nil
     )
-      if SchemaRegistry.debug
-        logger.info("Creating Confluent Schema Registry client with url: #{url}, schema_context: #{schema_context}, user: #{user}, path_prefix: #{path_prefix}")
-      end
       @path_prefix = path_prefix
       @schema_context_prefix = schema_context.nil? ? "" : ":.#{schema_context}:"
       @schema_context_options = schema_context.nil? ? {} : {query: {subject: @schema_context_prefix}}
@@ -76,7 +73,6 @@ module SchemaRegistry
     # @param references [Array<Hash>] optional references to other schemas
     # @return [Integer] the ID of the registered schema
     def register(subject, schema, references: [], schema_type: "PROTOBUF")
-      puts("schema_type #{schema_type}")
       body = {schema: schema.to_s}
       # Not all schema registry versions support schemaType
       if schema_type != "AVRO"

data/lib/schema_registry_client/schema/avro.rb

@@ -22,12 +22,18 @@ module SchemaRegistry
         @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
           path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
         )
-        @schema_store.load_schemas!
+        unless @schemas_loaded
+          @schema_store.load_schemas!
+          @schemas_loaded = true
+        end
         @schema_store
       end
 
+      # Register the fully-resolved (inlined) schema. The raw .avsc text is not a
+      # valid standalone schema when it references a type defined in another file.
       def schema_text(_message, schema_name: nil)
-        schema_store.find_text(schema_name)
+        @registration_text ||= {}
+        @registration_text[schema_name] ||= schema_store.find(schema_name).to_avro.to_json
       end
 
       def encode(message, stream, schema_name: nil)
@@ -44,10 +50,10 @@ module SchemaRegistry
       end
 
       def decode(stream, schema_text)
-        # Parse the schema text from the registry into an Avro schema object
-        JSON.parse(schema_text)
-        writers_schema = ::Avro::Schema.parse(schema_text)
-
+        # Cache parsed writer schemas to avoid re-parsing on every decode
+        @parsed_writers_schemas ||= {}
+        @parsed_writers_schemas[schema_text] ||= ::Avro::Schema.parse(schema_text)
+        writers_schema = @parsed_writers_schemas[schema_text]
         decoder = ::Avro::IO::BinaryDecoder.new(stream)
 
         # Try to find the reader schema locally, fall back to writer schema

data/lib/schema_registry_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaRegistry
-  VERSION = "0.0.11-beta1"
+  VERSION = "0.1.0"
 end

data/lib/schema_registry_client.rb

@@ -14,8 +14,6 @@ module SchemaRegistry
 
   class << self
     attr_accessor :avro_schema_path
-
-    attr_accessor :debug
   end
 
   class Client
@@ -136,7 +134,12 @@ module SchemaRegistry
 
     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)
+
+      # Fast path: if already registered, return the cached ID without
+      # resolving dependencies again.
+      if @registry.registered?(subject, schema_text)
+        return @registry.fetch_id(subject, schema_text)
+      end
 
       # register dependencies first
       dependencies = @schema.dependencies(message)

data/schema_registry_client.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   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.required_ruby_version = ">= 3.2"
 
   spec.metadata["rubygems_mfa_required"] = "true"
 

data/spec/decoding_spec.rb

@@ -60,18 +60,19 @@ RSpec.describe "decoding" do
   end
 
   describe "with Avro" do
-    let(:schema_registry_client) do
+    around(:each) do |ex|
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      ex.run
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     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")
@@ -180,4 +181,121 @@ RSpec.describe "decoding" do
       end.to raise_error(/Schema|not found/i)
     end
   end
+
+  describe "caching" do
+    it "should not fetch the same schema ID twice (Protobuf)" 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}"
+
+      3.times { schema_registry_client.decode(encoded) }
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it "should fetch different schema IDs independently" do
+      simple_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub_15 = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: simple_schema})
+
+      ref_schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+      stub_20 = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+        .to_return_json(body: {schema: ref_schema})
+
+      msg1 = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded1 = "\u0000\u0000\u0000\u0000\u000F\u0000#{msg1.to_proto}"
+
+      msg2 = Referenced::V1::MessageB::MessageBA.new(
+        simple: Simple::V1::SimpleMessage.new(name: "my name")
+      )
+      encoded2 = "\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg2.to_proto}"
+
+      # Decode both messages
+      schema_registry_client.decode(encoded1)
+      schema_registry_client.decode(encoded2)
+
+      # Each schema fetched exactly once
+      expect(stub_15).to have_been_requested.once
+      expect(stub_20).to have_been_requested.once
+
+      # Decode again - no new requests
+      schema_registry_client.decode(encoded1)
+      schema_registry_client.decode(encoded2)
+
+      expect(stub_15).to have_been_requested.once
+      expect(stub_20).to have_been_requested.once
+    end
+
+    it "should not share cache between different client instances" 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}"
+
+      schema_registry_client.decode(encoded)
+
+      # A second client should make its own request
+      client2 = SchemaRegistry::Client.new(registry_url: "http://localhost:8081")
+      client2.decode(encoded)
+
+      expect(stub).to have_been_requested.twice
+    end
+
+    describe "with Avro" do
+      around(:each) do |ex|
+        SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+        ex.run
+        SchemaRegistry.avro_schema_path = nil
+      end
+
+      let(:schema_registry_client) do
+        SchemaRegistry::Client.new(
+          registry_url: "http://localhost:8081",
+          schema_type: SchemaRegistry::Schema::Avro.new
+        )
+      end
+
+      it "should not fetch the same schema ID twice" 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})
+
+        encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
+
+        3.times { schema_registry_client.decode(encoded) }
+
+        expect(stub).to have_been_requested.once
+      end
+
+      it "should fetch different schema IDs independently" do
+        simple_schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+        stub_15 = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+          .to_return_json(body: {schema: simple_schema})
+
+        nested_schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
+        stub_20 = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+          .to_return_json(body: {schema: nested_schema})
+
+        encoded1 = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
+        encoded2 = "\u0000\u0000\u0000\u0000\u0014\u000Emy name"
+
+        # Decode both messages
+        schema_registry_client.decode(encoded1)
+        schema_registry_client.decode(encoded2)
+
+        expect(stub_15).to have_been_requested.once
+        expect(stub_20).to have_been_requested.once
+
+        # Decode again - no new requests
+        schema_registry_client.decode(encoded1)
+        schema_registry_client.decode(encoded2)
+
+        expect(stub_15).to have_been_requested.once
+        expect(stub_20).to have_been_requested.once
+      end
+    end
+  end
 end

data/spec/encoding_spec.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 RSpec.describe "encoding" do
+  def avro_registration_text(raw)
+    Avro::Schema.parse(raw).to_avro.to_json
+  end
+
   let(:schema_registry_client) do
     SchemaRegistry::Client.new(
       registry_url: "http://localhost:8081"
@@ -102,20 +106,21 @@ RSpec.describe "encoding" do
   end
 
   describe "with Avro" do
-    let(:schema_registry_client) do
+    around(:each) do |ex|
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      ex.run
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     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")
+      schema = avro_registration_text(File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc"))
       stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
         .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
       msg = {"name" => "my name"}
@@ -132,7 +137,7 @@ RSpec.describe "encoding" do
     end
 
     it "should encode a complex message with nested record" do
-      schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
+      schema = avro_registration_text(File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc"))
       stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
         .with(body: {"schema" => schema}).to_return_json(body: {id: 20})
       msg = {
@@ -168,7 +173,7 @@ RSpec.describe "encoding" do
       File.write("#{multi_schema_path}/MultiFieldMessage.avsc", schema_json)
 
       stub = stub_request(:post, "http://localhost:8081/subjects/multi/versions")
-        .with(body: {"schema" => schema_json}).to_return_json(body: {id: 25})
+        .with(body: {"schema" => avro_registration_text(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")
@@ -184,7 +189,7 @@ RSpec.describe "encoding" do
     end
 
     it "should validate schema before encoding" do
-      schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+      schema = avro_registration_text(File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc"))
       stub_request(:post, "http://localhost:8081/subjects/simple/versions")
         .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
 
@@ -195,5 +200,165 @@ RSpec.describe "encoding" do
         schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       end.to raise_error(Avro::SchemaValidator::ValidationError)
     end
+
+    it "registers a self-contained schema when the .avsc references another file" do
+      # cross_file.v1.Outer references cross_file.v1.Inner, which is defined in a
+      # *separate* .avsc file, so the raw Outer.avsc text is not a valid
+      # standalone Avro schema...
+      raw = File.read("#{__dir__}/schemas/cross_file/v1/Outer.avsc")
+      expect { Avro::Schema.parse(raw) }.to raise_error(Avro::UnknownSchemaError)
+
+      # ...and the fully-resolved (inlined) schema is registered instead.
+      resolved = SchemaRegistry::Schema::Avro.new.schema_text(nil, schema_name: "cross_file.v1.Outer")
+      expect { Avro::Schema.parse(resolved) }.not_to raise_error
+
+      stub = stub_request(:post, "http://localhost:8081/subjects/cross/versions")
+        .with(body: {"schema" => resolved}).to_return_json(body: {id: 30})
+
+      encoded = schema_registry_client.encode({"inner" => {"name" => "my name"}},
+        subject: "cross", schema_name: "cross_file.v1.Outer")
+
+      expect(encoded[1..4].unpack1("N")).to eq(30)
+      expect(stub).to have_been_requested.once
+    end
+  end
+
+  describe "caching" do
+    it "should not register the same schema twice (Protobuf)" 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")
+
+      3.times { schema_registry_client.encode(msg, subject: "simple") }
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it "should register schemas for different subjects separately" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub_a = stub_request(:post, "http://localhost:8081/subjects/subject-a/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      stub_b = stub_request(:post, "http://localhost:8081/subjects/subject-b/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 16})
+
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+
+      schema_registry_client.encode(msg, subject: "subject-a")
+      schema_registry_client.encode(msg, subject: "subject-b")
+
+      # Both subjects should get their own registration
+      expect(stub_a).to have_been_requested.once
+      expect(stub_b).to have_been_requested.once
+
+      # Encoding again for either subject should not re-register
+      schema_registry_client.encode(msg, subject: "subject-a")
+      schema_registry_client.encode(msg, subject: "subject-b")
+
+      expect(stub_a).to have_been_requested.once
+      expect(stub_b).to have_been_requested.once
+    end
+
+    it "should not re-register dependencies on subsequent encodes (Protobuf)" 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")
+      )
+
+      3.times { schema_registry_client.encode(msg, subject: "referenced") }
+
+      expect(stub).to have_been_requested.once
+      expect(dep_stub).to have_been_requested.once
+      expect(version_stub).to have_been_requested.once
+    end
+
+    it "should not share cache between different client instances" 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")
+
+      schema_registry_client.encode(msg, subject: "simple")
+
+      # A second client should make its own registration request
+      client2 = SchemaRegistry::Client.new(registry_url: "http://localhost:8081")
+      client2.encode(msg, subject: "simple")
+
+      expect(stub).to have_been_requested.twice
+    end
+
+    describe "with Avro" do
+      around(:each) do |ex|
+        SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+        ex.run
+        SchemaRegistry.avro_schema_path = nil
+      end
+
+      let(:schema_registry_client) do
+        SchemaRegistry::Client.new(
+          registry_url: "http://localhost:8081",
+          schema_type: SchemaRegistry::Schema::Avro.new
+        )
+      end
+
+      it "should not register the same schema twice" do
+        schema = avro_registration_text(File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc"))
+        stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
+        msg = {"name" => "my name"}
+
+        3.times { schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage") }
+
+        expect(stub).to have_been_requested.once
+      end
+
+      it "should register schemas for different subjects separately" do
+        schema = avro_registration_text(File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc"))
+        stub_a = stub_request(:post, "http://localhost:8081/subjects/subject-a/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
+        stub_b = stub_request(:post, "http://localhost:8081/subjects/subject-b/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 16})
+
+        msg = {"name" => "my name"}
+
+        schema_registry_client.encode(msg, subject: "subject-a", schema_name: "simple.v1.SimpleMessage")
+        schema_registry_client.encode(msg, subject: "subject-b", schema_name: "simple.v1.SimpleMessage")
+
+        expect(stub_a).to have_been_requested.once
+        expect(stub_b).to have_been_requested.once
+
+        # Encoding again should not re-register
+        schema_registry_client.encode(msg, subject: "subject-a", schema_name: "simple.v1.SimpleMessage")
+        schema_registry_client.encode(msg, subject: "subject-b", schema_name: "simple.v1.SimpleMessage")
+
+        expect(stub_a).to have_been_requested.once
+        expect(stub_b).to have_been_requested.once
+      end
+    end
   end
 end

data/spec/schemas/cross_file/v1/Inner.avsc

@@ -0,0 +1,11 @@
+{
+  "type": "record",
+  "name": "Inner",
+  "namespace": "cross_file.v1",
+  "fields": [
+    {
+      "name": "name",
+      "type": "string"
+    }
+  ]
+}

data/spec/schemas/cross_file/v1/Outer.avsc

@@ -0,0 +1,11 @@
+{
+  "type": "record",
+  "name": "Outer",
+  "namespace": "cross_file.v1",
+  "fields": [
+    {
+      "name": "inner",
+      "type": "cross_file.v1.Inner"
+    }
+  ]
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_registry_client
 version: !ruby/object:Gem::Version
-  version: 0.0.11.pre.beta1
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Orner
@@ -173,6 +173,8 @@ files:
 - spec/gen/simple/simple_pb.rb
 - spec/json_schema_spec.rb
 - spec/proto_text_spec.rb
+- spec/schemas/cross_file/v1/Inner.avsc
+- spec/schemas/cross_file/v1/Outer.avsc
 - spec/schemas/everything/everything.json
 - spec/schemas/everything/everything.proto
 - spec/schemas/referenced/referenced.json
@@ -194,7 +196,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="