changeling 0.0.7 → 0.1.0

data/spec/fixtures/app/application.rb

@@ -2,11 +2,6 @@ require 'spec_helper'
 
 module RailsApp
   class Application < Rails::Application
-    # app config here
-    # config.secret_token = '572c86f5ede338bd8aba8dae0fd3a326aabababc98d1e6ce34b9f5'
-    # routes.draw do
-    #   resources :blog_posts
-    # end
   end
 
   class ApplicationController < ActionController::Base

data/spec/fixtures/app/models/async_blog_post.rb

@@ -0,0 +1,10 @@
+class AsyncBlogPost
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Changeling::Async::Trackling
+  include Changeling::Probeling
+
+  field :title
+  field :content
+  field :public, :type => Boolean
+end

data/spec/fixtures/app/models/async_blog_post_active_record.rb

@@ -0,0 +1,5 @@
+# Setup for the fields etc. happens in spec_helper.
+class AsyncBlogPostActiveRecord < ActiveRecord::Base
+  include Changeling::Async::Trackling
+  include Changeling::Probeling
+end

data/spec/fixtures/app/models/async_blog_post_no_timestamp.rb

@@ -0,0 +1,9 @@
+class AsyncBlogPostNoTimestamp
+  include Mongoid::Document
+  include Changeling::Async::Trackling
+  include Changeling::Probeling
+
+  field :title
+  field :content
+  field :public, :type => Boolean
+end

data/spec/lib/changeling/async/trackling_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'resque'
+require 'sidekiq'
+
+describe Changeling::Async::Trackling do
+  before(:all) do
+    @klass = Changeling::Models::Logling
+  end
+
+  async_models.each_pair do |model, args|
+    before(:each) do
+      @object = model.new(args[:options])
+    end
+
+    context "#{model}" do
+      describe "without Sidekiq or Resque" do
+        before(:each) do
+          hide_const("Resque")
+          hide_const("Sidekiq")
+        end
+
+        it "should raise the AsyncGemRequired exception" do
+          expect { @object.async_save_logling }.to raise_error(Changeling::Exceptions::AsyncGemRequired)
+        end
+      end
+
+      describe "with Sidekiq" do
+        before(:each) do
+          hide_const("Resque")
+        end
+
+        describe "callbacks" do
+          before(:each) do
+            @logling = @klass.new(@object)
+          end
+
+          it "should not create a logling when doing the initial save of a new object" do
+            @klass.should_not_receive(:new)
+            @object.run_callbacks(:create)
+          end
+
+          context "after_update" do
+            it "should queue a logling to be made when updating an object and changes are made" do
+              @object.stub(:changes).and_return({ :field => 'value' })
+              @klass.should_receive(:new).and_return(@logling)
+              Changeling::Async::SidekiqWorker.should_receive(:perform_async).with(@logling.to_indexed_json)
+            end
+
+            it "should not queue a logling to be made when updating an object and changes are empty" do
+              @object.stub(:changes).and_return({})
+              @klass.should_not_receive(:new)
+              Changeling::Async::SidekiqWorker.should_not_receive(:perform_async)
+            end
+
+            it "should not queue a logling to be made when updating an object and no changes have been made" do
+              @object.stub(:changes).and_return(nil)
+              @klass.should_not_receive(:create)
+              Changeling::Async::SidekiqWorker.should_not_receive(:perform_async)
+            end
+
+            after(:each) do
+              @object.run_callbacks(:update)
+            end
+          end
+        end
+      end
+
+      describe "with Resque" do
+        before(:each) do
+          hide_const("Sidekiq")
+        end
+
+        describe "callbacks" do
+          before(:each) do
+            @logling = @klass.new(@object)
+          end
+
+          it "should not create a logling when doing the initial save of a new object" do
+            @klass.should_not_receive(:new)
+            @object.run_callbacks(:create)
+          end
+
+          context "after_update" do
+            it "should queue a logling to be made when updating an object and changes are made" do
+              @object.stub(:changes).and_return({ :field => 'value' })
+              @klass.should_receive(:new).and_return(@logling)
+              Resque.should_receive(:enqueue).with(Changeling::Async::ResqueWorker, @logling.to_indexed_json)
+            end
+
+            it "should not queue a logling to be made when updating an object and changes are empty" do
+              @object.stub(:changes).and_return({})
+              @klass.should_not_receive(:new)
+              Resque.should_not_receive(:enqueue)
+            end
+
+            it "should not queue a logling to be made when updating an object and no changes have been made" do
+              @object.stub(:changes).and_return(nil)
+              @klass.should_not_receive(:create)
+              Resque.should_not_receive(:enqueue)
+            end
+
+            after(:each) do
+              @object.run_callbacks(:update)
+            end
+          end
+        end
+      end
+
+      describe "with Sidekiq and Resque" do
+        describe "callbacks" do
+          before(:each) do
+            @logling = @klass.new(@object)
+          end
+
+          it "should prefer Sidekiq to Resque" do
+            @object.stub(:changes).and_return({ :field => 'value' })
+            @klass.should_receive(:new).and_return(@logling)
+            Changeling::Async::SidekiqWorker.should_receive(:perform_async).with(@logling.to_indexed_json)
+            Resque.should_not_receive(:enqueue)
+            @object.run_callbacks(:update)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/changeling/models/logling_spec.rb

@@ -7,8 +7,6 @@ describe Changeling::Models::Logling do
 
   # .models is defined in spec_helper.
   models.each_pair do |model, args|
-    puts "Testing #{model} now."
-
     before(:each) do
       @object = model.new(args[:options])
       @changes = args[:changes]
@@ -17,287 +15,289 @@ describe Changeling::Models::Logling do
       @logling = @klass.new(@object)
     end
 
-    context "Class Methods" do
-      describe ".create" do
-        before(:each) do
+    context "#{model}" do
+      context "Class Methods" do
+        describe ".create" do
+          before(:each) do
 
-          @klass.should_receive(:new).with(@object).and_return(@logling)
-        end
+            @klass.should_receive(:new).with(@object).and_return(@logling)
+          end
 
-        it "should call new with it's parameters then save the initialized logling" do
-          @logling.should_receive(:save)
+          it "should call new with it's parameters then save the initialized logling" do
+            @logling.should_receive(:save)
 
-          @klass.create(@object)
+            @klass.create(@object)
+          end
         end
-      end
 
-      describe ".new" do
-        context "when passed object is a ElasticSearch response hash" do
-          before(:each) do
-            @object = {
-              "klass"=>"BlogPost",
-              "oid"=>"50b8355f7a93d04908000001",
-              "modifications"=>"{\"public\":[true,false]}",
-              "modified_at"=>"2012-11-29T20:26:07-08:00"
-            }
-
-            @logling = @klass.new(@object)
-            @changes = JSON.parse(@object['modifications'])
-            @before, @after = @klass.parse_changes(@changes)
-            @modified_time = DateTime.parse(@object['modified_at'])
-          end
+        describe ".new" do
+          context "when passed object is a ElasticSearch response hash" do
+            before(:each) do
+              @object = {
+                "klass"=>"BlogPost",
+                "oid"=>"50b8355f7a93d04908000001",
+                "modifications"=>"{\"public\":[true,false]}",
+                "modified_at"=>"2012-11-29T20:26:07-08:00"
+              }
+
+              @logling = @klass.new(@object)
+              @changes = JSON.parse(@object['modifications'])
+              @before, @after = @klass.parse_changes(@changes)
+              @modified_time = DateTime.parse(@object['modified_at'])
+            end
 
-          it "should set klass as the returned klass value" do
-            @logling.klass.should == @object['klass'].constantize
-          end
+            it "should set klass as the returned klass value" do
+              @logling.klass.should == @object['klass'].constantize
+            end
 
-          it "should set oid as the returned oid value" do
-            @logling.oid.should == @object['oid']
-          end
+            it "should set oid as the returned oid value" do
+              @logling.oid.should == @object['oid']
+            end
 
-          it "should convert oid to an integer if it's supposed to be an integer" do
-            @object["oid"] = "1"
-            @klass.new(@object).oid.should == @object["oid"].to_i
-          end
+            it "should convert oid to an integer if it's supposed to be an integer" do
+              @object["oid"] = "1"
+              @klass.new(@object).oid.should == @object["oid"].to_i
+            end
 
-          it "should set the modifications as the incoming changes parameter" do
-            @logling.modifications.should == @changes
-          end
+            it "should set the modifications as the incoming changes parameter" do
+              @logling.modifications.should == @changes
+            end
 
-          it "should set the modified_fields as the keys of the modifications" do
-            @logling.modified_fields.should == @changes.keys
-          end
+            it "should set the modified_fields as the keys of the modifications" do
+              @logling.modified_fields.should == @changes.keys
+            end
 
-          it "should set before and after based on .parse_changes" do
-            @logling.before.should == @before
-            @logling.after.should == @after
-          end
+            it "should set before and after based on .parse_changes" do
+              @logling.before.should == @before
+              @logling.after.should == @after
+            end
 
-          it "should set modified_at as the parsed version of the returned modified_at value" do
-            @logling.modified_at.should == @modified_time
+            it "should set modified_at as the parsed version of the returned modified_at value" do
+              @logling.modified_at.should == @modified_time
+            end
           end
-        end
 
-        context "when passed object is a real object" do
-          before(:each) do
-            @before, @after = @klass.parse_changes(@changes)
-          end
+          context "when passed object is a real object" do
+            before(:each) do
+              @before, @after = @klass.parse_changes(@changes)
+            end
 
-          it "should set klass as the object's class" do
-            @logling.klass.should == @object.class
-          end
+            it "should set klass as the object's class" do
+              @logling.klass.should == @object.class
+            end
 
-          it "should set oid as the object's ID" do
-            @logling.oid.should == @object.id
-          end
+            it "should set oid as the object's ID" do
+              @logling.oid.should == @object.id
+            end
 
-          it "should set the modifications as the incoming changes parameter" do
-            @logling.modifications.should == @changes
-          end
+            it "should set the modifications as the incoming changes parameter" do
+              @logling.modifications.should == @changes
+            end
 
-          it "should set before and after based on .parse_changes" do
-            @logling.before.should == @before
-            @logling.after.should == @after
-          end
+            it "should set before and after based on .parse_changes" do
+              @logling.before.should == @before
+              @logling.after.should == @after
+            end
 
-          it "should set the modified_fields as the keys of the modifications" do
-            @logling.modified_fields.should == @changes.keys
-          end
+            it "should set the modified_fields as the keys of the modifications" do
+              @logling.modified_fields.should == @changes.keys
+            end
 
-          it "should ignore changes that are nil" do
-            changes = {}
+            it "should ignore changes that are nil" do
+              changes = {}
 
-            @changes.keys.each do |key|
-              changes[key] = nil
-            end
+              @changes.keys.each do |key|
+                changes[key] = nil
+              end
 
-            @object.stub(:changes).and_return(changes)
+              @object.stub(:changes).and_return(changes)
 
-            @klass.new(@object).modifications.should be_empty
-          end
+              @klass.new(@object).modifications.should be_empty
+            end
 
-          it "should set modified_at to the object's time of update if the object responds to the updated_at method" do
-            @object.should_receive(:respond_to?).with(:updated_at).and_return(true)
+            it "should set modified_at to the object's time of update if the object responds to the updated_at method" do
+              @object.should_receive(:respond_to?).with(:updated_at).and_return(true)
 
-            # Setting up a variable to prevent test flakiness from passing time.
-            time = Time.now
-            @object.stub(:updated_at).and_return(time)
+              # Setting up a variable to prevent test flakiness from passing time.
+              time = Time.now
+              @object.stub(:updated_at).and_return(time)
 
-            # Create a new logling to trigger the initialize method
-            @logling = @klass.new(@object)
-            @logling.modified_at.should == @object.updated_at
-          end
+              # Create a new logling to trigger the initialize method
+              @logling = @klass.new(@object)
+              @logling.modified_at.should == @object.updated_at
+            end
 
-          it "should set modified_at to the current time if the object doesn't respond to updated_at" do
-            @object.should_receive(:respond_to?).with(:updated_at).and_return(false)
+            it "should set modified_at to the current time if the object doesn't respond to updated_at" do
+              @object.should_receive(:respond_to?).with(:updated_at).and_return(false)
 
-            # Setting up a variable to prevent test flakiness from passing time.
-            time = Time.now
-            Time.stub(:now).and_return(time)
+              # Setting up a variable to prevent test flakiness from passing time.
+              time = Time.now
+              Time.stub(:now).and_return(time)
 
-            # Create a new logling to trigger the initialize method
-            @logling = @klass.new(@object)
-            @logling.modified_at.should == time
+              # Create a new logling to trigger the initialize method
+              @logling = @klass.new(@object)
+              @logling.modified_at.should == time
+            end
           end
         end
-      end
 
-      describe ".parse_changes" do
-        before(:each) do
-          @object.save!
+        describe ".parse_changes" do
+          before(:each) do
+            @object.save!
 
-          @before = @object.attributes.select { |attr| @changes.keys.include?(attr) }
+            @before = @object.attributes.select { |attr| @changes.keys.include?(attr) }
 
-          @changes.each_pair do |k, v|
-            @object.send("#{k}=", v[1])
-          end
-
-          @after = @object.attributes.select { |attr| @changes.keys.include?(attr) }
-        end
+            @changes.each_pair do |k, v|
+              @object.send("#{k}=", v[1])
+            end
 
-        it "should correctly match the before and after states of the object" do
-          @klass.parse_changes(@object.changes).should == [@before, @after]
-        end
-      end
+            @after = @object.attributes.select { |attr| @changes.keys.include?(attr) }
+          end
 
-      describe ".klassify" do
-        it "should return the object's class as an underscored string" do
-          @klass.klassify(@object).should == @object.class.to_s.underscore
+          it "should correctly match the before and after states of the object" do
+            @klass.parse_changes(@object.changes).should == [@before, @after]
+          end
         end
-      end
 
-      describe ".records_for" do
-        before(:each) do
-          @search = Changeling::Support::Search
-          @results = []
+        describe ".klassify" do
+          it "should return the object's class as an underscored string" do
+            @klass.klassify(@object).should == @object.class.to_s.underscore
+          end
         end
 
-        context "length parameter" do
+        describe ".records_for" do
           before(:each) do
-            @search.stub(:find_by).and_return(@results)
+            @search = Changeling::Support::Search
+            @results = []
           end
 
-          it "should only return the amount specified" do
-            num = 5
-            @results.should_receive(:take).with(num).and_return([])
-            @klass.records_for(@object, 5)
+          context "length parameter" do
+            before(:each) do
+              @search.stub(:find_by).and_return(@results)
+            end
+
+            it "should only return the amount specified" do
+              num = 5
+              @results.should_receive(:take).with(num).and_return([])
+              @klass.records_for(@object, 5)
+            end
+
+            it "should return all if no amount is specified" do
+              @results.should_not_receive(:take)
+              @klass.records_for(@object)
+            end
           end
 
-          it "should return all if no amount is specified" do
-            @results.should_not_receive(:take)
+          it "should search with filters on the klass and oid" do
+            @search.should_receive(:find_by).with(hash_including({
+              :filters => [
+                { :klass => @klass.klassify(@object) },
+                { :oid => @object.id.to_s }
+              ]
+            })).and_return(@results)
             @klass.records_for(@object)
           end
-        end
 
-        it "should search with filters on the klass and oid" do
-          @search.should_receive(:find_by).with(hash_including({
-            :filters => [
-              { :klass => @klass.klassify(@object) },
-              { :oid => @object.id.to_s }
-            ]
-          })).and_return(@results)
-          @klass.records_for(@object)
-        end
-
-        it "should search with a filter on the field if one is passed in" do
-          @search.should_receive(:find_by).with(hash_including(
-            :filters => [
-              { :klass => @klass.klassify(@object) },
-              { :oid => @object.id.to_s },
-              { :modified_fields => "field" }
-            ]
-          )).and_return(@results)
-          @klass.records_for(@object, nil, "field")
-        end
+          it "should search with a filter on the field if one is passed in" do
+            @search.should_receive(:find_by).with(hash_including(
+              :filters => [
+                { :klass => @klass.klassify(@object) },
+                { :oid => @object.id.to_s },
+                { :modified_fields => "field" }
+              ]
+            )).and_return(@results)
+            @klass.records_for(@object, nil, "field")
+          end
 
-        it "should sort by descending modified_at" do
-          @search.should_receive(:find_by).with(hash_including({
-            :sort => {
-              :field => :modified_at,
-              :direction => :desc
-            }
-          })).and_return(@results)
-          @klass.records_for(@object, nil)
+          it "should sort by descending modified_at" do
+            @search.should_receive(:find_by).with(hash_including({
+              :sort => {
+                :field => :modified_at,
+                :direction => :desc
+              }
+            })).and_return(@results)
+            @klass.records_for(@object, nil)
+          end
         end
       end
-    end
 
-    context "Instance Methods" do
-      before(:each) do
-        # Stub :id so that it doesn't screw up these test's expectations.
-        @logling.stub(:id).and_return(1)
-      end
-
-      describe ".to_indexed_json" do
-        it "should include the object's klass attribute" do
-          @logling.should_receive(:klass)
+      context "Instance Methods" do
+        before(:each) do
+          # Stub :id so that it doesn't screw up these test's expectations.
+          @logling.stub(:id).and_return(1)
         end
 
-        it "should include the object's oid attribute" do
-          @logling.should_receive(:oid)
-        end
+        describe ".to_indexed_json" do
+          it "should include the object's klass attribute" do
+            @logling.should_receive(:klass)
+          end
 
-        it "should include the object's modifications attribute" do
-          @logling.should_receive(:modifications)
-        end
+          it "should include the object's oid attribute" do
+            @logling.should_receive(:oid)
+          end
 
-        it "should convert the object's modifications attribute to JSON" do
-          mods = {}
-          @logling.should_receive(:modifications).and_return(mods)
-          mods.should_receive(:to_json)
-        end
+          it "should include the object's modifications attribute" do
+            @logling.should_receive(:modifications)
+          end
 
-        it "should include the object's modified_at attribute" do
-          @logling.should_receive(:modified_at)
-        end
+          it "should convert the object's modifications attribute to JSON" do
+            mods = {}
+            @logling.should_receive(:modifications).and_return(mods)
+            mods.should_receive(:to_json)
+          end
 
-        it "should include an array of the object's modified fields" do
-          @logling.should_receive(:modified_fields)
-        end
+          it "should include the object's modified_at attribute" do
+            @logling.should_receive(:modified_at)
+          end
 
-        after(:each) do
-          @logling.to_indexed_json
-        end
-      end
+          it "should include an array of the object's modified fields" do
+            @logling.should_receive(:modified_fields)
+          end
 
-      describe ".as_json" do
-        before(:each) do
-          @json = @logling.as_json
+          after(:each) do
+            @logling.to_indexed_json
+          end
         end
 
-        it "should include the object's klass attribute" do
-          @json[:class].should == @object.class
-        end
+        describe ".as_json" do
+          before(:each) do
+            @json = @logling.as_json
+          end
 
-        it "should include the object's oid attribute" do
-          @json[:oid].should == @object.id
-        end
+          it "should include the object's klass attribute" do
+            @json[:class].should == @object.class
+          end
 
-        it "should include the object's modifications attribute" do
-          @json[:modifications].should == @changes
-        end
+          it "should include the object's oid attribute" do
+            @json[:oid].should == @object.id
+          end
 
-        it "should include the object's modified_at attribute" do
-          @json[:modified_at].should == @logling.modified_at
-        end
+          it "should include the object's modifications attribute" do
+            @json[:modifications].should == @changes
+          end
 
-        after(:each) do
-          @logling.to_indexed_json
-        end
-      end
+          it "should include the object's modified_at attribute" do
+            @json[:modified_at].should == @logling.modified_at
+          end
 
-      describe ".save" do
-        it "should update the ElasticSearch index" do
-          @logling.should_receive(:update_index)
+          after(:each) do
+            @logling.to_indexed_json
+          end
         end
 
-        it "should not update the index if there are no changes" do
-          @logling.stub(:modifications).and_return({})
-          @logling.should_not_receive(:_run_save_callbacks)
-        end
+        describe ".save" do
+          it "should update the ElasticSearch index" do
+            @logling.should_receive(:update_index)
+          end
 
-        after(:each) do
-          @logling.save
+          it "should not update the index if there are no changes" do
+            @logling.stub(:modifications).and_return({})
+            @logling.should_not_receive(:_run_save_callbacks)
+          end
+
+          after(:each) do
+            @logling.save
+          end
         end
       end
     end