deimos-ruby 1.11.1 → 1.12.2

data/spec/producer_spec.rb

@@ -390,6 +390,116 @@ module ProducerTest
                                                       }, '456', '4561')
     end
 
+    context 'with Schema Class payloads' do
+      it 'should fail on invalid message with error handler' do
+        subscriber = Deimos.subscribe('produce') do |event|
+          expect(event.payload[:payloads]).to eq([{ 'invalid' => 'key' }])
+        end
+        expect(MyProducer.encoder).to receive(:validate).and_raise('OH NOES')
+        expect {
+          MyProducer.publish(Schemas::MySchema.new(test_id: 'foo', some_int: 'invalid'))
+        }.to raise_error('OH NOES')
+        Deimos.unsubscribe(subscriber)
+      end
+
+      it 'should produce a message' do
+        expect(described_class).to receive(:produce_batch).once.with(
+          Deimos::Backends::Test,
+          [
+            Deimos::Message.new({ 'test_id' => 'foo', 'some_int' => 123 },
+                                MyProducer,
+                                topic: 'my-topic',
+                                partition_key: 'foo',
+                                key: 'foo'),
+            Deimos::Message.new({ 'test_id' => 'bar', 'some_int' => 124 },
+                                MyProducer,
+                                topic: 'my-topic',
+                                partition_key: 'bar',
+                                key: 'bar')
+          ]
+        ).and_call_original
+
+        MyProducer.publish_list(
+          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+        )
+        expect('my-topic').to have_sent('test_id' => 'foo', 'some_int' => 123)
+        expect('your-topic').not_to have_sent('test_id' => 'foo', 'some_int' => 123)
+        expect('my-topic').not_to have_sent('test_id' => 'foo2', 'some_int' => 123)
+      end
+
+      it 'should not publish if publish disabled' do
+        expect(described_class).not_to receive(:produce_batch)
+        Deimos.configure { |c| c.producers.disabled = true }
+        MyProducer.publish_list(
+          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+        )
+        expect(MyProducer.topic).not_to have_sent(anything)
+      end
+
+      it 'should encode the key' do
+        Deimos.configure { |c| c.producers.topic_prefix = nil }
+        expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
+        expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'bar', topic: 'my-topic-key')
+        expect(MyProducer.encoder).to receive(:encode).with({
+                                                              'test_id' => 'foo',
+                                                              'some_int' => 123
+                                                            }, { topic: 'my-topic-value' })
+        expect(MyProducer.encoder).to receive(:encode).with({
+                                                              'test_id' => 'bar',
+                                                              'some_int' => 124
+                                                            }, { topic: 'my-topic-value' })
+
+        MyProducer.publish_list(
+          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+        )
+      end
+
+      it 'should encode with a schema' do
+        expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'foo_key' },
+                                                                      { topic: 'my-topic2-key' })
+        expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'bar_key' },
+                                                                      { topic: 'my-topic2-key' })
+
+        MySchemaProducer.publish_list(
+          [Schemas::MySchema.new(test_id: 'foo', some_int: 123, payload_key: { 'test_id' => 'foo_key' }),
+           Schemas::MySchema.new(test_id: 'bar', some_int: 124, payload_key: { 'test_id' => 'bar_key' })]
+        )
+      end
+
+      it 'should properly encode and coerce values with a nested record' do
+        expect(MyNestedSchemaProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
+        MyNestedSchemaProducer.publish(
+          Schemas::MyNestedSchema.new(
+            test_id: 'foo',
+            test_float: BigDecimal('123.456'),
+            test_array: ['1'],
+            some_nested_record: Schemas::MyNestedRecord.new(
+              some_int: 123,
+              some_float: BigDecimal('456.789'),
+              some_string: '123',
+              some_optional_int: nil
+            ),
+            some_optional_record: nil
+          )
+        )
+        expect(MyNestedSchemaProducer.topic).to have_sent(
+          'test_id' => 'foo',
+          'test_float' => 123.456,
+          'test_array' => ['1'],
+          'some_nested_record' => {
+            'some_int' => 123,
+            'some_float' => 456.789,
+            'some_string' => '123',
+            'some_optional_int' => nil
+          },
+          'some_optional_record' => nil
+        )
+      end
+    end
+
     describe 'disabling' do
       it 'should disable globally' do
         Deimos.disable_producers do

data/spec/schema_classes/generated.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Secondary Schema Classes ###
+  # Autogenerated Schema for Enum at com.my-namespace.AnEnum
+  class AnEnum < Deimos::SchemaClass::Enum
+    # @return ['sym1', 'sym2']
+    attr_accessor :an_enum
+
+    # :nodoc:
+    def initialize(an_enum)
+      super
+      self.an_enum = an_enum
+    end
+
+    # @override
+    def symbols
+      %w(sym1 sym2)
+    end
+
+    # @override
+    def to_h
+      @an_enum
+    end
+  end
+
+  # Autogenerated Schema for Record at com.my-namespace.ARecord
+  class ARecord < Deimos::SchemaClass::Record
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :a_record_field
+
+    # @override
+    def initialize(a_record_field: nil)
+      super
+      self.a_record_field = a_record_field
+    end
+
+    # @override
+    def schema
+      'ARecord'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'a_record_field' => @a_record_field
+      }
+    end
+  end
+
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.Generated
+  class Generated < Deimos::SchemaClass::Record
+    ### Attribute Readers ###
+    # @return [AnEnum]
+    attr_reader :an_enum
+    # @return [ARecord]
+    attr_reader :a_record
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :a_string
+    # @param value [Integer]
+    attr_accessor :a_int
+    # @param value [Integer]
+    attr_accessor :a_long
+    # @param value [Float]
+    attr_accessor :a_float
+    # @param value [Float]
+    attr_accessor :a_double
+    # @param value [nil, Integer]
+    attr_accessor :an_optional_int
+    # @param values [Array<Integer>]
+    attr_accessor :an_array
+    # @param values [Hash<String, String>]
+    attr_accessor :a_map
+    # @param value [String]
+    attr_accessor :timestamp
+    # @param value [String]
+    attr_accessor :message_id
+
+    ### Attribute Writers ###
+    # @param value [AnEnum]
+    def an_enum=(value)
+      @an_enum = AnEnum.initialize_from_value(value)
+    end
+
+    # @param value [ARecord]
+    def a_record=(value)
+      @a_record = ARecord.initialize_from_value(value)
+    end
+
+    # @override
+    def initialize(a_string: nil,
+                   a_int: nil,
+                   a_long: nil,
+                   a_float: nil,
+                   a_double: nil,
+                   an_optional_int: nil,
+                   an_enum: nil,
+                   an_array: nil,
+                   a_map: nil,
+                   timestamp: nil,
+                   message_id: nil,
+                   a_record: nil)
+      super
+      self.a_string = a_string
+      self.a_int = a_int
+      self.a_long = a_long
+      self.a_float = a_float
+      self.a_double = a_double
+      self.an_optional_int = an_optional_int
+      self.an_enum = an_enum
+      self.an_array = an_array
+      self.a_map = a_map
+      self.timestamp = timestamp
+      self.message_id = message_id
+      self.a_record = a_record
+    end
+
+    # @override
+    def schema
+      'Generated'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'a_string' => @a_string,
+        'a_int' => @a_int,
+        'a_long' => @a_long,
+        'a_float' => @a_float,
+        'a_double' => @a_double,
+        'an_optional_int' => @an_optional_int,
+        'an_enum' => @an_enum&.to_h,
+        'an_array' => @an_array,
+        'a_map' => @a_map,
+        'timestamp' => @timestamp,
+        'message_id' => @message_id,
+        'a_record' => @a_record&.to_h
+      }
+    end
+  end
+end

data/spec/schema_classes/my_nested_schema.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Secondary Schema Classes ###
+  # Autogenerated Schema for Record at com.my-namespace.MyNestedRecord
+  class MyNestedRecord < Deimos::SchemaClass::Record
+    ### Attribute Accessors ###
+    # @param value [Integer]
+    attr_accessor :some_int
+    # @param value [Float]
+    attr_accessor :some_float
+    # @param value [String]
+    attr_accessor :some_string
+    # @param value [nil, Integer]
+    attr_accessor :some_optional_int
+
+    # @override
+    def initialize(some_int: nil,
+                   some_float: nil,
+                   some_string: nil,
+                   some_optional_int: nil)
+      super
+      self.some_int = some_int
+      self.some_float = some_float
+      self.some_string = some_string
+      self.some_optional_int = some_optional_int
+    end
+
+    # @override
+    def schema
+      'MyNestedRecord'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'some_int' => @some_int,
+        'some_float' => @some_float,
+        'some_string' => @some_string,
+        'some_optional_int' => @some_optional_int
+      }
+    end
+  end
+
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MyNestedSchema
+  class MyNestedSchema < Deimos::SchemaClass::Record
+    ### Attribute Readers ###
+    # @return [MyNestedRecord]
+    attr_reader :some_nested_record
+    # @return [nil, MyNestedRecord]
+    attr_reader :some_optional_record
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :test_id
+    # @param value [Float]
+    attr_accessor :test_float
+    # @param values [Array<String>]
+    attr_accessor :test_array
+
+    ### Attribute Writers ###
+    # @param value [MyNestedRecord]
+    def some_nested_record=(value)
+      @some_nested_record = MyNestedRecord.initialize_from_value(value)
+    end
+
+    # @param value [nil, MyNestedRecord]
+    def some_optional_record=(value)
+      @some_optional_record = MyNestedRecord.initialize_from_value(value)
+    end
+
+    # @override
+    def initialize(test_id: nil,
+                   test_float: nil,
+                   test_array: nil,
+                   some_nested_record: nil,
+                   some_optional_record: nil)
+      super
+      self.test_id = test_id
+      self.test_float = test_float
+      self.test_array = test_array
+      self.some_nested_record = some_nested_record
+      self.some_optional_record = some_optional_record
+    end
+
+    # @override
+    def schema
+      'MyNestedSchema'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'test_id' => @test_id,
+        'test_float' => @test_float,
+        'test_array' => @test_array,
+        'some_nested_record' => @some_nested_record&.to_h,
+        'some_optional_record' => @some_optional_record&.to_h
+      }
+    end
+  end
+end

data/spec/schema_classes/my_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MySchema
+  class MySchema < Deimos::SchemaClass::Record
+    ### Attribute Readers ###
+    # @return [MySchemaKey]
+    attr_reader :payload_key
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :test_id
+    # @param value [Integer]
+    attr_accessor :some_int
+
+    ### Attribute Writers ###
+    # @param value [MySchemaKey]
+    def payload_key=(value)
+      @payload_key = MySchemaKey.initialize_from_value(value)
+    end
+
+    # @override
+    def initialize(test_id: nil,
+                   some_int: nil,
+                   payload_key: nil)
+      super
+      self.test_id = test_id
+      self.some_int = some_int
+      self.payload_key = payload_key
+    end
+
+    # @override
+    def schema
+      'MySchema'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'test_id' => @test_id,
+        'some_int' => @some_int,
+        'payload_key' => @payload_key&.to_h
+      }
+    end
+  end
+end

data/spec/schema_classes/my_schema_key.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MySchema-key
+  class MySchemaKey < Deimos::SchemaClass::Record
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :test_id
+
+    # @override
+    def initialize(test_id: nil)
+      super
+      self.test_id = test_id
+    end
+
+    # @override
+    def schema
+      'MySchema-key'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'test_id' => @test_id
+      }
+    end
+  end
+end

data/spec/schema_classes/my_schema_with_complex_types.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Secondary Schema Classes ###
+  # Autogenerated Schema for Record at com.my-namespace.ARecord
+  class ARecord < Deimos::SchemaClass::Record
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :a_record_field
+
+    # @override
+    def initialize(a_record_field: nil)
+      super
+      self.a_record_field = a_record_field
+    end
+
+    # @override
+    def schema
+      'ARecord'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'a_record_field' => @a_record_field
+      }
+    end
+  end
+
+  # Autogenerated Schema for Enum at com.my-namespace.AnEnum
+  class AnEnum < Deimos::SchemaClass::Enum
+    # @return ['sym1', 'sym2']
+    attr_accessor :an_enum
+
+    # :nodoc:
+    def initialize(an_enum)
+      super
+      self.an_enum = an_enum
+    end
+
+    # @override
+    def symbols
+      %w(sym1 sym2)
+    end
+
+    # @override
+    def to_h
+      @an_enum
+    end
+  end
+
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MySchemaWithComplexTypes
+  class MySchemaWithComplexTypes < Deimos::SchemaClass::Record
+    ### Attribute Readers ###
+    # @return [ARecord]
+    attr_reader :some_record
+    # @return [nil, ARecord]
+    attr_reader :some_optional_record
+    # @return [Array<ARecord>]
+    attr_reader :some_record_array
+    # @return [Hash<String, ARecord>]
+    attr_reader :some_record_map
+    # @return [Array<AnEnum>]
+    attr_reader :some_enum_array
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :test_id
+    # @param value [Float]
+    attr_accessor :test_float
+    # @param values [Array<String>]
+    attr_accessor :test_string_array
+    # @param values [Array<Integer>]
+    attr_accessor :test_int_array
+    # @param value [Integer, nil]
+    attr_accessor :test_optional_int
+    # @param values [Hash<String, Integer>]
+    attr_accessor :some_integer_map
+
+    ### Attribute Writers ###
+    # @param value [ARecord]
+    def some_record=(value)
+      @some_record = ARecord.initialize_from_value(value)
+    end
+
+    # @param value [nil, ARecord]
+    def some_optional_record=(value)
+      @some_optional_record = ARecord.initialize_from_value(value)
+    end
+
+    # @param values [Array<ARecord>]
+    def some_record_array=(values)
+      @some_record_array = values.map do |value|
+        ARecord.initialize_from_value(value)
+      end
+    end
+
+    # @param values [Hash<String, ARecord>]
+    def some_record_map=(values)
+      @some_record_map = values.transform_values do |value|
+        ARecord.initialize_from_value(value)
+      end
+    end
+
+    # @param values [Array<AnEnum>]
+    def some_enum_array=(values)
+      @some_enum_array = values.map do |value|
+        AnEnum.initialize_from_value(value)
+      end
+    end
+
+    # @override
+    def initialize(test_id: nil,
+                   test_float: nil,
+                   test_string_array: ["test"],
+                   test_int_array: [123],
+                   test_optional_int: 123,
+                   some_integer_map: {"abc"=>123},
+                   some_record: {"a_record_field"=>"Test String"},
+                   some_optional_record: nil,
+                   some_record_array: nil,
+                   some_record_map: nil,
+                   some_enum_array: nil)
+      super
+      self.test_id = test_id
+      self.test_float = test_float
+      self.test_string_array = test_string_array
+      self.test_int_array = test_int_array
+      self.test_optional_int = test_optional_int
+      self.some_integer_map = some_integer_map
+      self.some_record = some_record
+      self.some_optional_record = some_optional_record
+      self.some_record_array = some_record_array
+      self.some_record_map = some_record_map
+      self.some_enum_array = some_enum_array
+    end
+
+    # @override
+    def schema
+      'MySchemaWithComplexTypes'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'test_id' => @test_id,
+        'test_float' => @test_float,
+        'test_string_array' => @test_string_array,
+        'test_int_array' => @test_int_array,
+        'test_optional_int' => @test_optional_int,
+        'some_integer_map' => @some_integer_map,
+        'some_record' => @some_record&.to_h,
+        'some_optional_record' => @some_optional_record&.to_h,
+        'some_record_array' => @some_record_array.map { |v| v&.to_h },
+        'some_record_map' => @some_record_map.transform_values { |v| v&.to_h },
+        'some_enum_array' => @some_enum_array.map { |v| v&.to_h }
+      }
+    end
+  end
+end

data/spec/schemas/com/my-namespace/Generated.avsc

@@ -24,6 +24,12 @@
       "name": "a_double",
       "type": "double"
     },
+    {
+      "name": "an_optional_int",
+      "type": [ "null", "int" ],
+      "doc": "an optional int",
+      "default": null
+    },
     {
       "name": "an_enum",
       "type": {