avro_turf 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a708d217a7af1550daca801dec09f63eee619c882bf099dc456ce300e2414aee
-  data.tar.gz: e4fe1fa9f4b8af78f36a2eb59caeb6946aa1ef3a1dc0db20d548d122c8ab7802
+  metadata.gz: 8fc2d29f1112e649cc2cd5ec96f2126a0ea5fa8f46ebee01d908cdceeac8da0d
+  data.tar.gz: e1989abd9d9b0e5db24f360e96e7bce7ce18e5f488cc794d25a2b3fae6102e66
 SHA512:
-  metadata.gz: 5476655050a88e2e38ccedaa9cf3228810802507fa8fb0c6b7b345b2da617577a8f6d015d3d5290630ebf07476fe1aa1b2c3eea3c7de7bcf6969ee511039eff6
-  data.tar.gz: 7a61be786f276dec7a62385413f89be39188670337d739e2eddfcfc2b2ed7cf8fa73c5148d06a4a4f113cfa7d8627885529d1900b58e7f5ba624b68a8137b1b9
+  metadata.gz: f562a66ba746d2c0e4bee8b8f3a0e7fcf65900f261eca444986c8ff6c68231e67aa9c4dc659213721d0d09c65fd9273e12e158938c0773baa48cf86598d6bef9
+  data.tar.gz: 53e3640900a3b64038fe063f5dadab2049417490be1833bb5f17124307abe628af64ea0c68b5bdc2bd4ef2f6e58bbfac287696eaf5ece9a35ddb7c2ab8e5127e

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## v1.2.0
+
+- Expose `fetch_schema`, `fetch_schema_by_id` and `register_schema` schema in `Messaging` interface (#117, #119)
+- Add ability to validate message before encoding in `Messaging#encode` interface (#116, #118)
+
 ## v1.1.0
 
 - Compatibility with Avro v1.10.x.

data/README.md

@@ -178,6 +178,10 @@ data = avro.encode({ "title" => "hello, world" }, subject: 'greeting', version:
 # of the same schema version will be served by the cache.
 data = avro.encode({ "title" => "hello, world" }, schema_id: 2)
 
+# Message can be validated before encoding to get a description of problem through
+# Avro::SchemaValidator::ValidationError exception
+data = avro.encode({ "titl" => "hello, world" }, schema_name: "greeting", validate: true)
+
 # When decoding, the schema will be fetched from the registry and cached. Subsequent
 # instances of the same schema id will be served by the cache.
 avro.decode(data) #=> { "title" => "hello, world" }
@@ -189,6 +193,20 @@ result.message       #=> { "title" => "hello, world" }
 result.schema_id     #=> 3
 result.writer_schema #=> #<Avro::Schema: ...>
 result.reader_schema #=> nil
+
+# You can also work with schema through this interface:
+# Fetch latest schema for subject from registry
+schema, schema_id = avro.fetch_schema(subject: 'greeting')
+# Fetch specific version
+schema, schema_id = avro.fetch_schema(subject: 'greeting', version: 1)
+# Fetch schema by id
+schema, schema_id = avro.fetch_schema_by_id(3)
+# Register schema fetched from store by name
+schema, schema_id = avro.register_schema(schema_name: 'greeting')
+# Specify namespace (same as schema_name: 'somewhere.greeting')
+schema, schema_id = avro.register_schema(schema_name: 'greeting', namespace: 'somewhere')
+# Customize subject under which to register schema
+schema, schema_id = avro.register_schema(schema_name: 'greeting', namespace: 'somewhere', subject: 'test')
 ```
 
 ### Confluent Schema Registry Client

data/lib/avro_turf/messaging.rb

@@ -84,19 +84,26 @@ class AvroTurf
     #               the data. Must match the schema used when encoding (optional).
     # schema_id   - The integer id of the schema that should be used to encode
     #               the data.
+    # validate    - The boolean for performing complete message validation before
+    #               encoding it, Avro::SchemaValidator::ValidationError with
+    #               a descriptive message will be raised in case of invalid message.
     #
     # Returns the encoded data as a String.
-    def encode(message, schema_name: nil, namespace: @namespace, subject: nil, version: nil, schema_id: nil)
-      schema_id, schema = if schema_id
+    def encode(message, schema_name: nil, namespace: @namespace, subject: nil, version: nil, schema_id: nil, validate: false)
+      schema, schema_id = if schema_id
         fetch_schema_by_id(schema_id)
       elsif subject && version
-        fetch_schema(subject, version)
+        fetch_schema(subject: subject, version: version)
       elsif schema_name
-        register_schema(subject, schema_name, namespace)
+        register_schema(subject: subject, schema_name: schema_name, namespace: namespace)
       else
         raise ArgumentError.new('Neither schema_name nor schema_id nor subject + version provided to determine the schema.')
       end
 
+      if validate
+        Avro::SchemaValidator.validate!(schema, message, recursive: true, encoded: false, fail_on_extra_fields: true)
+      end
+
       stream = StringIO.new
       writer = Avro::IO::DatumWriter.new(schema)
       encoder = Avro::IO::BinaryEncoder.new(stream)
@@ -169,31 +176,29 @@ class AvroTurf
       raise SchemaNotFoundError.new("Schema with id: #{schema_id} is not found on registry")
     end
 
-    private
-
     # Providing subject and version to determine the schema,
     # which skips the auto registeration of schema on the schema registry.
     # Fetch the schema from registry with the provided subject name and version.
-    def fetch_schema(subject, version)
+    def fetch_schema(subject:, version: 'latest')
       schema_data = @registry.subject_version(subject, version)
       schema_id = schema_data.fetch('id')
       schema = Avro::Schema.parse(schema_data.fetch('schema'))
-      [schema_id, schema]
+      [schema, schema_id]
     end
 
     # Fetch the schema from registry with the provided schema_id.
     def fetch_schema_by_id(schema_id)
       schema_json = @registry.fetch(schema_id)
       schema = Avro::Schema.parse(schema_json)
-      [schema_id, schema]
+      [schema, schema_id]
     end
 
     # Schemas are registered under the full name of the top level Avro record
     # type, or `subject` if it's provided.
-    def register_schema(subject, schema_name, namespace)
+    def register_schema(schema_name:, subject: nil, namespace: nil)
       schema = @schema_store.find(schema_name, namespace)
       schema_id = @registry.register(subject || schema.fullname, schema)
-      [schema_id, schema]
+      [schema, schema_id]
     end
   end
 end

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/messaging_spec.rb

@@ -297,4 +297,106 @@ describe AvroTurf::Messaging do
       end
     end
   end
+
+  context "validating" do
+    subject(:encode){ avro.encode(message, schema_name: "person", validate: true) }
+
+    context "for correct message" do
+      it { expect { encode }.not_to raise_error }
+    end
+
+    context "when message has wrong type" do
+      let(:message) { { "full_name" => 123 } }
+
+      it { expect { encode }.to raise_error(Avro::SchemaValidator::ValidationError, /\.full_name expected type string, got int/) }
+    end
+
+    context "when message contains extra fields (typo in key)" do
+      let(:message) { { "fulll_name" => "John Doe" } }
+
+      it { expect { encode }.to raise_error(Avro::SchemaValidator::ValidationError, /extra field 'fulll_name'/) }
+    end
+  end
+
+  context 'fetching and registering schema' do
+    let(:schema_store) { AvroTurf::SchemaStore.new(path: "spec/schemas") }
+
+    let(:registry) { AvroTurf::ConfluentSchemaRegistry.new(registry_url, logger: logger) }
+
+    let(:avro) do
+      AvroTurf::Messaging.new(
+        registry: registry,
+        schema_store: schema_store,
+        logger: logger
+      )
+    end
+
+    let(:schema_id) { 234 }
+
+    context 'using fetch_schema' do
+      subject { avro.fetch_schema(subject: subj, version: version) }
+
+      let(:subj) { 'subject' }
+
+      let(:version) { 'version' }
+
+      let(:response) { {'id' => schema_id, 'schema' => schema_json} }
+
+      before do
+        allow(registry).to receive(:subject_version).with(subj, version).and_return(response)
+      end
+
+      it 'gets schema from registry' do
+        expect(subject).to eq([schema, schema_id])
+      end
+    end
+
+    context 'using fetch_schema_by_id' do
+      subject { avro.fetch_schema_by_id(schema_id) }
+
+      before do
+        allow(registry).to receive(:fetch).with(schema_id).and_return(schema_json)
+      end
+
+      it 'gets schema from registry' do
+        expect(subject).to eq([schema, schema_id])
+      end
+    end
+
+    context 'using register_schema' do
+      let(:schema_name) { 'schema_name' }
+
+      let(:namespace) { 'namespace' }
+
+      before do
+        allow(schema_store).to receive(:find).with(schema_name, namespace).and_return(schema)
+      end
+
+      context 'when subject is not set' do
+        subject { avro.register_schema(schema_name: schema_name, namespace: namespace) }
+
+        before do
+          allow(registry).to receive(:register).with(schema.fullname, schema).and_return(schema_id)
+        end
+
+        it 'registers schema in registry' do
+          expect(subject).to eq([schema, schema_id])
+        end
+      end
+
+      context 'when subject is set' do
+        subject { avro.register_schema(schema_name: schema_name, namespace: namespace, subject: subj) }
+
+        let(:subj) { 'subject' }
+
+        before do
+          allow(registry).to receive(:register).with(subj, schema).and_return(schema_id)
+        end
+
+        it 'registers schema in registry' do
+          expect(subject).to eq([schema, schema_id])
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-30 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro