lifesaver 0.0.1 → 0.1.0

data/spec/lifesaver/marshal_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe Lifesaver::Marshal do
-  describe ".is_serialized?" do
-    it "returns true if Hash has :id and :class" do
-      obj = { class: :post, id: 1 }
-      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(true)
-    end
-
-    it "returns true if Hash has 'id' and 'class'" do
-      obj = { "class" => "post", "id" => "1" }
-      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(true)
-    end
-
-    it "returns false if Hash does not have id and class keys" do
-      obj = { some_key: 1, id: 4 }
-      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(false)
-    end
-
-    it "returns false if passed an non-Hash object" do
-      obj = Post.new
-      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(false)
-    end
-  end
-
-  describe ".sanitize" do
-    it "returns symbolized version of the Hash'" do
-      obj = { "class" => "post", "id" => "1", "status" => "updated" }
-      out = { class: :post, id: 1, status: :updated }
-      expect(Lifesaver::Marshal.sanitize(obj)).to eql(out)
-    end
-
-    it "rejects non-Hashes" do
-      obj = Post.new
-      expect { Lifesaver::Marshal.sanitize(obj) }.to raise_error
-    end
-  end
-
-  describe ".load" do
-    before(:all) do
-      Post.create(title: "Test Post")
-    end
-
-    it "loads a serialized object from ActiveRecord" do
-      obj = { class: :post, id: 1 }
-      expect(Lifesaver::Marshal.load(obj)).to eql([Post.find(1), {}])
-    end
-
-    it "returns nil if model not found" do
-      obj = { class: :post, id: 12 }
-      expect(Lifesaver::Marshal.load(obj)).to eql(nil)
-    end
-
-    it "returns options if they were passed" do
-      obj = { class: :post, id: 1, status: :notified }
-      m = Lifesaver::Marshal.load(obj)
-      expect(m).to eql([Post.find(1), {status: :notified}])
-    end
-
-
-    it "rejects bad input" do
-      obj = Post.new
-      expect { Lifesaver::Marshal.load(obj) }.to raise_error
-    end
-  end
-
-  describe ".dump" do
-    it "decomposes an object to a Hash" do
-      obj = Post.create(title: "Test Post")
-      out = { class: :post, id: 2 }
-      expect(Lifesaver::Marshal.dump(obj)).to eql(out)
-    end
-
-    it "adds additional key, value pairs if passed" do
-      obj = Post.create(title: "Test Post")
-      out = { status: :updated, class: :post, id: 2 }
-      expect(Lifesaver::Marshal.dump(obj, {status: :updated})).to eql(out)
-    end
-  end
-end

data/spec/lifesaver/model_additions_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-describe Lifesaver::ModelAdditions do
-  Lifesaver.suppress_indexing
-
-  describe ".notifies_for_indexing" do
-    after(:each) do 
-      Post.send(:notifies_for_indexing, only_on_change: :authorships)
-    end
-    it "should return a Hash of models for notification on save and notify" do
-      Post.send(:notifies_for_indexing, :comments, 
-        only_on_change: :authorships,
-        only_on_notify: :authors
-      )
-      exp_hash = { on_change: [], on_notify: [] }
-      exp_hash[:on_change] << :comments
-      exp_hash[:on_change] << :authorships
-      exp_hash[:on_notify] << :comments
-      exp_hash[:on_notify] << :authors
-      expect(Post.notifiable_associations).to eql(exp_hash)
-    end
-  end
-
-  describe "#association_models" do
-    before(:each) do
-      @post = Post.create(title: "Some post")
-      affiliate = Affiliate.create(name: "Some place")
-      @author = Author.create(name: "Some guy", affiliate_id: affiliate.id)
-      Authorship.create(post: @post, author: @author)
-    end
-    after(:all) do
-      Post.destroy_all
-      Author.destroy_all
-      Authorship.destroy_all
-      Affiliate.destroy_all
-    end
-
-    it "should return an array of models for multiple association" do
-      association = @post.association_models(:authorships)
-      expect(association[0]).to be_a_kind_of(Authorship)
-    end
-
-    it "should return an array of one model for a singular association" do
-      association = @author.association_models(:affiliate)
-      expect(association[0]).to be_a_kind_of(Affiliate)
-    end
-  end
-  
-  Lifesaver.unsuppress_indexing
-
-  describe "#indexing_suppressed?" do
-    let(:post) { Post.new(title: "Test Post") }
-
-    it "should be false by default" do
-      expect(post.send(:suppress_indexing?)).to eql(false)
-    end
-
-    it "should be true if overridden locally" do
-      Lifesaver.suppress_indexing
-      expect(post.send(:suppress_indexing?)).to eql(true)
-    end
-
-    it "should be false if override is cancelled" do
-      Lifesaver.unsuppress_indexing
-      expect(post.send(:suppress_indexing?)).to eql(false)
-    end
-
-    it "should be true if set individually" do
-      post.suppress_indexing
-      expect(post.send(:suppress_indexing?)).to eql(true)
-    end
-
-    it "should be false if unset individually" do
-      post.unsuppress_indexing
-      expect(post.send(:suppress_indexing?)).to eql(false)
-    end
-  end
-
-  describe "#dependent_association_map" do
-    it "returns an empty Hash when there are no dependent associations" do
-      expect(Comment.new.send(:dependent_association_map)).to eql({})
-    end
-
-    it "returns a Hash with the keys of dependent_association" do
-      dependent_map = Author.new.send(:dependent_association_map)
-      expect(dependent_map).to eql({authorships: true})
-    end
-
-  end
-
-end

data/spec/lifesaver_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Lifesaver do
-  before(:all) do
-    Lifesaver.suppress_indexing
-    Post.destroy_all
-    Author.destroy_all
-    Authorship.destroy_all
-    Affiliate.destroy_all
-    Comment.destroy_all
-    Lifesaver.unsuppress_indexing
-  end
-  before(:each) do
-    [Author, Post].each do |klass|
-      klass.tire.index.delete
-      klass.tire.create_elasticsearch_index
-    end
-
-    Lifesaver.suppress_indexing
-    
-    @posts = []
-    @posts << Post.create(
-      title: "Lifesavers are my favorite candy", 
-      content: "Lorem ipsum",
-      tags: %w(candy stuff opinions)
-      )
-    @posts << Post.create(
-      title: "Birds are the best animal", 
-      content: "Lorem ipsum",
-      tags: %w(animals stuff facts)
-    )
-    @posts << Post.create(
-      title: "Chicago Cubs have a winning season", 
-      content: "Lorem ipsum",
-      tags: %w(sports stuff jokes)
-    )
-    @comments = []
-    @comments << Comment.create(
-      post: @posts.last,
-      text: "We love this!"
-    )
-    @comments << Comment.create(
-      post: @posts.last,
-      text: "We lied. Didn't realize it was a joke."
-    )
-    @authors = []
-    @authors << Author.create(name: "Paul Sorensen")
-    @authors << Author.create(name: "Paul Sorensen's Ghost Writer")
-    @authors << Author.create(name: "Theo Epstein")
-    @affiliates = []
-    @affiliates << Affiliate.create(name: "Prosper Forebearer")
-    @affiliates << Affiliate.create(name: "Chicago Cubs")
-    @authors[0].affiliate_id = @affiliates.first.id
-    @authors[1].affiliate_id = @affiliates.first.id
-    @authors[2].affiliate_id = @affiliates.last.id
-    @authors.each { |a| a.save! }
-    Authorship.create(post: @posts[0], author: @authors[0])
-    Authorship.create(post: @posts[1], author: @authors[0])
-    Authorship.create(post: @posts[1], author: @authors[1])
-    Authorship.create(post: @posts[2], author: @authors[2])
-
-    Lifesaver.unsuppress_indexing
-
-    [Author, Post].each do |klass|
-      klass.all.each { |k| k.tire.update_index }
-      klass.tire.index.refresh
-    end
-  end
-
-  after(:each) do
-    Post.destroy_all
-    Author.destroy_all
-    Authorship.destroy_all
-    Affiliate.destroy_all
-    Comment.destroy_all
-  end
-
-  it "should traverse the provided graph" do
-    models = Lifesaver::IndexGraph.generate([{"class"=>"author", "id"=>1, "status"=>"changed"}])
-    expect(models.size).to eql(2)
-  end
-
-  it "should reindex on destroy" do
-    @authors[2].destroy
-    sleep(1.seconds)
-    expect(Author.search(query: "Theo Epstein").to_a.size).to eql(0)
-  end
-
-  it "should reindex on update" do
-    @authors[2].name = "Harry Carry"
-    @authors[2].save!
-    sleep(1.seconds) # need to wait for elasticsearch to update
-    expect(Author.search(query: "Harry Carry").to_a.size).to eql(1)
-  end
-
-  it "should update distant related indexes" do
-    @posts[0].tags << 'werd'
-    @posts[0].save!
-    sleep(1.seconds)
-    expect(Author.search(query: "werd").to_a.size).to eql(1)
-  end
-
-  it "should update related indexes if saved model doesn't have index" do
-    @comments[0].text = "We hate this!"
-    @comments[0].save!
-    sleep(1.seconds)
-    result = Post.search(query: "Chicago").to_a.first
-    comment_text = result.comments.first.text
-    expect(comment_text).to eql("We hate this!")
-  end
-end