materialist 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c126eb6aa8d3e7fd91c9628f1a9a4a16e6476e8
-  data.tar.gz: 3d20acfd6c6ae59358dcfffb0b6270d438d6f7e4
+  metadata.gz: 99e85711c6de342809785430291c11d6a11b3379
+  data.tar.gz: d6b3f3bfecd9ce4b20ee699c3a75028294f7ab5f
 SHA512:
-  metadata.gz: 39310ca655d95cd3b51b6765da39f5e7ccb6479ca8df8680c5b6f27100cd7fd5479458d36b5baca80d80b1c8b29dec266453b2e2bd26c98dd4b65e01044b5351
-  data.tar.gz: df9c7c8f9c59a6a1b640f011deb7e848ac2cb9e705b288bbb6d8238c1c08e3db5a4cca8014ddfa061236d52a13d60d6a1d239758a414e352adc09e9b1a6d8b64
+  metadata.gz: 498ac330b0331c78ab2ce69aa71dbc0c3ddb0e5277711c0f9f1b4c836f4c810c9ae1f9df4e46c2a83ba1690817fe07cc97d694f10f3718728619c26719fd4ffe
+  data.tar.gz: d5e784ae7827bdc7defff614a3d47601efc4035f965e679c9ea4ad639ebc558440c1740556fead09f6788f66f3045b9ab9b037c822101ed95a41b6147263d986

data/README.md

@@ -118,7 +118,7 @@ map '/events' do
 end
 ```
 
-### DSL
+#### DSL
 
 Next you would need to define a materializer for each of the topic. The name of
 the materializer class should match the topic name (in singular)
@@ -131,6 +131,8 @@ require 'materialist/materializer'
 class ZoneMaterializer
   include Materialist::Materializer
 
+  sidekiq_options queue: :orderweb_service, retry: false
+
   persist_to :zone
 
   source_key :source_id do |url|
@@ -156,12 +158,17 @@ end
 
 Here is what each part of the DSL mean:
 
+#### `sidekiq_options <options>`
+allows to override options for the Sidekiq job which does the materialization.
+Typically it will specify which queue to put the job on or how many times 
+should the job try to retry. These options override the options specified in 
+`Materialist.configuration.sidekiq_options`.
+
 #### `persist_to <model_name>`
 describes the name of the active record model to be used.
 If missing, materialist skips materialising the resource itself, but will continue
 with any other functionality -- such as `materialize_link`.
 
-
 #### `source_key <column> <url_parser_block> (default: url)`
 describes the column used to persist the unique identifier parsed from the url_parser_block.
 By default the column used is `:source_url` and the original `url` is used as the identifier.

data/lib/materialist/event_handler.rb

@@ -1,36 +1,44 @@
 require 'active_support/inflector'
-require_relative './event_worker'
+require_relative './workers/event'
+require_relative './materializer_factory'
 
 module Materialist
   class EventHandler
 
     DEFAULT_SIDEKIQ_OPTIONS = { retry: 10 }.freeze
 
-    def initialize
-    end
-
     def on_events_received(batch)
-      batch.each { |event| call(event) if should_materialize?(event['topic']) }
+      batch.each { |event| call(event) if should_materialize?(topic(event)) }
     end
 
     def call(event)
-      worker.perform_async(event)
+      worker(topic(event)).perform_async(event)
     end
 
     private
 
-    attr_reader :topics
+    def topic(event)
+      event['topic'].to_s
+    end
 
     def should_materialize?(topic)
-      Materialist.configuration.topics.include?(topic.to_s)
+      Materialist.configuration.topics.include?(topic)
+    end
+
+    def sidekiq_options(topic)
+      [
+        DEFAULT_SIDEKIQ_OPTIONS,
+        Materialist.configuration.sidekiq_options,
+        materializer_sidekiq_options(topic)
+      ].inject(:merge)
     end
 
-    def sidekiq_options
-      DEFAULT_SIDEKIQ_OPTIONS.merge(Materialist.configuration.sidekiq_options)
+    def worker(topic)
+      Materialist::Workers::Event.set(sidekiq_options(topic))
     end
 
-    def worker
-      Materialist::EventWorker.set(sidekiq_options)
+    def materializer_sidekiq_options(topic)
+      Materialist::MaterializerFactory.class_from_topic(topic)._sidekiq_options
     end
   end
 end

data/lib/materialist/event_worker.rb

@@ -1,41 +1,11 @@
-require 'sidekiq'
-require 'active_support/inflector'
+require_relative 'workers/event'
 
+# This class is here for backwards compatibility with pre 3.1 versions. It can be removed with the
+# next major version (4.0)
 module Materialist
-  class EventWorker
-    include Sidekiq::Worker
-
+  class EventWorker < Workers::Event
     def perform(event)
-      topic = event['topic']
-      action = event['type'].to_sym
-      timestamp = event['t']
-
-      materializer = "#{topic.to_s.singularize.classify}Materializer".constantize
-      materializer.perform(event['url'], action)
-
-      report_latency(topic, timestamp) if timestamp
-      report_stats(topic, action, :success)
-    rescue
-      report_stats(topic, action, :failure)
-      raise
-    end
-
-    private
-
-    def report_latency(topic, timestamp)
-      t = (Time.now.to_f - (timestamp.to_i / 1e3)).round(1)
-      Materialist.configuration.metrics_client.histogram(
-        "materialist.event_latency",
-        t,
-        tags: ["topic:#{topic}"]
-      )
-    end
-
-    def report_stats(topic, action, kind)
-      Materialist.configuration.metrics_client.increment(
-        "materialist.event_worker.#{kind}",
-        tags: ["action:#{action}", "topic:#{topic}"]
-      )
+      super(event)
     end
   end
 end

data/lib/materialist/materializer/internals/class_methods.rb

@@ -0,0 +1,18 @@
+module Materialist
+  module Materializer
+    module Internals
+      module ClassMethods
+        attr_reader :__materialist_options, :__materialist_dsl_mapping_stack
+
+        def perform(url, action)
+          materializer = Materializer.new(url, self)
+          action == :delete ? materializer.destroy : materializer.upsert
+        end
+
+        def _sidekiq_options
+          __materialist_options[:sidekiq_options] || {}
+        end
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals/dsl.rb

@@ -0,0 +1,56 @@
+module Materialist
+  module Materializer
+    module Internals
+      module DSL
+        def materialize_link(key, topic: key)
+          __materialist_options[:links_to_materialize][key] = { topic: topic }
+        end
+
+        def capture(key, as: key)
+          __materialist_dsl_mapping_stack.last << FieldMapping.new(key: key, as: as)
+        end
+
+        def capture_link_href(key, as:)
+          __materialist_dsl_mapping_stack.last << LinkHrefMapping.new(key: key, as: as)
+        end
+
+        def link(key)
+          link_mapping = LinkMapping.new(key: key)
+          __materialist_dsl_mapping_stack.last << link_mapping
+          __materialist_dsl_mapping_stack << link_mapping.mapping
+          yield
+          __materialist_dsl_mapping_stack.pop
+        end
+
+        def persist_to(klass)
+          __materialist_options[:model_class] = klass
+        end
+
+        def sidekiq_options(options)
+          __materialist_options[:sidekiq_options] = options
+        end
+
+        def source_key(key, &url_parser_block)
+          __materialist_options[:source_key] = key
+          __materialist_options[:url_parser] = url_parser_block
+        end
+
+        def before_upsert(*method_array)
+          __materialist_options[:before_upsert] = method_array
+        end
+
+        def after_upsert(*method_array)
+          __materialist_options[:after_upsert] = method_array
+        end
+
+        def after_destroy(*method_array)
+          __materialist_options[:after_destroy] = method_array
+        end
+
+        def before_destroy(*method_array)
+          __materialist_options[:before_destroy] = method_array
+        end
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals/field_mapping.rb

@@ -0,0 +1,14 @@
+module Materialist
+  module Materializer
+    module Internals
+      class FieldMapping
+        def initialize(key:, as:)
+          @key = key
+          @as = as
+        end
+
+        attr_reader :key, :as
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals/link_href_mapping.rb

@@ -0,0 +1,14 @@
+module Materialist
+  module Materializer
+    module Internals
+      class LinkHrefMapping
+        def initialize(key:, as:)
+          @key = key
+          @as = as
+        end
+
+        attr_reader :key, :as
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals/link_mapping.rb

@@ -0,0 +1,14 @@
+module Materialist
+  module Materializer
+    module Internals
+      class LinkMapping
+        def initialize(key:)
+          @key = key
+          @mapping = []
+        end
+
+        attr_reader :key, :mapping
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals/materializer.rb

@@ -0,0 +1,166 @@
+require 'routemaster/api_client'
+require_relative '../../workers/event'
+
+module Materialist
+  module Materializer
+    module Internals
+      class Materializer
+        def initialize(url, klass)
+          @url = url
+          @instance = klass.new
+          @options = klass.__materialist_options
+        end
+
+        def upsert(retry_on_race_condition: true)
+          return unless root_resource
+
+          if materialize_self?
+            upsert_record.tap do |entity|
+              send_messages(after_upsert, entity) unless after_upsert.nil?
+            end
+          end
+
+          materialize_links
+        rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid
+          # when there is a race condition and uniqueness of :source_url
+          # is enforced by database index, this error is raised
+          # so we simply try upsert again
+          # if error is due to another type of uniqueness constraint
+          # second call will also fail and error would bubble up
+          retry_on_race_condition ?
+            upsert(retry_on_race_condition: false) :
+            raise
+        end
+
+        def destroy
+          return unless materialize_self?
+          model_class.find_by(source_lookup(url)).tap do |entity|
+            send_messages(before_destroy, entity) unless before_destroy.nil?
+            entity.destroy!.tap do |entity|
+              send_messages(after_destroy, entity) unless after_destroy.nil?
+            end if entity
+          end
+        end
+
+        private
+
+        attr_reader :url, :instance, :options
+
+        def materialize_self?
+          options.include? :model_class
+        end
+
+        def upsert_record
+          model_class.find_or_initialize_by(source_lookup(url)).tap do |entity|
+            send_messages(before_upsert, entity) unless before_upsert.nil?
+            entity.update_attributes! attributes
+          end
+        end
+
+        def materialize_links
+          (options[:links_to_materialize] || [])
+            .each { |key, opts| materialize_link(key, opts) }
+        end
+
+        def materialize_link(key, opts)
+          return unless root_resource.body._links.include?(key)
+
+          # this can't happen asynchronously
+          # because the handler options are unavailable in this context
+          # :(
+          ::Materialist::Workers::Event.new.perform({
+            'topic' => opts[:topic],
+            'url' => root_resource.body._links[key].href,
+            'type' => 'noop'
+          })
+        end
+
+        def mapping
+          options.fetch :mapping
+        end
+
+        def before_upsert
+          options[:before_upsert]
+        end
+
+        def after_upsert
+          options[:after_upsert]
+        end
+
+        def before_destroy
+          options[:before_destroy]
+        end
+
+        def after_destroy
+          options[:after_destroy]
+        end
+
+        def model_class
+          options.fetch(:model_class).to_s.camelize.constantize
+        end
+
+        def source_key
+          options.fetch(:source_key, :source_url)
+        end
+
+        def url_parser
+          options[:url_parser] || ->url { url }
+        end
+
+        def source_lookup(url)
+          @_source_lookup ||= { source_key => url_parser.call(url) }
+        end
+
+        def attributes
+          build_attributes root_resource, mapping
+        end
+
+        def root_resource
+          @_root_resource ||= resource_at(url)
+        end
+
+        def build_attributes(resource, mapping)
+          return {} unless resource
+
+          mapping.inject({}) do |result, m|
+            case m
+              when FieldMapping
+                result.tap { |r| r[m.as] = resource.body[m.key] }
+              when LinkHrefMapping
+                result.tap do |r|
+                  if resource.body._links.include?(m.key)
+                    r[m.as] = resource.body._links[m.key].href
+                  end
+                end
+              when LinkMapping
+                resource.body._links.include?(m.key) ?
+                  result.merge(build_attributes(resource_at(resource.send(m.key).url), m.mapping || [])) :
+                  result
+              else
+                result
+            end
+          end
+        end
+
+        def resource_at(url)
+          api_client.get(url, options: { enable_caching: false })
+        rescue Routemaster::Errors::ResourceNotFound
+          # this is due to a race condition between an upsert event
+          # and a :delete event
+          # when this happens we should silently ignore the case
+          nil
+        end
+
+        def api_client
+          @_api_client ||= Routemaster::APIClient.new(
+            response_class: Routemaster::Responses::HateoasResponse
+          )
+        end
+
+        def send_messages(messages, arguments)
+          messages.each { |message| instance.send(message, arguments) }
+        end
+      end
+    end
+  end
+end

data/lib/materialist/materializer/internals.rb

@@ -0,0 +1,13 @@
+require_relative './internals/field_mapping'
+require_relative './internals/link_mapping'
+require_relative './internals/link_href_mapping'
+require_relative './internals/class_methods'
+require_relative './internals/dsl'
+require_relative './internals/materializer'
+
+module Materialist
+  module Materializer
+    module Internals
+    end
+  end
+end

data/lib/materialist/materializer.rb

@@ -1,6 +1,4 @@
-require 'active_support/inflector'
-require 'routemaster/api_client'
-require_relative './event_worker'
+require_relative './materializer/internals'
 
 module Materialist
   module Materializer
@@ -16,250 +14,5 @@ module Materialist
       })
       base.instance_variable_set(:@__materialist_dsl_mapping_stack, [root_mapping])
     end
-
-    module Internals
-      class FieldMapping
-        def initialize(key:, as:)
-          @key = key
-          @as = as
-        end
-
-        attr_reader :key, :as
-      end
-
-      class LinkMapping
-        def initialize(key:)
-          @key = key
-          @mapping = []
-        end
-
-        attr_reader :key, :mapping
-      end
-
-      class LinkHrefMapping
-        def initialize(key:, as:)
-          @key = key
-          @as = as
-        end
-
-        attr_reader :key, :as
-      end
-
-      module ClassMethods
-        attr_reader :__materialist_options, :__materialist_dsl_mapping_stack
-
-        def perform(url, action)
-          materializer = Materializer.new(url, self)
-          action == :delete ? materializer.destroy : materializer.upsert
-        end
-      end
-
-      module DSL
-
-        def materialize_link(key, topic: key)
-          __materialist_options[:links_to_materialize][key] = { topic: topic }
-        end
-
-        def capture(key, as: key)
-          __materialist_dsl_mapping_stack.last << FieldMapping.new(key: key, as: as)
-        end
-
-        def capture_link_href(key, as:)
-          __materialist_dsl_mapping_stack.last << LinkHrefMapping.new(key: key, as: as)
-        end
-
-        def link(key)
-          link_mapping = LinkMapping.new(key: key)
-          __materialist_dsl_mapping_stack.last << link_mapping
-          __materialist_dsl_mapping_stack << link_mapping.mapping
-          yield
-          __materialist_dsl_mapping_stack.pop
-        end
-
-        def persist_to(klass)
-          __materialist_options[:model_class] = klass
-        end
-
-        def source_key(key, &url_parser_block)
-          __materialist_options[:source_key] = key
-          __materialist_options[:url_parser] = url_parser_block
-        end
-
-        def before_upsert(*method_array)
-          __materialist_options[:before_upsert] = method_array
-        end
-
-        def after_upsert(*method_array)
-          __materialist_options[:after_upsert] = method_array
-        end
-
-        def after_destroy(*method_array)
-          __materialist_options[:after_destroy] = method_array
-        end
-
-        def before_destroy(*method_array)
-          __materialist_options[:before_destroy] = method_array
-        end
-      end
-
-      class Materializer
-
-        def initialize(url, klass)
-          @url = url
-          @instance = klass.new
-          @options = klass.__materialist_options
-        end
-
-        def upsert(retry_on_race_condition: true)
-          return unless root_resource
-
-          if materialize_self?
-            upsert_record.tap do |entity|
-              send_messages(after_upsert, entity) unless after_upsert.nil?
-            end
-          end
-
-          materialize_links
-        rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid
-          # when there is a race condition and uniqueness of :source_url
-          # is enforced by database index, this error is raised
-          # so we simply try upsert again
-          # if error is due to another type of uniqueness constraint
-          # second call will also fail and error would bubble up
-          retry_on_race_condition ?
-            upsert(retry_on_race_condition: false) :
-            raise
-        end
-
-        def destroy
-          return unless materialize_self?
-          model_class.find_by(source_lookup(url)).tap do |entity|
-            send_messages(before_destroy, entity) unless before_destroy.nil?
-            entity.destroy!.tap do |entity|
-              send_messages(after_destroy, entity) unless after_destroy.nil?
-            end if entity
-          end
-        end
-
-        private
-
-        attr_reader :url, :instance, :options
-
-        def materialize_self?
-          options.include? :model_class
-        end
-
-        def upsert_record
-          model_class.find_or_initialize_by(source_lookup(url)).tap do |entity|
-            send_messages(before_upsert, entity) unless before_upsert.nil?
-            entity.update_attributes! attributes
-          end
-        end
-
-        def materialize_links
-          (options[:links_to_materialize] || [])
-            .each { |key, opts| materialize_link(key, opts) }
-        end
-
-        def materialize_link(key, opts)
-          return unless root_resource.body._links.include?(key)
-
-          # this can't happen asynchronously
-          # because the handler options are unavailable in this context
-          # :(
-          ::Materialist::EventWorker.new.perform({
-            'topic' => opts[:topic],
-            'url' => root_resource.body._links[key].href,
-            'type' => 'noop'
-          })
-        end
-
-        def mapping
-          options.fetch :mapping
-        end
-
-        def before_upsert
-          options[:before_upsert]
-        end
-
-        def after_upsert
-          options[:after_upsert]
-        end
-
-        def before_destroy
-          options[:before_destroy]
-        end
-
-        def after_destroy
-          options[:after_destroy]
-        end
-
-        def model_class
-          options.fetch(:model_class).to_s.camelize.constantize
-        end
-
-        def source_key
-          options.fetch(:source_key, :source_url)
-        end
-
-        def url_parser
-          options[:url_parser] || ->url { url }
-        end
-
-        def source_lookup(url)
-          @_source_lookup ||= { source_key => url_parser.call(url) }
-        end
-
-        def attributes
-          build_attributes root_resource, mapping
-        end
-
-        def root_resource
-          @_root_resource ||= resource_at(url)
-        end
-
-        def build_attributes(resource, mapping)
-          return {} unless resource
-
-          mapping.inject({}) do |result, m|
-            case m
-            when FieldMapping
-              result.tap { |r| r[m.as] = resource.body[m.key] }
-            when LinkHrefMapping
-              result.tap do |r|
-                if resource.body._links.include?(m.key)
-                  r[m.as] = resource.body._links[m.key].href
-                end
-              end
-            when LinkMapping
-              resource.body._links.include?(m.key) ?
-                result.merge(build_attributes(resource_at(resource.send(m.key).url), m.mapping || [])) :
-                result
-            else
-              result
-            end
-          end
-        end
-
-        def resource_at(url)
-          api_client.get(url, options: { enable_caching: false })
-        rescue Routemaster::Errors::ResourceNotFound
-          # this is due to a race condition between an upsert event
-          # and a :delete event
-          # when this happens we should silently ignore the case
-          nil
-        end
-
-        def api_client
-          @_api_client ||= Routemaster::APIClient.new(
-            response_class: Routemaster::Responses::HateoasResponse
-          )
-        end
-
-        def send_messages(messages, arguments)
-            messages.each { |message| instance.send(message, arguments) }
-        end
-      end
-    end
   end
 end

data/lib/materialist/materializer_factory.rb

@@ -0,0 +1,9 @@
+module Materialist
+  class MaterializerFactory
+    def self.class_from_topic(topic)
+      "#{topic.to_s.singularize.classify}Materializer".constantize
+    rescue NameError
+      nil
+    end
+  end
+end

data/lib/materialist/workers/event.rb

@@ -0,0 +1,43 @@
+require 'sidekiq'
+require_relative '../materializer_factory'
+
+module Materialist
+  module Workers
+      class Event
+      include Sidekiq::Worker
+
+      def perform(event)
+        topic = event['topic']
+        action = event['type'].to_sym
+        timestamp = event['t']
+
+        materializer = Materialist::MaterializerFactory.class_from_topic(topic)
+        materializer.perform(event['url'], action)
+
+        report_latency(topic, timestamp) if timestamp
+        report_stats(topic, action, :success)
+      rescue
+        report_stats(topic, action, :failure)
+        raise
+      end
+
+      private
+
+      def report_latency(topic, timestamp)
+        t = (Time.now.to_f - (timestamp.to_i / 1e3)).round(1)
+        Materialist.configuration.metrics_client.histogram(
+          "materialist.event_latency",
+          t,
+          tags: ["topic:#{topic}"]
+        )
+      end
+
+      def report_stats(topic, action, kind)
+        Materialist.configuration.metrics_client.increment(
+          "materialist.event_worker.#{kind}",
+          tags: ["action:#{action}", "topic:#{topic}"]
+        )
+      end
+    end
+  end
+end

data/lib/materialist.rb

@@ -1,5 +1,5 @@
 require_relative './configuration'
 
 module Materialist
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/spec/materialist/event_handler_spec.rb

@@ -1,20 +1,23 @@
 require 'spec_helper'
 require 'materialist/event_handler'
-require 'materialist/event_worker'
+require 'materialist/workers/event'
 
 RSpec.describe Materialist::EventHandler do
+  let(:configuration) do
+    OpenStruct.new({
+      sidekiq_options: sidekiq_options,
+      topics: topics
+    })
+  end
   let(:topics) {[]}
   let(:sidekiq_options) {{}}
+  let(:materializer_class) { double(_sidekiq_options: {}) }
   let(:worker_double) { double() }
 
   before do
-    Materialist.configure do |config|
-      config.sidekiq_options = sidekiq_options
-      config.topics = topics
-    end
-
-    allow(Materialist::EventWorker).to receive(:set)
-      .and_return worker_double
+    allow(Materialist).to receive(:configuration).and_return(configuration)
+    allow(Materialist::MaterializerFactory).to receive(:class_from_topic).and_return(materializer_class)
+    allow(Materialist::Workers::Event).to receive(:set).and_return(worker_double)
   end
 
   describe "#on_events_received" do
@@ -50,35 +53,30 @@ RSpec.describe Materialist::EventHandler do
   end
 
   describe "#call" do
-    let(:event) { { "topic" => :foobar } }
-    let(:perform) { subject.call event }
+    subject { described_class.new.call(event) }
 
-    it "enqueues the event" do
-      expect(worker_double).to receive(:perform_async).with(event)
-      perform
+    let(:configuration) do
+      OpenStruct.new({
+        sidekiq_options: { unique: false, retry: 5 }
+      })
     end
-
-    context "if queue name is privided" do
-      let(:queue_name) { :some_queue_name }
-      let(:sidekiq_options) {{ queue: queue_name }}
-
-      it "enqueues the event in the given queue" do
-        expect(Materialist::EventWorker).to receive(:set)
-          .with(queue: queue_name, retry: 10)
-        expect(worker_double).to receive(:perform_async).with(event)
-        perform
-      end
+    let(:event) { { "topic" => topic, "data" => "data" } }
+    let(:topic) { "foobar" }
+    let(:materializer_class) { double(_sidekiq_options: materializer_sidekiq_options) }
+    let(:materializer_sidekiq_options) { { queue: :dedicated, retry: 2 } }
+    let(:expected_event_options) { { queue: :dedicated, retry: 2, unique: false } }
+    let(:worker_class) { double(perform_async: nil) }
+
+    before do
+      allow(Materialist).to receive(:configuration).and_return(configuration)
+      allow(Materialist::MaterializerFactory).to receive(:class_from_topic).with(topic).and_return(materializer_class)
+      allow(Materialist::Workers::Event).to receive(:set).with(expected_event_options).and_return(worker_class)
     end
 
-    context "when a retry is specified in options" do
-      let(:sidekiq_options) {{ retry: false }}
+    it "enqueues the event worker with sidekiq options merged from configuration, default and the materializer" do
+      subject
 
-      it "uses the given retry option for sidekiq" do
-        expect(Materialist::EventWorker).to receive(:set)
-          .with(retry: false)
-        expect(worker_double).to receive(:perform_async).with(event)
-        perform
-      end
+      expect(worker_class).to have_received(:perform_async).with(event)
     end
   end
 end

data/spec/materialist/materializer_factory_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'materialist/materializer_factory'
+
+RSpec.describe Materialist::MaterializerFactory do
+  class BuffaloMozarellaMaterializer; end
+
+  describe '.class_from_topic' do
+    subject { described_class.class_from_topic(topic) }
+
+    context 'when the materializer class exists' do
+      let(:topic) { 'buffalo_mozarella'}
+
+      it 'returns the class' do
+        is_expected.to eql(BuffaloMozarellaMaterializer)
+      end
+    end
+
+    context 'when the materializer class does not exist' do
+      let(:topic) { 'cheddar' }
+
+      it { is_expected.to be nil }
+    end
+  end
+end

data/spec/materialist/materializer_spec.rb

@@ -5,7 +5,7 @@ require 'materialist/materializer'
 RSpec.describe Materialist::Materializer do
   uses_redis
 
-  describe "#perform" do
+  describe ".perform" do
     let!(:materializer_class) do
       FoobarMaterializer = Class.new do
         include Materialist::Materializer
@@ -71,6 +71,7 @@ RSpec.describe Materialist::Materializer do
 
     let(:action) { :create }
     let(:perform) { materializer_class.perform(source_url, action) }
+    let(:actions_called) { materializer_class.class_variable_get(:@@actions_called) }
 
     it "materializes record in db" do
       expect{perform}.to change{Foobar.count}.by 1
@@ -168,18 +169,17 @@ RSpec.describe Materialist::Materializer do
 
     context "when {after, before}_upsert is configured" do
       let!(:record) { Foobar.create!(source_url: source_url, name: 'mo') }
-      let(:actions_called) { materializer_class.class_variable_get(:@@actions_called) }
       let!(:materializer_class) do
         FoobarMaterializer = Class.new do
           include Materialist::Materializer
-          @@actions_called = {}
+          cattr_accessor(:actions_called) { {} }
 
           persist_to :foobar
           before_upsert :before_hook
           after_upsert :after_hook
 
-          def before_hook(entity); @@actions_called[:before_hook] = true; end
-          def after_hook(entity); @@actions_called[:after_hook] = true; end
+          def before_hook(entity); self.actions_called[:before_hook] = true; end
+          def after_hook(entity); self.actions_called[:after_hook] = true; end
         end
       end
 
@@ -198,16 +198,16 @@ RSpec.describe Materialist::Materializer do
             let(:materializer_class) do
               FoobarMaterializer = Class.new do
                 include Materialist::Materializer
-                @@actions_called = {}
+                cattr_accessor(:actions_called) { {} }
 
                 persist_to :foobar
                 before_upsert :before_hook, :before_hook2
                 after_upsert :after_hook, :after_hook2
 
-                def before_hook(entity); @@actions_called[:before_hook] = true; end
-                def before_hook2(entity); @@actions_called[:before_hook2] = true; end
-                def after_hook(entity); @@actions_called[:after_hook] = true; end
-                def after_hook2(entity); @@actions_called[:after_hook2] = true; end
+                def before_hook(entity); self.actions_called[:before_hook] = true; end
+                def before_hook2(entity); self.actions_called[:before_hook2] = true; end
+                def after_hook(entity); self.actions_called[:after_hook] = true; end
+                def after_hook2(entity); self.actions_called[:after_hook2] = true; end
               end
             end
 
@@ -237,18 +237,17 @@ RSpec.describe Materialist::Materializer do
 
     context "when {before, after}_destroy is configured" do
       let!(:record) { Foobar.create!(source_url: source_url, name: 'mo') }
-      let(:actions_called) { materializer_class.class_variable_get(:@@actions_called) }
       let!(:materializer_class) do
         FoobarMaterializer = Class.new do
           include Materialist::Materializer
-          @@actions_called = {}
+          cattr_accessor(:actions_called) { {} }
 
           persist_to :foobar
           before_destroy :before_hook
           after_destroy :after_hook
 
-          def before_hook(entity); @@actions_called[:before_hook] = true; end
-          def after_hook(entity); @@actions_called[:after_hook] = true; end
+          def before_hook(entity); self.actions_called[:before_hook] = true; end
+          def after_hook(entity); self.actions_called[:after_hook] = true; end
         end
       end
 
@@ -280,16 +279,16 @@ RSpec.describe Materialist::Materializer do
           let(:materializer_class) do
             FoobarMaterializer = Class.new do
               include Materialist::Materializer
-              @@actions_called = {}
+              cattr_accessor(:actions_called) { {} }
 
               persist_to :foobar
               before_destroy :before_hook, :before_hook2
               after_destroy :after_hook, :after_hook2
 
-              def before_hook(entity); @@actions_called[:before_hook] = true; end
-              def before_hook2(entity); @@actions_called[:before_hook2] = true; end
-              def after_hook(entity); @@actions_called[:after_hook] = true; end
-              def after_hook2(entity); @@actions_called[:after_hook2] = true; end
+              def before_hook(entity); self.actions_called[:before_hook] = true; end
+              def before_hook2(entity); self.actions_called[:before_hook2] = true; end
+              def after_hook(entity); self.actions_called[:after_hook] = true; end
+              def after_hook2(entity); self.actions_called[:after_hook2] = true; end
             end
           end
 
@@ -397,4 +396,35 @@ RSpec.describe Materialist::Materializer do
       end
     end
   end
+
+  describe "._sidekiq_options" do
+    subject { materializer_class._sidekiq_options }
+
+    context "when sidekiq options have been set" do
+      let(:materializer_class) do
+        Class.new do
+          include Materialist::Materializer
+
+          sidekiq_options  queue: :dedicated, option: 'value'
+        end
+      end
+
+
+      it "returns the options" do
+        is_expected.to eql(queue: :dedicated, option: 'value')
+      end
+    end
+
+    context "when sidekiq options have not been set" do
+      let(:materializer_class) do
+        Class.new do
+          include Materialist::Materializer
+        end
+      end
+
+      it "returns empty hash" do
+        is_expected.to eql({})
+      end
+    end
+  end
 end

data/spec/materialist/{event_worker_spec.rb → workers/event_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'materialist/event_worker'
+require 'materialist/workers/event'
 
-RSpec.describe Materialist::EventWorker do
+RSpec.describe Materialist::Workers::Event do
   describe "#perform" do
     let(:source_url) { 'https://service.dev/foobars/1' }
     let(:event) {{ 'topic' => :foobar, 'url' => source_url, 'type' => 'noop' }}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: materialist
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Mo Valipour
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-26 00:00:00.000000000 Z
+date: 2018-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -205,11 +205,21 @@ files:
 - lib/materialist/event_worker.rb
 - lib/materialist/materialized_record.rb
 - lib/materialist/materializer.rb
+- lib/materialist/materializer/internals.rb
+- lib/materialist/materializer/internals/class_methods.rb
+- lib/materialist/materializer/internals/dsl.rb
+- lib/materialist/materializer/internals/field_mapping.rb
+- lib/materialist/materializer/internals/link_href_mapping.rb
+- lib/materialist/materializer/internals/link_mapping.rb
+- lib/materialist/materializer/internals/materializer.rb
+- lib/materialist/materializer_factory.rb
+- lib/materialist/workers/event.rb
 - materialist.gemspec
 - spec/materialist/event_handler_spec.rb
-- spec/materialist/event_worker_spec.rb
 - spec/materialist/materialized_record_spec.rb
+- spec/materialist/materializer_factory_spec.rb
 - spec/materialist/materializer_spec.rb
+- spec/materialist/workers/event_spec.rb
 - spec/models.rb
 - spec/schema.rb
 - spec/spec_helper.rb
@@ -234,15 +244,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Utilities to materialize routemaster topics
 test_files:
 - spec/materialist/event_handler_spec.rb
-- spec/materialist/event_worker_spec.rb
 - spec/materialist/materialized_record_spec.rb
+- spec/materialist/materializer_factory_spec.rb
 - spec/materialist/materializer_spec.rb
+- spec/materialist/workers/event_spec.rb
 - spec/models.rb
 - spec/schema.rb
 - spec/spec_helper.rb