avro_turf 1.16.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2345cdad9c7472c5fd79aa3710150c40095ff2b970b28ea17b3db8b951fd143f
-  data.tar.gz: 264fbec47c582106134b51fc80823f93a82c9f1053a2d61e8899eac72a27256f
+  metadata.gz: 1c6f4cafa2c752c6b0dbe23703a4d2efccf558e11cec1c33db5a1af911cca43a
+  data.tar.gz: 61c9bc9c1963bb89f8b00c01ad0c4195d8cf48473ea191b3d91afa88361c7aa5
 SHA512:
-  metadata.gz: 2f17112a66c063514d56c7a4a5d785fa61e1c2079b7a02eede619b1b030997ba689b897ac8fc55f355fc781a1fd48dd77c545315478155b70853a0263fd571ac
-  data.tar.gz: 9d34639b83ee204e15143cc073aacd24157556eaede70e855384ba43ec769c6ed12505ffa2cf6d17ae6e216095c0ad097ace8af42579efaec4fc34ad92c482fe
+  metadata.gz: 1b7792365879b2d4dab3f7a160687ba7308c8f5cb6f9d788506ad087bfb56056f867328bc5357ab011917588bb7e67219300c00e3cadcdef389b927f8cf398de
+  data.tar.gz: 834dcc062ca3e2a6f6b4eafecd8425abacad9ca64d972bbe03100def4e7af2adb706d2fcde541d31d6ff199e9b3ce51f47774269adc55191a7b6d9dc2ed5e224

data/.github/workflows/push_gem.yml

@@ -0,0 +1,24 @@
+on:
+  push:
+    branches:
+    - master
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
+
+    steps:
+      # Set up
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      # Release
+      - uses: rubygems/release-gem@v1

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## v1.18.0
+
+- Add `compatibility_issues` method to `ConfluentSchemaRegistry` to debug compatibility issues between a schema versions for a given subject (#212)
+- Update tests to support `sinatra` version 4.1 that includes a new `host_authorization` parameter to permit only authorized requests
+
+## v1.17.0
+
+- Add `register_schemas` option to `encode` method [#210](https://github.com/dasch/avro_turf/pull/210)
+
 ## v1.16.0
 
 - Add compatibility with Avro v1.12.x.

data/README.md

@@ -92,6 +92,9 @@ avro.encode({ "name" => "Jane", "age" => 28 }, schema_name: "person")
 # Data can be validated before encoding to get a description of problem through
 # Avro::SchemaValidator::ValidationError exception
 avro.encode({ "titl" => "hello, world" }, schema_name: "person", validate: true)
+
+# If you do not want to register the schema in case it does not exist, you can pass the register_schemas option as false
+avro.encode({ "name" => "Jane", "age" => 28 }, schema_name: "person", register_schemas: false)
 ```
 
 ### Inter-schema references
@@ -251,6 +254,9 @@ registry = AvroTurf::ConfluentSchemaRegistry.new("http://my-registry:8081/")
 
 # Returns true if the schema is compatible, nil if the subject or version is not registered, and false if incompatible.
 registry.compatible?("person", schema)
+
+# Returns an array of any breaking changes, nil if the subject or version is not registered
+registry.compatibility_issues("person", schema)
 ```
 
 The ConfluentSchemaRegistry client can also change the global compatibility level or the compatibility level for an individual subject using the [Config API](http://docs.confluent.io/3.1.2/schema-registry/docs/api.html#config):
@@ -267,17 +273,23 @@ fake schema registry server depends on Sinatra but it is _not_ listed as a runti
 dependency for AvroTurf. Sinatra must be added to your Gemfile or gemspec in order
 to use the fake server.
 
+Given the recent update in `sinatra` to fix [CVE-2024-21510](https://github.com/advisories/GHSA-hxx2-7vcw-mqr3) that included a new `HostAuthorization` middleware, the `FakeConfluentSchemaRegistryServer` is provided as a base implementation that has to be inherited into a new class and configured by the user so requests are properly authorised to the test registry host.
+
 Example using RSpec:
 
 ```ruby
 require 'avro_turf/test/fake_confluent_schema_registry_server'
 require 'webmock/rspec'
 
+class AuthorizedFakeConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
+  set :host_authentication, permitted_hosts: ['registry.example.com']
+end
+
 # within an example
 let(:registry_url) { "http://registry.example.com" }
 before do
-  stub_request(:any, /^#{registry_url}/).to_rack(FakeConfluentSchemaRegistryServer)
-  FakeConfluentSchemaRegistryServer.clear
+  stub_request(:any, /^#{registry_url}/).to_rack(AuthorizedFakeConfluentSchemaRegistryServer)
+  AuthorizedFakeConfluentSchemaRegistryServer.clear
 end
 
 # Messaging objects created with the same registry_url will now use the fake server.

data/lib/avro_turf/cached_confluent_schema_registry.rb

@@ -17,13 +17,17 @@ class AvroTurf::CachedConfluentSchemaRegistry
   end
 
   # Delegate the following methods to the upstream
-  %i(subjects subject_versions schema_subject_versions check compatible?
+  %i(subjects subject_versions schema_subject_versions compatible?
      global_config update_global_config subject_config update_subject_config).each do |name|
     define_method(name) do |*args|
       instance_variable_get(:@upstream).send(name, *args)
     end
   end
 
+  def check(subject, schema)
+    @cache.lookup_data_by_schema(subject, schema) || @cache.store_data_by_schema(subject, schema, @upstream.check(subject, schema))
+  end
+
   def fetch(id)
     @cache.lookup_by_id(id) || @cache.store_by_id(id, @upstream.fetch(id))
   end

data/lib/avro_turf/confluent_schema_registry.rb

@@ -101,6 +101,18 @@ class AvroTurf::ConfluentSchemaRegistry
     data.fetch('is_compatible', false) unless data.has_key?('error_code')
   end
 
+  # Check for specific schema compatibility issues
+  # Returns:
+  # - nil if the subject or version does not exist
+  # - a list of compatibility issues
+  # https://docs.confluent.io/platform/current/schema-registry/develop/api.html#sr-api-compatibility
+  def compatibility_issues(subject, schema, version = 'latest')
+    data = post("/compatibility/subjects/#{@schema_context_prefix}#{subject}/versions/#{version}",
+      expects: [200, 404], body: { schema: schema.to_s }.to_json, query: { verbose: true }, idempotent: true)
+
+    data.fetch('messages', []) unless data.has_key?('error_code')
+  end
+
   # Get global config
   def global_config
     get("/config", idempotent: true)

data/lib/avro_turf/disk_cache.rb

@@ -16,6 +16,10 @@ class AvroTurf::DiskCache
 
     @schemas_by_subject_version_path = File.join(disk_path, 'schemas_by_subject_version.json')
     @schemas_by_subject_version = {}
+
+    @data_by_schema_path = File.join(disk_path, 'data_by_schema.json')
+    hash = read_from_disk_cache(@data_by_schema_path)
+    @data_by_schema = hash || {}
   end
 
   # override
@@ -40,6 +44,12 @@ class AvroTurf::DiskCache
     @ids_by_schema[key]
   end
 
+  # override to use a json serializable cache key
+  def lookup_data_by_schema(subject, schema)
+    key = "#{subject}#{schema}"
+    @data_by_schema[key]
+  end
+
   # override to use a json serializable cache key and update the file cache
   def store_by_schema(subject, schema, id)
     key = "#{subject}#{schema}"
@@ -49,6 +59,15 @@ class AvroTurf::DiskCache
     id
   end
 
+  def store_data_by_schema(subject, schema, data)
+    return unless data
+
+    key = "#{subject}#{schema}"
+    @data_by_schema[key] = data
+    write_to_disk_cache(@data_by_schema_path, @data_by_schema)
+    data
+  end
+
   # checks instance var (in-memory cache) for schema
   # checks disk cache if in-memory cache doesn't exists
   # if file exists but no in-memory cache, read from file and sync in-memory cache

data/lib/avro_turf/in_memory_cache.rb

@@ -1,11 +1,11 @@
 # A cache for the CachedConfluentSchemaRegistry.
 # Simply stores the schemas and ids in in-memory hashes.
 class AvroTurf::InMemoryCache
-
   def initialize
     @schemas_by_id = {}
     @ids_by_schema = {}
     @schema_by_subject_version = {}
+    @data_by_schema = {}
   end
 
   def lookup_by_id(id)
@@ -21,11 +21,23 @@ class AvroTurf::InMemoryCache
     @ids_by_schema[key]
   end
 
+  def lookup_data_by_schema(subject, schema)
+    key = [subject, schema]
+    @data_by_schema[key]
+  end
+
   def store_by_schema(subject, schema, id)
     key = [subject, schema]
     @ids_by_schema[key] = id
   end
 
+  def store_data_by_schema(subject, schema, data)
+    return unless data
+
+    key = [subject, schema]
+    @data_by_schema[key] = data
+  end
+
   def lookup_by_version(subject, version)
     key = "#{subject}#{version}"
     @schema_by_subject_version[key]

data/lib/avro_turf/messaging.rb

@@ -106,27 +106,33 @@ class AvroTurf
 
     # Encodes a message using the specified schema.
     #
-    # message     - The message that should be encoded. Must be compatible with
-    #               the schema.
-    # schema_name - The String name of the schema that should be used to encode
-    #               the data.
-    # namespace   - The namespace of the schema (optional).
-    # subject     - The subject name the schema should be registered under in
-    #               the schema registry (optional).
-    # version     - The integer version of the schema that should be used to decode
-    #               the data. Must match the schema used when encoding (optional).
-    # schema_id   - The integer id of the schema that should be used to encode
-    #               the data.
-    # validate    - The boolean for performing complete message validation before
-    #               encoding it, Avro::SchemaValidator::ValidationError with
-    #               a descriptive message will be raised in case of invalid message.
+    # message           - The message that should be encoded. Must be compatible with
+    #                     the schema.
+    # schema_name       - The String name of the schema that should be used to encode
+    #                     the data.
+    # namespace         - The namespace of the schema (optional).
+    # subject           - The subject name the schema should be registered under in
+    #                     the schema registry (optional).
+    # version           - The integer version of the schema that should be used to decode
+    #                     the data. Must match the schema used when encoding (optional).
+    # schema_id         - The integer id of the schema that should be used to encode
+    #                     the data.
+    # validate          - The boolean for performing complete message validation before
+    #                     encoding it, Avro::SchemaValidator::ValidationError with
+    #                     a descriptive message will be raised in case of invalid message.
+    # register_schemas  - The boolean that indicates whether or not the schema should be
+    #                     registered in case it does not exist, or if it should be fetched
+    #                     from the registry without registering it (register_schemas: false).
     #
     # Returns the encoded data as a String.
-    def encode(message, schema_name: nil, namespace: @namespace, subject: nil, version: nil, schema_id: nil, validate: false)
+    def encode(message, schema_name: nil, namespace: @namespace, subject: nil, version: nil, schema_id: nil, validate: false,
+               register_schemas: true)
       schema, schema_id = if schema_id
         fetch_schema_by_id(schema_id)
       elsif subject && version
         fetch_schema(subject: subject, version: version)
+      elsif schema_name && !register_schemas
+        fetch_schema_by_body(subject: subject, schema_name: schema_name, namespace: namespace)
       elsif schema_name
         register_schema(subject: subject, schema_name: schema_name, namespace: namespace)
       else
@@ -228,6 +234,14 @@ class AvroTurf
       [schema, schema_id]
     end
 
+    def fetch_schema_by_body(schema_name:, subject: nil, namespace: nil)
+      schema = @schema_store.find(schema_name, namespace)
+      schema_data = @registry.check(subject || schema.fullname, schema)
+      raise SchemaNotFoundError.new("Schema with structure: #{schema} not found on registry") unless schema_data
+
+      [schema, schema_data["id"]]
+    end
+
     # Schemas are registered under the full name of the top level Avro record
     # type, or `subject` if it's provided.
     def register_schema(schema_name:, subject: nil, namespace: nil)

data/lib/avro_turf/schema_store.rb

@@ -92,6 +92,6 @@ class AvroTurf::SchemaStore
 
   def build_schema_path(fullname)
     *namespace, schema_name = fullname.split(".")
-    schema_path = File.join(@path, *namespace, schema_name + ".avsc")
+    File.join(@path, *namespace, "#{schema_name}.avsc")
   end
 end

data/lib/avro_turf/test/fake_prefixed_confluent_schema_registry_server.rb

@@ -64,7 +64,8 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
 
     # Note: this does not actually handle the same schema registered under
     # multiple subjects
-    schema_id = SCHEMAS.index(schema)
+    context, _subject = parse_qualified_subject(params[:subject])
+    schema_id = SCHEMAS[context].index(schema)
 
     halt(404, SCHEMA_NOT_FOUND) unless schema_id
 

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "1.16.0"
+  VERSION = "1.18.0"
 end

data/spec/cached_confluent_schema_registry_spec.rb

@@ -6,6 +6,7 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
   let(:upstream) { instance_double(AvroTurf::ConfluentSchemaRegistry) }
   let(:registry) { described_class.new(upstream) }
   let(:id) { rand(999) }
+  let(:subject_name) { 'a_subject' }
   let(:schema) do
     {
       type: "record",
@@ -25,8 +26,6 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
   end
 
   describe "#register" do
-    let(:subject_name) { "a_subject" }
-
     it "caches the result of register" do
       # multiple calls return same result, with only one upstream call
       allow(upstream).to receive(:register).with(subject_name, schema).and_return(id)
@@ -36,8 +35,29 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
     end
   end
 
+  describe "#check" do
+    let(:schema_data) do
+      {
+        "subject" => subject_name,
+        "version" => 123,
+        "id" => id,
+        "schema" => schema
+      }
+    end
+
+    before do
+      allow(upstream).to receive(:check).with(subject_name, schema).and_return(schema_data)
+    end
+
+    it "caches the result of check" do
+      # multiple calls return same result, with only one upstream call
+      expect(registry.check(subject_name, schema)).to eq(schema_data)
+      expect(registry.check(subject_name, schema)).to eq(schema_data)
+      expect(upstream).to have_received(:check).exactly(1).times
+    end
+  end
+
   describe '#subject_version' do
-    let(:subject_name) { 'a_subject' }
     let(:version) { 1 }
     let(:schema_with_meta) do
       {

data/spec/disk_cached_confluent_schema_registry_spec.rb

@@ -222,6 +222,66 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
     end
   end
 
+  describe "#check" do
+    let(:city_name) { "a_city" }
+    let(:schema_data) do
+      {
+        "subject" => subject,
+        "version" => version,
+        "id" => id,
+        "schema" => schema
+      }
+    end
+
+    let(:city_schema_data) do
+      {
+        "subject" => city_name,
+        "version" => version,
+        "id" => city_id,
+        "schema" => city_schema
+      }
+    end
+
+    let(:cache_before) do
+      {
+        "#{subject}#{schema}" => schema_data
+      }
+    end
+
+    let(:cache_after) do
+      {
+        "#{subject}#{schema}" => schema_data,
+        "#{city_name}#{city_schema}" => city_schema_data
+      }
+    end
+
+    # setup the disk cache to avoid performing the upstream fetch
+    before do
+      store_cache("data_by_schema.json", cache_before)
+      allow(upstream).to receive(:check).with(subject, schema).and_return(schema_data)
+      allow(upstream).to receive(:check).with(city_name, city_schema).and_return(city_schema_data)
+    end
+
+    context "when the schema is not found in the cache" do
+      it "makes only one request using upstream" do
+        expect(registry.check(city_name, city_schema)).to eq(city_schema_data)
+        expect(registry.check(city_name, city_schema)).to eq(city_schema_data)
+        expect(upstream).to have_received(:check).with(city_name, city_schema).exactly(1).times
+        expect(load_cache("data_by_schema.json")).to eq cache_after
+      end
+    end
+
+    context "when schema is already in the cache" do
+      it "uses preloaded disk cache" do
+        # multiple calls return same result, with zero upstream calls
+        expect(registry.check(subject, schema)).to eq(schema_data)
+        expect(registry.check(subject, schema)).to eq(schema_data)
+        expect(upstream).to have_received(:check).exactly(0).times
+        expect(load_cache("data_by_schema.json")).to eq cache_before
+      end
+    end
+  end
+
   it_behaves_like "a confluent schema registry client" do
     let(:upstream) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
     let(:registry) { described_class.new(upstream) }

data/spec/messaging_spec.rb

@@ -1,7 +1,5 @@
 require 'webmock/rspec'
 require 'avro_turf/messaging'
-require 'avro_turf/test/fake_confluent_schema_registry_server'
-require 'avro_turf/test/fake_prefixed_confluent_schema_registry_server'
 
 describe AvroTurf::Messaging do
   let(:registry_url) { "http://registry.example.com" }
@@ -36,6 +34,24 @@ describe AvroTurf::Messaging do
       }
     AVSC
   end
+
+  let(:city_message) { { "name" => "Paris" } }
+  let(:city_schema_json) do
+    <<-AVSC
+      {
+        "name": "city",
+        "type": "record",
+        "fields": [
+          {
+            "type": "string",
+            "name": "name"
+          }
+        ]
+      }
+    AVSC
+  end
+
+  let(:city_schema) { Avro::Schema.parse(city_schema_json) }
   let(:schema) { Avro::Schema.parse(schema_json) }
 
   before do
@@ -43,12 +59,13 @@ describe AvroTurf::Messaging do
   end
 
   before do
-    stub_request(:any, /^#{registry_url}/).to_rack(FakeConfluentSchemaRegistryServer)
-    FakeConfluentSchemaRegistryServer.clear
+    stub_request(:any, /^#{registry_url}/).to_rack(AuthorizedFakeConfluentSchemaRegistryServer)
+    AuthorizedFakeConfluentSchemaRegistryServer.clear
   end
 
   before do
     define_schema "person.avsc", schema_json
+    define_schema "city.avsc", city_schema_json
   end
 
   shared_examples_for "encoding and decoding with the schema from schema store" do
@@ -92,6 +109,16 @@ describe AvroTurf::Messaging do
       expect { avro.encode(message, subject: 'missing', version: 1) }.to raise_error(AvroTurf::SchemaNotFoundError)
     end
 
+    it 'raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry and register_schemas false' do
+      expect { avro.encode(city_message, schema_name: 'city', register_schemas: false) }.
+        to raise_error(AvroTurf::SchemaNotFoundError, "Schema with structure: #{city_schema} not found on registry")
+    end
+
+    it 'encodes with register_schemas false when the schema exists on the registry' do
+      data = avro.encode(message, schema_name: 'person', register_schemas: false)
+      expect(avro.decode(data, schema_name: 'person')).to eq message
+    end
+
     it 'caches parsed schemas for decoding' do
       data = avro.encode(message, subject: 'person', version: 1)
       avro.decode(data)
@@ -364,6 +391,34 @@ describe AvroTurf::Messaging do
       end
     end
 
+    context 'using fetch_schema_by_body' do
+      let(:subject_name) { 'city' }
+      let(:schema_name) { 'city' }
+      let(:namespace) { 'namespace' }
+      let(:city_schema_id) { 125 }
+      let(:city_schema_data) do
+        {
+          "subject" => subject_name,
+          "version" => 123,
+          "id" => city_schema_id,
+          "schema" => city_schema
+        }
+      end
+
+      subject(:fetch_schema_by_body) do
+        avro.fetch_schema_by_body(schema_name: schema_name, namespace: namespace, subject: subject_name)
+      end
+
+      before do
+        allow(schema_store).to receive(:find).with(schema_name, namespace).and_return(city_schema)
+        allow(registry).to receive(:check).with(subject_name, city_schema).and_return(city_schema_data)
+      end
+
+      it 'gets schema from registry' do
+        expect(fetch_schema_by_body).to eq([city_schema, city_schema_id])
+      end
+    end
+
     context 'using register_schema' do
       let(:schema_name) { 'schema_name' }
 
@@ -417,8 +472,8 @@ describe AvroTurf::Messaging do
     }
 
     before do
-      stub_request(:any, /^#{registry_url}/).to_rack(FakePrefixedConfluentSchemaRegistryServer)
-      FakePrefixedConfluentSchemaRegistryServer.clear
+      stub_request(:any, /^#{registry_url}/).to_rack(AuthorizedFakePrefixedConfluentSchemaRegistryServer)
+      AuthorizedFakePrefixedConfluentSchemaRegistryServer.clear
     end
 
     it_behaves_like "encoding and decoding with the schema from schema store"

data/spec/support/authorized_fake_confluent_schema_registry_server.rb

@@ -0,0 +1,5 @@
+require 'avro_turf/test/fake_confluent_schema_registry_server'
+
+class AuthorizedFakeConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
+  set :host_authorization, permitted_hosts: ['example.org', 'registry.example.com']
+end

data/spec/support/authorized_fake_prefixed_confluent_schema_registry_server.rb

@@ -0,0 +1,5 @@
+require 'avro_turf/test/fake_prefixed_confluent_schema_registry_server'
+
+class AuthorizedFakePrefixedConfluentSchemaRegistryServer < FakePrefixedConfluentSchemaRegistryServer
+  set :host_authorization, permitted_hosts: ['example.org', 'registry.example.com']
+end

data/spec/support/confluent_schema_registry_context.rb

@@ -26,9 +26,9 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
   before do
     stub_request(:any, /^#{registry_url}/)
       .with(headers: headers)
-      .to_rack(FakeConfluentSchemaRegistryServer)
+      .to_rack(AuthorizedFakeConfluentSchemaRegistryServer)
 
-    FakeConfluentSchemaRegistryServer.clear
+    AuthorizedFakeConfluentSchemaRegistryServer.clear
   end
 
   describe "#register and #fetch" do

data/spec/test/fake_confluent_schema_registry_server_spec.rb

@@ -1,10 +1,9 @@
 require 'rack/test'
-require 'avro_turf/test/fake_confluent_schema_registry_server'
 
 describe FakeConfluentSchemaRegistryServer do
   include Rack::Test::Methods
 
-  def app; described_class; end
+  def app; AuthorizedFakeConfluentSchemaRegistryServer; end
 
   describe 'POST /subjects/:subject/versions' do
     it 'returns the same schema ID when invoked with same schema and same subject' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.18.0
 platform: ruby
 authors:
 - Daniel Schierbeck
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-12 00:00:00.000000000 Z
+date: 2024-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -170,13 +170,14 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
+description: 
 email:
 - dasch@zendesk.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/push_gem.yml"
 - ".github/workflows/ruby.yml"
 - ".github/workflows/stale.yml"
 - ".gitignore"
@@ -235,6 +236,8 @@ files:
 - spec/schema_store_spec.rb
 - spec/schema_to_avro_patch_spec.rb
 - spec/spec_helper.rb
+- spec/support/authorized_fake_confluent_schema_registry_server.rb
+- spec/support/authorized_fake_prefixed_confluent_schema_registry_server.rb
 - spec/support/confluent_schema_registry_context.rb
 - spec/test/fake_confluent_schema_registry_server_spec.rb
 homepage: https://github.com/dasch/avro_turf
@@ -265,8 +268,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.5.22
+signing_key: 
 specification_version: 4
 summary: A library that makes it easier to use the Avro serialization format from
   Ruby
@@ -289,5 +292,7 @@ test_files:
 - spec/schema_store_spec.rb
 - spec/schema_to_avro_patch_spec.rb
 - spec/spec_helper.rb
+- spec/support/authorized_fake_confluent_schema_registry_server.rb
+- spec/support/authorized_fake_prefixed_confluent_schema_registry_server.rb
 - spec/support/confluent_schema_registry_context.rb
 - spec/test/fake_confluent_schema_registry_server_spec.rb