mongoid-audit 0.3.2 → 1.0.0.alpha.1

data/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci

data/.rspec

@@ -1 +0,0 @@
---color

data/.travis.yml

@@ -1,15 +0,0 @@
-services: mongodb
-
-notifications:
-  email: false
-
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - jruby-19mode
-
-gemfile:
-  - Gemfile
-  - gemfiles/mongoid-4.0.gemfile
-

data/lib/mongoid-audit/mongoid_observer.rb

@@ -1,172 +0,0 @@
-# encoding: utf-8
-module Mongoid
-
-  # Observer classes respond to life cycle callbacks to implement trigger-like
-  # behavior outside the original class. This is a great way to reduce the
-  # clutter that normally comes when the model class is burdened with
-  # functionality that doesn't pertain to the core responsibility of the
-  # class. Mongoid's observers work similar to ActiveRecord's. Example:
-  #
-  #   class CommentObserver < Mongoid::Observer
-  #     def after_save(comment)
-  #       Notifications.comment(
-  #         "admin@do.com", "New comment was posted", comment
-  #       ).deliver
-  #     end
-  #   end
-  #
-  # This Observer sends an email when a Comment#save is finished.
-  #
-  #   class ContactObserver < Mongoid::Observer
-  #     def after_create(contact)
-  #       contact.logger.info('New contact added!')
-  #     end
-  #
-  #     def after_destroy(contact)
-  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
-  #     end
-  #   end
-  #
-  # This Observer uses logger to log when specific callbacks are triggered.
-  #
-  # == Observing a class that can't be inferred
-  #
-  # Observers will by default be mapped to the class with which they share a
-  # name. So CommentObserver will be tied to observing Comment,
-  # ProductManagerObserver to ProductManager, and so on. If you want to
-  # name your observer differently than the class you're interested in
-  # observing, you can use the Observer.observe class method which takes
-  # either the concrete class (Product) or a symbol for that class (:product):
-  #
-  #   class AuditObserver < Mongoid::Observer
-  #     observe :account
-  #
-  #     def after_update(account)
-  #       AuditTrail.new(account, "UPDATED")
-  #     end
-  #   end
-  #
-  # If the audit observer needs to watch more than one kind of object,
-  # this can be specified with multiple arguments:
-  #
-  #   class AuditObserver < Mongoid::Observer
-  #     observe :account, :balance
-  #
-  #     def after_update(record)
-  #       AuditTrail.new(record, "UPDATED")
-  #     end
-  #   end
-  #
-  # The AuditObserver will now act on both updates to Account and Balance
-  # by treating them both as records.
-  #
-  # == Available callback methods
-  #
-  # * after_initialize
-  # * before_validation
-  # * after_validation
-  # * before_create
-  # * around_create
-  # * after_create
-  # * before_update
-  # * around_update
-  # * after_update
-  # * before_upsert
-  # * around_upsert
-  # * after_upsert
-  # * before_save
-  # * around_save
-  # * after_save
-  # * before_destroy
-  # * around_destroy
-  # * after_destroy
-  #
-  # == Storing Observers in Rails
-  #
-  # If you're using Mongoid within Rails, observer classes are usually stored
-  # in +app/models+ with the naming convention of +app/models/audit_observer.rb+.
-  #
-  # == Configuration
-  #
-  # In order to activate an observer, list it in the +config.mongoid.observers+
-  # configuration setting in your +config/application.rb+ file.
-  #
-  #   config.mongoid.observers = :comment_observer, :signup_observer
-  #
-  # Observers will not be invoked unless you define them in your
-  # application configuration.
-  #
-  # == Loading
-  #
-  # Observers register themselves with the model class that they observe,
-  # since it is the class that notifies them of events when they occur.
-  # As a side-effect, when an observer is loaded, its corresponding model
-  # class is loaded.
-  #
-  # Observers are loaded after the application initializers, so that
-  # observed models can make use of extensions. If by any chance you are
-  # using observed models in the initialization, you can
-  # still load their observers by calling +ModelObserver.instance+ before.
-  # Observers are singletons and that call instantiates and registers them.
-  class Observer < ActiveModel::Observer
-
-    private
-
-    # Adds the specified observer to the class.
-    #
-    # @example Add the observer.
-    #   observer.add_observer!(Document)
-    #
-    # @param [ Class ] klass The child observer to add.
-    #
-    # @since 2.0.0.rc.8
-    def add_observer!(klass)
-      super
-      define_callbacks(klass)
-    end
-
-    # Defines all the callbacks for each observer of the model.
-    #
-    # @example Define all the callbacks.
-    #   observer.define_callbacks(Document)
-    #
-    # @param [ Class ] klass The model to define them on.
-    #
-    # @since 2.0.0.rc.8
-    def define_callbacks(klass)
-      observer = self
-      observer_name = observer.class.name.underscore.gsub('/', '__')
-      Mongoid::Callbacks.observables.each do |callback|
-        next unless respond_to?(callback)
-        callback_meth = :"_notify_#{observer_name}_for_#{callback}"
-        unless klass.respond_to?(callback_meth)
-          klass.send(:define_method, callback_meth) do |&block|
-            if value = observer.update(callback, self, &block)
-              value
-            else
-              block.call if block
-            end
-          end
-          klass.send(callback, callback_meth)
-        end
-      end
-      self
-    end
-
-    # Are the observers disabled for the object?
-    #
-    # @api private
-    #
-    # @example If the observer disabled?
-    #   Observer.disabled_for(band)
-    #
-    # @param [ Document ] object The model instance.
-    #
-    # @return [ true, false ] If the observer is disabled.
-    def disabled_for?(object)
-      klass = object.class
-      return false unless klass.respond_to?(:observers)
-      klass.observers.disabled_for?(self) || Mongoid.observers.disabled_for?(self)
-    end
-  end
-end

data/lib/mongoid-audit/sweeper.rb

@@ -1,46 +0,0 @@
-module Mongoid::Audit
-  class Sweeper < ActiveModel::Observer
-    def controller
-      Thread.current[:mongoid_history_sweeper_controller]
-    end
-
-    def controller=(value)
-      Thread.current[:mongoid_history_sweeper_controller] = value
-    end
-
-    def self.observed_classes
-      [ Mongoid::Audit.tracker_class ]
-    end
-
-    # Hook to ActionController::Base#around_filter.
-    # Runs before a controller action is run.
-    # It should always return true so controller actions
-    # can continue.
-    def before(controller)
-      self.controller = controller
-      true
-    end
-
-    # Hook to ActionController::Base#around_filter.
-    # Runs after a controller action is run.
-    # Clean up so that the controller can
-    # be collected after this request
-    def after(controller)
-      self.controller = nil
-    end
-
-    def before_create(track)
-      track.modifier = audit_current_user if track.modifier.nil?
-    end
-
-    def audit_current_user
-      if controller.nil?
-        nil
-      elsif controller.respond_to?(Mongoid::Audit.current_user_method, true)
-        controller.send Mongoid::Audit.current_user_method
-      else
-        nil
-      end
-    end
-  end
-end

data/lib/mongoid-audit/tracker.rb

@@ -1,170 +0,0 @@
-module Mongoid::Audit
-  module Tracker
-    extend ActiveSupport::Concern
-
-    included do
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include ActiveModel::Observing
-
-      attr_writer :trackable
-
-      field       :association_chain,       :type => Array,     :default => []
-      field       :modified,                :type => Hash
-      field       :original,                :type => Hash
-      field       :version,                 :type => Integer
-      field       :action,                  :type => String
-      field       :scope,                   :type => String
-      belongs_to  :modifier,                :class_name => Mongoid::Audit.modifier_class_name
-
-      Mongoid::Audit.tracker_class_name = self.name.tableize.singularize.to_sym
-
-      index({'association_chain.name' => 1, 'association_chain.id' => 1})
-
-      Mongoid::Interceptable::CALLBACKS.each do |callback|
-        callback_method = :"_notify_#{Mongoid::Audit.tracker_class_name}_#{callback}"
-        module_eval <<-RUBY, __FILE__, __LINE__+1
-          #{callback} #{callback_method.inspect}
-          def #{callback_method}(&block)
-            if "#{callback}".start_with?( 'around_' )
-              notify_observers(#{callback.inspect}, &block)
-              yield
-            else
-              notify_observers(#{callback.inspect}, &block)
-              true
-            end
-          end
-          private #{callback_method.inspect}
-        RUBY
-      end
-
-    end
-
-    def undo!(modifier)
-      if action.to_sym == :destroy
-        re_create
-      elsif action.to_sym == :create
-        re_destroy
-      else
-        trackable.update_attributes!(undo_attr(modifier))
-      end
-    end
-
-    def redo!(modifier)
-      if action.to_sym == :destroy
-        re_destroy
-      elsif action.to_sym == :create
-        re_create
-      else
-        trackable.update_attributes!(redo_attr(modifier))
-      end
-    end
-
-    def undo_attr(modifier)
-      undo_hash = affected.easy_unmerge(modified)
-      undo_hash.easy_merge!(original)
-      modifier_field = trackable.history_trackable_options[:modifier_field]
-      undo_hash[modifier_field] = modifier
-      undo_hash
-    end
-
-    def redo_attr(modifier)
-      redo_hash = affected.easy_unmerge(original)
-      redo_hash.easy_merge!(modified)
-      modifier_field = trackable.history_trackable_options[:modifier_field]
-      redo_hash[modifier_field] = modifier
-      redo_hash
-    end
-
-    def trackable_root
-      @trackable_root ||= trackable_parents_and_trackable.first
-    end
-
-    def trackable
-      @trackable ||= trackable_parents_and_trackable.last
-    end
-
-    def trackable_parents
-      @trackable_parents ||= trackable_parents_and_trackable[0, -1]
-    end
-
-    def trackable_parent
-      @trackable_parent ||= trackable_parents_and_trackable[-2]
-    end
-
-    def affected
-      @affected ||= (modified.keys | original.keys).inject({}){ |h,k| h[k] =
-        trackable ? trackable.attributes[k] : modified[k]; h}
-    end
-
-private
-
-    def re_create
-      association_chain.length > 1 ? create_on_parent : create_standalone
-    end
-
-    def re_destroy
-      trackable.destroy
-    end
-
-    def create_standalone
-      class_name = association_chain.first["name"]
-      restored = class_name.constantize.new(modified)
-      restored.id = modified["_id"]
-      restored.save!
-    end
-
-    def create_on_parent
-      name = association_chain.last["name"]
-      if embeds_one?(trackable_parent, name)
-        trackable_parent.send("create_#{name}!", modified)
-      elsif embeds_many?(trackable_parent, name)
-         trackable_parent.send(name).create!(modified)
-      else
-        raise "This should never happen. Please report bug!"
-      end
-    end
-
-    def trackable_parents_and_trackable
-      @trackable_parents_and_trackable ||= traverse_association_chain
-    end
-
-    def relation_of(doc, name)
-      meta = doc.reflect_on_association(name)
-      meta ? meta.relation : nil
-    end
-
-    def embeds_one?(doc, name)
-      relation_of(doc, name) == Mongoid::Relations::Embedded::One
-    end
-
-    def embeds_many?(doc, name)
-      relation_of(doc, name) == Mongoid::Relations::Embedded::Many
-    end
-
-    def traverse_association_chain
-      chain = association_chain.dup
-      doc = nil
-      documents = []
-
-      begin
-        node = chain.shift
-        name = node['name']
-
-        doc = if doc.nil?
-          # root association. First element of the association chain
-          klass = name.classify.constantize
-          klass.where(:_id => node['id']).first
-        elsif embeds_one?(doc, name)
-          doc.send(name)
-        elsif embeds_many?(doc, name)
-          doc.send(name).where(:_id => node['id']).first
-        else
-          raise "This should never happen. Please report bug."
-        end
-        documents << doc
-      end while( !chain.empty? )
-      documents
-    end
-  end
-end

data/spec/integration/integration_spec.rb

@@ -1,666 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Mongoid::Audit do
-  before :all do
-    class Post
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include Mongoid::Audit::Trackable
-
-      field           :title
-      field           :body
-      field           :rating
-      field           :views
-
-      embeds_many     :comments
-      embeds_one      :section
-      embeds_many     :tags
-
-      accepts_nested_attributes_for :tags, :allow_destroy => true
-
-      track_history   :on => [:title, :body], :track_destroy => true
-    end
-
-    class Comment
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include Mongoid::Audit::Trackable
-
-      field             :title
-      field             :body
-      embedded_in       :post
-      track_history     :on => [:title, :body], :scope => :post, :track_create => true, :track_destroy => true
-    end
-
-    class Section
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include Mongoid::Audit::Trackable
-
-      field             :title
-      embedded_in       :post
-      track_history     :on => [:title], :scope => :post, :track_create => true, :track_destroy => true
-    end
-
-    class User
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include Mongoid::Audit::Trackable
-
-      has_and_belongs_to_many :own_restaurants, class_name: 'Restaurant', inverse_of: :owners
-
-      field             :email
-      field             :name
-      track_history     :except => [:email]
-    end
-
-    class Tag
-      include Mongoid::Document
-      include Mongoid::Timestamps
-      include Mongoid::Audit::Trackable
-
-      belongs_to :updated_by, :class_name => "User"
-
-      field             :title
-      track_history     :on => [:title], :scope => :post, :track_create => true, :track_destroy => true, :modifier_field => :updated_by
-    end
-
-    class Restaurant 
-      include Mongoid::Document
-      include Mongoid::Audit::Trackable
-
-      has_and_belongs_to_many :owners, class_name: 'User', inverse_of: nil
-
-      field             :title
-
-      track_history     :on => [:title], :track_create => true, :track_destroy => true
-    end
-  end
-
-  before :each do
-    @user = User.create(:name => "Aaron", :email => "aaron@randomemail.com")
-    @another_user = User.create(:name => "Another Guy", :email => "anotherguy@randomemail.com")
-    @post = Post.create(:title => "Test", :body => "Post", :modifier => @user, :views => 100)
-    @comment = @post.comments.create(:title => "test", :body => "comment", :modifier => @user)
-  end
-
-  describe "track" do
-    describe "on creation" do
-      it "should have one history track in comment" do
-        @comment.history_tracks.count.should == 1
-      end
-
-      it "should assign title and body on modified" do
-        @comment.history_tracks.first.modified.should == {'title' => "test", 'body' =>  "comment"}
-      end
-
-      it "should not assign title and body on original" do
-        @comment.history_tracks.first.original.should == {}
-      end
-
-      it "should assign modifier" do
-        @comment.history_tracks.first.modifier.should == @user
-      end
-
-      it "should assign version" do
-        @comment.history_tracks.first.version.should == 1
-      end
-
-      it "should assign scope" do
-        @comment.history_tracks.first.scope.should == "post"
-      end
-
-      it "should assign method" do
-        @comment.history_tracks.first.action.should == "create"
-      end
-
-      it "should assign association_chain" do
-        expected = [
-          {'id' => @post.id, 'name' => "Post"},
-          {'id' => @comment.id, 'name' => "comments"}
-        ]
-        @comment.history_tracks.first.association_chain.should == expected
-      end
-    end
-
-    describe "on destruction" do
-      it "should have two history track records in post" do
-        lambda {
-          @post.destroy
-        }.should change(HistoryTracker, :count).by(1)
-      end
-
-      it "should assign destroy on track record" do
-        @post.destroy
-        @post.history_tracks.last.action.should == "destroy"
-      end
-
-      it "should return affected attributes from track record" do
-        @post.destroy
-        @post.history_tracks.last.affected["title"].should == "Test"
-      end
-    end
-
-    describe "on update non-embedded" do
-      it "should create a history track if changed attributes match tracked attributes" do
-        lambda {
-          @post.update_attributes(:title => "Another Test")
-        }.should change(HistoryTracker, :count).by(1)
-      end
-
-      it "should not create a history track if changed attributes do not match tracked attributes" do
-        lambda {
-          @post.update_attributes(:rating => "untracked")
-        }.should change(HistoryTracker, :count).by(0)
-      end
-
-      it "should assign modified fields" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.last.modified.should == {
-          "title" => "Another Test"
-        }
-      end
-
-      it "should assign method field" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.last.action.should == "update"
-      end
-
-      it "should assign original fields" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.last.original.should == {
-          "title" => "Test"
-        }
-      end
-
-      it "should assign modifier" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.first.modifier.should == @user
-      end
-
-      it "should assign version on history tracks" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.first.version.should == 1
-      end
-
-      it "should assign version on post" do
-        @post.update_attributes(:title => "Another Test")
-        @post.version.should == 1
-      end
-
-      it "should assign scope" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.first.scope.should == "post"
-      end
-
-      it "should assign association_chain" do
-        @post.update_attributes(:title => "Another Test")
-        @post.history_tracks.last.association_chain.should == [{'id' => @post.id, 'name' => "Post"}]
-      end
-
-      it "should exclude defined options" do
-        @user.update_attributes(:name => "Aaron2", :email => "aaronsnewemail@randomemail.com")
-        @user.history_tracks.first.modified.keys.should include "name"
-        @user.history_tracks.first.modified.keys.should_not include "email"
-      end
-    end
-
-    describe "on update non-embedded twice" do
-      it "should assign version on post" do
-        @post.update_attributes(:title => "Test2")
-        @post.update_attributes(:title => "Test3")
-        @post.version.should == 2
-      end
-
-      it "should create a history track if changed attributes match tracked attributes" do
-        lambda {
-          @post.update_attributes(:title => "Test2")
-          @post.update_attributes(:title => "Test3")
-        }.should change(HistoryTracker, :count).by(2)
-      end
-
-      it "should create a history track of version 2" do
-        @post.update_attributes(:title => "Test2")
-        @post.update_attributes(:title => "Test3")
-        @post.history_tracks.where(:version => 2).first.should_not be_nil
-      end
-
-      it "should assign modified fields" do
-        @post.update_attributes(:title => "Test2")
-        @post.update_attributes(:title => "Test3")
-        @post.history_tracks.where(:version => 2).first.modified.should == {
-          "title" => "Test3"
-        }
-      end
-
-      it "should assign original fields" do
-        @post.update_attributes(:title => "Test2")
-        @post.update_attributes(:title => "Test3")
-        @post.history_tracks.where(:version => 2).first.original.should == {
-          "title" => "Test2"
-        }
-      end
-
-
-      it "should assign modifier" do
-        @post.update_attributes(:title => "Another Test", :modifier => @another_user)
-        @post.history_tracks.last.modifier.should == @another_user
-      end
-    end
-
-    describe "on update embedded 1..N (embeds_many)" do
-      it "should assign version on comment" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.version.should == 2 # first track generated on creation
-      end
-
-      it "should create a history track of version 2" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.should_not be_nil
-      end
-
-      it "should assign modified fields" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.modified.should == {
-          "title" => "Test2"
-        }
-      end
-
-      it "should assign original fields" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.original.should == {
-          "title" => "test"
-        }
-      end
-
-      it "should be possible to undo from parent" do
-        @comment.update_attributes(:title => "Test 2")
-        @post.history_tracks.last.undo!(@user)
-        @comment.reload
-        @comment.title.should == "test"
-      end
-
-      it "should assign modifier" do
-        @post.update_attributes(:title => "Another Test", :modifier => @another_user)
-        @post.history_tracks.last.modifier.should == @another_user
-      end
-    end
-
-    describe "on update embedded 1..1 (embeds_one)" do
-      before(:each) do
-        @section = Section.new(:title => 'Technology')
-        @post.section = @section
-        @post.save!
-        @post.reload
-        @section = @post.section
-      end
-
-      it "should assign version on create section" do
-        @section.version.should == 1
-      end
-
-      it "should assign version on section" do
-        @section.update_attributes(:title => 'Technology 2')
-        @section.version.should == 2 # first track generated on creation
-      end
-
-      it "should create a history track of version 2" do
-        @section.update_attributes(:title => 'Technology 2')
-        @section.history_tracks.where(:version => 2).first.should_not be_nil
-      end
-
-      it "should assign modified fields" do
-        @section.update_attributes(:title => 'Technology 2')
-        @section.history_tracks.where(:version => 2).first.modified.should == {
-          "title" => "Technology 2"
-        }
-      end
-
-      it "should assign original fields" do
-        @section.update_attributes(:title => 'Technology 2')
-        @section.history_tracks.where(:version => 2).first.original.should == {
-          "title" => "Technology"
-        }
-      end
-
-      it "should be possible to undo from parent" do
-        @section.update_attributes(:title => 'Technology 2')
-        @post.history_tracks.last.undo!(@user)
-        @section.reload
-        @section.title.should == "Technology"
-      end
-
-      it "should assign modifier" do
-        @section.update_attributes(:title => "Business", :modifier => @another_user)
-        @post.reload
-        # just workaround strange mongoid #last bug for now
-        @post.history_tracks.to_a[-1].modifier.should == @another_user
-      end
-      
-      it "should update modifier" do
-        @section.update_attributes(:title => 'Technology 2', :modifier => @user)
-        @section.update_attributes(:title => "Business", :modifier => @another_user)
-        @post.reload
-        @post.history_tracks.last.modifier.should == @another_user
-      end
-    end
-
-    describe "on destroy embedded" do
-      it "should be possible to re-create destroyed embedded" do
-        @comment.destroy
-        @comment.history_tracks.last.undo!(@user)
-        @post.reload
-        @post.comments.first.title.should == "test"
-      end
-
-      it "should be possible to re-create destroyed embedded from parent" do
-        @comment.destroy
-        @post.history_tracks.last.undo!(@user)
-        @post.reload
-        @post.comments.first.title.should == "test"
-      end
-
-      it "should be possible to destroy after re-create embedded from parent" do
-        @comment.destroy
-        @post.history_tracks.last.undo!(@user)
-        @post.history_tracks.last.undo!(@user)
-        @post.reload
-        @post.comments.count.should == 0
-      end
-
-      it "should be possible to create with redo after undo create embedded from parent" do
-        @post.comments.create!(:title => "The second one")
-        @track = @post.history_tracks.last
-        @track.undo!(@user)
-        @track.redo!(@user)
-        @post.reload
-        @post.comments.count.should == 2
-      end
-    end
-
-    describe "embedded with cascading callbacks" do
-      before(:each) do
-        Thread.current[:mongoid_history_sweeper_controller] = self
-        # self.stub!(:current_user).and_return @user
-        allow(self).to receive(:current_user).and_return(@user)
-        @tag_foo = @post.tags.create(:title => "foo", :updated_by => @user)
-        @tag_bar = @post.tags.create(:title => "bar")
-      end
-
-      after(:each) do
-        Thread.current[:mongoid_history_sweeper_controller] = nil
-      end
-
-      it "should have cascaded the creation callbacks and set timestamps" do
-        @tag_foo.created_at.should_not be_nil
-        @tag_foo.updated_at.should_not be_nil
-      end
-
-      it "should allow an update through the parent model" do
-        update_hash = { "post" => { "tags_attributes" => { "1234" => { "id" => @tag_bar.id, "title" => "baz" } } } }
-        @post.update_attributes(update_hash["post"])
-        @post.tags.last.title.should == "baz"
-      end
-
-      it "should be possible to destroy through parent model using canoncial _destroy macro" do
-        @post.tags.count.should == 2
-        update_hash = { "post" => { "tags_attributes" => { "1234" => { "id" => @tag_bar.id, "title" => "baz", "_destroy" => "true"} } } }
-        @post.update_attributes(update_hash["post"])
-        @post.tags.count.should == 1
-        @post.history_tracks.last.action.should == "destroy"
-      end
-
-      it "should write relationship name for association_chain hiearchy instead of class name when using _destroy macro" do
-        update_hash = {"tags_attributes" => { "1234" => { "id" => @tag_foo.id, "_destroy" => "1"} } }
-        @post.update_attributes(update_hash)
-
-        # historically this would have evaluated to 'Tags' and an error would be thrown
-        # on any call that walked up the association_chain, e.g. 'trackable'
-        @tag_foo.history_tracks.last.association_chain.last["name"].should == "tags"
-        lambda{ @tag_foo.history_tracks.last.trackable }.should_not raise_error
-      end
-
-      it "should save modifier" do
-        @tag_foo.history_tracks.last.modifier.should eq @user
-        @tag_bar.history_tracks.last.modifier.should eq @user
-      end
-    end
-
-    describe "non-embedded" do
-      it "should undo changes" do
-        @post.update_attributes(:title => "Test2")
-        @post.history_tracks.where(:version => 1).last.undo!(@user)
-        @post.reload
-        @post.title.should == "Test"
-      end
-
-      it "should undo destruction" do
-        @post.destroy
-        @post.history_tracks.where(:version => 1).last.undo!(@user)
-        Post.find(@post.id).title.should == "Test"
-      end
-
-      it "should create a new history track after undo" do
-        @post.update_attributes(:title => "Test2")
-        @post.history_tracks.last.undo!(@user)
-        @post.reload
-        @post.history_tracks.count.should == 3
-      end
-
-      it "should assign @user as the modifier of the newly created history track" do
-        @post.update_attributes(:title => "Test2")
-        @post.history_tracks.where(:version => 1).last.undo!(@user)
-        @post.reload
-        @post.history_tracks.where(:version => 2).last.modifier.should == @user
-      end
-
-      it "should stay the same after undo and redo" do
-        @post.update_attributes(:title => "Test2")
-        @track = @post.history_tracks.last
-        @track.undo!(@user)
-        @track.redo!(@user)
-        @post2 = Post.where(:_id => @post.id).first
-
-        @post.title.should == @post2.title
-      end
-
-      it "should be destroyed after undo and redo" do
-        @post.destroy
-        @track = @post.history_tracks.where(:version => 1).last
-        @track.undo!(@user)
-        @track.redo!(@user)
-        Post.where(:_id => @post.id).first.should == nil
-      end
-    end
-
-    describe "embedded" do
-      it "should undo changes" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.undo!(@user)
-        # reloading an embedded document === KAMIKAZE
-        # at least for the current release of mongoid...
-        @post.reload
-        @comment = @post.comments.first
-        @comment.title.should == "test"
-      end
-
-      it "should create a new history track after undo" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.undo!(@user)
-        @post.reload
-        @comment = @post.comments.first
-        @comment.history_tracks.count.should == 3
-      end
-
-      it "should assign @user as the modifier of the newly created history track" do
-        @comment.update_attributes(:title => "Test2")
-        @comment.history_tracks.where(:version => 2).first.undo!(@user)
-        @post.reload
-        @comment = @post.comments.first
-        @comment.history_tracks.where(:version => 3).first.modifier.should == @user
-      end
-
-      it "should stay the same after undo and redo" do
-        @comment.update_attributes(:title => "Test2")
-        @track = @comment.history_tracks.where(:version => 2).first
-        @track.undo!(@user)
-        @track.redo!(@user)
-        @post2 = Post.where(:_id => @post.id).first
-        @comment2 = @post2.comments.first
-
-        @comment.title.should == @comment2.title
-      end
-    end
-
-    describe "trackables" do
-      before :each do
-        @comment.update_attributes(:title => "Test2") # version == 2
-        @comment.update_attributes(:title => "Test3") # version == 3
-        @comment.update_attributes(:title => "Test4") # version == 4
-      end
-
-      describe "undo" do
-        it "should recognize :from, :to options" do
-          @comment.undo! @user, :from => 4, :to => 2
-          @comment.title.should == "test"
-        end
-
-        it "should recognize parameter as version number" do
-          @comment.undo! @user, 3
-          @comment.title.should == "Test2"
-        end
-
-        it "should undo last version when no parameter is specified" do
-          @comment.undo! @user
-          @comment.title.should == "Test3"
-        end
-
-        it "should recognize :last options" do
-          @comment.undo! @user, :last => 2
-          @comment.title.should == "Test2"
-        end
-      end
-
-      describe "redo" do
-        before :each do
-          @comment.update_attributes(:title => "Test5")
-        end
-
-        it "should recognize :from, :to options" do
-          @comment.redo! @user,  :from => 2, :to => 4
-          @comment.title.should == "Test4"
-        end
-
-        it "should recognize parameter as version number" do
-          @comment.redo! @user, 2
-          @comment.title.should == "Test2"
-        end
-
-        it "should redo last version when no parameter is specified" do
-          @comment.redo! @user
-          @comment.title.should == "Test5"
-        end
-
-        it "should recognize :last options" do
-          @comment.redo! @user, :last => 1
-          @comment.title.should == "Test5"
-        end
-      end
-    end
-
-    describe "duplicate relations" do
-      it "should save correct relation" do
-        lambda{ Restaurant.create!( title: 'test', modifier_id: @user.id ) }.should_not raise_error
-      end
-    end
-
-
-    describe "rails admin history" do 
-      before :each do
-        @restaurant = Restaurant.create!( title: 'test', modifier_id: @user.id )
-        @adapter = ::RailsAdmin::Extensions::MongoidAudit::AuditingAdapter.new( nil )
-        @model = Struct.new( :model_name ).new( 'Restaurant' )
-      end
-      
-      it "should list all records from history table" do 
-        query = ''
-
-        items = @adapter.listing_for_model(@model, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-        expect( item.table ).to eq 'Restaurant'
-        expect( item.username ).to eq @user.email
-        expect( item.item ).to eq @restaurant.id
-
-        query = nil
-
-        items = @adapter.listing_for_model(@model, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-      end
-      
-      it "should list records from history table specified by query" do 
-        query = 'create'
-
-        items = @adapter.listing_for_model(@model, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-        expect( item.table ).to eq 'Restaurant'
-        expect( item.username ).to eq @user.email
-        expect( item.item ).to eq @restaurant.id
-      end
-      
-      it "should list records from history table specified by item" do 
-        query = ''
-
-        items = @adapter.listing_for_object(@model, @restaurant, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-        expect( item.table ).to eq 'Restaurant'
-        expect( item.username ).to eq @user.email
-        expect( item.item ).to eq @restaurant.id
-
-        query = nil
-
-        items = @adapter.listing_for_object(@model, @restaurant, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-      end
-      
-      it "should list records from history table specified by item and query" do 
-        query = 'create'
-
-        items = @adapter.listing_for_object(@model, @restaurant, query, false, 'false', true, 1, 10)
-
-        expect( items ).not_to be_empty
-
-        item = items.first
-
-        expect( item.message ).to eq 'create Restaurant [title = test]'
-        expect( item.table ).to eq 'Restaurant'
-        expect( item.username ).to eq @user.email
-        expect( item.item ).to eq @restaurant.id
-      end
-    end
-  end
-end