avro_turf 1.14.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1c7e87bc8dc94207072e7d09f7ddc844c31b81d3ff46825fa49b5c2548d316c
-  data.tar.gz: 83b58c9806c7b24096f6c615e5d9e0c260cb1cf37e95e7f87134fbfc8c35bdf1
+  metadata.gz: b361914bf3a0900924b82bebf5d61f155834f08ce43b2ba110cf6f7a86e976f5
+  data.tar.gz: f3ffe6b3820088e478e047df3ac639f8bc331b7baa829f6069911b0a2b1180da
 SHA512:
-  metadata.gz: 4c8e705866a589d86bbfcb44f4715b4fc089968a329fbbdd00b56476f905d096b224d013fb8db115c2c307b438d58e37d3a7be184a46dfdc5bf8cc3d4c9710a5
-  data.tar.gz: deb82d030abf247b7d1616250d964c6ade5c91fa4e8fcf5247d5157d9d013efe387b3255da0b1364855a28a0a7282de8dd1e29b5e616aba63a5f400400049287
+  metadata.gz: f6c4eac8425408913411ab45e25fbbdf94f30c2fd28a273f288dc0bc671d0dd4f65302c880d5eafb4cf7a42bb4c91fd4b9871768644e7fb7ee9344363b1d53ca
+  data.tar.gz: '09590e6ab35dbf5099b2fdb3ac800d3e0b78c6b62b0ecfc18ddee5b0cdf98523edbe3c85bd00a1e6730b6c15caad3d65fef9137e67c440d6904d90e79b16738f'

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## v1.15.0
+
+- Use `default_namespace` from exception to load nested schemas from the correct namespace. (#203)
+- Bump minimum avro version to 1.11.3
+- Add support for schema contexts (#205)
+
 ## v1.14.0
 
 - Add `resolv_resolver` parameter to `AvroTurf::Messaging` to make use of custom domain name resolvers and their options, for example `nameserver` and `timeouts` (#202)

data/README.md

@@ -153,6 +153,10 @@ By default, AvroTurf will encode data in the Avro data file format. This means t
 
 The Messaging API will automatically register schemas used for encoding data, and will fetch the corresponding schema when decoding. Instead of including the full schema in the output, only a schema id generated by the registry is included. Registering the same schema twice is idempotent, so no coordination is needed.
 
+An optional `schema_context` parameter allows the registry to be scoped to a
+[schema context](https://docs.confluent.io/platform/7.5/schema-registry/schema-linking-cp.html#schema-contexts).
+If there is a need to access multiple contexts, you will need to use multiple instances of `ConfluentSchemaRegistry`.
+
 **NOTE:** [The Messaging format](https://github.com/confluentinc/schema-registry/blob/master/docs/serializer-formatter.rst#wire-format) is _not_ compatible with the Avro data file API.
 
 The Messaging API is not included by default, so you must require 'avro_turf/messaging' explicitly if you want to use it.

data/avro_turf.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "avro", ">= 1.8.0", "< 1.12"
+  spec.add_dependency "avro", ">= 1.11.3", "< 1.12"
   spec.add_dependency "excon", "~> 0.104"
 
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/avro_turf/confluent_schema_registry.rb

@@ -5,6 +5,7 @@ class AvroTurf::ConfluentSchemaRegistry
 
   def initialize(
     url,
+    schema_context: nil,
     logger: Logger.new($stdout),
     proxy: nil,
     user: nil,
@@ -20,6 +21,8 @@ class AvroTurf::ConfluentSchemaRegistry
     resolv_resolver: nil
   )
     @path_prefix = path_prefix
+    @schema_context_prefix = schema_context.nil? ? '' : ":.#{schema_context}:"
+    @schema_context_options = schema_context.nil? ? {} : {query: {subject: @schema_context_prefix}}
     @logger = logger
     headers = Excon.defaults[:headers].merge(
       "Content-Type" => CONTENT_TYPE
@@ -43,16 +46,16 @@ class AvroTurf::ConfluentSchemaRegistry
 
   def fetch(id)
     @logger.info "Fetching schema with id #{id}"
-    data = get("/schemas/ids/#{id}", idempotent: true)
+    data = get("/schemas/ids/#{id}", idempotent: true, **@schema_context_options, )
     data.fetch("schema")
   end
 
   def register(subject, schema)
-    data = post("/subjects/#{subject}/versions", body: { schema: schema.to_s }.to_json)
+    data = post("/subjects/#{@schema_context_prefix}#{subject}/versions", body: { schema: schema.to_s }.to_json)
 
     id = data.fetch("id")
 
-    @logger.info "Registered schema for subject `#{subject}`; id = #{id}"
+    @logger.info "Registered schema for subject `#{@schema_context_prefix}#{subject}`; id = #{id}"
 
     id
   end
@@ -64,22 +67,22 @@ class AvroTurf::ConfluentSchemaRegistry
 
   # List all versions for a subject
   def subject_versions(subject)
-    get("/subjects/#{subject}/versions", idempotent: true)
+    get("/subjects/#{@schema_context_prefix}#{subject}/versions", idempotent: true)
   end
 
   # Get a specific version for a subject
   def subject_version(subject, version = 'latest')
-    get("/subjects/#{subject}/versions/#{version}", idempotent: true)
+    get("/subjects/#{@schema_context_prefix}#{subject}/versions/#{version}", idempotent: true)
   end
 
   # Get the subject and version for a schema id
   def schema_subject_versions(schema_id)
-    get("/schemas/ids/#{schema_id}/versions", idempotent: true)
+    get("/schemas/ids/#{schema_id}/versions", idempotent: true, **@schema_context_options)
   end
 
   # Check if a schema exists. Returns nil if not found.
   def check(subject, schema)
-    data = post("/subjects/#{subject}",
+    data = post("/subjects/#{@schema_context_prefix}#{subject}",
                 expects: [200, 404],
                 body: { schema: schema.to_s }.to_json,
                 idempotent: true)
@@ -93,7 +96,7 @@ class AvroTurf::ConfluentSchemaRegistry
   # - false if incompatible
   # 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}",
+    data = post("/compatibility/subjects/#{@schema_context_prefix}#{subject}/versions/#{version}",
                 expects: [200, 404], body: { schema: schema.to_s }.to_json, idempotent: true)
     data.fetch('is_compatible', false) unless data.has_key?('error_code')
   end
@@ -110,12 +113,12 @@ class AvroTurf::ConfluentSchemaRegistry
 
   # Get config for subject
   def subject_config(subject)
-    get("/config/#{subject}", idempotent: true)
+    get("/config/#{@schema_context_prefix}#{subject}", idempotent: true)
   end
 
   # Update config for subject
   def update_subject_config(subject, config)
-    put("/config/#{subject}", body: config.to_json, idempotent: true)
+    put("/config/#{@schema_context_prefix}#{subject}", body: config.to_json, idempotent: true)
   end
 
   private

data/lib/avro_turf/messaging.rb

@@ -41,6 +41,7 @@ class AvroTurf
     # 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_context       - Schema registry context name (optional)
     # 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.
@@ -60,6 +61,7 @@ class AvroTurf
     def initialize(
       registry: nil,
       registry_url: nil,
+      schema_context: nil,
       schema_store: nil,
       schemas_path: nil,
       namespace: nil,
@@ -83,6 +85,7 @@ class AvroTurf
       @registry = registry || CachedConfluentSchemaRegistry.new(
         ConfluentSchemaRegistry.new(
           registry_url,
+          schema_context: schema_context,
           logger: @logger,
           proxy: proxy,
           user: user,

data/lib/avro_turf/schema_store.rb

@@ -74,7 +74,7 @@ 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!(e.type_name, local_schemas_cache)
+    load_schema!(::Avro::Name.make_fullname(e.type_name, e.default_namespace), 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

data/lib/avro_turf/test/fake_confluent_schema_registry_server.rb

@@ -1,8 +1,13 @@
 require 'sinatra/base'
 
 class FakeConfluentSchemaRegistryServer < Sinatra::Base
-  SUBJECTS = Hash.new { Array.new }
-  SCHEMAS = []
+  QUALIFIED_SUBJECT = /
+      :(?<context>\.[^:]*)
+      :(?<subject>.*)
+    /x
+  DEFAULT_CONTEXT = '.'
+  SUBJECTS = Hash.new { |hash, key| hash[key] = Hash.new { Array.new } }
+  SCHEMAS = Hash.new { |hash, key| hash[key] = Array.new }
   CONFIGS = Hash.new
   SUBJECT_NOT_FOUND = { error_code: 40401, message: 'Subject not found' }.to_json.freeze
   VERSION_NOT_FOUND = { error_code: 40402, message: 'Version not found' }.to_json.freeze
@@ -33,17 +38,17 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     end
   end
 
-  post "/subjects/:subject/versions" do
+  post "/subjects/:qualified_subject/versions" do
     schema = parse_schema
-    schema_id = SCHEMAS.index(schema)
+    context, subject = parse_qualified_subject(params[:qualified_subject])
+    schema_id = SCHEMAS[context].index(schema)
     if schema_id.nil?
-      SCHEMAS << schema
-      schema_id = SCHEMAS.size - 1
+      SCHEMAS[context] << schema
+      schema_id = SCHEMAS[context].size - 1
     end
 
-    subject = params[:subject]
-    unless SUBJECTS[subject].include?(schema_id)
-      SUBJECTS[subject] = SUBJECTS[subject] << schema_id
+    unless SUBJECTS[context][subject].include?(schema_id)
+      SUBJECTS[context][subject] = SUBJECTS[context][subject] << schema_id
     end
 
     { id: schema_id }.to_json
@@ -51,37 +56,46 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
 
   get "/schemas/ids/:schema_id/versions" do
     schema_id = params[:schema_id].to_i
-    schema = SCHEMAS.at(schema_id)
+    context, _subject = parse_qualified_subject(params[:subject])
+    schema = SCHEMAS[context].at(schema_id)
     halt(404, SCHEMA_NOT_FOUND) unless schema
 
-    related_subjects = SUBJECTS.select {|_, vs| vs.include? schema_id }
+    related_subjects = SUBJECTS[context].select {|_, vs| vs.include? schema_id }
 
     related_subjects.map do |subject, versions|
       {
-        subject: subject,
+        subject: qualify_subject(context, subject),
         version: versions.find_index(schema_id) + 1
       }
     end.to_json
   end
 
   get "/schemas/ids/:schema_id" do
-    schema = SCHEMAS.at(params[:schema_id].to_i)
+    context, _subject = parse_qualified_subject(params[:subject])
+    schema = SCHEMAS[context].at(params[:schema_id].to_i)
     halt(404, SCHEMA_NOT_FOUND) unless schema
     { schema: schema }.to_json
   end
 
   get "/subjects" do
-    SUBJECTS.keys.to_json
+    subject_names = SUBJECTS.reduce([]) do |acc, args|
+      context, subjects = args
+      subjects.keys.each { |subject| acc << (context == '.' ? subject : ":#{context}:#{subject}") }
+      acc
+    end
+    subject_names.to_json
   end
 
-  get "/subjects/:subject/versions" do
-    schema_ids = SUBJECTS[params[:subject]]
+  get "/subjects/:qualified_subject/versions" do
+    context, subject = parse_qualified_subject(params[:qualified_subject])
+    schema_ids = SUBJECTS[context][subject]
     halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
     (1..schema_ids.size).to_a.to_json
   end
 
-  get "/subjects/:subject/versions/:version" do
-    schema_ids = SUBJECTS[params[:subject]]
+  get "/subjects/:qualified_subject/versions/:version" do
+    context, subject = parse_qualified_subject(params[:qualified_subject])
+    schema_ids = SUBJECTS[context][subject]
     halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
 
     schema_id = if params[:version] == 'latest'
@@ -91,29 +105,30 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
                 end
     halt(404, VERSION_NOT_FOUND) unless schema_id
 
-    schema = SCHEMAS.at(schema_id)
+    schema = SCHEMAS[context].at(schema_id)
 
     {
-      name: params[:subject],
+      subject: params[:qualified_subject],
       version: schema_ids.index(schema_id) + 1,
       id: schema_id,
       schema: schema
     }.to_json
   end
 
-  post "/subjects/:subject" do
+  post "/subjects/:qualified_subject" do
     schema = parse_schema
 
     # Note: this does not actually handle the same schema registered under
     # multiple subjects
-    schema_id = SCHEMAS.index(schema)
+    context, subject = parse_qualified_subject(params[:qualified_subject])
+    schema_id = SCHEMAS[context].index(schema)
 
     halt(404, SCHEMA_NOT_FOUND) unless schema_id
 
     {
-      subject: params[:subject],
+      subject: params[:qualified_subject],
       id: schema_id,
-      version: SUBJECTS[params[:subject]].index(schema_id) + 1,
+      version: SUBJECTS[context][subject].index(schema_id) + 1,
       schema: schema
     }.to_json
   end
@@ -150,4 +165,19 @@ class FakeConfluentSchemaRegistryServer < Sinatra::Base
     CONFIGS.clear
     @global_config = DEFAULT_GLOBAL_CONFIG.dup
   end
+
+  private
+
+  def parse_qualified_subject(qualified_subject)
+    match = QUALIFIED_SUBJECT.match(qualified_subject)
+    if !match.nil?
+      match.named_captures.values_at('context', 'subject')
+    else
+      [ DEFAULT_CONTEXT, qualified_subject]
+    end
+  end
+
+  def qualify_subject(context, subject)
+    context == "." ? subject : ":#{context}:#{subject}"
+  end
 end

data/lib/avro_turf/test/fake_prefixed_confluent_schema_registry_server.rb

@@ -1,43 +1,45 @@
 require 'sinatra/base'
 
 class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
+  DEFAULT_CONTEXT='.'
+
   post "/prefix/subjects/:subject/versions" do
     schema = parse_schema
-    ids_for_subject = SUBJECTS[params[:subject]]
+    ids_for_subject = SUBJECTS[DEFAULT_CONTEXT][params[:subject]]
 
     schemas_for_subject =
-      SCHEMAS.select
+      SCHEMAS[DEFAULT_CONTEXT].select
              .with_index { |_, i| ids_for_subject.include?(i) }
 
     if schemas_for_subject.include?(schema)
-      schema_id = SCHEMAS.index(schema)
+      schema_id = SCHEMAS[DEFAULT_CONTEXT].index(schema)
     else
-      SCHEMAS << schema
-      schema_id = SCHEMAS.size - 1
-      SUBJECTS[params[:subject]] = SUBJECTS[params[:subject]] << schema_id
+      SCHEMAS[DEFAULT_CONTEXT] << schema
+      schema_id = SCHEMAS[DEFAULT_CONTEXT].size - 1
+      SUBJECTS[DEFAULT_CONTEXT][params[:subject]] = SUBJECTS[DEFAULT_CONTEXT][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)
+    schema = SCHEMAS[DEFAULT_CONTEXT].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
+    SUBJECTS[DEFAULT_CONTEXT].keys.to_json
   end
 
   get "/prefix/subjects/:subject/versions" do
-    schema_ids = SUBJECTS[params[:subject]]
+    schema_ids = SUBJECTS[DEFAULT_CONTEXT][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]]
+    schema_ids = SUBJECTS[DEFAULT_CONTEXT][params[:subject]]
     halt(404, SUBJECT_NOT_FOUND) if schema_ids.empty?
 
     schema_id = if params[:version] == 'latest'
@@ -47,7 +49,7 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
                 end
     halt(404, VERSION_NOT_FOUND) unless schema_id
 
-    schema = SCHEMAS.at(schema_id)
+    schema = SCHEMAS[DEFAULT_CONTEXT].at(schema_id)
 
     {
       name: params[:subject],
@@ -69,7 +71,7 @@ class FakePrefixedConfluentSchemaRegistryServer < FakeConfluentSchemaRegistrySer
     {
       subject: params[:subject],
       id: schema_id,
-      version: SUBJECTS[params[:subject]].index(schema_id) + 1,
+      version: SUBJECTS[DEFAULT_CONTEXT][params[:subject]].index(schema_id) + 1,
       schema: schema
     }.to_json
   end

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "1.14.0"
+  VERSION = "1.15.0"
 end

data/spec/confluent_schema_registry_spec.rb

@@ -10,36 +10,56 @@ describe AvroTurf::ConfluentSchemaRegistry do
   let(:client_key_pass) { "test client key password" }
   let(:connect_timeout) { 10 }
 
-  it_behaves_like "a confluent schema registry client" do
-    let(:registry) {
-      described_class.new(
-        registry_url,
-        logger: logger,
-        client_cert: client_cert,
-        client_key: client_key,
-        client_key_pass: client_key_pass
-      )
-    }
+  context 'authenticated by cert' do
+    it_behaves_like "a confluent schema registry client" do
+      let(:registry) {
+        described_class.new(
+          registry_url,
+          logger: logger,
+          client_cert: client_cert,
+          client_key: client_key,
+          client_key_pass: client_key_pass
+        )
+      }
+    end
   end
 
-  it_behaves_like "a confluent schema registry client" do
-    let(:registry) {
-      described_class.new(
-        registry_url,
-        user: user,
-        password: password,
-      )
-    }
+  context 'authenticated by basic auth' do
+    it_behaves_like "a confluent schema registry client" do
+      let(:registry) {
+        described_class.new(
+          registry_url,
+          user: user,
+          password: password,
+        )
+      }
+    end
   end
 
-  it_behaves_like "a confluent schema registry client" do
-    let(:registry) {
-      described_class.new(
-        registry_url,
-        user: user,
-        password: password,
-        connect_timeout: connect_timeout
-      )
-    }
+  context 'with connect_timeout' do
+    it_behaves_like "a confluent schema registry client" do
+      let(:registry) {
+        described_class.new(
+          registry_url,
+          user: user,
+          password: password,
+          connect_timeout: connect_timeout
+        )
+      }
+    end
+  end
+
+  context 'with non default schema_context' do
+    it_behaves_like "a confluent schema registry client", schema_context: 'other' do
+      let(:registry) {
+        described_class.new(
+          registry_url,
+          schema_context: 'other',
+          user: user,
+          password: password,
+          connect_timeout: connect_timeout
+        )
+      }
+    end
   end
 end

data/spec/schema_store_spec.rb

@@ -26,6 +26,35 @@ describe AvroTurf::SchemaStore do
       expect(schema.fullname).to eq "message"
     end
 
+    it 'searches for nested types with the correct namespace' do
+      define_schema "foo/bar.avsc", <<-AVSC
+        {
+          "type": "record",
+          "namespace": "foo",
+          "name": "bar",
+          "fields": [
+            {
+              "name": "another",
+              "type": "another_schema"
+            }     
+          ]
+        }
+      AVSC
+
+      define_schema "foo/another_schema.avsc", <<-AVSC
+        {
+          "namespace": "foo",
+          "name": "another_schema", 
+          "type": "record",
+          "fields": [ { "name": "str", "type": "string" } ]
+        }
+      AVSC
+
+      schema = store.find('foo.bar')
+      expect(schema.fullname).to eq "foo.bar"
+      expect(schema.fields.first.type.fullname).to eq "foo.another_schema"
+    end
+
     it "resolves missing references when nested schema is not a named type" do
       define_schema "root.avsc", <<-AVSC
         {

data/spec/spec_helper.rb

@@ -9,7 +9,10 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 module Helpers
   def define_schema(path, content)
-    File.open(File.join("spec/schemas", path), "w") do |f|
+    file = File.join("spec/schemas", path)
+    dir = File.dirname(file)
+    FileUtils.mkdir_p(dir)
+    File.open(file, "w") do |f|
       f.write(content)
     end
   end

data/spec/support/confluent_schema_registry_context.rb

@@ -1,9 +1,10 @@
 # This shared example expects a registry variable to be defined
 # with an instance of the registry class being tested.
-shared_examples_for "a confluent schema registry client" do
+shared_examples_for "a confluent schema registry client" do |schema_context: nil|
   let(:logger) { Logger.new(StringIO.new) }
   let(:registry_url) { "http://registry.example.com" }
   let(:subject_name) { "some-subject" }
+  let(:expected_subject_name) { with_schema_context_if_applicable(schema_context, subject_name) }
   let(:schema) do
     {
       type: "record",
@@ -72,8 +73,9 @@ shared_examples_for "a confluent schema registry client" do
   describe "#subjects" do
     it "lists the subjects in the registry" do
       subjects = Array.new(2) { |n| "subject#{n}" }
+      expected_subjects = subjects.map { |subject| with_schema_context_if_applicable(schema_context, subject) }
       subjects.each { |subject| registry.register(subject, schema) }
-      expect(registry.subjects).to be_json_eql(subjects.to_json)
+      expect(registry.subjects).to be_json_eql(expected_subjects.to_json)
     end
   end
 
@@ -81,16 +83,17 @@ shared_examples_for "a confluent schema registry client" do
     it "returns subject and version for a schema id" do
       schema_id1 = registry.register(subject_name, { type: :record, name: "r1", fields: [] }.to_json)
       registry.register(subject_name, { type: :record, name: "r2", fields: [] }.to_json)
-      schema_id2 = registry.register("other#{subject_name}", { type: :record, name: "r2", fields: [] }.to_json)
+      other_subject_name = "other#{subject_name}"
+      schema_id2 = registry.register(other_subject_name, { type: :record, name: "r2", fields: [] }.to_json)
       expect(registry.schema_subject_versions(schema_id1)).to eq([
-        'subject' => subject_name,
+        'subject' => expected_subject_name,
         'version' => 1
       ])
       expect(registry.schema_subject_versions(schema_id2)).to include({
-        'subject' => subject_name,
+        'subject' => expected_subject_name,
         'version' => 2
       },{
-        'subject' => "other#{subject_name}",
+        'subject' => with_schema_context_if_applicable(schema_context, other_subject_name),
         'version' => 1
       } )
     end
@@ -135,7 +138,7 @@ shared_examples_for "a confluent schema registry client" do
 
     let(:expected) do
       {
-        name: subject_name,
+        subject: expected_subject_name,
         version: 1,
         id: schema_id1,
         schema: { type: :record, name: "r0", fields: [] }.to_json
@@ -150,7 +153,7 @@ shared_examples_for "a confluent schema registry client" do
     context "when the version is not specified" do
       let(:expected) do
         {
-          name: subject_name,
+          subject: expected_subject_name,
           version: 2,
           id: schema_id2,
           schema: { type: :record, name: "r1", fields: [] }.to_json
@@ -185,7 +188,7 @@ shared_examples_for "a confluent schema registry client" do
       let!(:schema_id) { registry.register(subject_name, schema) }
       let(:expected) do
         {
-          subject: subject_name,
+          subject: expected_subject_name,
           id: schema_id,
           version: 1,
           schema: schema
@@ -289,4 +292,8 @@ shared_examples_for "a confluent schema registry client" do
       end.to_json(*args)
     end
   end
+
+  def with_schema_context_if_applicable(schema_context, subject_name)
+    schema_context.nil? ? subject_name : ":.#{schema_context}:#{subject_name}"
+  end
 end

data/spec/test/fake_confluent_schema_registry_server_spec.rb

@@ -6,66 +6,55 @@ describe FakeConfluentSchemaRegistryServer do
 
   def app; described_class; end
 
-  let(:schema) do
-    {
-      type: "record",
-      name: "person",
-      fields: [
-        { name: "name", type: "string" }
-      ]
-    }.to_json
-  end
-
   describe 'POST /subjects/:subject/versions' do
     it 'returns the same schema ID when invoked with same schema and same subject' do
-      post '/subjects/person/versions', { schema: schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/person/versions', { schema: schema(name: "person") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       expected_id = JSON.parse(last_response.body).fetch('id')
 
-      post '/subjects/person/versions', { schema: schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/person/versions', { schema: schema(name: "person") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       expect(JSON.parse(last_response.body).fetch('id')).to eq expected_id
     end
 
     it 'returns the same schema ID when invoked with same schema and different subject' do
-      post '/subjects/person/versions', { schema: schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/person/versions', { schema: schema(name: "person") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       original_id = JSON.parse(last_response.body).fetch('id')
 
-      post '/subjects/happy-person/versions', { schema: schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/happy-person/versions', { schema: schema(name: "person") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       expect(JSON.parse(last_response.body).fetch('id')).to eq original_id
     end
 
     it 'returns a different schema ID when invoked with a different schema' do
-      post '/subjects/person/versions', { schema: schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/person/versions', { schema: schema(name: "person") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       original_id = JSON.parse(last_response.body).fetch('id')
 
-      other_schema = {
-        type: "record",
-        name: "other",
-        fields: [
-          { name: "name", type: "string" }
-        ]
-      }.to_json
-
-      post '/subjects/person/versions', { schema: other_schema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/person/versions', { schema: schema(name: "other") }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
 
       expect(JSON.parse(last_response.body).fetch('id')).to_not eq original_id
     end
+
+    context 'with a clean registry' do
+      before do
+        FakeConfluentSchemaRegistryServer.clear
+      end
+
+      it 'assigns same schema id for different schemas in different contexts' do
+        post '/subjects/:.context1:cats/versions', { schema: schema(name: 'name1') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+        schema1_id = JSON.parse(last_response.body).fetch('id') # Original cats schema
+
+        post '/subjects/:.context2:dogs/versions', { schema: schema(name: 'name2') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+        schema2_id = JSON.parse(last_response.body).fetch('id') # Original cats schema
+
+        expect(schema1_id).to eq(schema2_id)
+      end
+    end
   end
 
   describe 'GET /schemas/ids/:id/versions' do
-    def schema(name:)
-      {
-        type: "record",
-        name: name,
-        fields: [
-          { name: "name", type: "string" },
-        ]
-      }.to_json
-    end
 
     it "returns array containing subjects and versions for given schema id" do
       schema1 = schema(name: "name1")
@@ -97,5 +86,143 @@ describe FakeConfluentSchemaRegistryServer do
         'version' => 1
       })
     end
+
+    describe 'schema registry contexts' do
+      it 'allows different schemas to have same schema version', :aggregate_failures do
+        petSchema = schema(name: 'pet_cat')
+        animalSchema = schema(name: 'animal_cat')
+
+        post '/subjects/:.pets:cats/versions', { schema: petSchema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+        pet_id = JSON.parse(last_response.body).fetch('id') # Context1 cats schema
+
+        post '/subjects/:.animals:cats/versions', { schema: animalSchema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+        animal_id = JSON.parse(last_response.body).fetch('id') # Context2 cats schema
+
+        get "/schemas/ids/#{pet_id}/versions?subject=:.pets:"
+        result = JSON.parse(last_response.body)
+
+        expect(result).to eq [{
+          'subject' => ':.pets:cats',
+          'version' => 1
+        }]
+
+        get "/schemas/ids/#{animal_id}/versions?subject=:.animals:"
+        result = JSON.parse(last_response.body)
+
+        expect(result).to eq [{
+          'subject' => ':.animals:cats',
+          'version' => 1
+        }]
+      end
+    end
+  end
+
+  describe 'GET /schemas/ids/:schema_id' do
+    it 'returns schema by id', :aggregate_failures do
+      petSchema = schema(name: 'pet_ferret')
+
+      post '/subjects/ferret/versions', { schema: petSchema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      pet_id = JSON.parse(last_response.body).fetch('id')
+
+      get "/schemas/ids/#{pet_id}"
+      result = JSON.parse(last_response.body)
+
+      expect(result['schema']).to eq(petSchema)
+
+      get "/schemas/ids/#{pet_id}?subject=:.:"
+      default_context_result = JSON.parse(last_response.body)
+
+      expect(default_context_result['schema']).to eq(petSchema)
+    end
+
+    it 'returns schema by id from a non default context' do
+      petSchema = schema(name: 'pet_ferret_too')
+
+      post '/subjects/:.pets:ferret/versions', { schema: petSchema }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      pet_id = JSON.parse(last_response.body).fetch('id')
+
+      get "/schemas/ids/#{pet_id}?subject=:.pets:"
+      result = JSON.parse(last_response.body)
+
+      expect(result['schema']).to eq(petSchema)
+    end
+  end
+
+  describe 'GET /subjects' do
+    context 'with a clean registry' do
+      before do
+        FakeConfluentSchemaRegistryServer.clear
+      end
+
+      it "returns subjects from all contexts", :aggregate_failures do
+        post '/subjects/ferret/versions', { schema: schema(name: 'ferret') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+        post '/subjects/:.pets:cat/versions', { schema: schema(name: 'pet_cat') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+
+        get "/subjects"
+        result = JSON.parse(last_response.body)
+
+        expect(result).to include('ferret')
+        expect(result).to include(':.pets:cat')
+      end
+    end
+  end
+
+  describe 'GET /subjects/:subject/versions' do
+    it 'returns versions of the schema' do
+      post '/subjects/gerbil/versions', { schema: schema(name: 'v1') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/gerbil/versions', { schema: schema(name: 'v2') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+
+      get "/subjects/gerbil/versions"
+      result = JSON.parse(last_response.body)
+
+      expect(result).to include(1)
+      expect(result).to include(2)
+    end
+
+    it 'returns does not see versions ion another context' do
+      post '/subjects/gerbil/versions', { schema: schema(name: 'v1') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      post '/subjects/:.test:gerbil/versions', { schema: schema(name: 'v2') }.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+
+      get "/subjects/:.test:gerbil/versions"
+      result = JSON.parse(last_response.body)
+
+      expect(result).to include(1)
+    end
+  end
+
+  describe 'GET /subjects/:subject/versions/:version', :aggregate_failures do
+    it 'returns the schema by version' do
+      schema1 = schema(name: 'v1')
+      post '/subjects/gerbil/versions', { schema: schema1}.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      id1 = JSON.parse(last_response.body).fetch('id')
+
+      schema2 = schema(name: 'v2')
+      post '/subjects/gerbil/versions', { schema: schema2}.to_json, 'CONTENT_TYPE' => 'application/vnd.schemaregistry+json'
+      id2 = JSON.parse(last_response.body).fetch('id')
+
+      get '/subjects/gerbil/versions/1'
+      result = JSON.parse(last_response.body)
+      expect(result['subject']).to eq('gerbil')
+      expect(result['version']).to eq(1)
+      expect(result['id']).to eq(id1)
+      expect(result['schema']).to eq(schema1)
+
+      get '/subjects/gerbil/versions/2'
+      result = JSON.parse(last_response.body)
+      expect(result['subject']).to eq('gerbil')
+      expect(result['version']).to eq(2)
+      expect(result['id']).to eq(id2)
+      expect(result['schema']).to eq(schema2)
+    end
+  end
+
+  def schema(name:)
+    {
+      type: "record",
+      name: name,
+      fields: [
+        { name: "name", type: "string" },
+      ]
+    }.to_json
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 1.15.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2023-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.11.3
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.12'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.11.3
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.12'