pg_audit_log 0.0.2 → 0.1.0

data/Gemfile

@@ -3,5 +3,7 @@ source :rubygems
 # Specify your gem's dependencies the .gemspec
 gemspec
 
-gem "pg"
-gem "ZenTest"
+group :development do
+  gem 'wirble'
+end
+

data/Rakefile

@@ -1,6 +1,12 @@
+require 'rake'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-task :autotest do
-  sh "bundle update && autotest -s rspec2"
-end
+task :default => :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec)
+

data/lib/generators/pg_audit_log/install_generator.rb

@@ -4,7 +4,7 @@ module PgAuditLog
   module Generators
     class InstallGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
-      extend ActiveRecord::Generators::Migration
+      extend ::ActiveRecord::Generators::Migration
 
       source_root File.expand_path('../templates', __FILE__)
 

data/lib/pg_audit_log/function.rb

@@ -43,7 +43,9 @@ module PgAuditLog
                 END IF;
                 IF TG_OP = 'DELETE' OR TG_OP = 'UPDATE' THEN
                   EXECUTE 'SELECT CAST($1 . '|| column_name ||' AS TEXT)' INTO old_value USING OLD;
-                  EXECUTE 'SELECT CAST($1 . '|| primary_key_column ||' AS VARCHAR)' INTO primary_key_value USING OLD;
+                  IF primary_key_column IS NOT NULL THEN
+                    EXECUTE 'SELECT CAST($1 . '|| primary_key_column ||' AS VARCHAR)' INTO primary_key_value USING OLD;
+                  END IF;
                 END IF;
 
                 IF TG_RELNAME = 'users' AND column_name = 'last_accessed_at' THEN

data/lib/pg_audit_log/version.rb

@@ -1,3 +1,3 @@
 module PgAuditLog
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/pg_audit_log.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("rails", ">=2.3")
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('with_model')
+  s.add_dependency("rails", ">= 3.0.0")
+  s.add_dependency("pg", ">= 0.9.0")
+  s.add_development_dependency('rspec-rails')
+  s.add_development_dependency('with_model', '>= 0.1.3')
 end

data/spec/pg_audit_log_spec.rb

@@ -13,30 +13,37 @@ describe PgAuditLog do
       end
     end
 
+    with_model :audited_model_without_primary_key do
+      table :id => false do |t|
+        t.string :str
+        t.text :txt
+        t.integer :int
+        t.date :date
+        t.datetime :dt
+        t.boolean :bool
+      end
+    end
+
     before do
-      AuditedModel.connection.execute(<<-SQL)
-            CREATE TRIGGER audit_audited_models
-            AFTER INSERT OR UPDATE OR DELETE
-            ON #{AuditedModel.quoted_table_name}
-            FOR EACH ROW
-              EXECUTE PROCEDURE audit_changes()
-          SQL
+      PgAuditLog::Triggers.create_for_table(AuditedModel.table_name)
+      PgAuditLog::Triggers.create_for_table(AuditedModelWithoutPrimaryKey.table_name)
     end
 
     after do
-      AuditedModel.connection.execute("DROP TRIGGER audit_audited_models ON #{AuditedModel.quoted_table_name};")
+      PgAuditLog::Triggers.drop_for_table(AuditedModel.table_name)
+      PgAuditLog::Triggers.drop_for_table(AuditedModelWithoutPrimaryKey.table_name)
       PgAuditLog::Entry.connection.execute("TRUNCATE #{PgAuditLog::Entry.quoted_table_name}")
     end
 
     let(:attributes) { { :str => "foo", :txt => "bar", :int => 5, :date => Date.today, :dt => Time.now.midnight } }
 
-    context "on create" do
+    describe "on create" do
+      context "the audit log record with a primary key" do
 
-      before do
-        AuditedModel.create!(attributes)
-      end
+        before do
+          AuditedModel.create!(attributes)
+        end
 
-      describe "the audit log record" do
         subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
 
         it { should be }
@@ -75,110 +82,150 @@ describe PgAuditLog do
         end
 
       end
-    end
 
-    context "on update" do
-      before do
-        @model = AuditedModel.create!(attributes)
-      end
+      context "the audit log record without a primary key" do
+        before do
+          AuditedModelWithoutPrimaryKey.create!(attributes)
+        end
 
-      context "when going from a value to a another value" do
-        before { @model.update_attributes!(:str => "bar") }
         subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
 
-        its(:operation) { should == "UPDATE" }
-        its(:field_value_new) { should == "bar" }
-        its(:field_value_old) { should == "foo" }
+        it { should be }
+        its(:field_name) { should == "str" }
+        its(:primary_key) { should be_nil }
       end
+    end
 
-      context "when going from nil to a value" do
-        let(:attributes) { {:txt => nil} }
-        before { @model.update_attributes!(:txt => "baz") }
-        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt" }) }
+    describe "on update" do
+      context "the audit log record with a primary key" do
+        before do
+          @model = AuditedModel.create!(attributes)
+        end
 
-        its(:field_value_new) { should == "baz" }
-        its(:field_value_old) { should be_nil }
-      end
+        context "when going from a value to a another value" do
+          before { @model.update_attributes!(:str => "bar") }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
 
-      context "when going from a value to nil" do
-        before { @model.update_attributes!(:str => nil) }
-        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+          its(:operation) { should == "UPDATE" }
+          its(:field_value_new) { should == "bar" }
+          its(:field_value_old) { should == "foo" }
+        end
 
-        its(:field_value_new) { should be_nil }
-        its(:field_value_old) { should == "foo" }
-      end
+        context "when going from nil to a value" do
+          let(:attributes) { {:txt => nil} }
+          before { @model.update_attributes!(:txt => "baz") }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt" }) }
 
-      context "when the value does not change" do
-        before { @model.update_attributes!(:str => "foo") }
-        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str", :operation => "UPDATE" }) }
+          its(:field_value_new) { should == "baz" }
+          its(:field_value_old) { should be_nil }
+        end
 
-        it { should_not be }
-      end
+        context "when going from a value to nil" do
+          before { @model.update_attributes!(:str => nil) }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
 
-      context "when the value is nil and does not change" do
-        let(:attributes) { {:txt => nil} }
-        before { @model.update_attributes!(:txt => nil) }
-        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt", :operation => "UPDATE" }) }
+          its(:field_value_new) { should be_nil }
+          its(:field_value_old) { should == "foo" }
+        end
 
-        it { should_not be }
-      end
+        context "when the value does not change" do
+          before { @model.update_attributes!(:str => "foo") }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str", :operation => "UPDATE" }) }
 
-      context "when the value is a boolean" do
+          it { should_not be }
+        end
 
-        context "going from nil -> true" do
-          before { @model.update_attributes!(:bool => true) }
-          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+        context "when the value is nil and does not change" do
+          let(:attributes) { {:txt => nil} }
+          before { @model.update_attributes!(:txt => nil) }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt", :operation => "UPDATE" }) }
 
-          its(:field_value_new) { should == "true" }
-          its(:field_value_old) { should be_nil }
+          it { should_not be }
         end
 
-        context "going from false -> true" do
-          let(:attributes) { {:bool => false} }
-          before do
-            @model.update_attributes!(:bool => true)
+        context "when the value is a boolean" do
+
+          context "going from nil -> true" do
+            before { @model.update_attributes!(:bool => true) }
+            subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+
+            its(:field_value_new) { should == "true" }
+            its(:field_value_old) { should be_nil }
           end
-          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
 
-          its(:field_value_new) { should == "true" }
-          its(:field_value_old) { should == "false" }
-        end
+          context "going from false -> true" do
+            let(:attributes) { {:bool => false} }
+            before do
+              @model.update_attributes!(:bool => true)
+            end
+            subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
 
-        context "going from true -> false" do
-          let(:attributes) { {:bool => true} }
+            its(:field_value_new) { should == "true" }
+            its(:field_value_old) { should == "false" }
+          end
 
-          before do
-            @model.update_attributes!(:bool => false)
+          context "going from true -> false" do
+            let(:attributes) { {:bool => true} }
+
+            before do
+              @model.update_attributes!(:bool => false)
+            end
+            subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+
+            its(:field_value_new) { should == "false" }
+            its(:field_value_old) { should == "true" }
           end
-          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
 
-          its(:field_value_new) { should == "false" }
-          its(:field_value_old) { should == "true" }
+        end
+      end
+
+      context "the audit log record without a primary key" do
+        before do
+          AuditedModelWithoutPrimaryKey.create!(attributes)
+          AuditedModelWithoutPrimaryKey.update_all(:str => "bar")
         end
 
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+        its(:primary_key) { should be_nil }
       end
+
     end
 
-    context "on delete" do
-      before do
-        @model = AuditedModel.create!(attributes)
-        @model.delete
-      end
+    describe "on delete" do
+
+      context "the audit log record with a primary key" do
+        before do
+          model = AuditedModel.create!(attributes)
+          model.delete
+        end
 
-      subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
 
-      its(:operation) { should == "DELETE" }
+        its(:operation) { should == "DELETE" }
 
-      it "captures all new values for all fields" do
-        attributes.each do |field_name, value|
-          if field_name == :dt
-            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.strftime("%Y-%m-%d %H:%M:%S")
-          else
-            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.to_s
+        it "captures all new values for all fields" do
+          attributes.each do |field_name, value|
+            if field_name == :dt
+              PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.strftime("%Y-%m-%d %H:%M:%S")
+            else
+              PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.to_s
+            end
+            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_new.should be_nil
           end
-          PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_new.should be_nil
         end
       end
+
+      context "the audit log record without a primary key" do
+        before do
+          AuditedModelWithoutPrimaryKey.create!(attributes)
+          AuditedModelWithoutPrimaryKey.delete_all
+        end
+
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+        its(:primary_key) { should be_nil }
+      end
     end
   end
 

metadata

@@ -2,7 +2,7 @@
 name: pg_audit_log
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -21,22 +21,22 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "2.3"
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: pg
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
-  type: :development
+        version: 0.9.0
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: with_model
+  name: rspec-rails
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -46,6 +46,17 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: with_model
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.3
+  type: :development
+  version_requirements: *id004
 description: A completely transparent audit logging component for your application using a stored procedure and triggers. Comes with specs for your project and a rake task to generate the reverse SQL to undo changes logged
 email: 
 - casecommons-dev@googlegroups.com