avro_turf 1.5.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e110697cb451e5315414f8086d32aa6e6c43444a462fcdaa678d1311302fcab8
-  data.tar.gz: a54afac8d7e8cb4a599695825ccb3d666d08ad800ccfe63229f14b6b42b26f11
+  metadata.gz: 67ff8ee9b578227cd54a33d76a95fed8bd2c9a396aa360ad9df9f52d01e5c25a
+  data.tar.gz: 8bca24236ce42f19f6db457ad13d76d33e89b18703dc0eb74a8adca53b2c7b6e
 SHA512:
-  metadata.gz: 78ee7cc3c12975d15bc621d9b3a96ed014cc8265536650f365ed80a861a06d53f3e9db9f7d698f71c02485df6f9b371944102404e76cc05e13816e12d312d97c
-  data.tar.gz: ac02799c0f25b88f8c9bfbbd0de48a2b3c39a7744ee1b90c6c87439b5a547db9456a2b3f89a9730303c76ea302159fdce9189f417e6424ecbac45da14682dd0d
+  metadata.gz: 859e8fa6938679007704d35b1b4a54616da7637c83f41c58cbd10828216e0af198846e755334f465613ceb9086ec0c63a823dc2cbf3ddbdc191a97423d2e3147
+  data.tar.gz: 7900a85abaf9dd55ac3b89bba2d04935ddbafc850a92fb1941ff8984df864cfaa4bb5527ca4d48a74ef3715915d598044b7c486363909f2705ece83b0ffca50f

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## v1.8.0
+
+- add support for `Date` via appropriate logicalType defintion.  This is a backwards incompatible change  (#177)
+- Fixed schema file cache truncation on multiple running instances and parallel access to the cache files.
+
+## v1.7.0
+
+- Added extra params for the validation message schema before encode (#169)
+- Fix infinite retry when loading schema with nested primary type in separate file (#165)
+
+## v1.6.0
+
+- Schema registry path prefix (#162)
+
 ## v1.5.0
 
 - Add CA cert file option (#157)
@@ -51,7 +65,7 @@
 ## v0.9.0
 
 - Compatibility with Avro v1.9.0 (#94)
-- Disable the auto registeration of schema (#95)
+- Disable the auto registration of schema (#95)
 - abstracted caching from CachedConfluentSchemaRegistry (#74)
 - Load avro-patches if installed to silence deprecation errors (#85)
 - Make schema store to be thread safe (#92)

data/lib/avro_turf/cached_confluent_schema_registry.rb

@@ -13,7 +13,7 @@ class AvroTurf::CachedConfluentSchemaRegistry
   # cache     - Optional user provided Cache object that responds to all methods in the AvroTurf::InMemoryCache interface.
   def initialize(upstream, cache: nil)
     @upstream = upstream
-    @cache = cache || AvroTurf::InMemoryCache.new()
+    @cache = cache || AvroTurf::InMemoryCache.new
   end
 
   # Delegate the following methods to the upstream
@@ -34,7 +34,7 @@ class AvroTurf::CachedConfluentSchemaRegistry
 
   def subject_version(subject, version = 'latest')
     return @upstream.subject_version(subject, version) if version == 'latest'
-    
+
     @cache.lookup_by_version(subject, version) ||
       @cache.store_by_version(subject, version, @upstream.subject_version(subject, version))
   end

data/lib/avro_turf/confluent_schema_registry.rb

@@ -14,8 +14,10 @@ class AvroTurf::ConfluentSchemaRegistry
     client_key: nil,
     client_key_pass: nil,
     client_cert_data: nil,
-    client_key_data: nil
+    client_key_data: nil,
+    path_prefix: nil
   )
+    @path_prefix = path_prefix
     @logger = logger
     headers = {
       "Content-Type" => CONTENT_TYPE
@@ -122,6 +124,7 @@ class AvroTurf::ConfluentSchemaRegistry
 
   def request(path, **options)
     options = { expects: 200 }.merge!(options)
+    path = File.join(@path_prefix, path) unless @path_prefix.nil?
     response = @connection.request(path: path, **options)
     JSON.parse(response.body)
   end

data/lib/avro_turf/core_ext/date.rb

@@ -1,5 +1,5 @@
 class Date
   def as_avro
-    iso8601
+    self
   end
 end

data/lib/avro_turf/disk_cache.rb

@@ -1,20 +1,18 @@
 # A cache for the CachedConfluentSchemaRegistry.
 # Extends the InMemoryCache to provide a write-thru to disk for persistent cache.
-class AvroTurf::DiskCache < AvroTurf::InMemoryCache
+class AvroTurf::DiskCache
 
   def initialize(disk_path, logger: Logger.new($stdout))
-    super()
-
     @logger = logger
 
     # load the write-thru cache on startup, if it exists
     @schemas_by_id_path = File.join(disk_path, 'schemas_by_id.json')
     hash = read_from_disk_cache(@schemas_by_id_path)
-    @schemas_by_id = hash if hash
+    @schemas_by_id = hash || {}
 
     @ids_by_schema_path = File.join(disk_path, 'ids_by_schema.json')
     hash = read_from_disk_cache(@ids_by_schema_path)
-    @ids_by_schema = hash if hash
+    @ids_by_schema = hash || {}
 
     @schemas_by_subject_version_path = File.join(disk_path, 'schemas_by_subject_version.json')
     @schemas_by_subject_version = {}
@@ -24,15 +22,16 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
   # the write-thru cache (json) does not store keys in numeric format
   # so, convert id to a string for caching purposes
   def lookup_by_id(id)
-    super(id.to_s)
+    @schemas_by_id[id.to_s]
   end
 
   # override to include write-thru cache after storing result from upstream
   def store_by_id(id, schema)
     # must return the value from storing the result (i.e. do not return result from file write)
-    value = super(id.to_s, schema)
-    File.write(@schemas_by_id_path, JSON.pretty_generate(@schemas_by_id))
-    return value
+    @schemas_by_id[id.to_s] = schema
+    write_to_disk_cache(@schemas_by_id_path, @schemas_by_id)
+
+    schema
   end
 
   # override to use a json serializable cache key
@@ -45,7 +44,8 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
   def store_by_schema(subject, schema, id)
     key = "#{subject}#{schema}"
     @ids_by_schema[key] = id
-    File.write(@ids_by_schema_path, JSON.pretty_generate(@ids_by_schema))
+
+    write_to_disk_cache(@ids_by_schema_path, @ids_by_schema)
     id
   end
 
@@ -78,7 +78,7 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
              hash[key] = schema
              hash
            else
-             {key => schema}
+             { key => schema }
            end
 
     write_to_disk_cache(@schemas_by_subject_version_path, hash)
@@ -90,17 +90,27 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
   # Parse the file from disk, if it exists and is not zero length
   private def read_from_disk_cache(path)
     if File.exist?(path)
-      if File.size(path)!=0
-        return JSON.parse(File.read(path))
+      if File.size(path) != 0
+        json_data = File.open(path, 'r') do |file|
+          file.flock(File::LOCK_SH)
+          file.read
+        end
+
+        return JSON.parse(json_data)
       else
         # just log a message if skipping zero length file
         @logger.warn "skipping JSON.parse of zero length file at #{path}"
       end
     end
-    return nil
+
+    nil
   end
 
   private def write_to_disk_cache(path, hash)
-    File.write(path, JSON.pretty_generate(hash))
+    # don't use "w" because it truncates the file before lock
+    File.open(path, File::RDWR | File::CREAT, 0644) do |file|
+      file.flock(File::LOCK_EX)
+      file.write(JSON.pretty_generate(hash))
+    end
   end
 end

data/lib/avro_turf/messaging.rb

@@ -21,33 +21,47 @@ class AvroTurf
   # 1: https://github.com/confluentinc/schema-registry
   class Messaging
     MAGIC_BYTE = [0].pack("C").freeze
-    DecodedMessage = Struct.new(:schema_id, :writer_schema, :reader_schema, :message)
-    private_constant(:DecodedMessage)
+
+    class DecodedMessage
+      attr_reader :schema_id
+      attr_reader :writer_schema
+      attr_reader :reader_schema
+      attr_reader :message
+
+      def initialize(schema_id, writer_schema, reader_schema, message)
+        @schema_id = schema_id
+        @writer_schema = writer_schema
+        @reader_schema = reader_schema
+        @message = message
+      end
+    end
 
     # Instantiate a new Messaging instance with the given configuration.
     #
-    # registry          - A schema registry object that responds to all methods in the
-    #                     AvroTurf::ConfluentSchemaRegistry interface.
-    # registry_url      - The String URL of the schema registry that should be used.
-    # schema_store      - A schema store object that responds to #find(schema_name, namespace).
-    # schemas_path      - The String file system path where local schemas are stored.
-    # namespace         - The String default schema namespace.
-    # 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).
+    # registry             - A schema registry object that responds to all methods in the
+    #                        AvroTurf::ConfluentSchemaRegistry interface.
+    # registry_url         - The String URL of the schema registry that should be used.
+    # schema_store         - A schema store object that responds to #find(schema_name, namespace).
+    # schemas_path         - The String file system path where local schemas are stored.
+    # namespace            - The String default schema namespace.
+    # 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).
     def initialize(
       registry: nil,
       registry_url: nil,
       schema_store: nil,
       schemas_path: nil,
       namespace: nil,
+      registry_path_prefix: nil,
       logger: nil,
       proxy: nil,
       user: nil,
@@ -74,7 +88,8 @@ class AvroTurf
           client_key: client_key,
           client_key_pass: client_key_pass,
           client_cert_data: client_cert_data,
-          client_key_data: client_key_data
+          client_key_data: client_key_data,
+          path_prefix: registry_path_prefix
         )
       )
       @schemas_by_id = {}
@@ -127,7 +142,7 @@ class AvroTurf
       writer.write(message, encoder)
 
       stream.string
-    rescue Excon::Errors::NotFound
+    rescue Excon::Error::NotFound
       if schema_id
         raise SchemaNotFoundError.new("Schema with id: #{schema_id} is not found on registry")
       else

data/lib/avro_turf/schema_store.rb

@@ -88,7 +88,7 @@ class AvroTurf::SchemaStore
       local_schemas_cache.each do |schema_name, schema|
         local_schemas_cache.delete(schema_name) unless File.exist?(build_schema_path(schema_name))
       end
-      load_schema!(fullname, local_schemas_cache)
+      load_schema!(fullname, @schemas.dup)
     else
       raise
     end

data/lib/avro_turf/test/fake_prefixed_confluent_schema_registry_server.rb

@@ -0,0 +1,102 @@
+require 'sinatra/base'
+
+class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
+  post "/prefix/subjects/:subject/versions" do
+    schema = parse_schema
+    ids_for_subject = SUBJECTS[params[:subject]]
+
+    schemas_for_subject =
+      SCHEMAS.select
+             .with_index { |_, i| ids_for_subject.include?(i) }
+
+    if schemas_for_subject.include?(schema)
+      schema_id = SCHEMAS.index(schema)
+    else
+      SCHEMAS << schema
+      schema_id = SCHEMAS.size - 1
+      SUBJECTS[params[:subject]] = SUBJECTS[params[:subject]] << schema_id
+    end
+
+    { id: schema_id }.to_json
+  end
+
+  get "/prefix/schemas/ids/:schema_id" do
+    schema = SCHEMAS.at(params[:schema_id].to_i)
+    halt(404, SCHEMA_NOT_FOUND) unless schema
+    { schema: schema }.to_json
+  end
+
+  get "/prefix/subjects" do
+    SUBJECTS.keys.to_json
+  end
+
+  get "/prefix/subjects/:subject/versions" do
+    schema_ids = SUBJECTS[params[:subject]]
+    halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
+    (1..schema_ids.size).to_a.to_json
+  end
+
+  get "/prefix/subjects/:subject/versions/:version" do
+    schema_ids = SUBJECTS[params[:subject]]
+    halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
+
+    schema_id = if params[:version] == 'latest'
+                  schema_ids.last
+                else
+                  schema_ids.at(Integer(params[:version]) - 1)
+                end
+    halt(404, VERSION_NOT_FOUND) unless schema_id
+
+    schema = SCHEMAS.at(schema_id)
+
+    {
+      name: params[:subject],
+      version: schema_ids.index(schema_id) + 1,
+      id: schema_id,
+      schema: schema
+    }.to_json
+  end
+
+  post "/prefix/subjects/:subject" do
+    schema = parse_schema
+
+    # Note: this does not actually handle the same schema registered under
+    # multiple subjects
+    schema_id = SCHEMAS.index(schema)
+
+    halt(404, SCHEMA_NOT_FOUND) unless schema_id
+
+    {
+      subject: params[:subject],
+      id: schema_id,
+      version: SUBJECTS[params[:subject]].index(schema_id) + 1,
+      schema: schema
+    }.to_json
+  end
+
+  post "/prefix/compatibility/subjects/:subject/versions/:version" do
+    # The ruby avro gem does not yet include a compatibility check between schemas.
+    # See https://github.com/apache/avro/pull/170
+    raise NotImplementedError
+  end
+
+  get "/prefix/config" do
+    global_config.to_json
+  end
+
+  put "/prefix/config" do
+    global_config.merge!(parse_config).to_json
+  end
+
+  get "/prefix/config/:subject" do
+    CONFIGS.fetch(params[:subject], global_config).to_json
+  end
+
+  put "/prefix/config/:subject" do
+    config = parse_config
+    subject = params[:subject]
+    CONFIGS.fetch(subject) do
+      CONFIGS[subject] = {}
+    end.merge!(config).to_json
+  end
+end

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "1.5.0"
+  VERSION = "1.8.0"
 end

data/lib/avro_turf.rb

@@ -16,7 +16,9 @@ end
 
 class AvroTurf
   class Error < StandardError; end
+
   class SchemaError < Error; end
+
   class SchemaNotFoundError < Error; end
 
   DEFAULT_SCHEMAS_PATH = "./schemas"
@@ -31,7 +33,7 @@ class AvroTurf
   # Currently, the only valid codec name is `deflate`.
   def initialize(schemas_path: nil, schema_store: nil, namespace: nil, codec: nil)
     @namespace = namespace
-    @schema_store = schema_store || 
+    @schema_store = schema_store ||
       SchemaStore.new(path: schemas_path || DEFAULT_SCHEMAS_PATH)
     @codec = codec
   end
@@ -62,14 +64,20 @@ class AvroTurf
   # validate    - The boolean for performing complete data validation before
   #               encoding it, Avro::SchemaValidator::ValidationError with
   #               a descriptive message will be raised in case of invalid message.
+  # validate_options - Hash for the Avro::SchemaValidator, default
+  #               {recursive: true, encoded: false, fail_on_extra_fields: true}
   #
   # Returns nothing.
-  def encode_to_stream(data, schema_name: nil, stream: nil, namespace: @namespace, validate: false)
+  def encode_to_stream(data, schema_name: nil, stream: nil, namespace: @namespace,
+                       validate: false,
+                       validate_options: { recursive: true,
+                                           encoded: false,
+                                           fail_on_extra_fields: true })
     schema = @schema_store.find(schema_name, namespace)
     writer = Avro::IO::DatumWriter.new(schema)
 
     if validate
-      Avro::SchemaValidator.validate!(schema, data, recursive: true, encoded: false, fail_on_extra_fields: true)
+      Avro::SchemaValidator.validate!(schema, data, **validate_options)
     end
 
     dw = Avro::DataFile::Writer.new(stream, writer, schema, @codec)

data/spec/avro_turf_spec.rb

@@ -16,6 +16,13 @@ describe AvroTurf do
               {
                 "type": "string",
                 "name": "full_name"
+              },
+              {
+                "name": "birth_date",
+                "type": {
+                  "type": "int",
+                  "logicalType": "date"
+                }
               }
             ]
           }
@@ -24,7 +31,8 @@ describe AvroTurf do
 
       it "encodes data with Avro" do
         data = {
-          "full_name" => "John Doe"
+          "full_name" => "John Doe",
+          "birth_date" => Date.new(1934, 1, 2)
         }
 
         encoded_data = avro.encode(data, schema_name: "person")
@@ -36,7 +44,8 @@ describe AvroTurf do
         compressed_avro = AvroTurf.new(schemas_path: "spec/schemas/", codec: "deflate")
 
         data = {
-          "full_name" => "John Doe" * 100
+          "full_name" => "John Doe" * 100,
+          "birth_date" => Date.new(1934, 1, 2)
         }
 
         uncompressed_data = avro.encode(data, schema_name: "person")
@@ -251,6 +260,31 @@ describe AvroTurf do
           expect { encode_to_stream }.to raise_error(Avro::SchemaValidator::ValidationError, /extra field 'fulll_name'/)
         end
       end
+
+      context "when the `fail_on_extra_fields` validation option is disabled" do
+        let(:message) { { "full_name" => "John Doe", "first_name" => "John", "last_name" => "Doe" } }
+        subject(:encode_to_stream) do
+          stream = StringIO.new
+          avro.encode_to_stream(message, stream: stream, schema_name: "message",
+                                validate: true,
+                                validate_options: { recursive: true, encoded: false, fail_on_extra_fields: false }
+          )
+        end
+
+        it "should not raise Avro::SchemaValidator::ValidationError with a message about extra field" do
+          define_schema "message.avsc", <<-AVSC
+            {
+              "name": "message",
+              "type": "record",
+              "fields": [
+                { "name": "full_name", "type": "string" }
+              ]
+            }
+          AVSC
+
+          expect { encode_to_stream }.not_to raise_error
+        end
+      end
     end
   end
 
@@ -304,5 +338,33 @@ describe AvroTurf do
       datum = { message: "hello" }
       expect(avro.valid?(datum, schema_name: "postcard")).to eq true
     end
+
+    it "handles logicalType of date in schema" do
+      define_schema "postcard.avsc", <<-AVSC
+        {
+          "name": "postcard",
+          "type": "record",
+          "fields": [
+            {
+              "name": "message",
+              "type": "string"
+            },
+            {
+              "name": "sent_date",
+              "type": {
+                "type": "int",
+                "logicalType": "date"
+              }
+            }
+          ]
+        }
+      AVSC
+
+      datum = { 
+        message: "hello",
+        sent_date: Date.new(2022, 9, 11)
+      }
+      expect(avro.valid?(datum, schema_name: "postcard")).to eq true
+    end
   end
 end

data/spec/core_ext/date_spec.rb

@@ -1,6 +1,6 @@
 describe Date, "#as_avro" do
-  it "returns an ISO8601 string describing the time" do
+  it "returns Date object describing the time" do
     date = Date.today
-    expect(date.as_avro).to eq(date.iso8601)
+    expect(date.as_avro).to eq(date)
   end
 end

data/spec/messaging_spec.rb

@@ -1,6 +1,7 @@
 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" }
@@ -8,7 +9,7 @@ describe AvroTurf::Messaging do
   let(:client_key) { "test client key" }
   let(:client_key_pass) { "test client key password" }
   let(:logger) { Logger.new(StringIO.new) }
-
+  let(:path_prefix) { nil }
   let(:avro) {
     AvroTurf::Messaging.new(
       registry_url: registry_url,
@@ -72,7 +73,7 @@ describe AvroTurf::Messaging do
 
   shared_examples_for 'encoding and decoding with the schema from registry' do
     before do
-      registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger)
+      registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger, path_prefix: path_prefix)
       registry.register('person', schema)
       registry.register('people', schema)
     end
@@ -102,7 +103,7 @@ describe AvroTurf::Messaging do
 
   shared_examples_for 'encoding and decoding with the schema_id from registry' do
     before do
-      registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger)
+      registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger, path_prefix: path_prefix)
       registry.register('person', schema)
       registry.register('people', schema)
     end
@@ -399,4 +400,29 @@ describe AvroTurf::Messaging do
       end
     end
   end
-end
+
+  context 'with a registry path prefix' do
+    let(:path_prefix) { '/prefix' }
+
+    let(:avro) {
+      AvroTurf::Messaging.new(
+        registry_path_prefix: path_prefix,
+        registry_url: registry_url,
+        schemas_path: "spec/schemas",
+        logger: logger,
+        client_cert: client_cert,
+        client_key: client_key,
+        client_key_pass: client_key_pass
+      )
+    }
+
+    before do
+      stub_request(:any, /^#{registry_url}/).to_rack(FakePrefixedConfluentSchemaRegistryServer)
+      FakePrefixedConfluentSchemaRegistryServer.clear
+    end
+
+    it_behaves_like "encoding and decoding with the schema from schema store"
+    it_behaves_like 'encoding and decoding with the schema from registry'
+    it_behaves_like 'encoding and decoding with the schema_id from registry'
+  end
+end

data/spec/schema_store_spec.rb

@@ -26,6 +26,33 @@ describe AvroTurf::SchemaStore do
       expect(schema.fullname).to eq "message"
     end
 
+    it "resolves missing references when nested schema is not a named type" do
+      define_schema "root.avsc", <<-AVSC
+        {
+          "type": "record",
+          "name": "root",
+          "fields": [
+            {
+              "type": "nested",
+              "name": "nested_value"
+            }
+          ]
+        }
+      AVSC
+
+      define_schema "nested.avsc", <<-AVSC
+        {
+          "name": "nested",
+          "type": "string",
+          "logicalType": "uuid"
+        }
+      AVSC
+
+      schema = store.find("root")
+
+      expect(schema.fullname).to eq "root"
+    end
+
     it "resolves missing references" do
       define_schema "person.avsc", <<-AVSC
         {

data/spec/spec_helper.rb

@@ -22,6 +22,16 @@ module Helpers
   end
 end
 
+# gem `fakefs` does not support flock for the file, and require patch
+# https://github.com/fakefs/fakefs/issues/433
+module FakeFS
+  class File < StringIO
+    def flock(*)
+      true
+    end
+  end
+end
+
 RSpec.configure do |config|
   config.include FakeFS::SpecHelpers
   config.include Helpers

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Daniel Schierbeck
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -156,7 +156,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - dasch@zendesk.com
 executables: []
@@ -196,6 +196,7 @@ files:
 - lib/avro_turf/schema_store.rb
 - lib/avro_turf/schema_to_avro_patch.rb
 - lib/avro_turf/test/fake_confluent_schema_registry_server.rb
+- lib/avro_turf/test/fake_prefixed_confluent_schema_registry_server.rb
 - lib/avro_turf/test/fake_schema_registry_server.rb
 - lib/avro_turf/version.rb
 - perf/address.avsc
@@ -250,8 +251,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: A library that makes it easier to use the Avro serialization format from
   Ruby