tantot 0.1.5 → 0.1.6

data/spec/collector/watcher_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+describe Tantot::Agent::Watcher do
+  let(:watcher_instance) { double }
+
+  before do
+    stub_class("TestWatcher") { include Tantot::Watcher }
+    allow(TestWatcher).to receive(:new).and_return(watcher_instance)
+  end
+
+  describe '.derive_watcher' do
+    class TestWatcher
+      include Tantot::Watcher
+    end
+
+    class WrongWatcher
+    end
+
+    module Foo
+      class BarWatcher
+        include Tantot::Watcher
+      end
+    end
+
+    specify { expect { described_class.derive_watcher('foo') }.to raise_error(Tantot::UnderivableWatcher) }
+    specify { expect { described_class.derive_watcher(WrongWatcher) }.to raise_error(Tantot::UnderivableWatcher) }
+    specify { expect(described_class.derive_watcher(TestWatcher)).to eq(TestWatcher) }
+    specify { expect(described_class.derive_watcher(Foo::BarWatcher)).to eq(Foo::BarWatcher) }
+    specify { expect(described_class.derive_watcher('test')).to eq(TestWatcher) }
+    specify { expect(described_class.derive_watcher('foo/bar')).to eq(Foo::BarWatcher) }
+  end
+
+  [true, false].each do |use_after_commit_callbacks|
+    context "using after_commit hooks: #{use_after_commit_callbacks}" do
+      before { allow(Tantot.config).to receive(:use_after_commit_callbacks).and_return(use_after_commit_callbacks) }
+
+      context "watching an attribute" do
+        before do
+          stub_model(:city) do
+            watch TestWatcher, only: :name
+          end
+        end
+
+        it "doesn't call back when the attribute doesn't change" do
+          Tantot.manager.run do
+            City.create
+            expect(watcher_instance).not_to receive(:perform)
+          end
+        end
+
+        it "calls back when the attribute changes (on creation)" do
+          Tantot.manager.run do
+            city = City.create name: 'foo'
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+          end
+        end
+
+        it "calls back on model update" do
+          city = City.create!
+          city.reload
+          Tantot.manager.sweep(:bypass)
+
+          expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+          Tantot.manager.run do
+            city.name = "foo"
+            city.save
+          end
+        end
+
+        it "calls back on model destroy" do
+          city = City.create!(name: 'foo')
+          city.reload
+          Tantot.manager.sweep(:bypass)
+
+          expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo']}}}))
+          Tantot.manager.run do
+            city.destroy
+          end
+        end
+
+        it "calls back once per model even when updated more than once" do
+          Tantot.manager.run do
+            city = City.create! name: 'foo'
+            city.name = 'bar'
+            city.save
+            city.name = 'baz'
+            city.save
+            expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo', 'bar', 'baz']}}}))
+          end
+        end
+
+        it "allows to call a watcher mid-stream" do
+          Tantot.manager.run do
+            city = City.create name: 'foo'
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+            Tantot.manager.sweep(:inline)
+            city.name = 'bar'
+            city.save
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo', 'bar']}}}))
+          end
+        end
+      end
+    end
+  end
+
+  context "on multiple models" do
+    before do
+      stub_model(:city) do
+        watch TestWatcher, only: [:name, :country_id]
+      end
+      stub_model(:country) do
+        watch TestWatcher, only: [:country_code]
+      end
+    end
+
+    it "calls back once per watch when multiple watched models change" do
+      country = Country.create!(country_code: "CDN")
+      city = City.create!(name: "Quebec", country_id: country.id)
+      country.reload
+      city.reload
+      Tantot.manager.sweep(:bypass)
+
+      expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['Quebec', 'foo', 'bar'], "country_id" => [country.id, nil]}}, Country => {country.id => {"country_code" => ['CDN', 'US']}}}))
+      Tantot.manager.run do
+        city.name = "foo"
+        city.save
+        city.name = "bar"
+        city.save
+        city.country_id = nil
+        city.save
+        country.country_code = 'US'
+        country.save
+        city.destroy
+      end
+    end
+  end
+
+  context "with multiple watchers" do
+    let(:watchA_instance) { double }
+    let(:watchB_instance) { double }
+    before do
+      stub_class("TestWatcherA") { include Tantot::Watcher }
+      stub_class("TestWatcherB") { include Tantot::Watcher }
+      allow(TestWatcherA).to receive(:new).and_return(watchA_instance)
+      allow(TestWatcherB).to receive(:new).and_return(watchB_instance)
+      stub_model(:city) do
+        watch TestWatcherA, only: [:name, :country_id]
+        watch TestWatcherB, only: :rating
+      end
+      stub_model(:country) do
+        watch TestWatcherA, only: :country_code
+        watch TestWatcherB, only: [:name, :rating]
+      end
+    end
+
+    it "calls each watcher once for multiple models" do
+      country = Country.create!(country_code: "CDN")
+      city = City.create!(name: "Quebec", country_id: country.id, rating: 12)
+      country.reload
+      city.reload
+      expect(watchA_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['Quebec', 'foo', 'bar'], "country_id" => [country.id, nil]}}, Country => {country.id => {"country_code" => ['CDN', 'US']}}}))
+      # WatchB receives the last value of rating since it has been destroyed
+      expect(watchB_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"rating" => [12]}}}))
+      Tantot.manager.sweep(:bypass)
+
+      Tantot.manager.run do
+        city.name = "foo"
+        city.save
+        city.name = "bar"
+        city.save
+        city.country_id = nil
+        city.save
+        country.country_code = 'US'
+        country.save
+        city.destroy
+      end
+    end
+  end
+
+end

data/spec/extensions/chewy_spec.rb

@@ -5,117 +5,320 @@ if defined?(::Chewy)
   describe Tantot::Extensions::Chewy do
 
     [nil, :self, :class_method, :block].product([:some, :all]).each do |backreference_opt, attribute_opt|
-      it "should update indexes using backreference: #{backreference_opt.inspect}, attributes: #{attribute_opt}" do
-        chewy_type = double
+      context "should update indexes using backreference: #{backreference_opt.inspect}, attributes: #{attribute_opt}" do
+        let(:chewy_type) { double }
 
-        watch_index_params = ['foo']
-        watch_index_params << :id if attribute_opt == :some
+        before do
+          watch_index_options = {}
+          watch_index_params = ['foo']
+          watch_index_options[:only] = :id if attribute_opt == :some
 
-        block_callback = proc do |changes|
-          self.yielded_changes = changes
-          [1, 2, 3]
-        end
-
-        case backreference_opt
-        when nil, :block
-        when :self
-          watch_index_params << {method: :self}
-        when :class_method
-          watch_index_params << {method: :class_get_ids}
-        end
-
-        stub_model(:city) do
-          class_attribute :yielded_changes
-
-          if backreference_opt == :block
-            watch_index(*watch_index_params, &block_callback)
-          else
-            watch_index(*watch_index_params)
-          end
-
-          def self.class_get_ids(changes)
+          block_callback = proc do |changes|
             self.yielded_changes = changes
             [1, 2, 3]
           end
-        end
 
-        city1 = city2 = nil
+          case backreference_opt
+          when nil, :block
+          when :self
+            watch_index_options[:method] = :self
+          when :class_method
+            watch_index_options[:method] = :class_get_ids
+          end
 
-        Tantot.collector.run do
-          city1 = City.create!
-          city2 = City.create!
+          watch_index_params << watch_index_options
 
-          # Stub the integration point between us and Chewy
-          expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+          stub_model(:city) do
+            class_attribute :yielded_changes
 
-          # Depending on backreference
-          case backreference_opt
-          when nil, :self
-            # Implicit and self reference will update with the created model id
-            expect(chewy_type).to receive(:update_index).with([city1.id, city2.id], {})
-          when :class_method, :block
-            # Validate that the returned ids are updated
-            expect(chewy_type).to receive(:update_index).with([1, 2, 3], {})
+            if backreference_opt == :block
+              watch_index(*watch_index_params, &block_callback)
+            else
+              watch_index(*watch_index_params)
+            end
+
+            def self.class_get_ids(changes)
+              self.yielded_changes = changes
+              [1, 2, 3]
+            end
           end
         end
 
-        # Make sure the callbacks received the changes
-        if [:class_method, :block].include?(backreference_opt)
-          expect(City.yielded_changes).to eq(Tantot::Changes::ById.new({city1.id => {"id" => [nil, city1.id]}, city2.id => {"id" => [nil, city2.id]}}))
-        end
+        it "should update accordingly" do
+          city1 = city2 = nil
+
+          Tantot.manager.run do
+            city1 = City.create!(name: 'foo')
+            city2 = City.create!(name: 'bar')
+
+            # Stub the integration point between us and Chewy
+            expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+
+            # Depending on backreference
+            case backreference_opt
+            when nil, :self
+              # Implicit and self reference will update with the created model id
+              expect(chewy_type).to receive(:update_index).with([city1.id, city2.id], {})
+            when :class_method, :block
+              # Validate that the returned ids are updated
+              expect(chewy_type).to receive(:update_index).with([1, 2, 3], {})
+            end
+          end
+
+          # Make sure the callbacks received the changes
+          if [:class_method, :block].include?(backreference_opt)
+            if attribute_opt == :some
+              expect(City.yielded_changes).to eq(Tantot::Changes::ById.new({city1.id => {"id" => [nil, city1.id]}, city2.id => {"id" => [nil, city2.id]}}))
+            else
+              expect(City.yielded_changes).to eq(Tantot::Changes::ById.new({city1.id => {"id" => [nil, city1.id], "name" => [nil, 'foo']}, city2.id => {"id" => [nil, city2.id], "name" => [nil, 'bar']}}))
+            end
+          end
 
+        end
       end
     end
 
-    it "should allow registering an index watch on self (all attributes, destroy)" do
-      chewy_type = double
+    context "allow registering an index watch on self (all attributes, destroy)" do
+      let(:chewy_type) { double }
 
-      stub_model(:city) do
-        watch_index 'foo'
+      before do
+        stub_model(:city) do
+          watch_index 'foo'
+        end
       end
 
-      city = City.create!
-      Tantot.collector.sweep(:bypass)
+      it "should update accordingly" do
+        city = City.create!
+        Tantot.manager.sweep(:bypass)
 
-      Tantot.collector.run do
-        city.destroy
+        Tantot.manager.run do
+          city.destroy
 
-        expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
-        expect(chewy_type).to receive(:update_index).with([city.id], {})
+          expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+          expect(chewy_type).to receive(:update_index).with([city.id], {})
+        end
       end
     end
 
-    it "should allow registering an index watch on self (all attributes, destroy, block)" do
-      chewy_type = double
+    context "allow registering an index watch on self (all attributes, destroy, block)" do
+      let(:chewy_type) { double }
 
-      stub_model(:city) do
-        watch_index 'foo' do |changes|
-          changes.ids
+      before do
+        stub_model(:city) do
+          watch_index 'foo' do |changes|
+            changes.ids
+          end
         end
       end
 
-      city = City.create!
-      Tantot.collector.sweep(:bypass)
+      it "should update accordingly" do
+        city = City.create!
+        Tantot.manager.sweep(:bypass)
 
-      Tantot.collector.run do
-        city.destroy
+        Tantot.manager.run do
+          city.destroy
 
-        expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
-        expect(chewy_type).to receive(:update_index).with([city.id], {})
+          expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+          expect(chewy_type).to receive(:update_index).with([city.id], {})
+        end
       end
     end
 
-    it "should allow returning nothing in a callback" do
-      stub_model(:city) do
-        watch_index('foo') { 1 if false }
-        watch_index('bar') { [] }
-        watch_index('baz') { nil }
+    context "allow returning nothing in a callback" do
+      before do
+        stub_model(:city) do
+          watch_index('foo') { 1 if false }
+          watch_index('bar') { [] }
+          watch_index('baz') { nil }
+        end
       end
 
-      Tantot.collector.run do
-        City.create!
+      it "should update accordingly" do
+        Tantot.manager.run do
+          City.create!
 
-        expect(Chewy).not_to receive(:derive_type)
+          expect(Chewy).not_to receive(:derive_type)
+        end
+      end
+    end
+
+    context "association" do
+      context "simple" do
+        let(:chewy_type) { double }
+        before do
+          stub_model(:city) do
+            belongs_to :country
+
+            has_many :streets
+
+            watch_index 'country#countries', only: :name, association: :country
+          end
+
+          stub_model(:country) do
+            has_many :cities
+
+            watch_index 'city#cities', only: :name, association: :cities
+          end
+        end
+
+        it "allows automatically watching a :belongs_to association as a backreference" do
+          Tantot.manager.run do
+            country1 = Country.create! id: 111
+            country2 = Country.create! id: 222
+            city = City.create id: 999, country: country1
+            city.reload
+            Tantot.manager.sweep(:bypass)
+
+            city.country = country2
+            city.save
+
+            expect(Chewy).to receive(:derive_type).with('country#countries').and_return(chewy_type)
+            expect(chewy_type).to receive(:update_index).with([country1.id, country2.id], {})
+          end
+        end
+
+        it "allows automatically watching an :has_many association as a backreference" do
+          Tantot.manager.run do
+            country = Country.create! id: 111
+            country.cities.create id: 990
+            country.cities.create id: 991
+            country.reload
+            Tantot.manager.sweep(:bypass)
+
+            country.name = "foo"
+            country.save
+
+            expect(Chewy).to receive(:derive_type).with('city#cities').and_return(chewy_type)
+            expect(chewy_type).to receive(:update_index).with([990, 991], {})
+          end
+        end
+      end
+
+      context "through" do
+        context "has_many through -> has_many -> belongs_to" do
+          let(:chewy_type) { double }
+          before do
+            stub_model(:color) do
+              belongs_to :group
+            end
+
+            stub_model(:user) do
+              has_many :memberships
+              has_many :groups, through: :memberships
+
+              watch_index 'groups#group', only: :username, association: :groups
+            end
+
+            stub_model(:membership) do
+              belongs_to :user
+              belongs_to :group
+
+              has_many :colors, through: :group
+            end
+
+            stub_model(:group) do
+              has_many :colors
+              has_many :memberships
+              has_many :users, through: :memberships
+            end
+          end
+
+          it 'updates accordingly' do
+            Tantot.manager.run do
+
+              user = User.create! id: 111
+              group = Group.create! id: 999
+              Membership.create! id: 555, user: user, group: group
+              Tantot.manager.sweep(:bypass)
+
+              user.username = 'foo'
+              user.save
+
+              expect(Chewy).to receive(:derive_type).with('groups#group').and_return(chewy_type)
+              expect(chewy_type).to receive(:update_index).with([999], {})
+            end
+          end
+        end
+
+        context "has_many through -> has_many -> has_many" do
+          let(:chewy_type) { double }
+          before do
+            stub_model(:street) do
+              belongs_to :city
+            end
+
+            stub_model(:city) do
+              belongs_to :country
+
+              has_many :streets
+            end
+
+            stub_model(:country) do
+              has_many :cities
+              has_many :streets, through: :cities
+
+              watch_index 'streets#street', only: :name, association: :streets
+            end
+          end
+
+          it "updates accordingly" do
+            Tantot.manager.run do
+              country = Country.create! id: 111
+              city = City.create! id: 999, country: country
+              Street.create! id: 555, city: city
+              country.reload
+              Tantot.manager.sweep(:bypass)
+
+              country.name = "foo"
+              country.save
+
+              expect(Chewy).to receive(:derive_type).with('streets#street').and_return(chewy_type)
+              expect(chewy_type).to receive(:update_index).with([555], {})
+            end
+          end
+        end
+
+        context "has_many through -> belongs_to -> has_many" do
+          let(:chewy_type) { double }
+          before do
+            stub_model(:color) do
+              belongs_to :group
+            end
+
+            stub_model(:user) do
+              has_many :memberships
+            end
+
+            stub_model(:group) do
+              has_many :memberships
+              has_many :colors
+            end
+
+            stub_model(:membership) do
+              belongs_to :group
+
+              has_many :colors, through: :group
+
+              watch_index 'colors#color', association: :colors
+            end
+          end
+
+          it "updates accordingly" do
+            Tantot.manager.run do
+              group = Group.create! id: 111
+              group.colors.create! id: 222, name: 'red'
+              membership = Membership.create id: 333, group: group
+              Tantot.manager.sweep(:bypass)
+              membership.reload
+
+              membership.name = "foo"
+              membership.save
+
+              expect(Chewy).to receive(:derive_type).with('colors#color').and_return(chewy_type)
+              expect(chewy_type).to receive(:update_index).with([222], {})
+            end
+          end
+        end
       end
     end
   end
@@ -123,13 +326,12 @@ if defined?(::Chewy)
   describe "Chewy.strategy" do
     before do
       allow(Tantot.config).to receive(:sweep_on_push).and_return(true)
-    end
-
-    it "should bypass if Chewy.strategy is :bypass" do
       stub_model(:city) do
         watch_index('foo')
       end
+    end
 
+    it "should bypass if Chewy.strategy is :bypass" do
       expect(Chewy).not_to receive(:derive_type)
       Chewy.strategy :bypass do
         City.create!