avro_turf 1.18.0 → 1.20.0

data/spec/schema_store_spec.rb

@@ -1,4 +1,6 @@
-require 'avro_turf/schema_store'
+# frozen_string_literal: true
+
+require "avro_turf/schema_store"
 
 describe AvroTurf::SchemaStore do
   let(:store) { AvroTurf::SchemaStore.new(path: "spec/schemas") }
@@ -26,7 +28,7 @@ describe AvroTurf::SchemaStore do
       expect(schema.fullname).to eq "message"
     end
 
-    it 'searches for nested types with the correct namespace' do
+    it "searches for nested types with the correct namespace" do
       define_schema "foo/bar.avsc", <<-AVSC
         {
           "type": "record",
@@ -50,7 +52,7 @@ describe AvroTurf::SchemaStore do
         }
       AVSC
 
-      schema = store.find('foo.bar')
+      schema = store.find("foo.bar")
       expect(schema.fullname).to eq "foo.bar"
       expect(schema.fields.first.type.fullname).to eq "foo.another_schema"
     end
@@ -281,11 +283,11 @@ describe AvroTurf::SchemaStore do
         }
       AVSC
 
-      schema = store.find('person', 'test')
+      schema = store.find("person", "test")
       expect(schema.fullname).to eq "test.person"
 
-      expect { store.find('address', 'test') }.
-        to raise_error(AvroTurf::SchemaNotFoundError)
+      expect { store.find("address", "test") }
+        .to raise_error(AvroTurf::SchemaNotFoundError)
     end
 
     # This test would fail under avro_turf <= v0.11.0
@@ -335,21 +337,21 @@ describe AvroTurf::SchemaStore do
       AVSC
 
       company = nil
-      person = store.find('person', 'test')
+      person = store.find("person", "test")
 
       # This should *NOT* raise the error:
       # #<Avro::SchemaParseError: The name "test.location" is already in use.>
-      expect { company = store.find('company', 'test') }.not_to raise_error
+      expect { company = store.find("company", "test") }.not_to raise_error
 
-      person_location_field = person.fields_hash['location']
-      expect(person_location_field.type.name).to eq('location')
-      expect(person_location_field.type.fields_hash).to include('zipcode')
-      expect(person_location_field.type.fields_hash).not_to include('postcode')
+      person_location_field = person.fields_hash["location"]
+      expect(person_location_field.type.name).to eq("location")
+      expect(person_location_field.type.fields_hash).to include("zipcode")
+      expect(person_location_field.type.fields_hash).not_to include("postcode")
 
-      company_headquarters_field = company.fields_hash['headquarters']
-      expect(company_headquarters_field.type.name).to eq('location')
-      expect(company_headquarters_field.type.fields_hash).to include('postcode')
-      expect(company_headquarters_field.type.fields_hash).not_to include('zipcode')
+      company_headquarters_field = company.fields_hash["headquarters"]
+      expect(company_headquarters_field.type.name).to eq("location")
+      expect(company_headquarters_field.type.fields_hash).to include("postcode")
+      expect(company_headquarters_field.type.fields_hash).not_to include("zipcode")
     end
 
     it "is thread safe" do
@@ -364,10 +366,10 @@ describe AvroTurf::SchemaStore do
       # Set a Thread breakpoint right in the core place of race condition
       expect(Avro::Name)
         .to receive(:add_name)
-        .and_wrap_original { |m, *args|
-          Thread.stop
-          m.call(*args)
-        }
+          .and_wrap_original { |m, *args|
+              Thread.stop
+              m.call(*args)
+            }
 
       # Run two concurring threads which both will trigger the same schema loading
       threads = 2.times.map { Thread.new { store.find("address") } }
@@ -377,7 +379,7 @@ describe AvroTurf::SchemaStore do
       expect {
         # Resume the threads evaluation, one after one
         threads.each do |thread|
-          next unless thread.status == 'sleep'
+          next unless thread.status == "sleep"
 
           thread.run
           sleep 0.001 until thread.stop?

data/spec/schema_to_avro_patch_spec.rb

@@ -1,4 +1,6 @@
-require 'webmock/rspec'
+# frozen_string_literal: true
+
+require "webmock/rspec"
 
 # This spec verifies the monkey-patch that we have to apply until the avro
 # gem releases a fix for bug AVRO-1848:
@@ -13,17 +15,16 @@ describe Avro::Schema do
         ]
       }
     SCHEMA
-    
+
     expect(schema.to_avro).to eq({
-      'type' => 'record', 'name' => 'Record', 'namespace' => 'my.name.space',
-      'fields' => [
-        {'name' => 'is_usable', 'type' => 'boolean', 'default' => false}
+      "type" => "record", "name" => "Record", "namespace" => "my.name.space",
+      "fields" => [
+        {"name" => "is_usable", "type" => "boolean", "default" => false}
       ]
     })
   end
 end
 
-
 describe Avro::IO::DatumReader do
   let(:writer_schema) do
     Avro::Schema.parse <<-AVSC
@@ -53,7 +54,7 @@ describe Avro::IO::DatumReader do
     stream = StringIO.new
     writer = Avro::IO::DatumWriter.new(writer_schema)
     encoder = Avro::IO::BinaryEncoder.new(stream)
-    writer.write({ 'one' => 'first' }, encoder)
+    writer.write({"one" => "first"}, encoder)
     encoded = stream.string
 
     stream = StringIO.new(encoded)

data/spec/spec_helper.rb

@@ -1,9 +1,11 @@
-require 'bundler/setup'
-require 'logger'
-require 'json_spec'
-require 'pp' # Require pp before fakefs to fix TypeError: superclass mismatch for class File
-require 'fakefs/spec_helpers'
-require 'avro_turf'
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "logger"
+require "json_spec"
+require "pp" # Require pp before fakefs to fix TypeError: superclass mismatch for class File
+require "fakefs/spec_helpers"
+require "avro_turf"
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
@@ -12,9 +14,7 @@ module Helpers
     file = File.join("spec/schemas", path)
     dir = File.dirname(file)
     FileUtils.mkdir_p(dir)
-    File.open(file, "w") do |f|
-      f.write(content)
-    end
+    File.write(file, content)
   end
 
   def store_cache(path, hash)

data/spec/support/authorized_fake_confluent_schema_registry_server.rb

@@ -1,5 +1,7 @@
-require 'avro_turf/test/fake_confluent_schema_registry_server'
+# frozen_string_literal: true
+
+require "avro_turf/test/fake_confluent_schema_registry_server"
 
 class AuthorizedFakeConfluentSchemaRegistryServer < FakeConfluentSchemaRegistryServer
-  set :host_authorization, permitted_hosts: ['example.org', 'registry.example.com']
+  set :host_authorization, permitted_hosts: ["example.org", "registry.example.com"]
 end

data/spec/support/authorized_fake_prefixed_confluent_schema_registry_server.rb

@@ -1,5 +1,7 @@
-require 'avro_turf/test/fake_prefixed_confluent_schema_registry_server'
+# frozen_string_literal: true
+
+require "avro_turf/test/fake_prefixed_confluent_schema_registry_server"
 
 class AuthorizedFakePrefixedConfluentSchemaRegistryServer < FakePrefixedConfluentSchemaRegistryServer
-  set :host_authorization, permitted_hosts: ['example.org', 'registry.example.com']
+  set :host_authorization, permitted_hosts: ["example.org", "registry.example.com"]
 end

data/spec/support/confluent_schema_registry_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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 |schema_context: nil|
@@ -10,16 +12,16 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
       type: "record",
       name: "person",
       fields: [
-        { name: "name", type: "string" }
+        {name: "name", type: "string"}
       ]
     }.to_json
   end
   let(:headers) do
     {
-      'Accept'=>'*/*',
-      'Content-Type'=> AvroTurf::ConfluentSchemaRegistry::CONTENT_TYPE,
-      'Host'=> "#{URI.parse(registry_url).host}:80",
-      'User-Agent'=> "excon/#{Excon::VERSION}"
+      "Accept" => "*/*",
+      "Content-Type" => AvroTurf::ConfluentSchemaRegistry::CONTENT_TYPE,
+      "Host" => URI.parse(registry_url).host.to_s,
+      "User-Agent" => "excon/#{Excon::VERSION}"
     }
   end
 
@@ -81,21 +83,21 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#schema_subject_versions" 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_id1 = registry.register(subject_name, {type: :record, name: "r1", fields: []}.to_json)
+      registry.register(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)
+      schema_id2 = registry.register(other_subject_name, {type: :record, name: "r2", fields: []}.to_json)
       expect(registry.schema_subject_versions(schema_id1)).to eq([
-        'subject' => expected_subject_name,
-        'version' => 1
+        "subject" => expected_subject_name,
+        "version" => 1
       ])
       expect(registry.schema_subject_versions(schema_id2)).to include({
-        'subject' => expected_subject_name,
-        'version' => 2
-      },{
-        'subject' => with_schema_context_if_applicable(schema_context, other_subject_name),
-        'version' => 1
-      } )
+        "subject" => expected_subject_name,
+        "version" => 2
+      }, {
+        "subject" => with_schema_context_if_applicable(schema_context, other_subject_name),
+        "version" => 1
+      })
     end
 
     context "when the schema does not exist" do
@@ -111,14 +113,14 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
     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)
+          {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' }
+      let(:subject_name) { "missing" }
 
       it "raises an error" do
         expect do
@@ -130,10 +132,10 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#subject_version" do
     let!(:schema_id1) do
-      registry.register(subject_name, { type: :record, name: "r0", fields: [] }.to_json)
+      registry.register(subject_name, {type: :record, name: "r0", fields: []}.to_json)
     end
     let!(:schema_id2) do
-      registry.register(subject_name, { type: :record, name: "r1", fields: [] }.to_json)
+      registry.register(subject_name, {type: :record, name: "r1", fields: []}.to_json)
     end
 
     let(:expected) do
@@ -141,7 +143,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
         subject: expected_subject_name,
         version: 1,
         id: schema_id1,
-        schema: { type: :record, name: "r0", fields: [] }.to_json
+        schema: {type: :record, name: "r0", fields: []}.to_json
       }.to_json
     end
 
@@ -156,7 +158,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
           subject: expected_subject_name,
           version: 2,
           id: schema_id2,
-          schema: { type: :record, name: "r1", fields: [] }.to_json
+          schema: {type: :record, name: "r1", fields: []}.to_json
         }.to_json
       end
 
@@ -169,7 +171,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
     context "when the subject does not exist" do
       it "raises an error" do
         expect do
-          registry.subject_version('missing')
+          registry.subject_version("missing")
         end.to raise_error(Excon::Errors::NotFound)
       end
     end
@@ -224,7 +226,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#global_config" do
     let(:expected) do
-      { compatibility: 'BACKWARD' }.to_json
+      {compatibility: "BACKWARD"}.to_json
     end
 
     it "returns the global configuration" do
@@ -234,7 +236,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#update_global_config" do
     let(:config) do
-      { compatibility: 'FORWARD' }
+      {compatibility: "FORWARD"}
     end
     let(:expected) { config.to_json }
 
@@ -246,7 +248,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#subject_config" do
     let(:expected) do
-      { compatibility: 'BACKWARD' }.to_json
+      {compatibility: "BACKWARD"}.to_json
     end
 
     context "when the subject config is not set" do
@@ -257,7 +259,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
     context "when the subject config is set" do
       let(:config) do
-        { compatibility: 'FULL' }
+        {compatibility: "FULL"}
       end
       let(:expected) { config.to_json }
 
@@ -273,7 +275,7 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
 
   describe "#update_subject_config" do
     let(:config) do
-      { compatibility: 'NONE' }
+      {compatibility: "NONE"}
     end
     let(:expected) { config.to_json }
 
@@ -287,8 +289,8 @@ shared_examples_for "a confluent schema registry client" do |schema_context: nil
   # active_support/core_ext.
   def break_to_json(avro_schema)
     def avro_schema.to_json(*args)
-      instance_variables.each_with_object(Hash.new) do |ivar, result|
-        result[ivar.to_s.sub('@', '')] = instance_variable_get(ivar)
+      instance_variables.each_with_object({}) do |ivar, result|
+        result[ivar.to_s.sub("@", "")] = instance_variable_get(ivar)
       end.to_json(*args)
     end
   end