avro_turf 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0df3c290be95bcafd27a4473ba75df36a5275a6b
-  data.tar.gz: 17e1a0283f0479c60a691d3c52e33fb8eaf3f30c
+  metadata.gz: a708b9aabeca7d45e1db532e180b2d80e4a5aecb
+  data.tar.gz: acb21f2435fd5126efed47803395d84eb4f5a220
 SHA512:
-  metadata.gz: 7df0d445557d08c28a9a6e0357dea7b76159846ab3f3e456b1200e4a28c84bb1853727d4259bcf94432567f8031cfb34e80b30963b5fb1e1f43fff5ce0a52e1e
-  data.tar.gz: 144873d0859cb6c937898b94ca3649dca34284b9fa16ebaa122244faef4c20d838c871ab51ecf91c9c69d803d84fd55215867544ac57d5283a86b18fbc8ffc9f
+  metadata.gz: 4bcc5e9832804eafb4f295a6fc85273a5a52c17a515f87ab3da0deb31034ed428c6aaee3754abcaa45d78d37daf6062c6c1d1007644f8578e2561b17f70f1614
+  data.tar.gz: 89071ed406d0be937344cc70814499e29206f05e52484fd4ba4f797f12bcb9236c36c4b080f22ffedd815ac3f6081e13405cb10fa1dc4184cfe73c8bbb279952

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# avro_turf
+
+## v0.8.0
+- The names `AvroTurf::SchemaRegistry`, `AvroTurf::CachedSchemaRegistry`, and
+  `FakeSchemaRegistryServer` are deprecated and will be removed in a future release.
+  Use `AvroTurf::ConfluentSchemaRegistry`, `AvroTurf::CachedConfluentSchemaRegistry`,
+  and `FakeConfluentSchemaRegistryServer` instead.
+- Add support for the Config API (http://docs.confluent.io/3.1.2/schema-registry/docs/api.html#config)
+  to `AvroTurf::ConfluentSchemaRegistry`.

data/README.md

@@ -5,6 +5,17 @@ AvroTurf is a library that makes it easier to encode and decode data using the [
 * Provides an idiomatic Ruby interface.
 * Allows referencing schemas defined in another file.
 
+## Deprecation Notice
+
+The `AvroTurf::SchemaRegistry`, `AvroTurf::CachedSchemaRegistry`,
+and `FakeSchemaRegistryServer` names have been deprecated because the Avro spec recently
+introduced an incompatible [single-message encoding format](https://github.com/apache/avro/commit/30408a9c192c5f4eaaf42f01f0ffbfffd705aa57).
+
+These classes have been renamed to `AvroTurf::ConfluentSchemaRegistry`,
+`AvroTurf::CachedConfluentSchemaRegistry`, and `FakeConfluentSchemaRegistry`.
+
+The aliases for the original names will be removed in a future release.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -80,11 +91,8 @@ In the example above, the `person` schema references the `address` schema, even
 ```json
 // person_list.avsc
 {
-  "name": "person_list",
-  "type": {
-    "type": "array",
-    "items": "person"
-  }
+  "type": "array",
+  "items": "person"
 }
 ```
 
@@ -121,11 +129,14 @@ data = avro.encode({ "title" => "hello, world" }, schema_name: "greeting")
 avro.decode(data) #=> { "title" => "hello, world" }
 ```
 
-In addition to encoding and decoding data, you can check whether a schema is compatible
-with a subject in the registry using the [Compatibility API](http://docs.confluent.io/2.0.0/schema-registry/docs/api.html#compatibility)
+### Confluent Schema Registry Client
+
+The ConfluentSchemaRegistry client used by the Messaging API can also be used directly.
+It can check whether a schema is compatible with a subject in the registry using the [Compatibility API](http://docs.confluent.io/3.1.2/schema-registry/docs/api.html#compatibility):
 
 ```ruby
-require 'avro_turf/messaging'
+require 'avro_turf'
+require 'avro_turf/confluent_schema_registry'
 
 schema = <<-JSON
 {
@@ -144,15 +155,22 @@ schema = <<-JSON
 }
 JSON
 
-avro = AvroTurf::Messaging.new(registry_url: "http://my-registry:8081/")
+registry = AvroTurf::ConfluentSchemaRegistry.new("http://my-registry:8081/")
+
+# Returns true if the schema is compatible, nil if the subject or version is not registered, and false if incompatible.
+registry.compatible?("person", schema)
+```
 
-# Returns true if the schema is compatible, false otherwise.
-avro.compatible?("person", schema)
+The ConfluentSchemaRegistry client can also change the global compatibility level or the compatibility level for an individual subject using the [Config API](http://docs.confluent.io/3.1.2/schema-registry/docs/api.html#config):
+
+```ruby
+registry.update_global_config(compatibility: 'FULL')
+registry.update_subject_config("person", compatibility: 'NONE')
 ```
 
 ### Testing Support
 
-AvroTurf includes a `FakeSchemaRegistryServer` that can be used in tests. The
+AvroTurf includes a `FakeConfluentSchemaRegistryServer` that can be used in tests. The
 fake schema registry server depends on Sinatra but it is _not_ listed as a runtime
 dependency for AvroTurf. Sinatra must be added to your Gemfile or gemspec in order
 to use the fake server.
@@ -160,14 +178,14 @@ to use the fake server.
 Example using RSpec:
 
 ```ruby
-require 'avro_turf/test/fake_schema_registry_server'
+require 'avro_turf/test/fake_confluent_schema_registry_server'
 require 'webmock/rspec'
 
 # within an example
 let(:registry_url) { "http://registry.example.com" }
 before do
-  stub_request(:any, /^#{registry_url}/).to_rack(FakeSchemaRegistryServer)
-  FakeSchemaRegistryServer.clear
+  stub_request(:any, /^#{registry_url}/).to_rack(FakeConfluentSchemaRegistryServer)
+  FakeConfluentSchemaRegistryServer.clear
 end
 
 # Messaging objects created with the same registry_url will now use the fake server.

data/avro_turf.gemspec

@@ -27,4 +27,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "webmock"
   spec.add_development_dependency "sinatra"
   spec.add_development_dependency "json_spec"
+
+  spec.post_install_message = %{
+avro_turf v0.8.0 deprecates the names AvroTurf::SchemaRegistry,
+AvroTurf::CachedSchemaRegistry, and FakeSchemaRegistryServer.
+
+Use AvroTurf::ConfluentSchemaRegistry, AvroTurf::CachedConfluentSchemaRegistry,
+and FakeConfluentSchemaRegistryServer instead.
+
+See https://github.com/dasch/avro_turf#deprecation-notice
+}
 end

data/lib/avro_turf/cached_confluent_schema_registry.rb

@@ -0,0 +1,27 @@
+require 'avro_turf/confluent_schema_registry'
+
+# Caches registrations and lookups to the schema registry in memory.
+class AvroTurf::CachedConfluentSchemaRegistry
+
+  def initialize(upstream)
+    @upstream = upstream
+    @schemas_by_id = {}
+    @ids_by_schema = {}
+  end
+
+  # Delegate the following methods to the upstream
+  %i(subjects subject_versions subject_version check compatible?
+     global_config update_global_config subject_config update_subject_config).each do |name|
+    define_method(name) do |*args|
+      instance_variable_get(:@upstream).send(name, *args)
+    end
+  end
+
+  def fetch(id)
+    @schemas_by_id[id] ||= @upstream.fetch(id)
+  end
+
+  def register(subject, schema)
+    @ids_by_schema[subject + schema.to_s] ||= @upstream.register(subject, schema)
+  end
+end

data/lib/avro_turf/cached_schema_registry.rb

@@ -1,26 +1,6 @@
-require 'avro_turf/schema_registry'
+require 'avro_turf/cached_confluent_schema_registry'
 
-# Caches registrations and lookups to the schema registry in memory.
-class AvroTurf::CachedSchemaRegistry
+# AvroTurf::CachedSchemaRegistry is deprecated and will be removed in a future release.
+# Use AvroTurf::CachedConfluentSchemaRegistry instead.
 
-  def initialize(upstream)
-    @upstream = upstream
-    @schemas_by_id = {}
-    @ids_by_schema = {}
-  end
-
-  # Delegate the following methods to the upstream
-  %i(subjects subject_versions subject_version check compatible?).each do |name|
-    define_method(name) do |*args|
-      instance_variable_get(:@upstream).send(name, *args)
-    end
-  end
-
-  def fetch(id)
-    @schemas_by_id[id] ||= @upstream.fetch(id)
-  end
-
-  def register(subject, schema)
-    @ids_by_schema[subject + schema.to_s] ||= @upstream.register(subject, schema)
-  end
-end
+AvroTurf::CachedSchemaRegistry = AvroTurf::CachedConfluentSchemaRegistry

data/lib/avro_turf/confluent_schema_registry.rb

@@ -0,0 +1,106 @@
+require 'excon'
+
+class AvroTurf::ConfluentSchemaRegistry
+  CONTENT_TYPE = "application/vnd.schemaregistry.v1+json".freeze
+
+  def initialize(url, logger: Logger.new($stdout))
+    @logger = logger
+    @connection = Excon.new(url, headers: {
+      "Content-Type" => CONTENT_TYPE,
+    })
+  end
+
+  def fetch(id)
+    @logger.info "Fetching schema with id #{id}"
+    data = get("/schemas/ids/#{id}")
+    data.fetch("schema")
+  end
+
+  def register(subject, schema)
+    data = post("/subjects/#{subject}/versions", body: {
+      schema: schema.to_s
+    }.to_json)
+
+    id = data.fetch("id")
+
+    @logger.info "Registered schema for subject `#{subject}`; id = #{id}"
+
+    id
+  end
+
+  # List all subjects
+  def subjects
+    get('/subjects')
+  end
+
+  # List all versions for a subject
+  def subject_versions(subject)
+    get("/subjects/#{subject}/versions")
+  end
+
+  # Get a specific version for a subject
+  def subject_version(subject, version = 'latest')
+    get("/subjects/#{subject}/versions/#{version}")
+  end
+
+  # Check if a schema exists. Returns nil if not found.
+  def check(subject, schema)
+    data = post("/subjects/#{subject}",
+                expects: [200, 404],
+                body: { schema: schema.to_s }.to_json)
+    data unless data.has_key?("error_code")
+  end
+
+  # Check if a schema is compatible with the stored version.
+  # Returns:
+  # - true if compatible
+  # - nil if the subject or version does not exist
+  # - 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}",
+                expects: [200, 404],
+                body: { schema: schema.to_s }.to_json)
+    data.fetch('is_compatible', false) unless data.has_key?('error_code')
+  end
+
+  # Get global config
+  def global_config
+    get("/config")
+  end
+
+  # Update global config
+  def update_global_config(config)
+    put("/config", { body: config.to_json })
+  end
+
+  # Get config for subject
+  def subject_config(subject)
+    get("/config/#{subject}")
+  end
+
+  # Update config for subject
+  def update_subject_config(subject, config)
+    put("/config/#{subject}", { body: config.to_json })
+  end
+
+  private
+
+  def get(path, **options)
+    request(path, method: :get, **options)
+  end
+
+  def put(path, **options)
+    request(path, method: :put, **options)
+  end
+
+  def post(path, **options)
+    request(path, method: :post, **options)
+  end
+
+  def request(path, **options)
+    options = { expects: 200 }.merge!(options)
+    response = @connection.request(path: path, **options)
+    JSON.parse(response.body)
+  end
+end

data/lib/avro_turf/messaging.rb

@@ -1,6 +1,11 @@
 require 'logger'
 require 'avro_turf'
 require 'avro_turf/schema_store'
+require 'avro_turf/confluent_schema_registry'
+require 'avro_turf/cached_confluent_schema_registry'
+
+# For back-compatibility require the aliases along with the Messaging API.
+# These names are deprecated and will be removed in a future release.
 require 'avro_turf/schema_registry'
 require 'avro_turf/cached_schema_registry'
 
@@ -20,7 +25,7 @@ class AvroTurf
     # Instantiate a new Messaging instance with the given configuration.
     #
     # registry     - A schema registry object that responds to all methods in the
-    #                AvroTurf::SchemaRegistry interface.
+    #                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.
@@ -30,7 +35,7 @@ class AvroTurf
       @logger = logger || Logger.new($stderr)
       @namespace = namespace
       @schema_store = schema_store || SchemaStore.new(path: schemas_path || DEFAULT_SCHEMAS_PATH)
-      @registry = registry || CachedSchemaRegistry.new(SchemaRegistry.new(registry_url, logger: @logger))
+      @registry = registry || CachedConfluentSchemaRegistry.new(ConfluentSchemaRegistry.new(registry_url, logger: @logger))
       @schemas_by_id = {}
     end
 

data/lib/avro_turf/schema_registry.rb

@@ -1,79 +1,6 @@
-require 'excon'
+require 'avro_turf/confluent_schema_registry'
 
-class AvroTurf::SchemaRegistry
-  CONTENT_TYPE = "application/vnd.schemaregistry.v1+json".freeze
+# AvroTurf::SchemaRegistry is deprecated and will be removed in a future release.
+# Use AvroTurf::ConfluentSchemaRegistry instead.
 
-  def initialize(url, logger: Logger.new($stdout))
-    @logger = logger
-    @connection = Excon.new(url, headers: {
-      "Content-Type" => CONTENT_TYPE,
-    })
-  end
-
-  def fetch(id)
-    @logger.info "Fetching schema with id #{id}"
-    data = get("/schemas/ids/#{id}")
-    data.fetch("schema")
-  end
-
-  def register(subject, schema)
-    data = post("/subjects/#{subject}/versions", body: {
-      schema: schema.to_s
-    }.to_json)
-
-    id = data.fetch("id")
-
-    @logger.info "Registered schema for subject `#{subject}`; id = #{id}"
-
-    id
-  end
-
-  # List all subjects
-  def subjects
-    get('/subjects')
-  end
-
-  # List all versions for a subject
-  def subject_versions(subject)
-    get("/subjects/#{subject}/versions")
-  end
-
-  # Get a specific version for a subject
-  def subject_version(subject, version = 'latest')
-    get("/subjects/#{subject}/versions/#{version}")
-  end
-
-  # Check if a schema exists. Returns nil if not found.
-  def check(subject, schema)
-    data = post("/subjects/#{subject}",
-                expects: [200, 404],
-                body: { schema: schema.to_s }.to_json)
-    data unless data.has_key?("error_code")
-  end
-
-  # Check if a schema is compatible with the stored version.
-  # Returns true if compatible, false otherwise
-  # http://docs.confluent.io/2.0.0/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)
-    data.fetch('is_compatible', false) unless data.has_key?('error_code')
-  end
-
-  private
-
-  def get(path, **options)
-    request(path, method: :get, **options)
-  end
-
-  def post(path, **options)
-    request(path, method: :post, **options)
-  end
-
-  def request(path, **options)
-    options = { expects: 200 }.merge!(options)
-    response = @connection.request(path: path, **options)
-    JSON.parse(response.body)
-  end
-end
+AvroTurf::SchemaRegistry = AvroTurf::ConfluentSchemaRegistry

data/lib/avro_turf/test/fake_confluent_schema_registry_server.rb

@@ -0,0 +1,129 @@
+require 'sinatra/base'
+
+class FakeConfluentSchemaRegistryServer < Sinatra::Base
+  SUBJECTS = Hash.new { Array.new }
+  SCHEMAS = []
+  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
+  SCHEMA_NOT_FOUND = { error_code: 40403, message: 'Schema not found' }.to_json.freeze
+  DEFAULT_GLOBAL_CONFIG = { 'compatibility' => 'BACKWARD'.freeze }.freeze
+
+  @global_config = DEFAULT_GLOBAL_CONFIG.dup
+
+  class << self
+    attr_reader :global_config
+  end
+
+  helpers do
+    def parse_schema
+      request.body.rewind
+      JSON.parse(request.body.read).fetch("schema").tap do |schema|
+        Avro::Schema.parse(schema)
+      end
+    end
+
+    def parse_config
+      request.body.rewind
+      JSON.parse(request.body.read)
+    end
+
+    def global_config
+      self.class.global_config
+    end
+  end
+
+  post "/subjects/:subject/versions" do
+    SCHEMAS << parse_schema
+
+    schema_id = SCHEMAS.size - 1
+    SUBJECTS[params[:subject]] = SUBJECTS[params[:subject]] << schema_id
+    { id: schema_id }.to_json
+  end
+
+  get "/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 "/subjects" do
+    SUBJECTS.keys.to_json
+  end
+
+  get "/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 "/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,
+      schema: schema
+    }.to_json
+  end
+
+  post "/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 "/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 "/config" do
+    global_config.to_json
+  end
+
+  put "/config" do
+    global_config.merge!(parse_config).to_json
+  end
+
+  get "/config/:subject" do
+    CONFIGS.fetch(params[:subject], global_config).to_json
+  end
+
+  put "/config/:subject" do
+    config = parse_config
+    subject = params[:subject]
+    CONFIGS.fetch(subject) do
+      CONFIGS[subject] = {}
+    end.merge!(config).to_json
+  end
+
+  def self.clear
+    SUBJECTS.clear
+    SCHEMAS.clear
+    CONFIGS.clear
+    @global_config = DEFAULT_GLOBAL_CONFIG.dup
+  end
+end

data/lib/avro_turf/test/fake_schema_registry_server.rb

@@ -1,84 +1,6 @@
-require 'sinatra/base'
+require 'avro_turf/test/fake_confluent_schema_registry_server'
 
-class FakeSchemaRegistryServer < Sinatra::Base
-  SUBJECTS = Hash.new { Array.new }
-  SCHEMAS = []
-  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
-  SCHEMA_NOT_FOUND = { error_code: 40403, message: 'Schema not found' }.to_json.freeze
+# FakeSchemaRegistryServer is deprecated and will be removed in a future release.
+# Use FakeConfluentSchemaRegistryServer instead.
 
-  helpers do
-    def parse_schema
-      request.body.rewind
-      JSON.parse(request.body.read).fetch("schema").tap do |schema|
-        Avro::Schema.parse(schema)
-      end
-    end
-  end
-
-  post "/subjects/:subject/versions" do
-    SCHEMAS << parse_schema
-
-    schema_id = SCHEMAS.size - 1
-    SUBJECTS[params[:subject]] = SUBJECTS[params[:subject]] << schema_id
-    { id: schema_id }.to_json
-  end
-
-  get "/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 "/subjects" do
-    SUBJECTS.keys.to_json
-  end
-
-  get "/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 "/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,
-      schema: schema
-    }.to_json
-  end
-
-  post "/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
-
-  def self.clear
-    SUBJECTS.clear
-    SCHEMAS.clear
-  end
-end
+FakeSchemaRegistryServer = FakeConfluentSchemaRegistryServer

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "0.7.2"
+  VERSION = "0.8.0"
 end

data/spec/{cached_schema_registry_spec.rb → cached_confluent_schema_registry_spec.rb}

@@ -1,9 +1,9 @@
 require 'webmock/rspec'
-require 'avro_turf/cached_schema_registry'
-require 'avro_turf/test/fake_schema_registry_server'
+require 'avro_turf/cached_confluent_schema_registry'
+require 'avro_turf/test/fake_confluent_schema_registry_server'
 
-describe AvroTurf::CachedSchemaRegistry do
-  let(:upstream) { instance_double(AvroTurf::SchemaRegistry) }
+describe AvroTurf::CachedConfluentSchemaRegistry do
+  let(:upstream) { instance_double(AvroTurf::ConfluentSchemaRegistry) }
   let(:registry) { described_class.new(upstream) }
   let(:id) { rand(999) }
   let(:schema) do
@@ -34,8 +34,8 @@ describe AvroTurf::CachedSchemaRegistry do
     end
   end
 
-  it_behaves_like "a schema registry client" do
-    let(:upstream) { AvroTurf::SchemaRegistry.new(registry_url, logger: logger) }
+  it_behaves_like "a confluent schema registry client" do
+    let(:upstream) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
     let(:registry) { described_class.new(upstream) }
   end
 end

data/spec/confluent_schema_registry_spec.rb

@@ -0,0 +1,9 @@
+require 'webmock/rspec'
+require 'avro_turf/confluent_schema_registry'
+require 'avro_turf/test/fake_confluent_schema_registry_server'
+
+describe AvroTurf::ConfluentSchemaRegistry do
+  it_behaves_like "a confluent schema registry client" do
+    let(:registry) { described_class.new(registry_url, logger: logger) }
+  end
+end

data/spec/messaging_spec.rb

@@ -1,6 +1,6 @@
 require 'webmock/rspec'
 require 'avro_turf/messaging'
-require 'avro_turf/test/fake_schema_registry_server'
+require 'avro_turf/test/fake_confluent_schema_registry_server'
 
 describe AvroTurf::Messaging do
   let(:registry_url) { "http://registry.example.com" }
@@ -21,8 +21,8 @@ describe AvroTurf::Messaging do
   end
 
   before do
-    stub_request(:any, /^#{registry_url}/).to_rack(FakeSchemaRegistryServer)
-    FakeSchemaRegistryServer.clear
+    stub_request(:any, /^#{registry_url}/).to_rack(FakeConfluentSchemaRegistryServer)
+    FakeConfluentSchemaRegistryServer.clear
   end
 
   before do
@@ -63,7 +63,7 @@ describe AvroTurf::Messaging do
   it_behaves_like "encoding and decoding"
 
   context "with a provided registry" do
-    let(:registry) { AvroTurf::SchemaRegistry.new(registry_url, logger: logger) }
+    let(:registry) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
 
     let(:avro) do
       AvroTurf::Messaging.new(

data/spec/support/{schema_registry_context.rb → confluent_schema_registry_context.rb}

@@ -1,6 +1,6 @@
 # This shared example expects a registry variable to be defined
 # with an instance of the registry class being tested.
-shared_examples_for "a schema registry client" do
+shared_examples_for "a confluent schema registry client" do
   let(:logger) { Logger.new(StringIO.new) }
   let(:registry_url) { "http://registry.example.com" }
   let(:subject_name) { "some-subject" }
@@ -15,8 +15,8 @@ shared_examples_for "a schema registry client" do
   end
 
   before do
-    stub_request(:any, /^#{registry_url}/).to_rack(FakeSchemaRegistryServer)
-    FakeSchemaRegistryServer.clear
+    stub_request(:any, /^#{registry_url}/).to_rack(FakeConfluentSchemaRegistryServer)
+    FakeConfluentSchemaRegistryServer.clear
   end
 
   describe "#register and #fetch" do
@@ -178,6 +178,67 @@ shared_examples_for "a schema registry client" do
     end
   end
 
+  describe "#global_config" do
+    let(:expected) do
+      { compatibility: 'BACKWARD' }.to_json
+    end
+
+    it "returns the global configuration" do
+      expect(registry.global_config).to eq(JSON.parse(expected))
+    end
+  end
+
+  describe "#update_global_config" do
+    let(:config) do
+      { compatibility: 'FORWARD' }
+    end
+    let(:expected) { config.to_json }
+
+    it "updates the global configuration and returns it" do
+      expect(registry.update_global_config(config)).to eq(JSON.parse(expected))
+      expect(registry.global_config).to eq(JSON.parse(expected))
+    end
+  end
+
+  describe "#subject_config" do
+    let(:expected) do
+      { compatibility: 'BACKWARD' }.to_json
+    end
+
+    context "when the subject config is not set" do
+      it "returns the global configuration" do
+        expect(registry.subject_config(subject_name)).to eq(JSON.parse(expected))
+      end
+    end
+
+    context "when the subject config is set" do
+      let(:config) do
+        { compatibility: 'FULL' }
+      end
+      let(:expected) { config.to_json }
+
+      before do
+        registry.update_subject_config(subject_name, config)
+      end
+
+      it "returns the subject config" do
+        expect(registry.subject_config(subject_name)).to eq(JSON.parse(expected))
+      end
+    end
+  end
+
+  describe "#update_subject_config" do
+    let(:config) do
+      { compatibility: 'NONE' }
+    end
+    let(:expected) { config.to_json }
+
+    it "updates the subject config and returns it" do
+      expect(registry.update_subject_config(subject_name, config)).to eq(JSON.parse(expected))
+      expect(registry.subject_config(subject_name)).to eq(JSON.parse(expected))
+    end
+  end
+
   # Monkey patch an Avro::Schema to simulate the presence of
   # active_support/core_ext.
   def break_to_json(avro_schema)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2017-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -151,6 +151,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -158,7 +159,9 @@ files:
 - avro_turf.gemspec
 - circle.yml
 - lib/avro_turf.rb
+- lib/avro_turf/cached_confluent_schema_registry.rb
 - lib/avro_turf/cached_schema_registry.rb
+- lib/avro_turf/confluent_schema_registry.rb
 - lib/avro_turf/core_ext.rb
 - lib/avro_turf/core_ext/date.rb
 - lib/avro_turf/core_ext/enumerable.rb
@@ -174,6 +177,7 @@ files:
 - lib/avro_turf/schema_registry.rb
 - 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_schema_registry_server.rb
 - lib/avro_turf/version.rb
 - perf/address.avsc
@@ -181,7 +185,8 @@ files:
 - perf/encoding_speed.rb
 - perf/person.avsc
 - spec/avro_turf_spec.rb
-- spec/cached_schema_registry_spec.rb
+- spec/cached_confluent_schema_registry_spec.rb
+- spec/confluent_schema_registry_spec.rb
 - spec/core_ext/date_spec.rb
 - spec/core_ext/enumerable_spec.rb
 - spec/core_ext/false_class_spec.rb
@@ -193,16 +198,23 @@ files:
 - spec/core_ext/time_spec.rb
 - spec/core_ext/true_class_spec.rb
 - spec/messaging_spec.rb
-- spec/schema_registry_spec.rb
 - spec/schema_store_spec.rb
 - spec/schema_to_avro_patch_spec.rb
 - spec/spec_helper.rb
-- spec/support/schema_registry_context.rb
+- spec/support/confluent_schema_registry_context.rb
 homepage: https://github.com/dasch/avro_turf
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |2
+
+  avro_turf v0.8.0 deprecates the names AvroTurf::SchemaRegistry,
+  AvroTurf::CachedSchemaRegistry, and FakeSchemaRegistryServer.
+
+  Use AvroTurf::ConfluentSchemaRegistry, AvroTurf::CachedConfluentSchemaRegistry,
+  and FakeConfluentSchemaRegistryServer instead.
+
+  See https://github.com/dasch/avro_turf#deprecation-notice
 rdoc_options: []
 require_paths:
 - lib
@@ -225,7 +237,8 @@ summary: A library that makes it easier to use the Avro serialization format fro
   Ruby
 test_files:
 - spec/avro_turf_spec.rb
-- spec/cached_schema_registry_spec.rb
+- spec/cached_confluent_schema_registry_spec.rb
+- spec/confluent_schema_registry_spec.rb
 - spec/core_ext/date_spec.rb
 - spec/core_ext/enumerable_spec.rb
 - spec/core_ext/false_class_spec.rb
@@ -237,9 +250,7 @@ test_files:
 - spec/core_ext/time_spec.rb
 - spec/core_ext/true_class_spec.rb
 - spec/messaging_spec.rb
-- spec/schema_registry_spec.rb
 - spec/schema_store_spec.rb
 - spec/schema_to_avro_patch_spec.rb
 - spec/spec_helper.rb
-- spec/support/schema_registry_context.rb
-has_rdoc: 
+- spec/support/confluent_schema_registry_context.rb

data/spec/schema_registry_spec.rb

@@ -1,9 +0,0 @@
-require 'webmock/rspec'
-require 'avro_turf/schema_registry'
-require 'avro_turf/test/fake_schema_registry_server'
-
-describe AvroTurf::SchemaRegistry do
-  it_behaves_like "a schema registry client" do
-    let(:registry) { described_class.new(registry_url, logger: logger) }
-  end
-end