avro_turf 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccc550653b8422953e55c1319f37f478d1851afab78b54c716ba23fb0e59af17
-  data.tar.gz: a5f4721aa89807ee5b401c9a55d69d030cc2c0b7d54764b75e350f50aec9c118
+  metadata.gz: e110697cb451e5315414f8086d32aa6e6c43444a462fcdaa678d1311302fcab8
+  data.tar.gz: a54afac8d7e8cb4a599695825ccb3d666d08ad800ccfe63229f14b6b42b26f11
 SHA512:
-  metadata.gz: 8e8e81e7e00c1fb40d43bc8ef03c64af8b4d79c921d5eaac9b32ea0039e4c877956612e98061948d7dbc0b88b320a96858b7d31d6f9f9b7bd30bead3da985035
-  data.tar.gz: 3301e480eb51017cfd58fad552afc2b7c60b44545518fcaa8f892f90c15c7c03eb176e56af1447692d660c912cba1b22a20044f15d23d7ba949af3d075eed23b
+  metadata.gz: 78ee7cc3c12975d15bc621d9b3a96ed014cc8265536650f365ed80a861a06d53f3e9db9f7d698f71c02485df6f9b371944102404e76cc05e13816e12d312d97c
+  data.tar.gz: ac02799c0f25b88f8c9bfbbd0de48a2b3c39a7744ee1b90c6c87439b5a547db9456a2b3f89a9730303c76ea302159fdce9189f417e6424ecbac45da14682dd0d

data/.github/workflows/ruby.yml

@@ -6,13 +6,16 @@ jobs:
   build:
 
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0]
 
     steps:
-    - uses: actions/checkout@v1
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
+    - uses: actions/checkout@v2
+    - name: Set up Ruby ${{ matrix.ruby }}
+      uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6.x
+        ruby-version: ${{ matrix.ruby }}
     - name: Build and test with RSpec
       run: |
         gem install bundler

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## Unreleased
 
+## v1.5.0
+
+- Add CA cert file option (#157)
+- Add compatibility with Avro v1.11.x.
+
+## v1.4.1
+
+- Purge sub-schemas from cache before re-parsing schema (#151)
+
+## v1.4.0
+
+- Add support for Ruby 3 (#146)
+- Add ability to validate message before encoding in `AvroTurf#encode` interface
+
+## v1.3.1
+
+- Prevent CachedConfluentSchemaRegistry from caching the 'latest' version (#140)
+- Fix issue with zero length schema cache file (#138)
+
 ## v1.3.0
 
 - Add support for plain user/password auth to ConfluentSchemaRegistry (#120)

data/README.md

@@ -18,7 +18,7 @@ The aliases for the original names will be removed in a future release.
 
 ## Note about finding nested schemas
 
-As of AvroTurf version 0.12.0, only top-level schemas that have their own .avsc file will be loaded and resolvable by the `AvroTurf::SchemaStore#find` method. This change will likely not affect most users. However, if you use `AvroTurf::SchemaStore#load_schemas!` to pre-cache all your schemas and then rely on `AvroTurf::SchemaStore#find` to access nested schemas that are not defined by their own .avsc files, your code may stop working when you upgrade to v0.12.0.
+As of AvroTurf version 1.0.0, only top-level schemas that have their own .avsc file will be loaded and resolvable by the `AvroTurf::SchemaStore#find` method. This change will likely not affect most users. However, if you use `AvroTurf::SchemaStore#load_schemas!` to pre-cache all your schemas and then rely on `AvroTurf::SchemaStore#find` to access nested schemas that are not defined by their own .avsc files, your code may stop working when you upgrade to v1.0.0.
 
 As an example, if you have a `person` schema (defined in `my/schemas/contacts/person.avsc`) that defines a nested `address` schema like this:
 
@@ -44,7 +44,7 @@ As an example, if you have a `person` schema (defined in `my/schemas/contacts/pe
   ]
 }
 ```
-...this will no longer work in v0.12.0:
+...this will no longer work in v1.0.0:
 ```ruby
 store = AvroTurf::SchemaStore.new(path: 'my/schemas')
 store.load_schemas!
@@ -88,6 +88,10 @@ avro.decode(encoded_data, schema_name: "person")
 
 # Encode some data using the named schema.
 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)
 ```
 
 ### Inter-schema references

data/avro_turf.gemspec

@@ -12,12 +12,14 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/dasch/avro_turf"
   spec.license       = "MIT"
 
+  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.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "avro", ">= 1.7.7", "< 1.11"
+  spec.add_dependency "avro", ">= 1.7.7", "< 1.12"
   spec.add_dependency "excon", "~> 0.71"
 
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/avro_turf/cached_confluent_schema_registry.rb

@@ -33,6 +33,8 @@ class AvroTurf::CachedConfluentSchemaRegistry
   end
 
   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

@@ -9,6 +9,7 @@ class AvroTurf::ConfluentSchemaRegistry
     proxy: nil,
     user: nil,
     password: nil,
+    ssl_ca_file: nil,
     client_cert: nil,
     client_key: nil,
     client_key_pass: nil,
@@ -19,12 +20,13 @@ class AvroTurf::ConfluentSchemaRegistry
     headers = {
       "Content-Type" => CONTENT_TYPE
     }
-    headers[:proxy] = proxy if proxy&.present?
+    headers[:proxy] = proxy unless proxy.nil?
     @connection = Excon.new(
       url,
       headers: headers,
       user: user,
       password: password,
+      ssl_ca_file: ssl_ca_file,
       client_cert: client_cert,
       client_key: client_key,
       client_key_pass: client_key_pass,
@@ -40,9 +42,7 @@ class AvroTurf::ConfluentSchemaRegistry
   end
 
   def register(subject, schema)
-    data = post("/subjects/#{subject}/versions", body: {
-      schema: schema.to_s
-    }.to_json)
+    data = post("/subjects/#{subject}/versions", body: { schema: schema.to_s }.to_json)
 
     id = data.fetch("id")
 
@@ -82,8 +82,7 @@ class AvroTurf::ConfluentSchemaRegistry
   # http://docs.confluent.io/3.1.2/schema-registry/docs/api.html#compatibility
   def compatible?(subject, schema, version = 'latest')
     data = post("/compatibility/subjects/#{subject}/versions/#{version}",
-                expects: [200, 404],
-                body: { schema: schema.to_s }.to_json)
+                expects: [200, 404], body: { schema: schema.to_s }.to_json)
     data.fetch('is_compatible', false) unless data.has_key?('error_code')
   end
 
@@ -94,7 +93,7 @@ class AvroTurf::ConfluentSchemaRegistry
 
   # Update global config
   def update_global_config(config)
-    put("/config", { body: config.to_json })
+    put("/config", body: config.to_json)
   end
 
   # Get config for subject
@@ -104,7 +103,7 @@ class AvroTurf::ConfluentSchemaRegistry
 
   # Update config for subject
   def update_subject_config(subject, config)
-    put("/config/#{subject}", { body: config.to_json })
+    put("/config/#{subject}", body: config.to_json)
   end
 
   private

data/lib/avro_turf/disk_cache.rb

@@ -2,15 +2,19 @@
 # Extends the InMemoryCache to provide a write-thru to disk for persistent cache.
 class AvroTurf::DiskCache < AvroTurf::InMemoryCache
 
-  def initialize(disk_path)
+  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')
-    @schemas_by_id = JSON.parse(File.read(@schemas_by_id_path)) if File.exist?(@schemas_by_id_path)
+    hash = read_from_disk_cache(@schemas_by_id_path)
+    @schemas_by_id = hash if hash
 
     @ids_by_schema_path = File.join(disk_path, 'ids_by_schema.json')
-    @ids_by_schema = JSON.parse(File.read(@ids_by_schema_path)) if File.exist?(@ids_by_schema_path)
+    hash = read_from_disk_cache(@ids_by_schema_path)
+    @ids_by_schema = hash if hash
 
     @schemas_by_subject_version_path = File.join(disk_path, 'schemas_by_subject_version.json')
     @schemas_by_subject_version = {}
@@ -31,12 +35,18 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
     return value
   end
 
-  # override to include write-thru cache after storing result from upstream
+  # override to use a json serializable cache key
+  def lookup_by_schema(subject, schema)
+    key = "#{subject}#{schema}"
+    @ids_by_schema[key]
+  end
+
+  # override to use a json serializable cache key and update the file cache
   def store_by_schema(subject, schema, id)
-    # must return the value from storing the result (i.e. do not return result from file write)
-    value = super
+    key = "#{subject}#{schema}"
+    @ids_by_schema[key] = id
     File.write(@ids_by_schema_path, JSON.pretty_generate(@ids_by_schema))
-    return value
+    id
   end
 
   # checks instance var (in-memory cache) for schema
@@ -49,7 +59,7 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
 
     return schema unless schema.nil?
 
-    hash = JSON.parse(File.read(@schemas_by_subject_version_path)) if File.exist?(@schemas_by_subject_version_path)
+    hash = read_from_disk_cache(@schemas_by_subject_version_path)
     if hash
       @schemas_by_subject_version = hash
       @schemas_by_subject_version[key]
@@ -63,7 +73,7 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
   # update instance var (in memory-cache) to match
   def store_by_version(subject, version, schema)
     key = "#{subject}#{version}"
-    hash = JSON.parse(File.read(@schemas_by_subject_version_path)) if File.exist?(@schemas_by_subject_version_path)
+    hash = read_from_disk_cache(@schemas_by_subject_version_path)
     hash = if hash
              hash[key] = schema
              hash
@@ -77,6 +87,19 @@ class AvroTurf::DiskCache < AvroTurf::InMemoryCache
     @schemas_by_subject_version[key]
   end
 
+  # 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))
+      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
+  end
+
   private def write_to_disk_cache(path, hash)
     File.write(path, JSON.pretty_generate(hash))
   end

data/lib/avro_turf/in_memory_cache.rb

@@ -17,12 +17,12 @@ class AvroTurf::InMemoryCache
   end
 
   def lookup_by_schema(subject, schema)
-    key = subject + schema.to_s
+    key = [subject, schema.to_s]
     @ids_by_schema[key]
   end
 
   def store_by_schema(subject, schema, id)
-    key = subject + schema.to_s
+    key = [subject, schema.to_s]
     @ids_by_schema[key] = id
   end
 

data/lib/avro_turf/messaging.rb

@@ -36,6 +36,7 @@ class AvroTurf
     # 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).
@@ -51,6 +52,7 @@ class AvroTurf
       proxy: nil,
       user: nil,
       password: nil,
+      ssl_ca_file: nil,
       client_cert: nil,
       client_key: nil,
       client_key_pass: nil,
@@ -67,6 +69,7 @@ class AvroTurf
           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,
@@ -124,7 +127,7 @@ class AvroTurf
       writer.write(message, encoder)
 
       stream.string
-    rescue Excon::Error::NotFound
+    rescue Excon::Errors::NotFound
       if schema_id
         raise SchemaNotFoundError.new("Schema with id: #{schema_id} is not found on registry")
       else
@@ -194,8 +197,10 @@ class AvroTurf
 
     # Fetch the schema from registry with the provided schema_id.
     def fetch_schema_by_id(schema_id)
-      schema_json = @registry.fetch(schema_id)
-      schema = Avro::Schema.parse(schema_json)
+      schema = @schemas_by_id.fetch(schema_id) do
+        schema_json = @registry.fetch(schema_id)
+        Avro::Schema.parse(schema_json)
+      end
       [schema, schema_id]
     end
 

data/lib/avro_turf/schema_store.rb

@@ -22,7 +22,7 @@ class AvroTurf::SchemaStore
       # Still need to check is the schema already loaded
       return @schemas[fullname] if @schemas.key?(fullname)
 
-      load_schema!(fullname, namespace)
+      load_schema!(fullname)
     end
   end
 
@@ -42,13 +42,12 @@ class AvroTurf::SchemaStore
     end
   end
 
-  private
+  protected
 
   # Loads single schema
   # Such method is not thread-safe, do not call it of from mutex synchronization routine
-  def load_schema!(fullname, namespace = nil, local_schemas_cache = {})
-    *namespace, schema_name = fullname.split(".")
-    schema_path = File.join(@path, *namespace, schema_name + ".avsc")
+  def load_schema!(fullname, local_schemas_cache = {})
+    schema_path = build_schema_path(fullname)
     schema_json = JSON.parse(File.read(schema_path))
 
     schema = Avro::Schema.real_parse(schema_json, local_schemas_cache)
@@ -78,17 +77,27 @@ class AvroTurf::SchemaStore
       # Try to first resolve a referenced schema from disk.
       # If this is successful, the Avro gem will have mutated the
       # local_schemas_cache, adding all the new schemas it found.
-      load_schema!($1, nil, local_schemas_cache)
+      load_schema!($1, local_schemas_cache)
 
       # Attempt to re-parse the original schema now that the dependency
       # has been resolved and use the now-updated local_schemas_cache to
       # pick up where we left off.
       local_schemas_cache.delete(fullname)
-      load_schema!(fullname, nil, local_schemas_cache)
+      # Ensure all sub-schemas are cleaned up to avoid conflicts when re-parsing
+      # schema.
+      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)
     else
       raise
     end
   rescue Errno::ENOENT, Errno::ENAMETOOLONG
     raise AvroTurf::SchemaNotFoundError, "could not find Avro schema at `#{schema_path}'"
   end
+
+  def build_schema_path(fullname)
+    *namespace, schema_name = fullname.split(".")
+    schema_path = File.join(@path, *namespace, schema_name + ".avsc")
+  end
 end

data/lib/avro_turf/version.rb

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

data/lib/avro_turf.rb

@@ -40,12 +40,15 @@ class AvroTurf
   #
   # data        - The data that should be encoded.
   # schema_name - The name of a schema in the `schemas_path`.
+  # 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.
   #
   # Returns a String containing the encoded data.
-  def encode(data, schema_name: nil, namespace: @namespace)
+  def encode(data, schema_name: nil, namespace: @namespace, validate: false)
     stream = StringIO.new
 
-    encode_to_stream(data, stream: stream, schema_name: schema_name, namespace: namespace)
+    encode_to_stream(data, stream: stream, schema_name: schema_name, namespace: namespace, validate: validate)
 
     stream.string
   end
@@ -56,12 +59,19 @@ class AvroTurf
   # data        - The data that should be encoded.
   # schema_name - The name of a schema in the `schemas_path`.
   # stream      - An IO object that the encoded data should be written to (optional).
+  # 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.
   #
   # Returns nothing.
-  def encode_to_stream(data, schema_name: nil, stream: nil, namespace: @namespace)
+  def encode_to_stream(data, schema_name: nil, stream: nil, namespace: @namespace, validate: false)
     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)
+    end
+
     dw = Avro::DataFile::Writer.new(stream, writer, schema, @codec)
     dw << data.as_avro
     dw.close

data/spec/avro_turf_spec.rb

@@ -6,44 +6,130 @@ describe AvroTurf do
   end
 
   describe "#encode" do
-    before do
-      define_schema "person.avsc", <<-AVSC
-        {
-          "name": "person",
-          "type": "record",
-          "fields": [
-            {
-              "type": "string",
-              "name": "full_name"
-            }
-          ]
+    context "when using plain schema" do
+      before do
+        define_schema "person.avsc", <<-AVSC
+          {
+            "name": "person",
+            "type": "record",
+            "fields": [
+              {
+                "type": "string",
+                "name": "full_name"
+              }
+            ]
+          }
+        AVSC
+      end
+
+      it "encodes data with Avro" do
+        data = {
+          "full_name" => "John Doe"
         }
-      AVSC
-    end
 
-    it "encodes data with Avro" do
-      data = {
-        "full_name" => "John Doe"
-      }
+        encoded_data = avro.encode(data, schema_name: "person")
 
-      encoded_data = avro.encode(data, schema_name: "person")
+        expect(avro.decode(encoded_data)).to eq(data)
+      end
 
-      expect(avro.decode(encoded_data)).to eq(data)
+      it "allows specifying a codec that should be used to compress messages" do
+        compressed_avro = AvroTurf.new(schemas_path: "spec/schemas/", codec: "deflate")
+
+        data = {
+          "full_name" => "John Doe" * 100
+        }
+
+        uncompressed_data = avro.encode(data, schema_name: "person")
+        compressed_data = compressed_avro.encode(data, schema_name: "person")
+
+        expect(compressed_data.bytesize).to be < uncompressed_data.bytesize
+        expect(compressed_avro.decode(compressed_data)).to eq(data)
+      end
     end
 
-    it "allows specifying a codec that should be used to compress messages" do
-      compressed_avro = AvroTurf.new(schemas_path: "spec/schemas/", codec: "deflate")
+    context 'when using nested schemas' do
+      before do
+        define_schema "post.avsc", <<-AVSC
+          {
+            "name": "post",
+            "type": "record",
+            "fields": [
+              {
+                "name": "tag",
+                "type": {
+                  "type": "enum",
+                  "name": "tag",
+                  "symbols": ["foo", "bar"]
+                }
+              },
+              {
+                "name": "messages",
+                "type": {
+                  "type": "array",
+                  "items": "message"
+                }
+              },
+              {
+                "name": "status",
+                "type": "publishing_status"
+              }
+            ]
+          }
+        AVSC
+
+        define_schema "publishing_status.avsc", <<-AVSC
+          {
+            "name": "publishing_status",
+            "type": "enum",
+            "symbols": ["draft", "published", "archived"]
+          }
+        AVSC
 
-      data = {
-        "full_name" => "John Doe" * 100
-      }
+        define_schema "message.avsc", <<-AVSC
+          {
+            "name": "message",
+            "type": "record",
+            "fields": [
+              {
+                "type": "string",
+                "name": "content"
+              },
+              {
+                "name": "label",
+                "type": {
+                  "type": "enum",
+                  "name": "label",
+                  "symbols": ["foo", "bar"]
+                }
+              },
+              {
+                "name": "status",
+                "type": "publishing_status"
+              }
+            ]
+          }
+        AVSC
+      end
+
+      it "encodes data with Avro" do
+        data = {
+          "tag" => "foo",
+          "messages" => [
+            {
+              "content" => "hello",
+              "label" => "bar",
+              "status" => "draft"
+            }
+          ],
+          "status" => "published"
+        }
 
-      uncompressed_data = avro.encode(data, schema_name: "person")
-      compressed_data = compressed_avro.encode(data, schema_name: "person")
+        encoded_data = avro.encode(data, schema_name: "post")
 
-      expect(compressed_data.bytesize).to be < uncompressed_data.bytesize
-      expect(compressed_avro.decode(compressed_data)).to eq(data)
+        expect(avro.decode(encoded_data)).to eq(data)
+      end
     end
+
   end
 
   describe "#decode" do
@@ -105,6 +191,67 @@ describe AvroTurf do
 
       expect(avro.decode(stream.string)).to eq "hello"
     end
+
+    context "validating" do
+      subject(:encode_to_stream) do
+        stream = StringIO.new
+        avro.encode_to_stream(message, stream: stream, schema_name: "message", validate: true)
+      end
+
+      context "with a valid message" do
+        let(:message) { { "full_name" => "John Doe" } }
+
+        it "does not raise any error" 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
+
+      context "when message has wrong type" do
+        let(:message) { { "full_name" => 123 } }
+
+        it "raises Avro::SchemaValidator::ValidationError with a message about type mismatch" do
+          define_schema "message.avsc", <<-AVSC
+            {
+              "name": "message",
+              "type": "record",
+              "fields": [
+                { "name": "full_name", "type": "string" }
+              ]
+            }
+          AVSC
+
+          expect { encode_to_stream }.to raise_error(Avro::SchemaValidator::ValidationError, /\.full_name expected type string, got int/)
+        end
+      end
+
+      context "when message contains extra fields (typo in key)" do
+        let(:message) { { "fulll_name" => "John Doe" } }
+
+        it "raises 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 }.to raise_error(Avro::SchemaValidator::ValidationError, /extra field 'fulll_name'/)
+        end
+      end
+    end
   end
 
   describe "#decode_stream" do

data/spec/disk_cached_confluent_schema_registry_spec.rb

@@ -4,7 +4,8 @@ require 'avro_turf/test/fake_confluent_schema_registry_server'
 
 describe AvroTurf::CachedConfluentSchemaRegistry do
   let(:upstream) { instance_double(AvroTurf::ConfluentSchemaRegistry) }
-  let(:cache)    { AvroTurf::DiskCache.new("spec/cache")}
+  let(:logger_io) { StringIO.new }
+  let(:cache)    { AvroTurf::DiskCache.new("spec/cache", logger: Logger.new(logger_io))}
   let(:registry) { described_class.new(upstream, cache: cache) }
   let(:id) { rand(999) }
   let(:schema) do
@@ -80,6 +81,40 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
     end
   end
 
+  describe "#fetch (zero length cache file)" do
+    let(:cache_after) do
+      {
+        "#{id}" => "#{schema}"
+      }
+    end
+
+    before do
+      # setup the disk cache with a zero length file
+      File.write(File.join("spec/cache", "schemas_by_id.json"), '')
+    end
+
+    it "skips zero length disk cache" do
+      # multiple calls return same result, with only one upstream call
+      allow(upstream).to receive(:fetch).with(id).and_return(schema)
+      expect(registry.fetch(id)).to eq(schema)
+      expect(registry.fetch(id)).to eq(schema)
+      expect(upstream).to have_received(:fetch).exactly(1).times
+      expect(load_cache("schemas_by_id.json")).to eq cache_after
+      expect(logger_io.string).to include("zero length file at spec/cache/schemas_by_id.json")
+    end
+  end
+
+  describe "#fetch (corrupt cache file)" do
+    before do
+      # setup the disk cache with a corrupt file (i.e. not json)
+      File.write(File.join("spec/cache", "schemas_by_id.json"), 'NOTJSON')
+    end
+
+    it "raises error on corrupt cache file" do
+      expect{registry.fetch(id)}.to raise_error(JSON::ParserError, /unexpected token/)
+    end
+  end
+
   describe "#register" do
     let(:subject_name) { "a_subject" }
     let(:cache_before) do
@@ -120,6 +155,41 @@ describe AvroTurf::CachedConfluentSchemaRegistry do
     end
   end
 
+  describe "#register (zero length cache file)" do
+    let(:subject_name) { "a_subject" }
+    let(:cache_after) do
+      {
+        "#{subject_name}#{schema}" => id
+      }
+    end
+
+    before do
+      # setup the disk cache with a zero length file
+      File.write(File.join("spec/cache", "ids_by_schema.json"), '')
+    end
+
+    it "skips zero length disk cache" do
+      # multiple calls return same result, with only one upstream call
+      allow(upstream).to receive(:register).with(subject_name, schema).and_return(id)
+      expect(registry.register(subject_name, schema)).to eq(id)
+      expect(registry.register(subject_name, schema)).to eq(id)
+      expect(upstream).to have_received(:register).exactly(1).times
+      expect(load_cache("ids_by_schema.json")).to eq cache_after
+      expect(logger_io.string).to include("zero length file at spec/cache/ids_by_schema.json")
+    end
+  end
+
+  describe "#register (corrupt cache file)" do
+    before do
+      # setup the disk cache with a corrupt file (i.e. not json)
+      File.write(File.join("spec/cache", "ids_by_schema.json"), 'NOTJSON')
+    end
+
+    it "raises error on corrupt cache file" do
+      expect{registry.register(subject_name, schema)}.to raise_error(JSON::ParserError, /unexpected token/)
+    end
+  end
+
   describe "#subject_version" do
     it "writes thru to disk cache" do
       # multiple calls return same result, with zero upstream calls

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Daniel Schierbeck
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-10 00:00:00.000000000 Z
+date: 2021-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -19,7 +19,7 @@ dependencies:
         version: 1.7.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 1.7.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +156,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
+description: 
 email:
 - dasch@zendesk.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
 - ".github/workflows/ruby.yml"
 - ".github/workflows/stale.yml"
 - ".gitignore"
@@ -226,7 +225,8 @@ files:
 homepage: https://github.com/dasch/avro_turf
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: |2
 
   avro_turf v0.8.0 deprecates the names AvroTurf::SchemaRegistry,
@@ -251,7 +251,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A library that makes it easier to use the Avro serialization format from
   Ruby

data/.circleci/config.yml

@@ -1,36 +0,0 @@
-version: 2
-jobs:
-  build:
-    environment:
-      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts
-      CIRCLE_TEST_REPORTS: /tmp/circleci-test-results
-    docker:
-    - image: circleci/ruby:2.6.2
-    steps:
-    - checkout
-    - run: mkdir -p $CIRCLE_ARTIFACTS $CIRCLE_TEST_REPORTS
-    - restore_cache:
-        keys:
-        # This branch if available
-        - v1-dep-{{ .Branch }}-
-        # Default branch if not
-        - v1-dep-master-
-        # Any branch if there are none on the default branch - this should be unnecessary if you have your default branch configured correctly
-        - v1-dep-
-    - run: gem install bundler --no-document
-    - run: 'bundle check --path=vendor/bundle || bundle install --path=vendor/bundle --jobs=4 --retry=3'
-    # Save dependency cache
-    - save_cache:
-        key: v1-dep-{{ .Branch }}-{{ epoch }}
-        paths:
-        - vendor/bundle
-        - ~/.bundle
-    - run: mkdir -p $CIRCLE_TEST_REPORTS/rspec
-    - run:
-        command: bundle exec rspec --color --require spec_helper --format progress
-    - store_test_results:
-        path: /tmp/circleci-test-results
-    - store_artifacts:
-        path: /tmp/circleci-artifacts
-    - store_artifacts:
-        path: /tmp/circleci-test-results