lifesaver 0.0.1 → 0.1.0

data/spec/unit/config_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Lifesaver::Config do
+  describe '#initialize' do
+    context 'with no options' do
+      let(:config) { Lifesaver::Config.new }
+
+      it 'has the default indexing_queue' do
+        expect(config.indexing_queue).to eql(:lifesaver_indexing)
+      end
+
+      it 'has the default notification_queue' do
+        expect(config.notification_queue).to eql(:lifesaver_notification)
+      end
+    end
+  end
+end

data/spec/unit/indexing/indexer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Lifesaver::Indexing::Indexer do
+  context '#perform' do
+    let(:index) { double('index', remove: nil, store: nil) }
+    let(:index_name) { 'test-index-name' }
+    before do
+      Model.stub(:index_name).and_return(index_name)
+      Tire.stub(:index).with(index_name).and_return(index)
+    end
+
+    context 'when operation is update' do
+      let(:model) { Model.new(1) }
+      before do
+        Model.stub(:exists?).with('1').and_return(true)
+        Model.stub(:find).with('1').and_return(model)
+      end
+
+      it 'calls tire with the correct arguments' do
+        indexer = Lifesaver::Indexing::Indexer.new(
+                                                    class_name: 'model',
+                                                    model_id: '1',
+                                                    operation: 'update'
+                                                   )
+
+        expect(index).to receive(:store).with(model)
+
+        indexer.perform
+      end
+    end
+
+    context 'when operation is destroy' do
+      before do
+        Model.stub(:document_type).and_return('class')
+      end
+
+      it 'calls tire with the correct arguments' do
+        indexer = Lifesaver::Indexing::Indexer.new(
+                                                    class_name: 'model',
+                                                    model_id: '1',
+                                                    operation: 'destroy'
+                                                   )
+        correct_arguments = { type: 'class', id: '1' }
+
+        expect(index).to receive(:remove).with(correct_arguments)
+
+        indexer.perform
+      end
+    end
+  end
+end

data/spec/unit/indexing/model_addtions_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Lifesaver::Indexing::ModelAdditions do
+  let(:post) { Post.new(title: 'Test Post') }
+
+  describe '.enqueues_indexing' do
+    before do
+      post.stub(:enqueue_indexing)
+    end
+
+    it 'calls enqueue_indexing on save' do
+      expect(post).to receive(:enqueue_indexing)
+
+      post.save!
+    end
+
+    it 'calls enqueue_indexing on destroy' do
+      expect(post).to receive(:enqueue_indexing)
+
+      post.destroy
+    end
+  end
+
+  describe '#indexing_suppressed?' do
+    it 'is false by default' do
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+
+    it 'is true if overridden locally' do
+      Lifesaver.suppress_indexing
+
+      expect(post.send(:suppress_indexing?)).to eql(true)
+    end
+
+    it 'is false if override is cancelled' do
+      Lifesaver.unsuppress_indexing
+
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+
+    it 'is true if set individually' do
+      post.suppress_indexing
+
+      expect(post.send(:suppress_indexing?)).to eql(true)
+    end
+
+    it 'is false if unset individually' do
+      post.unsuppress_indexing
+
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+  end
+end

data/spec/unit/notification/eager_loader_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Lifesaver::Notification::EagerLoader do
+
+  let(:eager_loader) { Lifesaver::Notification::EagerLoader.new }
+
+  describe '#add_model' do
+
+    it 'adds when empty' do
+      eager_loader.add_model('Post', 34)
+      expected_result = { 'Post' => [34] }
+
+      expect(eager_loader.send(:models_to_load)).to eql(expected_result)
+    end
+
+    it 'adds to when other model ids exist' do
+      eager_loader.add_model('Post', 34)
+      eager_loader.add_model('Post', 38)
+      eager_loader.add_model('Article', 3)
+      expected_result = { 'Post' => [34, 38], 'Article' => [3] }
+
+      expect(eager_loader.send(:models_to_load)).to eql(expected_result)
+    end
+
+    it 'does not add a previously added model' do
+      eager_loader.add_model('Post', 38)
+      eager_loader.add_model('Post', 38)
+      expected_result = { 'Post' => [38] }
+
+      expect(eager_loader.send(:models_to_load)).to eql(expected_result)
+    end
+
+  end
+
+  describe '#load' do
+    before do
+      Post.stub(:load_with_notifiable_associations).and_return([])
+      eager_loader.add_model('Post', 34)
+      eager_loader.add_model('Post', 38)
+    end
+
+    it 'empties the models_to_load' do
+      eager_loader.load
+
+      expect(eager_loader.send(:models_to_load)).to be_empty
+    end
+
+    it 'returns an array' do
+      expect(eager_loader.load).to eq([])
+    end
+  end
+
+  describe '#empty?' do
+    it 'is true when empty' do
+      expect(eager_loader.empty?).to be_true
+    end
+
+    it 'is false when not empty' do
+      eager_loader.add_model('Post', 38)
+
+      expect(eager_loader.empty?).to be_false
+    end
+  end
+end

data/spec/unit/notification/enqueuer_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Lifesaver::Notification::Enqueuer do
+  let(:models) { [Lifesaver::SerializedModel.new('TestClass', '3')] }
+  let(:enqueuer) { Lifesaver::Notification::Enqueuer.new(models) }
+  before { ::Resque.stub(:enqueue) }
+
+  describe '#enqueue' do
+    context 'when indexing is not suppressed' do
+      context 'and there are models' do
+        it 'calls Resque.enqueue with the correct parameters' do
+          expect(::Resque).to receive(:enqueue)
+            .with(Lifesaver::VisitorWorker, models)
+
+          enqueuer.enqueue
+        end
+      end
+      context 'and there are no models' do
+        it 'does not call Resque.enqueue' do
+          empty_enqueuer = Lifesaver::Notification::Enqueuer.new([])
+
+          expect(::Resque).to_not receive(:enqueue)
+
+          empty_enqueuer.enqueue
+        end
+      end
+    end
+
+    context 'when indexing is suppressed' do
+      it 'does not call Resque.enqueue' do
+        Lifesaver.suppress_indexing
+
+        expect(::Resque).to_not receive(:enqueue)
+
+        enqueuer.enqueue
+      end
+    end
+  end
+end

data/spec/unit/notification/indexing_graph_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Lifesaver::Notification::IndexingGraph do
+  let(:indexing_graph) { Lifesaver::Notification::IndexingGraph.new }
+
+  describe '#initalize_models' do
+    it 'should load serialized models into the loader' do
+      indexing_graph.stub(:add_model_to_loader)
+      serialized_models = []
+      serialized_models << Lifesaver::SerializedModel.new('Post', 14)
+
+      expect(indexing_graph).to receive(:add_model_to_loader).with('Post', 14)
+
+      indexing_graph.initialize_models(serialized_models)
+    end
+  end
+
+  describe '#generate' do
+    context 'when queue is empty' do
+      before do
+        indexing_graph.stub(:queue_full?).and_return(false)
+      end
+
+      context 'and loader is empty' do
+        it 'exits and returns models_to_index' do
+          indexing_graph.stub(:loader_full?).and_return(false)
+          indexing_graph.stub(:models_to_index).and_return([Model.new(15)])
+
+          expect(indexing_graph.generate).to eql([Model.new(15)])
+        end
+      end
+
+      context 'and loader is not empty' do
+        it 'calls load_into_queue' do
+          indexing_graph.stub(:loader_full?).and_return(true, false)
+          indexing_graph.stub(:load_into_queue)
+
+          expect(indexing_graph).to receive(:load_into_queue)
+
+          indexing_graph.generate
+        end
+      end
+    end
+
+    context 'when queue is not empty' do
+      before do
+        indexing_graph.stub(:queue_full?).and_return(true, false)
+        indexing_graph.stub(:pop_model).and_return(Model.new(1))
+        indexing_graph.stub(:add_unvisited_associations)
+      end
+
+      it 'adds model if should be indexed' do
+        indexing_graph.stub(:model_should_be_indexed?).and_return(true)
+
+        expect(indexing_graph.generate).to eql([Model.new(1)])
+      end
+
+      it 'does not add a model if it should not be indexed' do
+        indexing_graph.stub(:model_should_be_indexed?).and_return(false)
+
+        expect(indexing_graph.generate).to eql([])
+      end
+
+      it 'adds unvisited associations to the graph' do
+        indexing_graph.stub(:model_should_be_indexed?).and_return(false)
+
+        expect(indexing_graph).to receive(:add_unvisited_associations)
+
+        indexing_graph.generate
+      end
+    end
+  end
+end

data/spec/unit/notification/model_additions_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Lifesaver::Notification::ModelAdditions do
+  let(:post) { Post.create!(title: 'Test', content: 'Lorem', tags: %w(tests)) }
+  let(:affiliate) { Affiliate.create(name: 'Some place') }
+  let(:author) { Author.create!(name: 'Paul Sorensen', affiliate: affiliate) }
+  let(:authorship) { Authorship.create!(post: post, author: author) }
+  before do
+    post.reload
+    author.reload
+    authorship.reload
+  end
+
+  describe '.notifies_for_indexing' do
+    before do
+      post.stub(:update_associations)
+    end
+
+    it 'calls update_associations on save' do
+      expect(post).to receive(:update_associations)
+
+      post.save!
+    end
+
+    it 'calls update_associations on destroy' do
+      expect(post).to receive(:update_associations)
+
+      post.destroy
+    end
+  end
+
+  describe '.load_with_notifiable_associations' do
+    it 'returns the correct eager-loaded models' do
+      model = Authorship.load_with_notifiable_associations(authorship.id).first
+
+      expect(model.association(:author).loaded?).to be_true
+    end
+  end
+
+  describe '#associations_to_notify' do
+    it 'returns the correct models' do
+      expect(author.associations_to_notify).to eql([authorship])
+    end
+  end
+
+  describe '#needs_to_notify?' do
+    it 'is false if there are no notifiable associations' do
+      expect(post.needs_to_notify?).to be_false
+    end
+
+    it 'is true if there are notifiable associations' do
+      expect(author.needs_to_notify?).to be_true
+    end
+  end
+
+  describe '#models_for_association' do
+    it 'should return an array of models for multiple association' do
+      models = post.models_for_association(:authorships)
+
+      expect(models.first).to be_a_kind_of(Authorship)
+    end
+
+    it 'should return an array of one model for a singular association' do
+      models = author.models_for_association(:affiliate)
+
+      expect(models.first).to be_a_kind_of(Affiliate)
+    end
+  end
+end

data/spec/unit/notification/notifiable_associations_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Lifesaver::Notification::NotifiableAssociations do
+  let(:notifiable_associations) do
+    Lifesaver::Notification::NotifiableAssociations.new
+  end
+
+  describe '#populate' do
+    it 'mirrors arguments for both keys' do
+      notifiable_associations.populate(:foo)
+      association_keys = notifiable_associations.send(:association_keys)
+
+      expect(association_keys.on_change).to eql(association_keys.on_notify)
+    end
+
+    it 'accepts arguments that are singular' do
+      notifiable_associations.populate(:foo)
+      association_keys = notifiable_associations.send(:association_keys)
+
+      expect(association_keys.on_change).to eql([:foo])
+    end
+
+    it 'accepts arguments that are arrays' do
+      notifiable_associations.populate([:foo, :bar])
+      association_keys = notifiable_associations.send(:association_keys)
+
+      expect(association_keys.on_notify).to eql([:foo, :bar])
+    end
+
+    it 'accepts an options hash for :only_on_notify' do
+      notifiable_associations.populate(:foo, only_on_notify: [:baz])
+      association_keys = notifiable_associations.send(:association_keys)
+
+      expect(association_keys.on_notify).to eql([:foo, :baz])
+    end
+
+    it 'accepts an options hash for :only_on_change' do
+      notifiable_associations.populate(:foo, only_on_change: [:baz])
+      association_keys = notifiable_associations.send(:association_keys)
+
+      expect(association_keys.on_change).to eql([:foo, :baz])
+    end
+  end
+
+  describe '#any_to_notify?' do
+    it 'is true if the :on_notify array is not empty' do
+      notifiable_associations.populate([], only_on_notify: [:baz])
+
+      expect(notifiable_associations.any_to_notify?).to be_true
+    end
+
+    it 'is false if the :on_notify array is empty' do
+      notifiable_associations.populate([], only_on_change: [:baz])
+
+      expect(notifiable_associations.any_to_notify?).to be_false
+    end
+  end
+
+  describe '#on_notify' do
+    it 'reads the :on_notify key' do
+      notifiable_associations.populate([], only_on_notify: [:baz])
+      keys = notifiable_associations.send(:association_keys)
+
+      expect(notifiable_associations.on_notify).to eql(keys.on_notify)
+    end
+  end
+  describe '#on_change' do
+    it 'reads the :on_change key' do
+      notifiable_associations.populate([], only_on_change: [:baz])
+      keys = notifiable_associations.send(:association_keys)
+
+      expect(notifiable_associations.on_change).to eql(keys.on_change)
+    end
+  end
+end