avro_turf 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e286ef91f22f8b2d66e7d91a7fb7eefef94911c
-  data.tar.gz: 774a729aaa90259a828a5c1080711fa9b95003b1
+  metadata.gz: f8eb00c2c29b7e52a48030bca31e7bebf9e84b49
+  data.tar.gz: f651f0a33989a08b6b17b43b75fa493e083954ba
 SHA512:
-  metadata.gz: ee5f9aaa4bf4df9025818a6de776e673386f8de7a64f5bfa8487e32bf276775a7e2c97f59e0791426b10cea27d0b7ab49a67973bd89fcf46924f989547d17191
-  data.tar.gz: f1ad05167aa4c72cc727d7d2788240fa19a69144a6c09bb67e4cbb8b08e97319eeb5341172ba9ca28b980dfcfa5d3b6d34c027c5a8f4c411e326c0b185980621
+  metadata.gz: 5011cc4ad6e53bf61d3fb88f3c89c17cb195044d37fa9bf91ec5f30003f3cea59b0edd9e7618aaae57e307aadc2cf000057032d87432fb91a8118ba8609d6f7f
+  data.tar.gz: 9ffb5c68c4ba50dd19ccf550e3fc861e9ffd7bbaa7117f57f0d7d0a987954f00f95f1385ff6ddf7d5953090623be38f6e2549f89ab1669c81741f66ed7d6292a

data/avro_turf.gemspec

@@ -17,7 +17,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.7.7"
+  spec.add_dependency "avro", ">= 1.7.7", "< 1.9"
   spec.add_dependency "excon", "~> 0.45.4"
 
   spec.add_development_dependency "bundler", "~> 1.7"
@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "fakefs", "~> 0.6.7"
   spec.add_development_dependency "webmock"
   spec.add_development_dependency "sinatra"
+  spec.add_development_dependency "json_spec"
 end

data/lib/avro_turf/cached_schema_registry.rb

@@ -1,11 +1,21 @@
+require 'avro_turf/schema_registry'
+
 # Caches registrations and lookups to the schema registry in memory.
 class AvroTurf::CachedSchemaRegistry
+
   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).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

data/lib/avro_turf/schema_registry.rb

@@ -18,7 +18,7 @@ class AvroTurf::SchemaRegistry
 
   def register(subject, schema)
     data = post("/subjects/#{subject}/versions", body: {
-      schema: schema
+      schema: schema.to_s
     }.to_json)
 
     id = data.fetch("id")
@@ -28,6 +28,29 @@ class AvroTurf::SchemaRegistry
     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
+
   private
 
   def get(path, **options)
@@ -39,7 +62,8 @@ class AvroTurf::SchemaRegistry
   end
 
   def request(path, **options)
-    response = @connection.request(path: path, expects: 200, **options)
+    options = { expects: 200 }.merge!(options)
+    response = @connection.request(path: path, **options)
     JSON.parse(response.body)
   end
 end

data/lib/avro_turf/schema_store.rb

@@ -36,7 +36,7 @@ class AvroTurf::SchemaStore
     else
       raise
     end
-  rescue Errno::ENOENT
+  rescue Errno::ENOENT, Errno::ENAMETOOLONG
     raise AvroTurf::SchemaNotFoundError, "could not find Avro schema at `#{schema_path}'"
   end
 
@@ -46,7 +46,7 @@ class AvroTurf::SchemaStore
 
     Dir.glob(pattern) do |schema_path|
       # Remove the path prefix.
-      schema_path.sub!(/^\/#{@path}\//, "")
+      schema_path.sub!(/^\/?#{@path}\//, "")
 
       # Replace `/` with `.` and chop off the file extension.
       schema_name = File.basename(schema_path.tr("/", "."), ".avsc")

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

data/spec/cached_schema_registry_spec.rb

@@ -0,0 +1,41 @@
+require 'webmock/rspec'
+require 'avro_turf/cached_schema_registry'
+require_relative 'fake_schema_registry_server'
+
+describe AvroTurf::CachedSchemaRegistry do
+  let(:upstream) { instance_double(AvroTurf::SchemaRegistry) }
+  let(:registry) { described_class.new(upstream) }
+  let(:id) { rand(999) }
+  let(:schema) do
+    {
+      type: "record",
+      name: "person",
+      fields: [{ name: "name", type: "string" }]
+    }.to_json
+  end
+
+  describe "#fetch" do
+    it "caches the result of fetch" do
+      allow(upstream).to receive(:fetch).with(id).and_return(schema)
+      registry.fetch(id)
+      expect(registry.fetch(id)).to eq(schema)
+      expect(upstream).to have_received(:fetch).exactly(1).times
+    end
+  end
+
+  describe "#register" do
+    let(:subject_name) { "a_subject" }
+
+    it "caches the result of register" do
+      allow(upstream).to receive(:register).with(subject_name, schema).and_return(id)
+      registry.register(subject_name, schema)
+      expect(registry.register(subject_name, schema)).to eq(id)
+      expect(upstream).to have_received(:register).exactly(1).times
+    end
+  end
+
+  it_behaves_like "a schema registry client" do
+    let(:upstream) { AvroTurf::SchemaRegistry.new(registry_url, logger: logger) }
+    let(:registry) { described_class.new(upstream) }
+  end
+end

data/spec/fake_schema_registry_server.rb

@@ -1,25 +1,84 @@
 require 'sinatra/base'
 
 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
+
+  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
-    request.body.rewind
-    schema = JSON.parse(request.body.read).fetch("schema")
+    SCHEMAS << parse_schema
 
-    SCHEMAS << 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

data/spec/messaging_spec.rb

@@ -49,4 +49,31 @@ describe AvroTurf::Messaging do
     data = avro.encode(message, schema_name: "person")
     expect(avro.decode(data, schema_name: "person")).to eq message
   end
+
+  context "when active_support/core_ext is present" do
+    let(:avro) do
+      super().tap do |messaging|
+        # Simulate the presence of active_support/core_ext by monkey patching
+        # the schema store to monkey patch #to_json on the returned schema.
+        schema_store = messaging.instance_variable_get(:@schema_store)
+        def schema_store.find(*)
+          super.extend(Module.new do
+            # Replace to_json on the returned schema with an implementation
+            # that returns something similar to active_support/core_ext/json
+            def to_json(*args)
+              instance_variables.each_with_object(Hash.new) do |ivar, result|
+                result[ivar.to_s.sub('@','')] = instance_variable_get(ivar)
+              end.to_json(*args)
+            end
+          end)
+        end
+      end
+    end
+
+    it "encodes and decodes messages" do
+      message = { "full_name" => "John Doe" }
+      data = avro.encode(message, schema_name: "person")
+      expect(avro.decode(data)).to eq message
+    end
+  end
 end

data/spec/schema_registry_spec.rb

@@ -3,30 +3,7 @@ require 'avro_turf/schema_registry'
 require_relative 'fake_schema_registry_server'
 
 describe AvroTurf::SchemaRegistry do
-  let(:registry_url) { "http://registry.example.com" }
-
-  before do
-    stub_request(:any, /^#{registry_url}/).to_rack(FakeSchemaRegistryServer)
-    FakeSchemaRegistryServer.clear
-  end
-
-  it "allows registering a schema" do
-    logger = Logger.new(StringIO.new)
-    registry = described_class.new(registry_url, logger: logger)
-
-    schema = <<-JSON
-      {
-        "type": "record",
-        "name": "person",
-        "fields": [
-          { "name": "name", "type": "string" }
-        ]
-      }
-    JSON
-
-    id = registry.register("some-subject", schema)
-    fetched_schema = registry.fetch(id)
-
-    expect(JSON.parse(fetched_schema)).to eq JSON.parse(schema)
+  it_behaves_like "a schema registry client" do
+    let(:registry) { described_class.new(registry_url, logger: logger) }
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,11 @@
 require 'bundler/setup'
 require 'logger'
+require 'json_spec'
 require 'fakefs/spec_helpers'
 require 'avro_turf'
 
+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|

data/spec/support/schema_registry_context.rb

@@ -0,0 +1,144 @@
+# 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
+  let(:logger) { Logger.new(StringIO.new) }
+  let(:registry_url) { "http://registry.example.com" }
+  let(:subject_name) { "some-subject" }
+  let(:schema) do
+    {
+      type: "record",
+      name: "person",
+      fields: [
+        { name: "name", type: "string" }
+      ]
+    }.to_json
+  end
+
+  before do
+    stub_request(:any, /^#{registry_url}/).to_rack(FakeSchemaRegistryServer)
+    FakeSchemaRegistryServer.clear
+  end
+
+  describe "#register and #fetch" do
+    it "allows registering a schema" do
+      id = registry.register(subject_name, schema)
+      fetched_schema = registry.fetch(id)
+
+      expect(fetched_schema).to eq(schema)
+    end
+  end
+
+  describe "#fetch" do
+    context "when the schema does not exist" do
+      it "raises an error" do
+        expect do
+          registry.fetch(-1)
+        end.to raise_error(Excon::Errors::NotFound)
+      end
+    end
+  end
+
+  describe "#subjects" do
+    it "lists the subjects in the registry" do
+      subjects = Array.new(2) { |n| "subject#{n}" }
+      subjects.each { |subject| registry.register(subject, schema) }
+      expect(registry.subjects).to be_json_eql(subjects.to_json)
+    end
+  end
+
+  describe "#subject_versions" do
+    it "lists all the versions for the subject" do
+      2.times do |n|
+        registry.register(subject_name,
+                          { type: :record, name: "r#{n}", fields: [] }.to_json)
+      end
+      expect(registry.subject_versions(subject_name))
+        .to be_json_eql((1..2).to_a.to_json)
+    end
+
+    context "when the subject does not exist" do
+      let(:subject_name) { 'missing' }
+
+      it "raises an error" do
+        expect do
+          registry.subject_versions(subject_name).inspect
+        end.to raise_error(Excon::Errors::NotFound)
+      end
+    end
+  end
+
+  describe "#subject_version" do
+    before do
+      2.times do |n|
+        registry.register(subject_name,
+                          { type: :record, name: "r#{n}", fields: [] }.to_json)
+      end
+    end
+    let(:expected) do
+      {
+        name: subject_name,
+        version: 1,
+        schema: { type: :record, name: "r0", fields: [] }.to_json
+      }.to_json
+    end
+
+    it "returns a specific version of a schema" do
+      expect(registry.subject_version(subject_name, 1))
+        .to eq(JSON.parse(expected))
+    end
+
+    context "when the version is not specified" do
+      let(:expected) do
+        {
+          name: subject_name,
+          version: 2,
+          schema: { type: :record, name: "r1", fields: [] }.to_json
+        }.to_json
+      end
+
+      it "returns the latest version" do
+        expect(registry.subject_version(subject_name))
+          .to eq(JSON.parse(expected))
+      end
+    end
+
+    context "when the subject does not exist" do
+      it "raises an error" do
+        expect do
+          registry.subject_version('missing')
+        end.to raise_error(Excon::Errors::NotFound)
+      end
+    end
+
+    context "when the version does not exist" do
+      it "raises an error" do
+        expect do
+          registry.subject_version(subject_name, 3)
+        end.to raise_error(Excon::Errors::NotFound)
+      end
+    end
+  end
+
+  describe "#check" do
+    context "when the schema exists" do
+      let!(:schema_id) { registry.register(subject_name, schema) }
+      let(:expected) do
+        {
+          subject: subject_name,
+          id: schema_id,
+          version: 1,
+          schema: schema
+        }.to_json
+      end
+      it "returns the schema details" do
+        expect(registry.check(subject_name, schema)).to eq(JSON.parse(expected))
+      end
+    end
+
+    context "when the schema is not registered" do
+      it "returns nil" do
+        expect(registry.check("missing", schema)).to be_nil
+      end
+    end
+  end
+end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2016-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.7
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.7
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +128,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - dasch@zendesk.com
@@ -159,6 +179,7 @@ files:
 - perf/encoding_speed.rb
 - perf/person.avsc
 - spec/avro_turf_spec.rb
+- spec/cached_schema_registry_spec.rb
 - spec/core_ext/date_spec.rb
 - spec/core_ext/enumerable_spec.rb
 - spec/core_ext/false_class_spec.rb
@@ -174,6 +195,7 @@ files:
 - spec/schema_registry_spec.rb
 - spec/schema_store_spec.rb
 - spec/spec_helper.rb
+- spec/support/schema_registry_context.rb
 homepage: https://github.com/dasch/avro_turf
 licenses:
 - MIT
@@ -201,6 +223,7 @@ 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/core_ext/date_spec.rb
 - spec/core_ext/enumerable_spec.rb
 - spec/core_ext/false_class_spec.rb
@@ -216,4 +239,5 @@ test_files:
 - spec/schema_registry_spec.rb
 - spec/schema_store_spec.rb
 - spec/spec_helper.rb
+- spec/support/schema_registry_context.rb
 has_rdoc: