auditor_tenancy 2.4.0

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+2.4.0
+-----
+* Added initial tenancy support (currently hard-coded; needs to become an option)
+
+2.3.2
+-----
+* Forked from https://github.com/nearinfinity/auditor

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Near Infinity Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,135 @@
+= Auditor
+
+Auditor is a Rails 3 plugin for auditing access to your ActiveRecord model objects. It allows you to declaratively specify what CRUD operations should be audited and store that audit data in the database. You can also specify what attributes of model objects should automatically be audited and which ones should be ignored.
+
+To audit your model objects you must specify which operations should be audited and which model attributes should be tracked. This "specify what you want to collect" approach avoids being overwhelmed with data and makes you carefully consider what is most important to audit.
+
+= Installation
+
+To use it with your Rails 3 project, add the following line to your Gemfile
+
+  gem 'auditor'
+  
+Auditor can also be installed as a Rails plugin
+  
+  rails plugin install git://github.com/nearinfinity/auditor.git
+
+Generate the migration and create the audits table
+
+  rails generate auditor:migration
+  rake db:migrate
+
+= Upgrading
+
+You will need to run the upgrade migration if coming from a version earlier than 2.1.0
+
+  rails generate auditor:upgrade
+  rake db:migrate
+
+= Setup
+
+Auditor needs to know who the current user is, but with no standard for doing so you'll have to do a little work to set things up. You simply need to set your current user model object as the Auditor current user before any CRUD operations are performed. For example, in a Rails application you could add the following to your application_controller.rb
+
+  class ApplicationController < ActionController::Base
+    before_filter :set_current_user
+    
+    private
+    
+    def set_current_user
+      Auditor::User.current_user = @current_user
+    end
+  end
+
+= Examples
+
+Auditor works very similarly to Joshua Clayton's acts_as_auditable plugin. There are two audit calls in the example below. The first declares that create and update actions should be audited for the EditablePage model and the string returned by the passed block should be included as a custom message. The second audit call simply changes the custom message when auditing destroy (aka delete) actions.
+
+  class Page < ActiveRecord::Base
+    audit(:create, :update) { |model, user, action| "Page modified by #{user.display_name}" }
+    audit(:destroy) { |model, user, action| "#{user.display_name} deleted page #{model.id}" }
+  end
+
+All audit data is stored in a table named Audits, which is automatically created for you when you run the migration included with the plugin. However, there's a lot more recorded than just the custom message, including:
+
+* auditable_id - the primary key of the table belonging to the audited model object
+* auditable_type - the class type of the audited model object
+* owner_id - the primary key of the of the model that owns this audit record
+* owner_type - the class type of the owner model object
+* user_id - the primary key of the table belonging to the user being audited
+* user_type - the class type of the model object representing users in your application
+* action - a string indicating the action that was audited (create, update, destroy, or find)
+* audited_changes - a YAML string containing the before and after state of any model attributes that changed
+* comment - the custom message returned by any block passed to the audit call
+* version - an auditor-internal revision number for the audited model
+* created_at - the date and time the audit record was recorded
+
+The audited_changes column automatically serializes the changes of any model attributes modified during the action. If there are only a few attributes you want to audit or a couple that you want to prevent from being audited, you can specify that in the audit call. For example
+
+  # Prevent SSN and passwords from being saved in the audit table
+  audit(:create, :destroy, :except => [:ssn, :password])
+  
+  # Only audit edits to the title column when destroying/deleting
+  audit(:destroy, :only => :title)
+
+  # Associate the audit records with a related model, which becomes the owner
+  audit(:update, :on => :book)
+
+  # Associate the audit records with a related model, multiple levels up.
+  # Here, we're auditing a great-grandchild where :parent will be the owner.  Order is important. 
+  audit(:update, :on => [:grandchild, :child, :parent])
+
+= Make Auditing Important
+
+There's an alternate form of specifying your audit requirements that will cause the create, find, update, or destroy to fail if for some reason the audit record cannot be saved to the database. Instead of calling audit, call audit! instead.
+
+  class Page < ActiveRecord::Base
+    audit!(:create, :update) { |model, user, action| "Page modified by #{user.display_name}" }
+    audit!(:destroy) { |model, user, action| "#{user.display_name} deleted page #{model.id}" }
+  end
+
+= Auditable Versioning
+
+Since auditor will keep a "diff" of all the changes applied to a model object, you can retrieve the state of any audited model object's attributes at any point in time. For this to work, you have to specify auditing for all actions that modify the table, which is create, update, and destroy. Assuming those attributes have been declared with a call to audit or audit!, the following shows you how to use the revisions.
+
+  p = Page.create(:title => "Revision 1")
+  p.audits.last.attribute_snapshot
+  > {:title => "Revision 1"}
+  time = Time.now
+  p.author = "Jeff"
+  p.save
+  p.audits.last.attribute_snapshot
+  > {:title => "Revision 1", :author => "Jeff"}
+  p.attributes_at(time)
+  > {:title => "Revision 1"}
+
+= Integration
+There may be some instances where you need to perform an action on your model object without Auditor recording the action. In those cases you can include the Auditor::Status module for help.
+
+  class PagesController < ApplicationController
+    include Auditor::Status
+
+    def update
+      page = Page.find(params[:id])
+        without_auditing { page.update_attributes(params[:page]) } # Auditor is disabled for the entire block
+      end
+    end
+  end
+
+You can also force Auditor to audit any actions within a block as a specified user.
+
+  class PagesController < ApplicationController
+    include Auditor::Status
+
+    def update
+      page = Page.find(params[:id])
+        # Auditor will attribute update to 'another user'
+        audit_as(another_user) { page.update_attributes(params[:page]) }
+      end
+    end
+  end
+
+= License
+
+Auditor is released under the MIT license.
+
+Copyright (c) 2011 Near Infinity. http://www.nearinfinity.com

data/auditor_tenancy.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "auditor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "auditor_tenancy"
+  s.version     = Auditor::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jeff Kunkle", "Geoff Mayes"]
+  s.homepage    = "http://github.com/mayesgr/auditor_tenancy"
+  s.summary     = %q{Rails 3 plugin for auditing access to your ActiveRecord model objects}
+  s.description = %q{Auditor allows you to declaratively specify what CRUD operations should be audited and save the audit data to the database.}
+  s.license     = "MIT"
+
+  s.files         = `git ls-files`.split("\n").reject { |path| path =~ /^(Gemfile|.gitignore|Rakefile)/ }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('activerecord', '~> 3.0')
+
+  s.add_development_dependency('rspec', '2.5.0')
+  s.add_development_dependency('sqlite3-ruby', '1.3.3')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'auditor_tenancy'

data/lib/auditor/audit.rb

@@ -0,0 +1,66 @@
+require 'active_record'
+require 'auditor/config'
+
+class Audit < ActiveRecord::Base
+  belongs_to :auditable, :polymorphic => true
+  belongs_to :owner, :polymorphic => true
+  belongs_to :user, :polymorphic => true
+  belongs_to :tenant
+
+  before_create :set_version_number
+  before_create :set_user
+  before_create :set_tenant
+
+  serialize :audited_changes
+
+  default_scope order("id DESC")
+  scope :modifying, lambda {
+    where( [
+      'audited_changes is not ? and audited_changes not like ?',
+      nil,        # ActiveRecord 3.0
+      nil.to_yaml # ActiveRecord 3.1
+    ] )
+  }
+  scope :trail, lambda { |audit|
+    where('auditable_id = ? and auditable_type = ? and version <= ?',
+    audit.auditable_id, audit.auditable_type, audit.version)
+  }
+
+  def attribute_snapshot
+    attributes = {}.with_indifferent_access
+    self.class.modifying.trail(self).each do |predecessor|
+      attributes.merge!(predecessor.new_attributes)
+    end
+    attributes
+  end
+
+protected
+
+  # Returns a hash of the changed attributes with the new values
+  def new_attributes
+    (audited_changes || {}).inject({}.with_indifferent_access) do |attrs,(attr,values)|
+      attrs[attr] = values.is_a?(Array) ? values.last : values
+      attrs
+    end
+  end
+
+private
+
+  def set_version_number
+    max = self.class.where(
+      :auditable_id => auditable_id,
+      :auditable_type => auditable_type
+    ).maximum(:version) || 0
+
+    self.version = self.audited_changes == nil ? max : max + 1
+  end
+
+  def set_user
+    self.user = Auditor::User.current_user if self.user_id.nil?
+  end
+
+  def set_tenant
+    self.tenant = Auditor::Tenant.current_tenant if self.tenant_id.nil?
+  end
+
+end

data/lib/auditor/auditable.rb

@@ -0,0 +1,44 @@
+require 'auditor/status'
+require 'auditor/config'
+require 'auditor/recorder'
+
+module Auditor
+  module Auditable
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def audit(*args, &blk)
+        unless self.included_modules.include?(Auditor::Auditable::InstanceMethods)
+          include InstanceMethods
+          include Auditor::Status unless self.included_modules.include?(Auditor::Status)
+          has_many :audits, :as => :auditable
+        end
+
+        config = Auditor::Config.new(*args)
+        config.actions.each do |action|
+          send "after_#{action}", Auditor::Recorder.new(config.options, &blk)
+        end
+      end
+
+      def audit!(*args, &blk)
+        if args.last.kind_of?(Hash)
+          args.last[:fail_on_error] = true
+        else
+          args << { :fail_on_error => true }
+        end
+
+        audit(*args, &blk)
+      end
+    end
+
+    module InstanceMethods
+      def attributes_at(date_or_time)
+        audits.where('created_at <= ?', date_or_time).last.attribute_snapshot
+      end
+    end
+
+  end
+end

data/lib/auditor/config.rb

@@ -0,0 +1,34 @@
+module Auditor
+  class Config
+    attr_reader :actions
+    attr_reader :options
+
+    def self.valid_actions
+      @valid_actions ||= [:create, :find, :update, :destroy]
+    end
+
+    def initialize(*args)
+      @options = (args.pop if args.last.kind_of?(Hash)) || {}
+      normalize_options(@options)
+
+      @actions = args.map(&:to_sym)
+      validate_actions(@actions)
+    end
+
+  private
+
+    def normalize_options(options)
+      options.each_pair { |k, v| options[k.to_sym] = options.delete(k) unless k.kind_of? Symbol }
+      options[:only] ||= []
+      options[:except] ||= []
+      options[:only] = Array(options[:only]).map(&:to_s)
+      options[:except] = Array(options[:except]).map(&:to_s)
+    end
+
+    def validate_actions(actions)
+      raise Auditor::Error.new "at least one action in #{Config.valid_actions.inspect} must be specified" if actions.empty?
+      raise Auditor::Error.new "#{Config.valid_actions.inspect} are the only valid actions" unless actions.all? { |a| Config.valid_actions.include?(a.to_sym) }
+    end
+
+  end
+end

data/lib/auditor/recorder.rb

@@ -0,0 +1,56 @@
+require 'auditor/status'
+
+module Auditor
+  class Recorder
+    include Status
+
+    def initialize(options, &blk)
+      @options = options
+      @blk = blk
+    end
+
+    [:create, :find, :update, :destroy].each do |action|
+      define_method("after_#{action}") do |model|
+        audit(model, action)
+      end
+    end
+
+  private
+
+    def audit(model, action)
+      return nil if auditing_disabled?
+      user = Auditor::User.current_user
+      tenant = Auditor::Tenant.current_tenant
+
+      audit = Audit.new
+      audit.tenant_id = tenant.id
+      audit.auditable_id = model.id
+      audit.auditable_type = model.class.name
+      audit.audited_changes = prepare_changes(model.changes) if model.changed?
+      audit.action = action
+
+      return if noop?(audit)
+
+      audit.comment = @blk.call(model, user, action) if @blk
+
+      without_auditing do
+        owner = @options[:on] ? Array(@options[:on]).inject(model) { |owner, parent| owner.send(parent.to_sym) } : model
+        audit.owner_id = owner.id
+        audit.owner_type = owner.class.name
+      end
+
+      @options[:fail_on_error] ? audit.save! : audit.save
+    end
+
+    def prepare_changes(changes)
+      chg = changes.dup
+      chg = chg.delete_if { |key, value| @options[:except].include?(key) } unless @options[:except].blank?
+      chg = chg.delete_if { |key, value| !@options[:only].include?(key) } unless @options[:only].blank?
+      chg.empty? ? nil : chg
+    end
+
+    def noop?(audit)
+      audit.action == :update && !audit.audited_changes.present?
+    end
+  end
+end

data/lib/auditor/spec_helpers.rb

@@ -0,0 +1,20 @@
+module Auditor
+  module SpecHelpers
+    include Auditor::Status
+
+    def self.included(base)
+      base.class_eval do
+        before(:each) do
+          disable_auditing
+        end
+
+        after(:each) do
+          enable_auditing
+        end
+      end
+    end
+
+  end
+end
+
+

data/lib/auditor/status.rb

@@ -0,0 +1,62 @@
+require 'auditor/user'
+
+module Auditor
+  module Status
+
+    def auditing_disabled?
+      Thread.current[:auditor_disabled] == true
+    end
+
+    def auditing_enabled?
+      Thread.current[:auditor_disabled] == false
+    end
+
+    def disable_auditing
+      Thread.current[:auditor_disabled] = true
+    end
+
+    def enable_auditing
+      Thread.current[:auditor_disabled] = false
+    end
+
+    def without_auditing
+      previously_disabled = auditing_disabled?
+
+      begin
+        disable_auditing
+        result = yield if block_given?
+      ensure
+        enable_auditing unless previously_disabled
+      end
+
+      result
+    end
+
+    def with_auditing
+      previously_disabled = auditing_disabled?
+
+      begin
+        enable_auditing
+        result = yield if block_given?
+      ensure
+        disable_auditing if previously_disabled
+      end
+
+      result
+    end
+
+    def audit_as(user)
+      previous_user = Auditor::User.current_user
+
+      begin
+        Auditor::User.current_user = user
+        result = yield if block_given?
+      ensure
+        Auditor::User.current_user = previous_user
+      end
+
+      result
+    end
+
+  end
+end

data/lib/auditor/tenant.rb

@@ -0,0 +1,15 @@
+module Auditor
+  module Tenant
+
+    def current_tenant
+      Thread.current[:auditor_tenant]
+    end
+
+    def current_tenant=(tenant)
+      Thread.current[:auditor_tenant] = tenant
+    end
+
+    module_function :current_tenant, :current_tenant=
+
+  end
+end

data/lib/auditor/user.rb

@@ -0,0 +1,15 @@
+module Auditor
+  module User
+
+    def current_user
+      Thread.current[:auditor_user]
+    end
+
+    def current_user=(user)
+      Thread.current[:auditor_user] = user
+    end
+
+    module_function :current_user, :current_user=
+
+  end
+end

data/lib/auditor/version.rb

@@ -0,0 +1,3 @@
+module Auditor
+  VERSION = "2.4.0"
+end

data/lib/auditor_tenancy.rb

@@ -0,0 +1,23 @@
+require 'auditor/audit'
+require 'auditor/auditable'
+
+module Auditor
+  class Error < StandardError; end
+end
+
+ActiveRecord::Base.send :include, Auditor::Auditable
+
+if defined?(ActionController) and defined?(ActionController::Base)
+
+  require 'auditor/user'
+  require 'auditor/tenant'
+
+  ActionController::Base.class_eval do
+    before_filter do |c|
+      Auditor::User.current_user = c.send(:current_user) if c.respond_to?(:current_user)
+      Auditor::Site.current_tenant = c.send(:current_tenant) if c.respond_to?(:current_tenant)
+    end
+  end
+
+end
+

data/lib/generators/auditor.rb

@@ -0,0 +1,9 @@
+module Auditor
+  module Generators
+    class Base < Rails::Generators::NamedBase
+      def self.source_root
+        File.expand_path(File.join(File.dirname(__FILE__), 'auditor', generator_name, 'templates'))
+      end
+    end
+  end
+end

data/lib/generators/auditor/migration/migration_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Auditor
+  module Generators
+    class MigrationGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Create migration for Auditor audits table"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def create_migration_file
+        migration_template 'migration.rb', 'db/migrate/create_audits_table.rb'
+      end
+    end
+  end
+end

data/lib/generators/auditor/migration/templates/migration.rb

@@ -0,0 +1,27 @@
+class CreateAuditsTable < ActiveRecord::Migration
+  def self.up
+    create_table :audits, :force => true do |t|
+      t.column :auditable_id, :integer, :null => false
+      t.column :auditable_type, :string, :null => false
+      t.column :owner_id, :integer, :null => false
+      t.column :owner_type, :string, :null => false
+      t.column :tenant_id, :integer, :null => false
+      t.column :user_id, :integer, :null => false
+      t.column :user_type, :string, :null => false
+      t.column :action, :string, :null => false
+      t.column :audited_changes, :text
+      t.column :version, :integer, :default => 0
+      t.column :comment, :text
+      t.column :created_at, :datetime, :null => false
+    end
+
+    add_index :audits, [:auditable_id, :auditable_type], :name => 'auditable_index'
+    add_index :audits, [:user_id, :user_type], :name => 'user_index'
+    add_index :audits, :tenant_id
+    add_index :audits, :created_at
+  end
+
+  def self.down
+    drop_table :audits
+  end
+end

data/lib/generators/auditor/upgrade/templates/upgrade.rb

@@ -0,0 +1,13 @@
+class UpgradeAuditsTable < ActiveRecord::Migration
+  def self.up
+    add_column :audits, :owner_id, :integer
+    add_column :audits, :owner_type, :string
+
+    add_index :audits, [:owner_id, :owner_type], :name => 'owner_index'
+  end
+
+  def self.down
+    remove_column :audits, :owner_type
+    remove_column :audits, :owner_id
+  end
+end

data/lib/generators/auditor/upgrade/upgrade_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Auditor
+  module Generators
+    class UpgradeGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Create upgrade migration for Auditor audits table"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def create_migration_file
+        migration_template 'upgrade.rb', 'db/migrate/upgrade_audits_table.rb'
+      end
+    end
+  end
+end

data/spec/audit_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/audit'
+
+describe Audit do
+  before(:each) do
+    @auditable = Model.create
+    @user = User.create
+  end
+
+  it 'should set the version number on save' do
+    audit = Audit.create(:auditable => @auditable, :owner => @auditable, :audited_changes => { :name => [nil, 'new']}, :user => @user, :action => :create)
+    audit.version.should == 1
+  end
+
+  it 'should provide access to the audited model object' do
+    audit = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :create)
+    audit.auditable.should == @auditable
+  end
+  it 'should provide access to the user associated with the audit' do
+    audit = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :create)
+    audit.user.should == @user
+  end
+
+  it 'should create a snapshot of the audited objects attributes at the time of the audit' do
+    audit1 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :create)
+    audit2 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => [nil, 'n1'], 'value' => [nil, 'v1']})
+    audit3 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :find)
+    audit4 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+    audit1.attribute_snapshot.should == {}
+    audit2.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v1'}
+    audit3.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v1'}
+    audit4.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v2'}
+  end
+
+  describe 'modifying scope' do
+    it 'should return all audit records that were a result of modifying the audited object attributes' do
+      audit1 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :create, :audited_changes  => {'name' => [nil, 'n0']})
+      audit2 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => ['n0', 'n1'], 'value' => [nil, 'v1']})
+      audit3 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :find)
+      audit4 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+      Audit.modifying.should include(audit1, audit2, audit4)
+      Audit.modifying.should_not include(audit3)
+    end
+  end
+
+  describe 'predecessors scope' do
+    it 'should return all previous audit records for the same auditable' do
+      auditable2 = Model.create
+      audit1 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :create)
+      audit2 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => [nil, 'n1'], 'value' => [nil, 'v1']})
+      audit3 = Audit.create(:auditable => auditable2, :owner => auditable2, :user => @user, :action => :find)
+      audit4 = Audit.create(:auditable => @auditable, :owner => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+      Audit.trail(audit4).should include(audit1, audit2, audit4)
+      Audit.trail(audit4).should_not include(audit3)
+    end
+  end
+end
+

data/spec/auditable_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/user'
+require 'auditor/status'
+
+describe Auditor::Auditable do
+  include Auditor::Status
+
+  before(:each) do
+    @user = User.create
+    @original_model = Model
+    Auditor::User.current_user = @user
+  end
+
+  after(:each) do
+    reset_model
+  end
+
+  it 'should audit find' do
+    redefine_model { audit!(:find) }
+    m = without_auditing { Model.create }
+
+    Model.find(m.id)
+
+    verify_audit(Audit.last, m)
+  end
+
+  it 'should audit create' do
+    redefine_model { audit!(:create) }
+
+    m = Model.create(:name => 'new')
+
+    verify_audit(Audit.last, m, { 'name' => [nil, 'new'], 'id' => [nil, m.id] })
+  end
+
+  it 'should audit update' do
+    redefine_model { audit!(:update) }
+    m = without_auditing { Model.create(:name => 'new') }
+
+    m.update_attributes(:name => 'newer')
+
+    verify_audit(Audit.last, m, { 'name' => ['new', 'newer'] })
+  end
+
+  it 'should audit destroy' do
+    redefine_model { audit!(:destroy) }
+    m = without_auditing { Model.create }
+
+    m.destroy
+
+    verify_audit(Audit.last, m)
+  end
+
+  it 'should allow multiple actions to be specified with one audit statment' do
+    redefine_model { audit!(:create, :destroy) }
+
+    m = Model.create
+    m.reload
+    m = Model.find(m.id)
+    m.update_attributes({:name => 'new'})
+    m.destroy
+
+    Audit.count.should == 2
+  end
+
+  it 'should record the comment returned from a comment block' do
+    redefine_model { audit!(:create) { 'comment' } }
+    Model.create
+    Audit.last.comment.should == 'comment'
+  end
+
+  it 'should provide the model object and user as parameters to the comment block' do
+    id = without_auditing { Model.create }.id
+    user = @user
+    redefine_model {
+      audit!(:find) { |model, user|
+        model.id.should == id
+        user.should == user
+      }
+    }
+    Model.find(id)
+  end
+
+  it 'should provide a snapshot of the object attributes at a given date or time' do
+    redefine_model { audit!(:create, :find, :update, :destroy) }
+    m = Model.create(:name => '1')
+    ts1 = Time.now
+    m = Model.find(m.id)
+    ts2 = Time.now
+    m.update_attributes(:name => '2')
+    ts3 = Time.now
+    m.destroy
+    ts4 = Time.now
+
+    m.attributes_at(ts1).should == {'name' => '1', 'id' => m.id}
+    m.attributes_at(ts2).should == {'name' => '1', 'id' => m.id}
+    m.attributes_at(ts3).should == {'name' => '2', 'id' => m.id}
+    m.attributes_at(ts4).should == {'name' => '2', 'id' => m.id}
+  end
+
+  it 'should not save an update record that does not have any audited changes' do
+    redefine_model { audit!(:update, :except => :name) }
+
+    lambda {
+      m = Model.create(:name => 'new')
+      m.update_attributes({:name => 'newer'})
+    }.should_not change(Audit, :count)
+  end
+
+  def verify_audit(audit, model, changes=nil)
+    audit.should_not be_nil
+    audit.auditable.should == model unless audit.action == 'destroy'
+    audit.user.should == @user
+    audit.audited_changes.should == changes unless changes.nil?
+  end
+
+  def redefine_model(&blk)
+    clazz = Class.new(ActiveRecord::Base, &blk)
+    Object.send :remove_const, 'Model'
+    Object.send :const_set, 'Model', clazz
+  end
+
+  def reset_model
+    Object.send :remove_const, 'Model'
+    Object.send :const_set, 'Model', @original_model
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/config'
+
+describe Auditor::Config do
+  
+  describe 'Configuration' do
+    it "should parse actions and options from a config array" do
+      config = Auditor::Config.new(:create, 'update', {:only => :username})
+      config.actions.should_not be_nil
+      config.options.should_not be_nil
+      config.actions.should have(2).items
+      config.actions.should =~ [:create, :update]
+      config.options.should == {:only => ["username"], :except => []}
+    end
+
+    it "should parse actions and options from a config array when options are absent" do
+      config = Auditor::Config.new(:create, 'update')
+      config.actions.should_not be_nil
+      config.actions.should have(2).items
+      config.actions.should =~ [:create, :update]
+      config.options.should == {:only => [], :except => []}
+    end
+
+    it "should parse actions" do
+      config = Auditor::Config.new(:create)
+      config.actions.should_not be_nil
+      config.actions.should have(1).item
+      config.actions.should =~ [:create]
+      config.options.should == {:only => [], :except => []}
+    end
+
+  end
+
+  describe 'Configuration Validation' do
+    it "should raise a Auditor::Error if no action is specified" do
+      lambda {
+        Auditor::Config.new
+      }.should raise_error(Auditor::Error)
+    end
+
+    it "should raise a Auditor::Error if an invalid action is specified" do
+      lambda {
+        Auditor::Config.new(:create, :view)
+      }.should raise_error(Auditor::Error)
+    end
+
+  end
+
+end

data/spec/recorder_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/user'
+
+describe Auditor::Recorder do
+  before(:each) do
+    @user = Auditor::User.current_user = User.create
+  end
+
+  it 'should create an audit record for create actions' do
+    verify_action(:create)
+  end
+
+  it 'should create an audit record for find actions' do
+    verify_action(:find)
+  end
+
+  it 'should create an audit record for update actions' do
+    verify_action(:update)
+  end
+
+  it 'should create an audit record for destroy actions' do
+    verify_action(:destroy)
+  end
+
+  def verify_action(action)
+    model = Model.create
+    model.reload
+    model.name = 'changed'
+    config = Auditor::Config.new(action)
+
+    recorder = Auditor::Recorder.new(config.options) { 'comment' }
+    recorder.send "after_#{action}", model
+    audit = Audit.last
+
+    audit.action.should == action.to_s
+    audit.auditable_id.should == model.id
+    audit.auditable_type.should == model.class.to_s
+    audit.owner_id.should == model.id
+    audit.owner_type.should == model.class.to_s
+    audit.user_id.should == @user.id
+    audit.user_type.should == @user.class.to_s
+    audit.comment.should == 'comment'
+    audit.audited_changes.should == {'name' => [nil, 'changed'] } if [:create, :update].include?(action)
+
+    audit.user.should == @user
+    audit.auditable.should == model
+    audit.owner.should == model
+  end
+
+  it 'should set comment details to nil if they are not given' do
+    model = Model.create
+    config = Auditor::Config.new(:create)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.comment.should be_nil
+  end
+
+  it 'should not save change details for excepted attributes' do
+    model = Model.create
+    model.name = 'changed'
+    model.value = 'newval'
+    config = Auditor::Config.new(:create, :except => :name)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.audited_changes.should == {'value' => [nil, 'newval'] }
+  end
+
+  it 'should only save change details for onlyed attributes' do
+    model = Model.create
+    model.name = 'changed'
+    model.value = 'newval'
+    config = Auditor::Config.new(:create, :only => :name)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.audited_changes.should == {'name' => [nil, 'changed'] }
+  end
+
+  it 'should associate audit records with an owner' do
+    model = Model.create
+    config = Auditor::Config.new(:create)
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+    audit.owner.should == model
+
+    owner = User.create
+    model.user = owner
+    config = Auditor::Config.new(:create, :on => :user)
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+    audit.owner.should == owner
+  end
+
+  it 'should pass the model, user, and action to any supplied block' do
+    model = Model.create
+    config = Auditor::Config.new(:create)
+    recorder = Auditor::Recorder.new(config.options) do |model, user, action|
+      model.should == model
+      user.should == @user
+      action.should == :create
+    end
+    recorder.after_create(model)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'rspec'
+require 'auditor'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include TransactionalSpecs
+
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  #
+  # == Notes
+  #
+  # For more information take a look at Spec::Runner::Configuration and Spec::Runner
+end

data/spec/status_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/status'
+
+describe Auditor::Status do
+  it "should be enabled if set to enabled" do
+    obj = Class.new { include Auditor::Status }.new
+    obj.enable_auditing
+    obj.should be_auditing_enabled
+    obj.should_not be_auditing_disabled
+  end
+
+  it "should be disabled if set to disabled" do
+    obj = Class.new { include Auditor::Status }.new
+    obj.disable_auditing
+    obj.should_not be_auditing_enabled
+    obj.should be_auditing_disabled
+  end
+
+  it "should allow auditing as a specified user for a block of code" do
+    obj = Class.new { include Auditor::Status }.new
+    user1 = "user1"
+    user2 = "user2"
+    Auditor::User.current_user = user1
+
+    obj.audit_as(user2) { Auditor::User.current_user.should == user2 }
+    Auditor::User.current_user.should == user1
+  end
+
+  it "should allow a block of code to be executed with auditing disabled" do
+    obj = Class.new { include Auditor::Status }.new
+    obj.enable_auditing
+    obj.should be_auditing_enabled
+    obj.without_auditing { obj.should be_auditing_disabled }
+    obj.should be_auditing_enabled
+  end
+
+  it "should allow a block of code to be executed with auditing enabled" do
+    obj = Class.new { include Auditor::Status }.new
+    obj.disable_auditing
+    obj.should be_auditing_disabled
+    obj.with_auditing { obj.should be_auditing_enabled }
+    obj.should be_auditing_disabled
+  end
+end

data/spec/support/db_setup.rb

@@ -0,0 +1,52 @@
+require 'active_support/core_ext'
+require 'active_record'
+require 'generators/auditor/migration/templates/migration'
+require 'fileutils'
+
+tmpdir = File.join(File.dirname(__FILE__), '..', '..', 'tmp')
+FileUtils.mkdir(tmpdir) unless File.exist?(tmpdir)
+test_db = File.join(tmpdir, 'test.db')
+
+connection_spec = {
+  :adapter => 'sqlite3',
+  :database => test_db
+}
+
+# Delete any existing instance of the test database
+FileUtils.rm test_db, :force => true
+
+# Create a new test database
+ActiveRecord::Base.establish_connection(connection_spec)
+
+# ActiveRecord::Base.connection.initialize_schema_migrations_table
+
+class CreateUser < ActiveRecord::Migration
+  def self.up
+    create_table :users, :force => true do |t|
+      t.column :username, :string
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end
+
+class CreateModel < ActiveRecord::Migration
+  def self.up
+    create_table :models, :force => true do |t|
+      t.column :name, :string
+      t.column :value, :string
+      t.column :user_id, :integer
+    end
+  end
+
+  def self.down
+    drop_table :models
+  end
+end
+
+CreateUser.up
+CreateModel.up
+CreateAuditsTable.up
+

data/spec/support/model_setup.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base; end
+class Model < ActiveRecord::Base
+  belongs_to :user
+end

data/spec/support/transactional_specs.rb

@@ -0,0 +1,17 @@
+module TransactionalSpecs
+
+  def self.included(base)
+    base.class_eval do
+      around(:each) do |spec|
+        ActiveRecord::Base.transaction do
+          begin
+            spec.call
+          ensure
+            raise ActiveRecord::Rollback
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/user_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/user'
+
+describe Auditor::User do
+  it "should return the same user that's set on the same thread" do
+    user = "user"
+    Auditor::User.current_user = user
+    Auditor::User.current_user.should == user
+  end
+
+  it "should not return the same user from a different thread" do
+    user = "user"
+    user2 = "user2"
+
+    Auditor::User.current_user = user
+
+    Thread.new do
+      Auditor::User.current_user.should be_nil
+      Auditor::User.current_user = user2
+      Auditor::User.current_user.should == user2
+    end
+
+    Auditor::User.current_user.should == user
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: auditor_tenancy
+version: !ruby/object:Gem::Version
+  version: 2.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Kunkle
+- Geoff Mayes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+description: Auditor allows you to declaratively specify what CRUD operations should
+  be audited and save the audit data to the database.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.rdoc
+- auditor_tenancy.gemspec
+- init.rb
+- lib/auditor/audit.rb
+- lib/auditor/auditable.rb
+- lib/auditor/config.rb
+- lib/auditor/recorder.rb
+- lib/auditor/spec_helpers.rb
+- lib/auditor/status.rb
+- lib/auditor/tenant.rb
+- lib/auditor/user.rb
+- lib/auditor/version.rb
+- lib/auditor_tenancy.rb
+- lib/generators/auditor.rb
+- lib/generators/auditor/migration/migration_generator.rb
+- lib/generators/auditor/migration/templates/migration.rb
+- lib/generators/auditor/upgrade/templates/upgrade.rb
+- lib/generators/auditor/upgrade/upgrade_generator.rb
+- spec/audit_spec.rb
+- spec/auditable_spec.rb
+- spec/config_spec.rb
+- spec/recorder_spec.rb
+- spec/spec_helper.rb
+- spec/status_spec.rb
+- spec/support/db_setup.rb
+- spec/support/model_setup.rb
+- spec/support/transactional_specs.rb
+- spec/user_spec.rb
+homepage: http://github.com/mayesgr/auditor_tenancy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rails 3 plugin for auditing access to your ActiveRecord model objects
+test_files: []