avro_turf 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64620bcf8c0a04337ecf571abe2d0e51098fce4a
-  data.tar.gz: cc45ee47d74ea7ee364463b105f8cfc92345058b
+  metadata.gz: 0845fc0e81baaa72df5abd34b47a0ce6d06a853f
+  data.tar.gz: 434aaa74efb2f96437045a8705c7889348bec9c3
 SHA512:
-  metadata.gz: 090cf294b97ea232c5ec8372eced0244d87f87a6fd3d9cdffdfb2ad73e467e52be0ae1ab3108e53a3e5aabfdd7a3bd2a35aae70c89ca1b448a74305d61d48964
-  data.tar.gz: 657f8b32c84d5b6e01a614bab06a4d17987e3c1832641e62bac8548c139810e60febfc72684983b1342e4839c889b667d037fcbb09932c940366636e32198c5f
+  metadata.gz: ef023ba8d9fb413e69a467c1ecb4a4ef73c6c1f1bb86f1f362b6f351abcd6ed8b2fae965d7b50b4d3ba6e81513c30dcffbe1e5d688044efa872f4b65f85ff39a
+  data.tar.gz: e095b79ce3f37a69efac8537e6d59fcb5c8d66350604eba7f00166911801699eccf945552fcbc5c950223f7c14ddfddd2f58157b70aff2466e6d2ea157485eab

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in avro_turf.gemspec
 gemspec
+
+# Used by CircleCI to format RSpec results.
+gem 'rspec_junit_formatter', :git => 'git@github.com:circleci/rspec_junit_formatter.git'

data/lib/avro_turf.rb

@@ -1,15 +1,17 @@
 require 'avro_turf/version'
 require 'avro'
 require 'json'
+require 'avro_turf/schema_store'
 
 class AvroTurf
   class Error < StandardError; end
   class SchemaError < Error; end
+  class SchemaNotFoundError < Error; end
 
-  def initialize(schemas_path:, namespace: nil)
-    @schemas_path = schemas_path or raise "Please specify a schema path"
-    @schemas = Hash.new
+  def initialize(schemas_path:, namespace: nil, codec: nil)
     @namespace = namespace
+    @schema_store = SchemaStore.new(path: schemas_path)
+    @codec = codec
   end
 
   # Encodes data to Avro using the specified schema.
@@ -19,15 +21,31 @@ class AvroTurf
   #
   # Returns a String containing the encoded data.
   def encode(data, schema_name:, namespace: @namespace)
-    schema = resolve_schema(schema_name, namespace)
+    stream = StringIO.new
+
+    encode_to_stream(data, stream: stream, schema_name: schema_name, namespace: namespace)
+
+    stream.string
+  end
+
+  # Encodes data to Avro using the specified schema and writes it to the
+  # specified stream.
+  #
+  # data        - The data that should be encoded.
+  # schema_name - The name of a schema in the `schemas_path`.
+  # stream      - An IO object that the encoded data should be written to (optional).
+  # codec       - The String name of a codec that should be used to compress messages (optional).
+  #
+  # Currently, the only valid codec name is `deflate`.
+  #
+  # Returns nothing.
+  def encode_to_stream(data, schema_name:, stream:, namespace: @namespace)
+    schema = @schema_store.find(schema_name, namespace)
     writer = Avro::IO::DatumWriter.new(schema)
 
-    io = StringIO.new
-    dw = Avro::DataFile::Writer.new(io, writer, schema)
+    dw = Avro::DataFile::Writer.new(stream, writer, schema, @codec)
     dw << data
     dw.close
-
-    io.string
   end
 
   # Decodes Avro data.
@@ -35,49 +53,31 @@ class AvroTurf
   # encoded_data - A String containing Avro-encoded data.
   # schema_name  - The String name of the schema that should be used to read
   #                the data. If nil, the writer schema will be used.
+  # namespace    - The namespace of the Avro schema used to decode the data.
   #
   # Returns whatever is encoded in the data.
   def decode(encoded_data, schema_name: nil, namespace: @namespace)
-    io = StringIO.new(encoded_data)
-    schema = schema_name && resolve_schema(schema_name, namespace)
-    reader = Avro::IO::DatumReader.new(nil, schema)
-    dr = Avro::DataFile::Reader.new(io, reader)
-    dr.first
+    stream = StringIO.new(encoded_data)
+    decode_stream(stream, schema_name: schema_name, namespace: namespace)
   end
 
-  private
-
-  # Resolves and returns a schema.
+  # Decodes Avro data from an IO stream.
   #
-  # schema_name - The String name of the schema to resolve.
+  # stream       - An IO object containing Avro data.
+  # schema_name  - The String name of the schema that should be used to read
+  #                the data. If nil, the writer schema will be used.
+  # namespace    - The namespace of the Avro schema used to decode the data.
   #
-  # Returns an Avro::Schema.
-  def resolve_schema(name, namespace = nil)
-    fullname = Avro::Name.make_fullname(name, namespace)
-
-    return @schemas[fullname] if @schemas.key?(fullname)
-
-    *namespace, schema_name = fullname.split(".")
-    schema_path = File.join(@schemas_path, *namespace, schema_name + ".avsc")
-    schema_json = JSON.parse(File.read(schema_path))
-    schema = Avro::Schema.real_parse(schema_json, @schemas)
-
-    if schema.respond_to?(:fullname) && schema.fullname != fullname
-      raise SchemaError, "expected schema `#{schema_path}' to define type `#{fullname}'"
-    end
-
-    schema
-  rescue ::Avro::SchemaParseError => e
-    # This is a hack in order to figure out exactly which type was missing. The
-    # Avro gem ought to provide this data directly.
-    if e.to_s =~ /"([\w\.]+)" is not a schema we know about/
-      resolve_schema($1)
+  # Returns whatever is encoded in the stream.
+  def decode_stream(stream, schema_name: nil, namespace: @namespace)
+    schema = schema_name && @schema_store.find(schema_name, namespace)
+    reader = Avro::IO::DatumReader.new(nil, schema)
+    dr = Avro::DataFile::Reader.new(stream, reader)
+    dr.first
+  end
 
-      # Re-resolve the original schema now that the dependency has been resolved.
-      @schemas.delete(fullname)
-      resolve_schema(fullname)
-    else
-      raise
-    end
+  # Loads all schema definition files in the `schemas_dir`.
+  def load_schemas!
+    @schema_store.load_schemas!
   end
 end

data/lib/avro_turf/schema_store.rb

@@ -0,0 +1,58 @@
+class AvroTurf::SchemaStore
+  def initialize(path:)
+    @path = path or raise "Please specify a schema path"
+    @schemas = Hash.new
+  end
+
+  # Resolves and returns a schema.
+  #
+  # schema_name - The String name of the schema to resolve.
+  #
+  # Returns an Avro::Schema.
+  def find(name, namespace = nil)
+    fullname = Avro::Name.make_fullname(name, namespace)
+
+    return @schemas[fullname] if @schemas.key?(fullname)
+
+    *namespace, schema_name = fullname.split(".")
+    schema_path = File.join(@path, *namespace, schema_name + ".avsc")
+    schema_json = JSON.parse(File.read(schema_path))
+    schema = Avro::Schema.real_parse(schema_json, @schemas)
+
+    if schema.respond_to?(:fullname) && schema.fullname != fullname
+      raise AvroTurf::SchemaError, "expected schema `#{schema_path}' to define type `#{fullname}'"
+    end
+
+    schema
+  rescue ::Avro::SchemaParseError => e
+    # This is a hack in order to figure out exactly which type was missing. The
+    # Avro gem ought to provide this data directly.
+    if e.to_s =~ /"([\w\.]+)" is not a schema we know about/
+      find($1)
+
+      # Re-resolve the original schema now that the dependency has been resolved.
+      @schemas.delete(fullname)
+      find(fullname)
+    else
+      raise
+    end
+  rescue Errno::ENOENT
+    raise AvroTurf::SchemaNotFoundError, "could not find Avro schema at `#{schema_path}'"
+  end
+
+  # Loads all schema definition files in the `schemas_dir`.
+  def load_schemas!
+    pattern = [@path, "**", "*.avsc"].join("/")
+
+    Dir.glob(pattern) do |schema_path|
+      # Remove the path prefix.
+      schema_path.sub!(/^\/#{@path}\//, "")
+
+      # Replace `/` with `.` and chop off the file extension.
+      schema_name = File.basename(schema_path.tr("/", "."), ".avsc")
+
+      # Load and cache the schema.
+      find(schema_name)
+    end
+  end
+end

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/perf/address.avsc

@@ -0,0 +1,14 @@
+{
+  "name": "address",
+  "type": "record",
+  "fields": [
+    {
+      "name": "street",
+      "type": "string"
+    },
+    {
+      "name": "city",
+      "type": "string"
+    }
+  ]
+}

data/perf/encoding_size.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+# Measures the encoded size of messages of increasing size.
+
+$LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require 'benchmark'
+require 'avro_turf'
+
+sizes = [1, 10, 100, 1_000, 10_000]
+avro = AvroTurf.new(schemas_path: File.dirname(__FILE__))
+
+sizes.each do |size|
+  data = {
+    "name" => "John" * size,
+    "address" => {
+      "street" => "1st st." * size,
+      "city" => "Citytown" * size
+    }
+  }
+
+  result = avro.encode(data, schema_name: "person")
+  encoded_size = result.bytesize
+  encode_factor = result.bytesize / size.to_f
+  puts "size #{size}: #{encoded_size} bytes (encoding factor #{encode_factor})"
+end

data/perf/encoding_speed.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+#
+# Measures the time it takes to encode messages of increasing size.
+
+$LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require 'benchmark'
+require 'avro_turf'
+
+# Number of iterations per run.
+N = 10_000
+
+Benchmark.bm(15) do |x|
+  sizes = [1, 10, 100, 1_000, 10_000]
+  avro = AvroTurf.new(schemas_path: File.dirname(__FILE__))
+
+  sizes.each do |size|
+    data = {
+      "name" => "John" * size,
+      "address" => {
+        "street" => "1st st." * size,
+        "city" => "Citytown" * size
+      }
+    }
+
+    x.report("size #{size}:") do
+      N.times { avro.encode(data, schema_name: "person") }
+    end
+  end
+end

data/perf/person.avsc

@@ -0,0 +1,14 @@
+{
+  "name": "person",
+  "type": "record",
+  "fields": [
+    {
+      "name": "name",
+      "type": "string"
+    },
+    {
+      "name": "address",
+      "type": "address"
+    }
+  ]
+}

data/spec/avro_turf_spec.rb

@@ -0,0 +1,125 @@
+describe AvroTurf do
+  let(:avro) { AvroTurf.new(schemas_path: "spec/schemas/") }
+
+  before do
+    FileUtils.mkdir_p("spec/schemas")
+  end
+
+  describe "#encode" do
+    before do
+      define_schema "person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "full_name"
+            }
+          ]
+        }
+      AVSC
+    end
+
+    it "encodes data with Avro" do
+      data = {
+        "full_name" => "John Doe"
+      }
+
+      encoded_data = avro.encode(data, schema_name: "person")
+
+      expect(avro.decode(encoded_data)).to eq(data)
+    end
+
+    it "allows specifying a codec that should be used to compress messages" do
+      compressed_avro = AvroTurf.new(schemas_path: "spec/schemas/", codec: "deflate")
+
+      data = {
+        "full_name" => "John Doe" * 100
+      }
+
+      uncompressed_data = avro.encode(data, schema_name: "person")
+      compressed_data = compressed_avro.encode(data, schema_name: "person")
+
+      expect(compressed_data.bytesize).to be < uncompressed_data.bytesize
+      expect(compressed_avro.decode(compressed_data)).to eq(data)
+    end
+  end
+
+  describe "#decode" do
+    it "decodes Avro data using the inlined writer's schema" do
+      define_schema "message.avsc", <<-AVSC
+        {
+          "name": "message",
+          "type": "string"
+        }
+      AVSC
+
+      encoded_data = avro.encode("hello, world", schema_name: "message")
+
+      expect(avro.decode(encoded_data)).to eq "hello, world"
+    end
+
+    it "decodes Avro data using a specified reader's schema" do
+      FileUtils.mkdir_p("spec/schemas/reader")
+
+      define_schema "point.avsc", <<-AVSC
+        {
+          "name": "point",
+          "type": "record",
+          "fields": [
+            { "name": "x", "type": "long" },
+            { "name": "y", "type": "long" }
+          ]
+        }
+      AVSC
+
+      define_schema "reader/point.avsc", <<-AVSC
+        {
+          "name": "point",
+          "type": "record",
+          "fields": [
+            { "name": "x", "type": "long" }
+          ]
+        }
+      AVSC
+
+      encoded_data = avro.encode({ "x" => 42, "y" => 13 }, schema_name: "point")
+      reader_avro = AvroTurf.new(schemas_path: "spec/schemas/reader")
+
+      expect(reader_avro.decode(encoded_data, schema_name: "point")).to eq({ "x" => 42 })
+    end
+  end
+
+  describe "#encode_to_stream" do
+    it "writes encoded data to an existing stream" do
+      define_schema "message.avsc", <<-AVSC
+        {
+          "name": "message",
+          "type": "string"
+        }
+      AVSC
+
+      stream = StringIO.new
+      avro.encode_to_stream("hello", stream: stream, schema_name: "message")
+
+      expect(avro.decode(stream.string)).to eq "hello"
+    end
+  end
+
+  describe "#decode_stream" do
+    it "decodes Avro data from a stream" do
+      define_schema "message.avsc", <<-AVSC
+        {
+          "name": "message",
+          "type": "string"
+        }
+      AVSC
+
+      encoded_data = avro.encode("hello", schema_name: "message")
+      stream = StringIO.new(encoded_data)
+
+      expect(avro.decode_stream(stream)).to eq "hello"
+    end
+  end
+end

data/spec/schema_store_spec.rb

@@ -0,0 +1,253 @@
+require 'avro_turf/schema_store'
+
+describe AvroTurf::SchemaStore do
+  let(:store) { AvroTurf::SchemaStore.new(path: "spec/schemas") }
+
+  before do
+    FileUtils.mkdir_p("spec/schemas")
+  end
+
+  describe "#find" do
+    it "finds schemas on the file system" do
+      define_schema "message.avsc", <<-AVSC
+        {
+          "name": "message",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "message"
+            }
+          ]
+        }
+      AVSC
+
+      schema = store.find("message")
+      expect(schema.fullname).to eq "message"
+    end
+
+    it "resolves missing references" do
+      define_schema "person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "name": "address",
+              "type": "address"
+            }
+          ]
+        }
+      AVSC
+
+      define_schema "address.avsc", <<-AVSC
+        {
+          "type": "record",
+          "name": "address",
+          "fields": []
+        }
+      AVSC
+
+      schema = store.find("person")
+
+      expect(schema.fullname).to eq "person"
+    end
+
+    it "finds namespaced schemas" do
+      FileUtils.mkdir_p("spec/schemas/test/people")
+
+      define_schema "test/people/person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "namespace": "test.people",
+          "type": "record",
+          "fields": [
+            {
+              "name": "address",
+              "type": "test.people.address"
+            }
+          ]
+        }
+      AVSC
+
+      define_schema "test/people/address.avsc", <<-AVSC
+        {
+          "name": "address",
+          "namespace": "test.people",
+          "type": "record",
+          "fields": []
+        }
+      AVSC
+
+      schema = store.find("person", "test.people")
+
+      expect(schema.fullname).to eq "test.people.person"
+    end
+
+    it "ignores the namespace when the name contains a dot" do
+      FileUtils.mkdir_p("spec/schemas/test/acme")
+
+      define_schema "test/acme/message.avsc", <<-AVSC
+        {
+          "name": "message",
+          "namespace": "test.acme",
+          "type": "record",
+          "fields": []
+        }
+      AVSC
+
+      schema = store.find("test.acme.message", "test.yolo")
+
+      expect(schema.fullname).to eq "test.acme.message"
+    end
+
+    it "raises AvroTurf::SchemaNotFoundError if there's no schema file matching the name" do
+      expect {
+        store.find("not_there")
+      }.to raise_error(AvroTurf::SchemaNotFoundError, "could not find Avro schema at `spec/schemas/not_there.avsc'")
+    end
+
+    it "raises AvroTurf::SchemaNotFoundError if a type reference cannot be resolved" do
+      define_schema "person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "name": "address",
+              "type": "address"
+            }
+          ]
+        }
+      AVSC
+
+      expect {
+        store.find("person")
+      }.to raise_exception(AvroTurf::SchemaNotFoundError)
+    end
+
+    it "raises AvroTurf::SchemaError if the schema's namespace doesn't match the file location" do
+      FileUtils.mkdir_p("spec/schemas/test/people")
+
+      define_schema "test/people/person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "namespace": "yoyoyo.nanana",
+          "type": "record",
+          "fields": []
+        }
+      AVSC
+
+      expect {
+        store.find("test.people.person")
+      }.to raise_error(AvroTurf::SchemaError, "expected schema `spec/schemas/test/people/person.avsc' to define type `test.people.person'")
+    end
+
+    it "handles circular dependencies" do
+      define_schema "a.avsc", <<-AVSC
+        {
+          "name": "a",
+          "type": "record",
+          "fields": [
+            {
+              "type": "b",
+              "name": "b"
+            }
+          ]
+        }
+      AVSC
+
+      define_schema "b.avsc", <<-AVSC
+        {
+          "name": "b",
+          "type": "record",
+          "fields": [
+            {
+              "type": "a",
+              "name": "a"
+            }
+          ]
+        }
+      AVSC
+
+      schema = store.find("a")
+      expect(schema.fullname).to eq "a"
+    end
+
+    it "caches schemas in memory" do
+      define_schema "person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "full_name"
+            }
+          ]
+        }
+      AVSC
+
+      # Warm the schema cache.
+      store.find("person")
+
+      # Force a failure if the schema file is read again.
+      FileUtils.rm("spec/schemas/person.avsc")
+
+      schema = store.find("person")
+      expect(schema.fullname).to eq "person"
+    end
+  end
+
+  describe "#load_schemas!" do
+    it "loads schemas defined in the `schemas_path` directory" do
+      define_schema "person.avsc", <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "full_name"
+            }
+          ]
+        }
+      AVSC
+
+      # Warm the schema cache.
+      store.load_schemas!
+
+      # Force a failure if the schema file is read again.
+      FileUtils.rm("spec/schemas/person.avsc")
+
+      schema = store.find("person")
+      expect(schema.fullname).to eq "person"
+    end
+
+    it "recursively finds schema definitions in subdirectories" do
+      FileUtils.mkdir_p("spec/schemas/foo/bar")
+
+      define_schema "foo/bar/person.avsc", <<-AVSC
+        {
+          "name": "foo.bar.person",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "full_name"
+            }
+          ]
+        }
+      AVSC
+
+      # Warm the schema cache.
+      store.load_schemas!
+
+      # Force a failure if the schema file is read again.
+      FileUtils.rm("spec/schemas/foo/bar/person.avsc")
+
+      schema = store.find("foo.bar.person")
+      expect(schema.fullname).to eq "foo.bar.person"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,16 @@
 require 'bundler/setup'
+require 'fakefs/spec_helpers'
 require 'avro_turf'
+
+module Helpers
+  def define_schema(path, content)
+    File.open(File.join("spec/schemas", path), "w") do |f|
+      f.write(content)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include FakeFS::SpecHelpers
+  config.include Helpers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -96,8 +96,14 @@ files:
 - avro_turf.gemspec
 - circle.yml
 - lib/avro_turf.rb
+- lib/avro_turf/schema_store.rb
 - lib/avro_turf/version.rb
-- spec/avro_spec.rb
+- perf/address.avsc
+- perf/encoding_size.rb
+- perf/encoding_speed.rb
+- perf/person.avsc
+- spec/avro_turf_spec.rb
+- spec/schema_store_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dasch/avro_turf
 licenses:
@@ -125,6 +131,7 @@ specification_version: 4
 summary: A library that makes it easier to use the Avro serialization format from
   Ruby
 test_files:
-- spec/avro_spec.rb
+- spec/avro_turf_spec.rb
+- spec/schema_store_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/avro_spec.rb

@@ -1,227 +0,0 @@
-require 'fakefs/spec_helpers'
-
-describe AvroTurf do
-  include FakeFS::SpecHelpers
-
-  let(:avro) { AvroTurf.new(schemas_path: "spec/schemas/") }
-
-  before do
-    FileUtils.mkdir_p("spec/schemas")
-  end
-
-  it "encodes and decodes data using a named schema" do
-    define_schema "person.avsc", <<-AVSC
-      {
-        "name": "person",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "full_name"
-          },
-          {
-            "name": "address",
-            "type": {
-              "type": "record",
-              "name": "address",
-              "fields": [
-                {
-                  "type": "string",
-                  "name": "street"
-                },
-                {
-                  "type": "string",
-                  "name": "city"
-                }
-              ]
-            }
-          }
-        ]
-      }
-    AVSC
-
-    data = {
-      "full_name" => "John Doe",
-      "address" => {
-        "street" => "Market st. 989",
-        "city" => "San Francisco"
-      }
-    }
-
-    encoded_data = avro.encode(data, schema_name: "person")
-
-    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
-  end
-
-  it "resolves named types" do
-    define_schema "person.avsc", <<-AVSC
-      {
-        "name": "person",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "full_name"
-          },
-          {
-            "name": "address",
-            "type": "address"
-          }
-        ]
-      }
-    AVSC
-
-    define_schema "address.avsc", <<-AVSC
-      {
-        "type": "record",
-        "name": "address",
-        "fields": [
-          {
-            "type": "string",
-            "name": "street"
-          },
-          {
-            "type": "string",
-            "name": "city"
-          }
-        ]
-      }
-    AVSC
-
-    data = {
-      "full_name" => "John Doe",
-      "address" => {
-        "street" => "Market st. 989",
-        "city" => "San Francisco"
-      }
-    }
-
-    encoded_data = avro.encode(data, schema_name: "person")
-
-    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
-  end
-
-  it "allows decoding without specifying a reader schema" do
-    define_schema "message.avsc", <<-AVSC
-      {
-        "name": "message",
-        "type": "string"
-      }
-    AVSC
-
-    encoded_data = avro.encode("hello, world", schema_name: "message")
-
-    expect(avro.decode(encoded_data)).to eq "hello, world"
-  end
-
-  it "allows using namespaces in schemas" do
-    FileUtils.mkdir_p("spec/schemas/test/people")
-
-    define_schema "test/people/person.avsc", <<-AVSC
-      {
-        "name": "person",
-        "namespace": "test.people",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "full_name"
-          },
-          {
-            "name": "address",
-            "type": "test.people.address"
-          }
-        ]
-      }
-    AVSC
-
-    define_schema "test/people/address.avsc", <<-AVSC
-      {
-        "name": "address",
-        "namespace": "test.people",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "street"
-          },
-          {
-            "type": "string",
-            "name": "city"
-          }
-        ]
-      }
-    AVSC
-
-    data = {
-      "full_name" => "John Doe",
-      "address" => {
-        "street" => "Market st. 989",
-        "city" => "San Francisco"
-      }
-    }
-
-    encoded_data = avro.encode(data, schema_name: "person", namespace: "test.people")
-
-    expect(avro.decode(encoded_data, schema_name: "person", namespace: "test.people")).to eq(data)
-  end
-
-  it "raises AvroTurf::SchemaError if the schema's namespace doesn't match the file location" do
-    FileUtils.mkdir_p("spec/schemas/test/people")
-
-    define_schema "test/people/person.avsc", <<-AVSC
-      {
-        "name": "person",
-        "namespace": "yoyoyo.nanana",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "full_name"
-          }
-        ]
-      }
-    AVSC
-
-    data = { "full_name" => "John Doe" }
-
-    expect {
-      avro.encode(data, schema_name: "test.people.person")
-    }.to raise_error(AvroTurf::SchemaError, "expected schema `spec/schemas/test/people/person.avsc' to define type `test.people.person'")
-  end
-
-  it "caches schemas in memory" do
-    define_schema "person.avsc", <<-AVSC
-      {
-        "name": "person",
-        "type": "record",
-        "fields": [
-          {
-            "type": "string",
-            "name": "full_name"
-          }
-        ]
-      }
-    AVSC
-
-    data = {
-      "full_name" => "John Doe"
-    }
-
-    # Warm the schema cache.
-    avro.encode(data, schema_name: "person")
-
-    # Force a failure if the schema file is read again.
-    FileUtils.rm("spec/schemas/person.avsc")
-
-    encoded_data = avro.encode(data, schema_name: "person")
-
-    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
-  end
-
-  def define_schema(path, content)
-    File.open(File.join("spec/schemas", path), "w") do |f|
-      f.write(content)
-    end
-  end
-end