avro_turf 1.19.0 → 1.20.1

data/spec/messaging_spec.rb

@@ -1,5 +1,7 @@
-require 'webmock/rspec'
-require 'avro_turf/messaging'
+# frozen_string_literal: true
+
+require "webmock/rspec"
+require "avro_turf/messaging"
 
 describe AvroTurf::Messaging do
   let(:registry_url) { "http://registry.example.com" }
@@ -19,7 +21,7 @@ describe AvroTurf::Messaging do
     )
   }
 
-  let(:message) { { "full_name" => "John Doe" } }
+  let(:message) { {"full_name" => "John Doe"} }
   let(:schema_json) do
     <<-AVSC
       {
@@ -35,7 +37,7 @@ describe AvroTurf::Messaging do
     AVSC
   end
 
-  let(:city_message) { { "name" => "Paris" } }
+  let(:city_message) { {"name" => "Paris"} }
   let(:city_schema_json) do
     <<-AVSC
       {
@@ -88,39 +90,39 @@ describe AvroTurf::Messaging do
     end
   end
 
-  shared_examples_for 'encoding and decoding with the schema from registry' do
+  shared_examples_for "encoding and decoding with the schema from registry" do
     before do
       registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger, path_prefix: path_prefix)
-      registry.register('person', schema)
-      registry.register('people', schema)
+      registry.register("person", schema)
+      registry.register("people", schema)
     end
 
-    it 'encodes and decodes messages' do
-      data = avro.encode(message, subject: 'person', version: 1)
+    it "encodes and decodes messages" do
+      data = avro.encode(message, subject: "person", version: 1)
       expect(avro.decode(data)).to eq message
     end
 
     it "allows specifying a reader's schema by subject and version" do
-      data = avro.encode(message, subject: 'person', version: 1)
-      expect(avro.decode(data, schema_name: 'person')).to eq message
+      data = avro.encode(message, subject: "person", version: 1)
+      expect(avro.decode(data, schema_name: "person")).to eq message
     end
 
-    it 'raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry' do
-      expect { avro.encode(message, subject: 'missing', version: 1) }.to raise_error(AvroTurf::SchemaNotFoundError)
+    it "raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry" 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")
+    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
+    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)
+    it "caches parsed schemas for decoding" do
+      data = avro.encode(message, subject: "person", version: 1)
       avro.decode(data)
       allow(Avro::Schema).to receive(:parse).and_call_original
       expect(avro.decode(data)).to eq message
@@ -128,23 +130,23 @@ describe AvroTurf::Messaging do
     end
   end
 
-  shared_examples_for 'encoding and decoding with the schema_id from registry' do
+  shared_examples_for "encoding and decoding with the schema_id from registry" do
     before do
       registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger, path_prefix: path_prefix)
-      registry.register('person', schema)
-      registry.register('people', schema)
+      registry.register("person", schema)
+      registry.register("people", schema)
     end
 
-    it 'encodes and decodes messages' do
+    it "encodes and decodes messages" do
       data = avro.encode(message, schema_id: 0)
       expect(avro.decode(data)).to eq message
     end
 
-    it 'raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry' do
+    it "raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry" do
       expect { avro.encode(message, schema_id: 5) }.to raise_error(AvroTurf::SchemaNotFoundError)
     end
 
-    it 'caches parsed schemas for decoding' do
+    it "caches parsed schemas for decoding" do
       data = avro.encode(message, schema_id: 0)
       avro.decode(data)
       allow(Avro::Schema).to receive(:parse).and_call_original
@@ -155,9 +157,9 @@ describe AvroTurf::Messaging do
 
   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 from registry"
 
-  it_behaves_like 'encoding and decoding with the schema_id from registry'
+  it_behaves_like "encoding and decoding with the schema_id from registry"
 
   context "with a provided registry" do
     let(:registry) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
@@ -172,20 +174,20 @@ describe AvroTurf::Messaging do
 
     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 from registry"
 
-    it_behaves_like 'encoding and decoding with the schema_id from registry'
+    it_behaves_like "encoding and decoding with the schema_id from registry"
 
     it "uses the provided registry" do
       allow(registry).to receive(:register).and_call_original
-      message = { "full_name" => "John Doe" }
+      message = {"full_name" => "John Doe"}
       avro.encode(message, schema_name: "person")
       expect(registry).to have_received(:register).with("person", anything)
     end
 
     it "allows specifying a schema registry subject" do
       allow(registry).to receive(:register).and_call_original
-      message = { "full_name" => "John Doe" }
+      message = {"full_name" => "John Doe"}
       avro.encode(message, schema_name: "person", subject: "people")
       expect(registry).to have_received(:register).with("people", anything)
     end
@@ -211,7 +213,7 @@ describe AvroTurf::Messaging do
     end
   end
 
-  describe 'decoding with #decode_message' do
+  describe "decoding with #decode_message" do
     shared_examples_for "encoding and decoding with the schema from schema store" do
       it "encodes and decodes messages" do
         data = avro.encode(message, schema_name: "person")
@@ -239,31 +241,31 @@ describe AvroTurf::Messaging do
       end
     end
 
-    shared_examples_for 'encoding and decoding with the schema from registry' do
+    shared_examples_for "encoding and decoding with the schema from registry" do
       before do
         registry = AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger)
-        registry.register('person', schema)
-        registry.register('people', schema)
+        registry.register("person", schema)
+        registry.register("people", schema)
       end
 
-      it 'encodes and decodes messages' do
-        data = avro.encode(message, subject: 'person', version: 1)
+      it "encodes and decodes messages" do
+        data = avro.encode(message, subject: "person", version: 1)
         result = avro.decode_message(data)
         expect(result.message).to eq message
         expect(result.schema_id).to eq 0
       end
 
       it "allows specifying a reader's schema by subject and version" do
-        data = avro.encode(message, subject: 'person', version: 1)
-        expect(avro.decode_message(data, schema_name: 'person').message).to eq message
+        data = avro.encode(message, subject: "person", version: 1)
+        expect(avro.decode_message(data, schema_name: "person").message).to eq message
       end
 
-      it 'raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry' do
-        expect { avro.encode(message, subject: 'missing', version: 1) }.to raise_error(AvroTurf::SchemaNotFoundError)
+      it "raises AvroTurf::SchemaNotFoundError when the schema does not exist on registry" do
+        expect { avro.encode(message, subject: "missing", version: 1) }.to raise_error(AvroTurf::SchemaNotFoundError)
       end
 
-      it 'caches parsed schemas for decoding' do
-        data = avro.encode(message, subject: 'person', version: 1)
+      it "caches parsed schemas for decoding" do
+        data = avro.encode(message, subject: "person", version: 1)
         avro.decode_message(data)
         allow(Avro::Schema).to receive(:parse).and_call_original
         expect(avro.decode_message(data).message).to eq message
@@ -273,7 +275,7 @@ describe AvroTurf::Messaging do
 
     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 from registry"
 
     context "with a provided registry" do
       let(:registry) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
@@ -288,18 +290,18 @@ describe AvroTurf::Messaging do
 
       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 from registry"
 
       it "uses the provided registry" do
         allow(registry).to receive(:register).and_call_original
-        message = { "full_name" => "John Doe" }
+        message = {"full_name" => "John Doe"}
         avro.encode(message, schema_name: "person")
         expect(registry).to have_received(:register).with("person", anything)
       end
 
       it "allows specifying a schema registry subject" do
         allow(registry).to receive(:register).and_call_original
-        message = { "full_name" => "John Doe" }
+        message = {"full_name" => "John Doe"}
         avro.encode(message, schema_name: "person", subject: "people")
         expect(registry).to have_received(:register).with("people", anything)
       end
@@ -327,26 +329,26 @@ describe AvroTurf::Messaging do
   end
 
   context "validating" do
-    subject(:encode){ avro.encode(message, schema_name: "person", validate: true) }
+    subject(:encode) { avro.encode(message, schema_name: "person", validate: true) }
 
     context "for correct message" do
       it { expect { encode }.not_to raise_error }
     end
 
     context "when message has wrong type" do
-      let(:message) { { "full_name" => 123 } }
+      let(:message) { {"full_name" => 123} }
 
       it { expect { encode }.to raise_error(Avro::SchemaValidator::ValidationError, /\.full_name expected type string, got int/) }
     end
 
     context "when message contains extra fields (typo in key)" do
-      let(:message) { { "fulll_name" => "John Doe" } }
+      let(:message) { {"fulll_name" => "John Doe"} }
 
       it { expect { encode }.to raise_error(Avro::SchemaValidator::ValidationError, /extra field 'fulll_name'/) }
     end
   end
 
-  context 'fetching and registering schema' do
+  context "fetching and registering schema" do
     let(:schema_store) { AvroTurf::SchemaStore.new(path: "spec/schemas") }
 
     let(:registry) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
@@ -361,28 +363,39 @@ describe AvroTurf::Messaging do
 
     let(:schema_id) { 234 }
 
-    context 'using fetch_schema' do
+    context "using fetch_schema" do
       subject { avro.fetch_schema(subject: subj, version: version) }
 
-      let(:subj) { 'subject' }
+      let(:subj) { "subject" }
 
-      let(:version) { 'version' }
+      let(:version) { "version" }
 
-      let(:response) { {'id' => schema_id, 'schema' => schema_json} }
+      let(:response) { {"id" => schema_id, "schema" => schema_json} }
 
       before do
         allow(registry).to receive(:subject_version).with(subj, version).and_return(response)
       end
 
-      it 'gets schema from registry' do
+      it "gets schema from registry" do
         expect(subject).to eq([schema, schema_id])
       end
 
+      it "memoizes parsed schema" do
+        expect(registry).to receive(:subject_version).with(subj, version).twice.and_return(response)
+        expect(Avro::Schema).to receive(:parse).with(schema_json).once.and_return(schema)
+
+        first_result = avro.fetch_schema(subject: subj, version: version)
+        second_result = avro.fetch_schema(subject: subj, version: version)
+
+        expect(first_result).to eq([schema, schema_id])
+        expect(second_result).to eq([schema, schema_id])
+      end
+
       context "with an incompatible schema type" do
-        let(:response) { {'id' => schema_id, 'schema' => 'blah', 'schemaType' => schema_type } }
-        let(:schema_type) { 'PROTOBUF' }
+        let(:response) { {"id" => schema_id, "schema" => "blah", "schemaType" => schema_type} }
+        let(:schema_type) { "PROTOBUF" }
 
-        it 'raises IncompatibleSchemaError' do
+        it "raises IncompatibleSchemaError" do
           expect { subject }.to raise_error(
             AvroTurf::IncompatibleSchemaError,
             "The #{schema_type} schema for #{subj} is incompatible."
@@ -391,22 +404,32 @@ describe AvroTurf::Messaging do
       end
     end
 
-    context 'using fetch_schema_by_id' do
+    context "using fetch_schema_by_id" do
       subject { avro.fetch_schema_by_id(schema_id) }
 
       before do
         allow(registry).to receive(:fetch).with(schema_id).and_return(schema_json)
       end
 
-      it 'gets schema from registry' do
+      it "gets schema from registry" do
         expect(subject).to eq([schema, schema_id])
       end
+
+      it "memoizes schema in @schemas_by_id after first call" do
+        expect(registry).to receive(:fetch).with(schema_id).once.and_return(schema_json)
+
+        first_result = avro.fetch_schema_by_id(schema_id)
+        second_result = avro.fetch_schema_by_id(schema_id)
+
+        expect(first_result).to eq([schema, schema_id])
+        expect(second_result).to eq([schema, schema_id])
+      end
     end
 
-    context 'using fetch_schema_by_body' do
-      let(:subject_name) { 'city' }
-      let(:schema_name) { 'city' }
-      let(:namespace) { 'namespace' }
+    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
         {
@@ -426,50 +449,50 @@ describe AvroTurf::Messaging do
         allow(registry).to receive(:check).with(subject_name, city_schema).and_return(city_schema_data)
       end
 
-      it 'gets schema from registry' do
+      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' }
+    context "using register_schema" do
+      let(:schema_name) { "schema_name" }
 
-      let(:namespace) { 'namespace' }
+      let(:namespace) { "namespace" }
 
       before do
         allow(schema_store).to receive(:find).with(schema_name, namespace).and_return(schema)
       end
 
-      context 'when subject is not set' do
+      context "when subject is not set" do
         subject { avro.register_schema(schema_name: schema_name, namespace: namespace) }
 
         before do
           allow(registry).to receive(:register).with(schema.fullname, schema).and_return(schema_id)
         end
 
-        it 'registers schema in registry' do
+        it "registers schema in registry" do
           expect(subject).to eq([schema, schema_id])
         end
       end
 
-      context 'when subject is set' do
+      context "when subject is set" do
         subject { avro.register_schema(schema_name: schema_name, namespace: namespace, subject: subj) }
 
-        let(:subj) { 'subject' }
+        let(:subj) { "subject" }
 
         before do
           allow(registry).to receive(:register).with(subj, schema).and_return(schema_id)
         end
 
-        it 'registers schema in registry' do
+        it "registers schema in registry" do
           expect(subject).to eq([schema, schema_id])
         end
       end
     end
   end
 
-  context 'with a registry path prefix' do
-    let(:path_prefix) { '/prefix' }
+  context "with a registry path prefix" do
+    let(:path_prefix) { "/prefix" }
 
     let(:avro) {
       AvroTurf::Messaging.new(
@@ -489,11 +512,11 @@ describe AvroTurf::Messaging do
     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'
+    it_behaves_like "encoding and decoding with the schema from registry"
+    it_behaves_like "encoding and decoding with the schema_id from registry"
   end
 
-  context 'with a connect timeout' do
+  context "with a connect timeout" do
     let(:avro) {
       AvroTurf::Messaging.new(
         registry_url: registry_url,
@@ -507,16 +530,16 @@ describe AvroTurf::Messaging do
     }
 
     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'
+    it_behaves_like "encoding and decoding with the schema from registry"
+    it_behaves_like "encoding and decoding with the schema_id from registry"
 
-    it 'passes the connect timeout setting to Excon' do
+    it "passes the connect timeout setting to Excon" do
       expect(Excon).to receive(:new).with(anything, hash_including(connect_timeout: 10)).and_call_original
       avro
     end
   end
 
-  context 'with a connect timeout' do
+  context "with a connect timeout" do
     let(:avro) {
       AvroTurf::Messaging.new(
         registry_url: registry_url,
@@ -530,17 +553,17 @@ describe AvroTurf::Messaging do
     }
 
     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'
+    it_behaves_like "encoding and decoding with the schema from registry"
+    it_behaves_like "encoding and decoding with the schema_id from registry"
 
-    it 'passes the connect timeout setting to Excon' do
+    it "passes the connect timeout setting to Excon" do
       expect(Excon).to receive(:new).with(anything, hash_including(retry_limit: 5)).and_call_original
       avro
     end
   end
 
-  context 'with a proxy' do
-    let(:proxy_url) { 'http://proxy.example.com' }
+  context "with a proxy" do
+    let(:proxy_url) { "http://proxy.example.com" }
     let(:avro) {
       AvroTurf::Messaging.new(
         registry_url: registry_url,
@@ -554,18 +577,17 @@ describe AvroTurf::Messaging do
     }
 
     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'
+    it_behaves_like "encoding and decoding with the schema from registry"
+    it_behaves_like "encoding and decoding with the schema_id from registry"
 
-    it 'passes the proxy setting to Excon' do
+    it "passes the proxy setting to Excon" do
       expect(Excon).to receive(:new).with(anything, hash_including(proxy: proxy_url)).and_call_original
       avro
     end
   end
 
-
-  context 'with a custom domain name resolver' do
-    let(:resolv_resolver) { Resolv.new([Resolv::Hosts.new, Resolv::DNS.new(nameserver: ['127.0.0.1', '127.0.0.1'])]) }
+  context "with a custom domain name resolver" do
+    let(:resolv_resolver) { Resolv.new([Resolv::Hosts.new, Resolv::DNS.new(nameserver: ["127.0.0.1", "127.0.0.1"])]) }
     let(:avro) {
       AvroTurf::Messaging.new(
         registry_url: registry_url,
@@ -579,12 +601,36 @@ describe AvroTurf::Messaging do
     }
 
     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'
+    it_behaves_like "encoding and decoding with the schema from registry"
+    it_behaves_like "encoding and decoding with the schema_id from registry"
 
-    it 'passes the domain name resolver setting to Excon' do
+    it "passes the domain name resolver setting to Excon" do
       expect(Excon).to receive(:new).with(anything, hash_including(resolv_resolver: resolv_resolver)).and_call_original
       avro
     end
   end
+
+  context "with a cert chain" do
+    let(:client_chain) { "test client chain" }
+    let(:avro) {
+      AvroTurf::Messaging.new(
+        registry_url: registry_url,
+        schemas_path: "spec/schemas",
+        logger: logger,
+        client_cert: client_cert,
+        client_chain: client_chain,
+        client_key: client_key,
+        client_key_pass: client_key_pass
+      )
+    }
+
+    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"
+
+    it "passes the client chain to Excon" do
+      expect(Excon).to receive(:new).with(anything, hash_including(client_chain: client_chain)).and_call_original
+      avro
+    end
+  end
 end

data/spec/mutable_schema_store_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "avro_turf/mutable_schema_store"
+
+describe AvroTurf::MutableSchemaStore do
+  let(:store) { AvroTurf::MutableSchemaStore.new(path: "spec/schemas") }
+
+  describe "#add_schema" do
+    it "adds a schema to the store" do
+      schema_hash = {
+        "name" => "person",
+        "namespace" => "test.people",
+        "type" => "record",
+        "fields" => [
+          {
+            "type" => "string",
+            "name" => "name"
+          }
+        ]
+      }
+
+      schema = store.add_schema(schema_hash)
+      expect(schema.fullname).to eq "test.people.person"
+      expect(store.schemas["test.people.person"]).to eq schema
+    end
+
+    # This test would fail under avro_turf <= v0.19.0
+    it "does NOT cache *nested* schemas in memory" do
+      schema_hash = {
+        "name" => "person",
+        "namespace" => "test",
+        "type" => "record",
+        "fields" => [
+          {
+            "name" => "address",
+            "type" => {
+              "name" => "address",
+              "type" => "record",
+              "fields" => [
+                {"name" => "addr1", "type" => "string"},
+                {"name" => "addr2", "type" => "string"},
+                {"name" => "city", "type" => "string"},
+                {"name" => "zip", "type" => "string"}
+              ]
+            }
+          }
+        ]
+      }
+
+      schema = store.add_schema(schema_hash)
+      expect(schema.fullname).to eq "test.person"
+      expect(store.schemas["test.person"]).to eq schema
+
+      expect { store.find("address", "test") }
+        .to raise_error(AvroTurf::SchemaNotFoundError)
+    end
+
+    # This test would fail under avro_turf <= v1.19.0
+    it "allows two different schemas to define nested sub-schemas with the same fullname" do
+      person_schema = {
+        "name" => "person",
+        "namespace" => "test",
+        "type" => "record",
+        "fields" => [
+          {
+            "name" => "location",
+            "type" => {
+              "name" => "location",
+              "type" => "record",
+              "fields" => [
+                {"name" => "city", "type" => "string"},
+                {"name" => "zipcode", "type" => "string"}
+              ]
+            }
+          }
+        ]
+      }
+
+      company_schema = {
+        "name" => "company",
+        "namespace" => "test",
+        "type" => "record",
+        "fields" => [
+          {
+            "name" => "headquarters",
+            "type" => {
+              "name" => "location",
+              "type" => "record",
+              "fields" => [
+                {"name" => "city", "type" => "string"},
+                {"name" => "postcode", "type" => "string"}
+              ]
+            }
+          }
+        ]
+      }
+
+      person = store.add_schema(person_schema)
+
+      # This should *NOT* raise the error:
+      # #<Avro::SchemaParseError: The name "test.location" is already in use.>
+      expect { store.add_schema(company_schema) }.not_to raise_error
+
+      company = store.schemas["test.company"]
+
+      person_location_field = person.fields_hash["location"]
+      expect(person_location_field.type.name).to eq("location")
+      expect(person_location_field.type.fields_hash).to include("zipcode")
+      expect(person_location_field.type.fields_hash).not_to include("postcode")
+
+      company_headquarters_field = company.fields_hash["headquarters"]
+      expect(company_headquarters_field.type.name).to eq("location")
+      expect(company_headquarters_field.type.fields_hash).to include("postcode")
+      expect(company_headquarters_field.type.fields_hash).not_to include("zipcode")
+    end
+  end
+
+  describe "#schemas" do
+    it "provides access to the internal schemas hash" do
+      expect(store.schemas).to be_a(Hash)
+      expect(store.schemas).to be_empty
+
+      schema_hash = {
+        "name" => "test",
+        "type" => "record",
+        "fields" => []
+      }
+
+      store.add_schema(schema_hash)
+      expect(store.schemas.size).to eq 1
+      expect(store.schemas["test"]).to be_a(Avro::Schema::RecordSchema)
+    end
+  end
+end