materialist 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad0c95193ee887dc776cdb28f54fa1fd7a00212a
+  data.tar.gz: 6e3dfb760278e54a275acdc667f5b32fe1809374
+SHA512:
+  metadata.gz: 54a84928a4d988d22741f038d02bc47757b331ff45f45cef201829691b204a239745a89abc9b67fac706f267fda054b0e65094ef1d62ac9836282e7ec608d448
+  data.tar.gz: 8758db7954c895a28ac969f4f166b570451f338a1a11d449ee9d9f8bae3e1dcc66cb57d1867af24bb9e3dcee1497d4c557411924a616171fbc2fd6580f2afb16

data/.env.test

@@ -0,0 +1,2 @@
+ROUTEMASTER_DRAIN_REDIS=redis://localhost/drain-rider-api
+ROUTEMASTER_CACHE_REDIS=redis://localhost/cache-rider-api

data/.gitignore

@@ -0,0 +1,11 @@
+.bundle/
+doc/
+.yardoc/
+pkg/
+tmp
+*.orig
+tags
+*.swp
+*.swo
+coverage/
+.byebug_history

data/.rspec

@@ -0,0 +1,3 @@
+-I.
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.4.0

data/Appraisals

@@ -0,0 +1,3 @@
+appraise "rails-5" do
+  gem "rails", "~> 5.0"
+end

data/Gemfile

@@ -0,0 +1,26 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in routemaster_client.gemspec
+gemspec
+
+gem 'activesupport'
+gem 'sidekiq'
+gem 'routemaster-drain', '~> 3.0'
+
+# Just here to avoid a safety warning
+gem 'psych',                      require: false
+
+# Used in builds and tests
+gem 'bundler',                    require: false
+gem 'dotenv',                     require: false
+gem 'simplecov',                  require: false
+gem 'codecov',                    require: false
+gem 'webmock',                    require: false
+
+gem 'guard-rspec',                require: false
+gem 'pry',                        require: false
+gem 'byebug',                     require: false
+gem 'rspec',                      require: false
+gem 'appraisal',                  require: false
+gem 'dogstatsd',                  require: false
+gem 'fork_break',                 require: false

data/Gemfile.lock

@@ -0,0 +1,165 @@
+PATH
+  remote: .
+  specs:
+    materialist (0.0.1)
+      sidekiq
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    appraisal (2.2.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    byebug (9.1.0)
+    codecov (0.1.10)
+      json
+      simplecov
+      url
+    coderay (1.1.1)
+    concurrent-ruby (1.0.5)
+    connection_pool (2.2.1)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    dogstatsd (2.0.0)
+    dotenv (2.2.1)
+    ethon (0.10.1)
+      ffi (>= 1.3.0)
+    faraday (0.13.1)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.12.2)
+      faraday (>= 0.7.4, < 1.0)
+    ffi (1.9.18)
+    fork (1.0.1)
+    fork_break (0.1.4)
+      fork (= 1.0.1)
+    formatador (0.2.5)
+    guard (2.14.1)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    hashdiff (0.3.2)
+    hashie (3.5.6)
+    i18n (0.8.6)
+    json (2.1.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.12)
+    method_source (0.8.2)
+    minitest (5.10.3)
+    multipart-post (2.0.0)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    psych (2.2.4)
+    public_suffix (2.0.5)
+    rack (2.0.3)
+    rack-protection (2.0.0)
+      rack
+    rake (12.0.0)
+    rb-fsevent (0.10.2)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    redis (3.3.3)
+    redis-namespace (1.5.3)
+      redis (~> 3.0, >= 3.0.4)
+    routemaster-drain (3.0.1)
+      addressable
+      concurrent-ruby
+      faraday (>= 0.9.0)
+      faraday_middleware
+      hashie
+      rack (>= 1.4.5)
+      redis-namespace
+      typhoeus (~> 1.1)
+      wisper (~> 1.6.1)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    ruby_dep (1.5.0)
+    safe_yaml (1.0.4)
+    shellany (0.0.1)
+    sidekiq (5.0.4)
+      concurrent-ruby (~> 1.0)
+      connection_pool (~> 2.2, >= 2.2.0)
+      rack-protection (>= 1.5.0)
+      redis (~> 3.3, >= 3.3.3)
+    simplecov (0.15.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    slop (3.6.0)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    typhoeus (1.3.0)
+      ethon (>= 0.9.0)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    url (0.3.2)
+    webmock (2.3.2)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+    wisper (1.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  appraisal
+  bundler
+  byebug
+  codecov
+  dogstatsd
+  dotenv
+  fork_break
+  guard-rspec
+  materialist!
+  pry
+  psych
+  routemaster-drain (~> 3.0)
+  rspec
+  sidekiq
+  simplecov
+  webmock
+
+BUNDLED WITH
+   1.15.4

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})   { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')        { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014-2016 HouseTrip Ltd.
+Copyright (c) 2016 Deliveroo Ltd.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+## Materialist
+
+> _adjective_ `philosophy`: relating to the theory that nothing exists except matter and its movements and modifications.
+
+A "materializer" is a ruby class that is responsible for receiving an event and
+materializing the remote resource (described by the event) in database.
+
+This library is a set of utilities that provide both the wiring and the DSL to
+painlessly do so.
+
+### Configuration
+
+First you need an "event handler":
+
+```ruby
+handler = Materialist::EventHandler.new({ ...options })
+```
+
+Where options could be:
+
+- `topics` (only when using in `.subscribe`): An array of topics to be used.
+If not provided nothing would be materialized.
+- `queue`: name of the queue to be used by sidekiq worker
+
+Then there are two ways to configure materialist in routemaster:
+
+1. **If you DON'T need resources to be cached in redis:** use `handler` as siphon:
+
+```ruby
+handler = Materialist::EventHandler.new
+siphon_events = {
+  zones:               handler,
+  rider_domain_riders: handler
+}
+
+app = Routemaster::Drain::Caching.new(siphon_events: siphon_events)
+# ...
+
+map '/events' do
+  run app
+end
+```
+
+2. **You DO need resources cached in redis:** In this case you need to use `handler` to subscribe to the caching pipeline:
+
+```ruby
+TOPICS = %w(
+  zones
+  rider_domain_riders
+)
+
+handler = Materialist::EventHandler.new({ topics: TOPICS })
+app = Routemaster::Drain::Caching.new # or ::Basic.new
+app.subscribe(handler, prefix: true)
+# ...
+
+map '/events' do
+  run app
+end
+```
+
+### 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)
+
+These materializers would live in a first-class directory (`/materializers`) in your rails app.
+
+```ruby
+require 'materialist/materializer'
+
+class ZoneMaterializer
+  include Materialist::Materializer
+
+  use_model :zone
+
+  materialize :id, as: :orderweb_id
+  materialize :code
+  materialize :name
+
+  link :city do
+    materialize :tz_name, as: :timezone
+
+    link :country do
+      materialize :name, as: :country_name
+      materialize :iso_alpha2_code, as: :country_iso_alpha2_code
+    end
+  end
+end
+```
+
+Here is what each part of the DSL mean:
+
+#### `use_model <model_name>`
+describes the name of the active record model to be used.
+
+#### `materialize <key>, as: <column> (default: key)`
+describes mapping a resource key to database column.
+
+#### `link <key>`
+describes materializing from a relation of the resource. This can be nested to any depth as shown above.
+
+When inside the block of a `link` any other part of DSL can be used and will be evaluated in the context of the relation resource.
+
+#### `after_upsert <method>`
+describes the name of the instance method to be invoked after a record was materialized.
+
+```ruby
+class ZoneMaterializer
+  include Materialist::Materializer
+
+  after_upsert :my_method
+
+  def my_method(record)
+  end
+end
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/appraise

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+# Run all appraisals, with all specified rubies
+#
+require 'yaml'
+
+
+RUBIES = YAML.load_file('.travis.yml')['rvm']
+APPRAISALS = `appraisal list`.strip.split(/\s+/)
+
+# setup
+RUBIES.each do |ruby|
+  ENV['RBENV_VERSION'] = ruby
+  system 'rbenv version'
+  system 'rbenv exec ruby -v'
+  system 'rbenv exec bundle check || rbenv exec bundle install'
+  system "rbenv exec appraisal install"
+end
+
+# tests
+RUBIES.each do |ruby|
+  ENV['RBENV_VERSION'] = ruby
+  system 'rbenv exec ruby -v'
+  APPRAISALS.each do |variant|
+    puts "*** Ruby #{ruby} / variant #{variant}"
+    system "rbenv exec appraisal #{variant} rspec"
+  end
+end

data/lib/materialist.rb

@@ -0,0 +1,3 @@
+module Materialist
+  VERSION = '0.0.1'
+end

data/lib/materialist/event_handler.rb

@@ -0,0 +1,31 @@
+require 'active_support/inflector'
+require_relative './event_worker'
+
+module Materialist
+  class EventHandler
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def on_events_received(batch)
+      batch.each { |event| call(event) if topics.include?(event['topic'].to_s) }
+    end
+
+    def call(event)
+      worker.perform_async(event)
+    end
+
+    private
+
+    attr_reader :options
+
+    def topics
+      @_topics ||= options.fetch(:topics, []).map(&:to_s)
+    end
+
+    def worker
+      @_worker ||= Materialist::EventWorker.set(options.slice(:queue))
+    end
+  end
+end

data/lib/materialist/event_worker.rb

@@ -0,0 +1,14 @@
+require 'sidekiq'
+require 'active_support/inflector'
+
+module Materialist
+  class EventWorker
+    include Sidekiq::Worker
+
+    def perform(event)
+      topic = event['topic']
+      materializer = "#{topic.to_s.singularize.classify}Materializer".constantize
+      materializer.perform(event['url'], event['type'].to_sym)
+    end
+  end
+end

data/lib/materialist/materializer.rb

@@ -0,0 +1,143 @@
+require 'routemaster/api_client'
+
+module Materialist
+  module Materializer
+
+    def self.included(base)
+      base.extend(Internals::ClassMethods)
+      base.extend(Internals::DSL)
+
+      root_mapping = []
+      base.instance_variable_set(:@materialist_options, { mapping: root_mapping })
+      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
+
+      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(key, as: key)
+          __materialist_dsl_mapping_stack.last << FieldMapping.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 use_model(klass)
+          materialist_options[:model_class] = klass
+        end
+
+        def after_upsert(method_name)
+          materialist_options[:after_upsert] = method_name
+        end
+
+      end
+
+      class Materializer
+
+        def initialize(url, klass)
+          @url = url
+          @instance = klass.new
+          @options = klass.materialist_options
+        end
+
+        def upsert
+          upsert_record.tap do |entity|
+            instance.send(after_upsert, entity) if after_upsert
+          end
+        end
+
+        def destroy
+          model_class.where(source_url: url).destroy_all
+        end
+
+        private
+
+        attr_reader :url, :instance, :options
+
+        def upsert_record
+          model_class.find_or_initialize_by(source_url: url).tap do |entity|
+            entity.update_attributes attributes
+            entity.save!
+          end
+        end
+
+        def mapping
+          options.fetch :mapping
+        end
+
+        def after_upsert
+          options[:after_upsert]
+        end
+
+        def model_class
+          options.fetch(:model_class).to_s.classify.constantize
+        end
+
+        def attributes
+          build_attributes resource_at(url), mapping
+        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 LinkMapping
+              resource.body._links.include?(m.key) ?
+                result.merge(build_attributes(resource_at(resource.send(m.key).url, allow_nil: true), m.mapping || [])) :
+                result
+            else
+              result
+            end
+          end
+        end
+
+        def resource_at(url, allow_nil: false)
+          api_client.get(url, options: { enable_caching: false })
+        rescue Routemaster::Errors::ResourceNotFound
+          raise unless allow_nil
+        end
+
+        def api_client
+          @_api_client ||= Routemaster::APIClient.new(
+            response_class: Routemaster::Responses::HateoasResponse
+          )
+        end
+      end
+    end
+  end
+end

data/materialist.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'materialist'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'materialist'
+  spec.version       = Materialist::VERSION
+  spec.authors       = ['Mo Valipour']
+  spec.email         = ['valipour@gmail.com']
+  spec.summary       = %q{Utilities to materialize routemaster topics}
+  spec.homepage      = 'http://github.com/deliveroo/materialist'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = %w(lib)
+
+  spec.add_runtime_dependency 'sidekiq'
+end

data/spec/materialist/event_handler_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'materialist/event_handler'
+require 'materialist/event_worker'
+
+RSpec.describe Materialist::EventHandler do
+  let(:options) {{}}
+  subject { described_class.new options }
+
+  let(:worker_double) { double() }
+  before do
+    allow(Materialist::EventWorker).to receive(:set)
+      .and_return worker_double
+  end
+
+  describe "#on_events_received" do
+    let(:events) {[{ "topic" => :topic_a }, { "topic" => :topic_b }]}
+    let(:perform) { subject.on_events_received events.map() }
+
+    context "when no topic is specified" do
+      let(:options) {{ topics: [] }}
+
+      it "doesn't enqueue any event" do
+        expect(worker_double).to_not receive(:perform_async)
+        perform
+      end
+    end
+
+    context "when a topic is specified" do
+      let(:options) {{ topics: [:topic_a] }}
+
+      it "enqueues event of that topic" do
+        expect(worker_double).to receive(:perform_async).with(events[0])
+        perform
+      end
+    end
+
+    context "when both topics are specified" do
+      let(:options) {{ topics: [:topic_a, :topic_b] }}
+
+      it "enqueues event of both topics" do
+        expect(worker_double).to receive(:perform_async).twice
+        perform
+      end
+    end
+  end
+
+  describe "#call" do
+    let(:event) { { "topic" => :foobar } }
+    let(:perform) { subject.call event }
+
+    it "enqueues the event" do
+      expect(worker_double).to receive(:perform_async).with(event)
+      perform
+    end
+
+    context "if queue name is privided" do
+      let(:queue_name) { :some_queue_name }
+      let(:options) {{ queue: queue_name }}
+
+      it "enqueues the event in the given queue" do
+        expect(Materialist::EventWorker).to receive(:set)
+          .with(queue: queue_name)
+        expect(worker_double).to receive(:perform_async).with(event)
+        perform
+      end
+    end
+  end
+end

data/spec/materialist/event_worker_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'materialist/event_worker'
+
+RSpec.describe Materialist::EventWorker do
+  describe "#perform" do
+    let(:source_url) { 'https://service.dev/foobars/1' }
+    let(:event) {{ 'topic' => :foobar, 'url' => source_url, 'type' => 'noop' }}
+    let!(:materializer_class) { class FoobarMaterializer; end }
+
+    before do
+      allow(FoobarMaterializer).to receive(:perform)
+    end
+
+    context "when run synchronously" do
+      let(:perform) { subject.perform(event) }
+
+      it "calls the relevant materializer" do
+        expect(FoobarMaterializer).to receive(:perform).with(source_url, :noop)
+        perform
+      end
+    end
+  end
+end

data/spec/materialist/materializer_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+require 'materialist/materializer'
+
+RSpec.describe Materialist::Materializer do
+  describe "#perform" do
+    let!(:materializer_class) do
+      class FoobarMaterializer
+        include Materialist::Materializer
+
+        use_model :foobar
+        materialize :name
+        materialize :age, as: :how_old
+
+        link :city do
+          materialize :timezone
+
+          link :country do
+            materialize :tld, as: :country_tld
+          end
+        end
+      end
+    end
+
+    let!(:foobar_class) { class Foobar; end }
+    let(:country_url) { 'https://service.dev/countries/1' }
+    let(:country_body) {{ tld: 'fr' }}
+    let(:city_url) { 'https://service.dev/cities/1' }
+    let(:city_body) {{ _links: { country: { href: country_url }}, timezone: 'Europe/Paris' }}
+    let(:source_url) { 'https://service.dev/foobars/1' }
+    let(:source_body) {{ _links: { city: { href: city_url }}, name: 'jack', age: 30 }}
+    before do
+      stub_request(:get, source_url).to_return(
+        status: 200,
+        body: source_body.to_json,
+        headers:  { 'Content-Type' => 'application/json' }
+      )
+      stub_request(:get, country_url).to_return(
+        status: 200,
+        body: country_body.to_json,
+        headers:  { 'Content-Type' => 'application/json' }
+      )
+      stub_request(:get, city_url).to_return(
+        status: 200,
+        body: city_body.to_json,
+        headers:  { 'Content-Type' => 'application/json' }
+      )
+    end
+
+    let(:expected_attributes) do
+      { name: 'jack', how_old: 30, country_tld: 'fr', timezone: 'Europe/Paris' }
+    end
+
+    let(:record_double) { double() }
+    before do
+      allow(Foobar).to receive(:find_or_initialize_by).and_return record_double
+    end
+
+    let(:action) { :create }
+    let(:perform) { FoobarMaterializer.perform(source_url, action) }
+
+    def performs_upsert
+      expect(Foobar).to receive(:find_or_initialize_by)
+        .with(source_url: source_url)
+      expect(record_double).to receive(:update_attributes).with(expected_attributes)
+      expect(record_double).to receive(:save!)
+      perform
+    end
+
+    def performs_destroy
+      expect(Foobar).to receive(:where)
+        .with(source_url: source_url)
+        .and_return record_double
+      expect(record_double).to receive(:destroy_all)
+      perform
+    end
+
+    it { performs_upsert }
+
+    %i(create update noop).each do |action_name|
+      context "when action is :#{action_name}" do
+        let(:action) { action_name }
+        it { performs_upsert }
+      end
+    end
+
+    context "when action is :delete" do
+      let(:action) { :delete }
+
+      it { performs_destroy }
+    end
+
+    context "if resource returns 404" do
+      before { stub_request(:get, source_url).to_return(status: 404) }
+
+      it "bubbles up routemaster not found error" do
+        expect { perform }.to raise_error Routemaster::Errors::ResourceNotFound
+      end
+    end
+
+    context "if a linked resource returns 404" do
+      before { stub_request(:get, city_url).to_return(status: 404) }
+
+      let(:expected_attributes) do
+        { name: 'jack', how_old: 30 }
+      end
+
+      it "ignores keys from the relation" do
+        performs_upsert
+      end
+    end
+
+    context "when after_upsert is configured" do
+      let(:expected_attributes) {{}}
+      let!(:materializer_class) do
+        class FoobarMaterializer
+          include Materialist::Materializer
+
+          use_model :foobar
+          after_upsert :my_method
+
+          def my_method(entity)
+            entity.after_upsert_action
+          end
+        end
+      end
+
+      %i(create update noop).each do |action_name|
+        context "when action is :#{action_name}" do
+          let(:action) { action_name }
+          it "calls after_upsert method" do
+            expect(record_double).to receive(:after_upsert_action)
+            performs_upsert
+          end
+        end
+      end
+
+      context "when action is :delete" do
+        let(:action) { :delete }
+
+        it "does not call after_upsert method" do
+          expect(record_double).to_not receive(:after_upsert_action)
+          performs_destroy
+        end
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'codecov'
+SimpleCov.formatter = SimpleCov::Formatter::Codecov if ENV['CI']
+
+require 'webmock/rspec'
+require 'dotenv'
+require 'pry'
+require 'byebug'
+Dotenv.overload('.env.test')
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.raise_errors_for_deprecations!
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: materialist
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mo Valipour
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- valipour@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.test"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Appraisals
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- appraise
+- lib/materialist.rb
+- lib/materialist/event_handler.rb
+- lib/materialist/event_worker.rb
+- lib/materialist/materializer.rb
+- materialist.gemspec
+- spec/materialist/event_handler_spec.rb
+- spec/materialist/event_worker_spec.rb
+- spec/materialist/materializer_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/deliveroo/materialist
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+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/materializer_spec.rb
+- spec/spec_helper.rb