deimos-ruby 1.10.2 → 1.12.0

data/lib/deimos/schema_backends/base.rb

@@ -3,15 +3,16 @@
 module Deimos
   # Represents a field in the schema.
   class SchemaField
-    attr_accessor :name, :type, :enum_values
+    attr_accessor :name, :type, :enum_values, :default
 
     # @param name [String]
     # @param type [Object]
     # @param enum_values [Array<String>]
-    def initialize(name, type, enum_values=[])
+    def initialize(name, type, enum_values=[], default=:no_default)
       @name = name
       @type = type
       @enum_values = enum_values
+      @default = default
     end
   end
 
@@ -43,6 +44,7 @@ module Deimos
       # @return [Hash,nil]
       def decode(payload, schema: nil)
         return nil if payload.nil?
+
         decode_payload(payload, schema: schema || @schema)
       end
 
@@ -78,6 +80,14 @@ module Deimos
         raise NotImplementedError
       end
 
+      # Converts your schema to String form for generated YARD docs.
+      # To be defined by subclass.
+      # @param schema [Object]
+      # @return [String] A string representation of the Type
+      def self.field_type(schema)
+        raise NotImplementedError
+      end
+
       # Encode a payload. To be defined by subclass.
       # @param payload [Hash]
       # @param schema [Symbol|String]
@@ -145,6 +155,12 @@ module Deimos
       def decode_key(_payload, _key_id)
         raise NotImplementedError
       end
+
+      # Forcefully loads the schema into memory.
+      # @return [Object] The schema that is of use.
+      def load_schema
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/deimos/schema_class/base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Deimos
+  module SchemaClass
+    # Base Class for Schema Classes generated from Avro.
+    class Base
+
+      # :nodoc:
+      def initialize(*_args)
+      end
+
+      # Converts the object to a string that represents a JSON object
+      # @return [String] a JSON string
+      def to_json(*_args)
+        to_h.to_json
+      end
+
+      # Converts the object to a hash which can be used for debugging.
+      # @return [Hash] a hash representation of the payload
+      def as_json(_opts={})
+        JSON.parse(to_json)
+      end
+
+      # Converts the object attributes to a hash which can be used for Kafka
+      # @return [Hash] the payload as a hash.
+      def to_h
+        raise NotImplementedError
+      end
+
+      # :nodoc:
+      def ==(other)
+        comparison = other
+        if other.class == self.class
+          comparison = other.state
+        end
+
+        comparison == self.state
+      end
+
+      # :nodoc:
+      def to_s
+        klass = self.class
+        "#{klass}(#{self.as_json.symbolize_keys.to_s[1..-2]})"
+      end
+
+      # Initializes this class from a given value
+      # @param value [Object]
+      def self.initialize_from_value(value)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # :nodoc:
+      def state
+        as_json
+      end
+
+      # :nodoc:
+      def hash
+        state.hash
+      end
+    end
+  end
+end

data/lib/deimos/schema_class/enum.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'json'
+
+module Deimos
+  module SchemaClass
+    # Base Class for Enum Classes generated from Avro.
+    class Enum < Base
+      # Returns all the valid symbols for this enum.
+      # @return [Array<String>]
+      def symbols
+        raise NotImplementedError
+      end
+
+      # :nodoc:
+      def self.initialize_from_value(value)
+        return nil if value.nil?
+
+        value.is_a?(self) ? value : self.new(value)
+      end
+    end
+  end
+end

data/lib/deimos/schema_class/record.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'json'
+
+module Deimos
+  module SchemaClass
+    # Base Class of Record Classes generated from Avro.
+    class Record < Base
+      # Element access method as if this Object were a hash
+      # @param key[String||Symbol]
+      # @return [Object] The value of the attribute if exists, nil otherwise
+      def [](key)
+        self.try(key.to_sym)
+      end
+
+      # :nodoc
+      def with_indifferent_access
+        self
+      end
+
+      # Returns the schema name of the inheriting class.
+      # @return [String]
+      def schema
+        raise NotImplementedError
+      end
+
+      # Returns the namespace for the schema of the inheriting class.
+      # @return [String]
+      def namespace
+        raise NotImplementedError
+      end
+
+      # Returns the full schema name of the inheriting class.
+      # @return [String]
+      def full_schema
+        "#{namespace}.#{schema}"
+      end
+
+      # Returns the schema validator from the schema backend
+      # @return [Deimos::SchemaBackends::Base]
+      def validator
+        Deimos.schema_backend(schema: schema, namespace: namespace)
+      end
+
+      # @return [Array<String>] an array of fields names in the schema.
+      def schema_fields
+        validator.schema_fields.map(&:name)
+      end
+
+      # :nodoc:
+      def self.initialize_from_value(value)
+        return nil if value.nil?
+
+        value.is_a?(self) ? value : self.new(**value.symbolize_keys)
+      end
+    end
+  end
+end

data/lib/deimos/shared_config.rb

@@ -58,6 +58,11 @@ module Deimos
         config[:key_field] = field&.to_s
         config[:key_schema] = schema
       end
+
+      # @param enabled [Boolean]
+      def schema_class_config(use_schema_classes)
+        config[:use_schema_classes] = use_schema_classes
+      end
     end
   end
 end

data/lib/deimos/test_helpers.rb

@@ -18,22 +18,38 @@ module Deimos
       def sent_messages
         Deimos::Backends::Test.sent_messages
       end
-    end
 
-    included do
+      # Set the config to the right settings for a unit test
+      def unit_test!
+        Deimos.configure do |deimos_config|
+          deimos_config.logger = Logger.new(STDOUT)
+          deimos_config.consumers.reraise_errors = true
+          deimos_config.kafka.seed_brokers ||= ['test_broker']
+          deimos_config.schema.backend = Deimos.schema_backend_class.mock_backend
+          deimos_config.producers.backend = :test
+        end
+      end
 
-      RSpec.configure do |config|
+      # Kafka test config with avro schema registry
+      def full_integration_test!
+        Deimos.configure do |deimos_config|
+          deimos_config.producers.backend = :kafka
+          deimos_config.schema.backend = :avro_schema_registry
+        end
+      end
 
-        config.before(:suite) do
-          Deimos.configure do |d_config|
-            d_config.logger = Logger.new(STDOUT)
-            d_config.consumers.reraise_errors = true
-            d_config.kafka.seed_brokers ||= ['test_broker']
-            d_config.schema.backend = Deimos.schema_backend_class.mock_backend
-            d_config.producers.backend = :test
-          end
+      # Set the config to the right settings for a kafka test
+      def kafka_test!
+        Deimos.configure do |deimos_config|
+          deimos_config.producers.backend = :kafka
+          deimos_config.schema.backend = :avro_validation
         end
+      end
+    end
 
+    included do
+
+      RSpec.configure do |config|
         config.prepend_before(:each) do
           client = double('client').as_null_object
           allow(client).to receive(:time) do |*_args, &block|
@@ -193,9 +209,11 @@ module Deimos
                        'value' => payload)
 
       unless skip_expectation
-        expectation = expect(handler).to receive(:consume).
-          with(payload, anything, &block)
-        expectation.and_call_original if call_original
+        _handler_expectation(:consume,
+                             payload,
+                             handler,
+                             call_original,
+                             &block)
       end
       Phobos::Actions::ProcessMessage.new(
         listener: listener,
@@ -260,9 +278,11 @@ module Deimos
                      'partition' => 1,
                      'offset_lag' => 0)
       unless skip_expectation
-        expectation = expect(handler).to receive(:consume_batch).
-          with(payloads, anything, &block)
-        expectation.and_call_original if call_original
+        _handler_expectation(:consume_batch,
+                             payloads,
+                             handler,
+                             call_original,
+                             &block)
       end
       action = Phobos::Actions::ProcessBatchInline.new(
         listener: listener,
@@ -339,5 +359,38 @@ module Deimos
 
       handler.handler.constantize
     end
+
+    # Test that a given handler will execute a `method` on an `input` correctly,
+    # If a block is given, that block will be executed when `method` is called.
+    # Otherwise it will just confirm that `method` is called at all.
+    # @param method [Symbol]
+    # @param input [Object]
+    # @param handler [Deimos::Consumer]
+    # @param call_original [Boolean]
+    def _handler_expectation(method,
+                             input,
+                             handler,
+                             call_original,
+                             &block)
+      schema_class = handler.class.config[:schema]
+      expected = input.dup
+
+      config = handler.class.config
+      use_schema_classes = config[:use_schema_classes]
+      use_schema_classes = use_schema_classes.present? ? use_schema_classes : Deimos.config.schema.use_schema_classes
+
+      if use_schema_classes && schema_class.present?
+        expected = if input.is_a?(Array)
+                     input.map do |payload|
+                       Utils::SchemaClass.instance(payload, schema_class)
+                     end
+                   else
+                     Utils::SchemaClass.instance(input, schema_class)
+                   end
+      end
+
+      expectation = expect(handler).to receive(method).with(expected, anything, &block)
+      expectation.and_call_original if call_original
+    end
   end
 end

data/lib/deimos/utils/schema_class.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Deimos
+  module Utils
+    # Class used by SchemaClassGenerator and Consumer/Producer interfaces
+    module SchemaClass
+      class << self
+        # Converts a raw payload into an instance of the Schema Class
+        # @param payload [Hash]
+        # @param schema [String]
+        # @return [Deimos::SchemaClass::Record]
+        def instance(payload, schema)
+          klass = "Deimos::#{schema.underscore.camelize}".safe_constantize
+          return payload if klass.nil? || payload.nil?
+
+          klass.new(**payload.symbolize_keys)
+        end
+
+        # @param config [Hash] Producer or Consumer config
+        # @return [Boolean]
+        def use?(config)
+          use_schema_classes = config[:use_schema_classes]
+          use_schema_classes.present? ? use_schema_classes : Deimos.config.schema.use_schema_classes
+        end
+
+      end
+    end
+  end
+end

data/lib/deimos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deimos
-  VERSION = '1.10.2'
+  VERSION = '1.12.0'
 end

data/lib/deimos.rb

@@ -19,6 +19,9 @@ require 'deimos/backends/kafka_async'
 require 'deimos/backends/test'
 
 require 'deimos/schema_backends/base'
+require 'deimos/utils/schema_class'
+require 'deimos/schema_class/enum'
+require 'deimos/schema_class/record'
 
 require 'deimos/monkey_patches/phobos_producer'
 require 'deimos/monkey_patches/phobos_cli'

data/lib/generators/deimos/schema_class/templates/schema_class.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+<% if @sub_schema_templates.present? && @sub_schema_templates.any? -%>
+  ### Secondary Schema Classes ###
+<% end -%>
+<%- @sub_schema_templates.each do |schema_template| -%>
+  <%=- schema_template %>
+
+<%- end -%>
+  ### Primary Schema Class ###
+  <%=- @main_class_definition -%>
+
+end

data/lib/generators/deimos/schema_class/templates/schema_enum.rb.tt

@@ -0,0 +1,21 @@
+  # Autogenerated Schema for Enum at <%= @current_schema.namespace %>.<%= @current_schema.name %>
+  class <%= Deimos::SchemaBackends::AvroBase.schema_classname(@current_schema) %> < Deimos::SchemaClass::Enum
+    # @return ['<%= @current_schema.symbols.join("', '") %>']
+    attr_accessor :<%= @current_schema.name.underscore %>
+
+    # :nodoc:
+    def initialize(<%= @current_schema.name.underscore %>)
+      super
+      self.<%= @current_schema.name.underscore %> = <%= @current_schema.name.underscore %>
+    end
+
+    # @override
+    def symbols
+      %w(<%= @current_schema.symbols.join(' ') %>)
+    end
+
+    # @override
+    def to_h
+      @<%= @current_schema.name.underscore %>
+    end
+  end

data/lib/generators/deimos/schema_class/templates/schema_record.rb.tt

@@ -0,0 +1,65 @@
+  # Autogenerated Schema for Record at <%= @current_schema.namespace %>.<%= @current_schema.name %>
+  class <%= Deimos::SchemaBackends::AvroBase.schema_classname(@current_schema) %> < Deimos::SchemaClass::Record
+<%- if @field_assignments.select{ |h| h[:is_schema_class] }.any? -%>
+    ### Attribute Readers ###
+  <%- @field_assignments.select{ |h| h[:is_schema_class] }.each do |method_definition| -%>
+    # @return [<%= method_definition[:deimos_type] %>]
+    attr_reader :<%= method_definition[:field].name %>
+  <%- end -%>
+
+<% end -%>
+<%- if @field_assignments.select{ |h| !h[:is_schema_class] }.any? -%>
+    ### Attribute Accessors ###
+  <%- @field_assignments.select{ |h| !h[:is_schema_class] }.each do |method_definition| -%>
+    # @param <%= method_definition[:method_argument] %> [<%= method_definition[:deimos_type] %>]
+    attr_accessor :<%= method_definition[:field].name %>
+  <%- end -%>
+
+<% end -%>
+<%- if @field_assignments.select{ |h| h[:is_schema_class] }.any? -%>
+    ### Attribute Writers ###
+  <%- @field_assignments.select{ |h| h[:is_schema_class] }.each do |method_definition| -%>
+    # @param <%= method_definition[:method_argument] %> [<%= method_definition[:deimos_type] %>]
+    def <%= method_definition[:field].name %>=(<%= method_definition[:method_argument] %>)
+    <%- if method_definition[:field_type] == :array -%>
+      @<%= method_definition[:field].name %> = values.map do |value|
+        <%= method_definition[:field_initialization] %>
+      end
+    <%- elsif method_definition[:field_type] == :map -%>
+      @<%= method_definition[:field].name %> = values.transform_values do |value|
+        <%= method_definition[:field_initialization] %>
+      end
+    <%- else -%>
+      @<%= method_definition[:field].name %> = <%= method_definition[:field_initialization] %>
+    <%- end -%>
+    end
+
+  <%- end -%>
+<% end -%>
+    # @override
+    <%= @initialization_definition %>
+      super
+<%- @fields.each do |field| -%>
+      self.<%= field.name %> = <%= field.name %>
+<% end -%>
+    end
+
+    # @override
+    def schema
+      '<%= @current_schema.name %>'
+    end
+
+    # @override
+    def namespace
+      '<%= @current_schema.namespace %>'
+    end
+
+    # @override
+    def to_h
+      {
+<%- @fields.each do |field| -%>
+        <%= field_to_h(field) %>
+<% end -%>
+      }
+    end
+  end