RubyGems - schema_registry_client - Versions diffs - 0.0.8 → 0.0.10 - Mend

schema_registry_client 0.0.8 → 0.0.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +4 -0
data/Gemfile +1 -1
data/Gemfile.lock +1 -1
data/Rakefile +1 -1
data/lib/schema_registry_client/avro_schema_store.rb +8 -8
data/lib/schema_registry_client/cached_confluent_schema_registry.rb +5 -5
data/lib/schema_registry_client/confluent_schema_registry.rb +17 -12
data/lib/schema_registry_client/output/json_schema.rb +12 -12
data/lib/schema_registry_client/output/proto_text.rb +45 -45
data/lib/schema_registry_client/schema/avro.rb +8 -8
data/lib/schema_registry_client/schema/base.rb +4 -4
data/lib/schema_registry_client/schema/proto_json_schema.rb +3 -3
data/lib/schema_registry_client/schema/protobuf.rb +20 -20
data/lib/schema_registry_client/version.rb +1 -1
data/lib/schema_registry_client.rb +19 -19
data/schema_registry_client.gemspec +20 -20
data/spec/decoding_spec.rb +51 -51
data/spec/encoding_spec.rb +80 -88
data/spec/json_schema_spec.rb +2 -2
data/spec/proto_text_spec.rb +1 -1
data/spec/spec_helper.rb +5 -5
metadata +1 -1

data/spec/encoding_spec.rb CHANGED Viewed

@@ -1,111 +1,111 @@
 # frozen_string_literal: true
-RSpec.describe 'encoding' do
+RSpec.describe "encoding" do
   let(:schema_registry_client) do
     SchemaRegistry::Client.new(
-      registry_url: 'http://localhost:8081'
+      registry_url: "http://localhost:8081"
     )
   end
-  it 'should encode a simple message' do
+  it "should encode a simple message" do
     schema = File.read("#{__dir__}/schemas/simple/simple.proto")
-    stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-           .with(body: { 'schemaType' => 'PROTOBUF',
-                         'references' => [],
-                         'schema' => schema }).to_return_json(body: { id: 15 })
-    msg = Simple::V1::SimpleMessage.new(name: 'my name')
-    encoded = schema_registry_client.encode(msg, subject: 'simple')
+    stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [],
+                   "schema" => schema}).to_return_json(body: {id: 15})
+    msg = Simple::V1::SimpleMessage.new(name: "my name")
+    encoded = schema_registry_client.encode(msg, subject: "simple")
     expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u0000#{msg.to_proto}")
     # if we do it again we should not see any more requests
-    encoded2 = schema_registry_client.encode(msg, subject: 'simple')
+    encoded2 = schema_registry_client.encode(msg, subject: "simple")
     expect(encoded2).to eq(encoded)
     expect(stub).to have_been_requested.once
   end
-  it 'should encode a complex message' do
+  it "should encode a complex message" do
     schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
     dep_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
-    dep_stub = stub_request(:post, 'http://localhost:8081/subjects/simple%2Fsimple.proto/versions')
-               .with(body: { 'schemaType' => 'PROTOBUF',
-                             'references' => [],
-                             'schema' => dep_schema }).to_return_json(body: { id: 15 })
-    version_stub = stub_request(:get, 'http://localhost:8081/schemas/ids/15/versions')
-                   .to_return_json(body: [{ version: 1, subject: 'simple/simple.proto' }])
-    stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
-           .with(body: { 'schemaType' => 'PROTOBUF',
-                         'references' => [
-                           {
-                             name: 'simple/simple.proto',
-                             subject: 'simple/simple.proto',
-                             version: 1
-                           }
-                         ],
-                         'schema' => schema }).to_return_json(body: { id: 20 })
+    dep_stub = stub_request(:post, "http://localhost:8081/subjects/simple%2Fsimple.proto/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [],
+                   "schema" => dep_schema}).to_return_json(body: {id: 15})
+    version_stub = stub_request(:get, "http://localhost:8081/schemas/ids/15/versions")
+      .to_return_json(body: [{version: 1, subject: "simple/simple.proto"}])
+    stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+      .with(body: {"schemaType" => "PROTOBUF",
+                   "references" => [
+                     {
+                       name: "simple/simple.proto",
+                       subject: "simple/simple.proto",
+                       version: 1
+                     }
+                   ],
+                   "schema" => schema}).to_return_json(body: {id: 20})
     msg = Referenced::V1::MessageB::MessageBA.new(
-      simple: Simple::V1::SimpleMessage.new(name: 'my name')
+      simple: Simple::V1::SimpleMessage.new(name: "my name")
     )
-    encoded = schema_registry_client.encode(msg, subject: 'referenced')
+    encoded = schema_registry_client.encode(msg, subject: "referenced")
     expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg.to_proto}")
     # if we do it again we should not see any more requests
-    encoded2 = schema_registry_client.encode(msg, subject: 'referenced')
+    encoded2 = schema_registry_client.encode(msg, subject: "referenced")
     expect(encoded2).to eq(encoded)
     expect(stub).to have_been_requested.once
     expect(dep_stub).to have_been_requested.once
     expect(version_stub).to have_been_requested.once
   end
-  describe 'with JSON' do
+  describe "with JSON" do
     let(:schema_registry_client) do
       SchemaRegistry::Client.new(
-        registry_url: 'http://localhost:8081',
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     end
-    it 'should encode a simple message' do
+    it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/simple.json").strip
-      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-             .with(body: { 'schemaType' => 'JSON',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 15 })
-      msg = Simple::V1::SimpleMessage.new(name: 'my name')
-      encoded = schema_registry_client.encode(msg, subject: 'simple')
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "JSON",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded = schema_registry_client.encode(msg, subject: "simple")
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F{\"name\":\"my name\"}")
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'simple')
+      encoded2 = schema_registry_client.encode(msg, subject: "simple")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
-    it 'should encode a complex message' do
+    it "should encode a complex message" do
       schema = File.read("#{__dir__}/schemas/referenced/referenced.json").strip
-      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
-             .with(body: { 'schemaType' => 'JSON',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 20 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+        .with(body: {"schemaType" => "JSON",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 20})
       msg = Referenced::V1::MessageB::MessageBA.new(
-        simple: Simple::V1::SimpleMessage.new(name: 'my name')
+        simple: Simple::V1::SimpleMessage.new(name: "my name")
       )
-      encoded = schema_registry_client.encode(msg, subject: 'referenced')
+      encoded = schema_registry_client.encode(msg, subject: "referenced")
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014{\"simple\":{\"name\":\"my name\"}}")
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'referenced')
+      encoded2 = schema_registry_client.encode(msg, subject: "referenced")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
   end
-  describe 'with Avro' do
+  describe "with Avro" do
     let(:schema_registry_client) do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
       SchemaRegistry::Client.new(
-        registry_url: 'http://localhost:8081',
+        registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
@@ -114,74 +114,68 @@ RSpec.describe 'encoding' do
       SchemaRegistry.avro_schema_path = nil
     end
-    it 'should encode a simple message' do
+    it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
-      stub = stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 15 })
-      msg = { 'name' => 'my name' }
-      encoded = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
+      msg = {"name" => "my name"}
+      encoded = schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       # Avro encoding: magic byte (0x00) + schema id (4 bytes, big-endian) + Avro binary data
       # "my name" encoded as Avro string: length (0x0E = 14) + "my name" bytes
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u000F\u000Emy name")
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+      encoded2 = schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
-    it 'should encode a complex message with nested record' do
+    it "should encode a complex message with nested record" do
       schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
-      stub = stub_request(:post, 'http://localhost:8081/subjects/referenced/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema }).to_return_json(body: { id: 20 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+        .with(body: {"schema" => schema}).to_return_json(body: {id: 20})
       msg = {
-        'simple' => {
-          'name' => 'my name'
+        "simple" => {
+          "name" => "my name"
         }
       }
-      encoded = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      encoded = schema_registry_client.encode(msg, subject: "referenced", schema_name: "referenced.v1.MessageBA")
       # Avro encoding: magic byte + schema id + Avro binary for nested record
       expect(encoded).to eq("\u0000\u0000\u0000\u0000\u0014\u000Emy name")
       # if we do it again we should not see any more requests
-      encoded2 = schema_registry_client.encode(msg, subject: 'referenced', schema_name: 'referenced.v1.MessageBA')
+      encoded2 = schema_registry_client.encode(msg, subject: "referenced", schema_name: "referenced.v1.MessageBA")
       expect(encoded2).to eq(encoded)
       expect(stub).to have_been_requested.once
     end
-    it 'should handle multiple fields' do
+    it "should handle multiple fields" do
       # Create a temporary schema file for testing
       multi_schema_path = "#{__dir__}/schemas/test/v1"
       FileUtils.mkdir_p(multi_schema_path)
       multi_schema = {
-        'type' => 'record',
-        'name' => 'MultiFieldMessage',
-        'namespace' => 'test.v1',
-        'fields' => [
-          { 'name' => 'name', 'type' => 'string' },
-          { 'name' => 'age', 'type' => 'int' }
+        "type" => "record",
+        "name" => "MultiFieldMessage",
+        "namespace" => "test.v1",
+        "fields" => [
+          {"name" => "name", "type" => "string"},
+          {"name" => "age", "type" => "int"}
         ]
       }
       schema_json = JSON.pretty_generate(multi_schema)
       File.write("#{multi_schema_path}/MultiFieldMessage.avsc", schema_json)
-      stub = stub_request(:post, 'http://localhost:8081/subjects/multi/versions')
-             .with(body: { 'schemaType' => 'AVRO',
-                           'references' => [],
-                           'schema' => schema_json }).to_return_json(body: { id: 25 })
+      stub = stub_request(:post, "http://localhost:8081/subjects/multi/versions")
+        .with(body: {"schema" => schema_json}).to_return_json(body: {id: 25})
-      msg = { 'name' => 'Alice', 'age' => 30 }
-      encoded = schema_registry_client.encode(msg, subject: 'multi', schema_name: 'test.v1.MultiFieldMessage')
+      msg = {"name" => "Alice", "age" => 30}
+      encoded = schema_registry_client.encode(msg, subject: "multi", schema_name: "test.v1.MultiFieldMessage")
       # Verify encoding starts with magic byte and schema id
       expect(encoded[0]).to eq("\u0000")
-      expect(encoded[1..4].unpack1('N')).to eq(25)
+      expect(encoded[1..4].unpack1("N")).to eq(25)
       expect(stub).to have_been_requested.once
@@ -189,18 +183,16 @@ RSpec.describe 'encoding' do
       FileUtils.rm_rf("#{__dir__}/schemas/test")
     end
-    it 'should validate schema before encoding' do
+    it "should validate schema before encoding" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
-      stub_request(:post, 'http://localhost:8081/subjects/simple/versions')
-        .with(body: { 'schemaType' => 'AVRO',
-                      'references' => [],
-                      'schema' => schema }).to_return_json(body: { id: 15 })
+      stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
       # Invalid message - missing required field
-      msg = { 'invalid_field' => 'value' }
+      msg = {"invalid_field" => "value"}
       expect do
-        schema_registry_client.encode(msg, subject: 'simple', schema_name: 'simple.v1.SimpleMessage')
+        schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
       end.to raise_error(Avro::SchemaValidator::ValidationError)
     end
   end

data/spec/json_schema_spec.rb CHANGED Viewed

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require 'schema_registry_client/output/json_schema'
+require "schema_registry_client/output/json_schema"
 RSpec.describe SchemaRegistry::Output::JsonSchema do
-  it 'should output as expected' do
+  it "should output as expected" do
     output = described_class.output(Everything::V1::TestAllTypes.descriptor.to_proto)
     expected = File.read("#{__dir__}/schemas/everything/everything.json")

data/spec/proto_text_spec.rb CHANGED Viewed

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 RSpec.describe SchemaRegistry::Output::ProtoText do
-  it 'should output as expected' do
+  it "should output as expected" do
     output = described_class.output(Everything::V1::TestAllTypes.descriptor.file_descriptor.to_proto)
     expected = File.read("#{__dir__}/schemas/everything/everything.proto")

data/spec/spec_helper.rb CHANGED Viewed

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
-require 'simplecov'
+require "simplecov"
 SimpleCov.start
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-$LOAD_PATH.unshift(File.expand_path('gen', __dir__))
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("gen", __dir__))
 Dir["#{__dir__}/gen/**/*.rb"].each { |file| require file }
-require 'schema_registry_client'
-require 'webmock/rspec'
+require "schema_registry_client"
+require "webmock/rspec"
 RSpec.configure do |config|
   config.full_backtrace = true

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_registry_client
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Daniel Orner