undestroy 0.0.1 → 0.0.2

data/lib/undestroy/without_binding.rb

@@ -0,0 +1,10 @@
+require "undestroy/version"
+require "undestroy/config"
+require "undestroy/transfer"
+require "undestroy/archive"
+require "undestroy/binding"
+
+module Undestroy
+end
+
+

data/test/fixtures/active_record_models.rb

@@ -0,0 +1,42 @@
+module Undestroy::Test::Fixtures::ActiveRecordModels
+
+  class Blog < Undestroy::Test::ARMain
+    undestroy
+    has_many :posts, :dependent => :destroy
+  end
+
+  class Post < Undestroy::Test::ARMain
+    undestroy
+    belongs_to :blog
+  end
+
+  def self.add_blog_tables(model)
+    model.connection.create_table :blogs do |t|
+      t.string :name
+    end
+    model.connection.create_table :archive_blogs do |t|
+      t.string :name
+      t.datetime :deleted_at
+    end
+
+    model.connection.create_table :posts do |t|
+      t.integer :blog_id
+      t.string :title
+      t.text :body
+    end
+    model.connection.create_table :archive_posts do |t|
+      t.datetime :deleted_at
+      t.integer :blog_id
+      t.string :title
+      t.text :body
+    end
+  end
+
+  def self.remove_blog_tables(model)
+    model.connection.drop_table :blogs
+    model.connection.drop_table :archive_blogs
+    model.connection.drop_table :posts
+    model.connection.drop_table :archive_posts
+  end
+
+end

data/test/fixtures/ar.rb

@@ -0,0 +1,41 @@
+
+class Undestroy::Test::Fixtures::ARFixture
+  attr_accessor :attributes
+  attr_reader :saved
+
+  alias :saved? :saved
+
+  def initialize(attributes={})
+    @saved = false
+    self.attributes = attributes.dup
+    self.attributes.delete(:id)
+  end
+
+  def [](key)
+    self.attributes[key.to_sym]
+  end
+
+  def []=(key, val)
+    self.attributes[key.to_sym] = val
+  end
+
+  # Method missing won't catch this one
+  def id
+    self.attributes[:id]
+  end
+
+  def save
+    @saved = true
+  end
+
+  # Shortcut to build an instance for testing purposes.
+  def self.construct(attributes={})
+    self.new.tap do |fixture|
+      attributes.each do |field, value|
+        fixture[field] = value
+      end
+    end
+  end
+
+end
+

data/test/fixtures/archive.rb

@@ -0,0 +1,21 @@
+
+class Undestroy::Test::Fixtures::Archive
+  def initialize(args)
+    @@data[:args] = args
+  end
+
+  def run
+    @@data[:calls] << [:run]
+  end
+
+  def self.data
+    @@data
+  end
+
+  def self.reset
+    @@data = { :calls => [] }
+  end
+end
+
+Undestroy::Test::Fixtures::Archive.reset
+

data/test/helper.rb

@@ -1,2 +1,43 @@
-require 'assert'
+require 'undestroy'
+
+ActiveRecord::Base.configurations = {
+  'main' => {
+    :adapter => 'sqlite3',
+    :database => 'tmp/main.db'
+  },
+  'alt' => {
+    :adapter => 'sqlite3',
+    :database => 'tmp/alt.db'
+  },
+}
+
+module Undestroy::Test
+
+  class Base < Assert::Context
+
+    teardown_once do
+      `rm -f tmp/*.db`
+    end
+
+  end
+
+  ActiveRecord::Base.establish_connection 'main'
+  class ARMain < ActiveRecord::Base
+    self.abstract_class = true
+  end
+
+  class ARAlt < ActiveRecord::Base
+    self.abstract_class = true
+    establish_connection 'alt'
+  end
+
+  module Integration
+  end
+
+  module Fixtures
+    autoload :ActiveRecordModels, 'test/fixtures/active_record_models'
+    autoload :ARFixture, 'test/fixtures/ar'
+    autoload :Archive, 'test/fixtures/archive'
+  end
+end
 

data/test/integration/active_record_test.rb

@@ -0,0 +1,180 @@
+require 'assert'
+
+module Undestroy::Test::Integration::ActiveRecordTest
+
+  class Base < Undestroy::Test::Base
+    desc 'ActiveRecord integration'
+
+    setup do
+      @ar = Undestroy::Test::ARMain
+      @ar_alt = Undestroy::Test::ARAlt
+    end
+
+  end
+
+  class ActiveRecordExtension < Base
+    desc 'extensions'
+
+    should "add extensions to AR" do
+      assert_respond_to :undestroy_model_binding, ActiveRecord::Base
+    end
+  end
+
+  class BasicModelWithoutUndestroy < Base
+    desc 'basic model without Undestroy'
+
+    setup do
+      @ar.connection.create_table :basic_model_table do |t|
+        t.string :name
+      end
+      @model = Class.new(@ar)
+      @model.table_name = 'basic_model_table'
+    end
+
+    teardown do
+      @ar.connection.drop_table :basic_model_table
+    end
+
+    should "successfully traverse the model lifecycle" do
+      record = @model.create!(:name => 'bar')
+      assert @model.first
+      assert_not_raises { record.destroy }
+    end
+  end
+
+  class BasicModel < Base
+    desc 'basic model with Undestroy'
+
+    setup do
+      @ar.connection.create_table :basic_model_table do |t|
+        t.string :name
+      end
+      @ar.connection.create_table :archive_basic_model_table do |t|
+        t.string :name
+        t.datetime :deleted_at
+      end
+      @model = Class.new(@ar)
+      @model.table_name = 'basic_model_table'
+    end
+
+    teardown do
+      @ar.connection.drop_table :basic_model_table
+      @ar.connection.drop_table :archive_basic_model_table
+    end
+
+    should "create an archive record on destroy" do
+      @model.undestroy
+      target_class = @model.undestroy_model_binding.config.target_class
+
+      @model.create(:name => "foo")
+      original = @model.first
+      original.destroy
+      archive = target_class.first
+
+      assert original
+      assert archive
+      assert_equal original.id, archive.id
+      assert_equal 'foo', archive.name
+      assert_kind_of Time, archive.deleted_at
+      assert (Time.now - archive.deleted_at) < 1.second
+      assert_equal 0, @model.all.size
+    end
+  end
+
+  class BasicModelWithDifferentBase < Base
+    desc 'basic model with Undestroy and alternate abstract class'
+
+    setup do
+      @ar.connection.create_table :basic_model_table do |t|
+        t.string :name
+      end
+      @ar_alt.connection.create_table :archive_basic_model_table do |t|
+        t.string :name
+        t.datetime :deleted_at
+      end
+      @model = Class.new(@ar)
+      @model.table_name = 'basic_model_table'
+
+      @model.undestroy :abstract_class => @ar_alt
+      @target_class = @model.undestroy_model_binding.config.target_class
+    end
+
+    teardown do
+      @ar.connection.drop_table :basic_model_table
+      @ar_alt.connection.drop_table :archive_basic_model_table
+    end
+
+    should "create an archive record on destroy" do
+      @model.create!(:name => "bar")
+      original = @model.first
+      original.destroy
+      archive = @target_class.first
+
+      assert_not @model.first
+      assert original
+      assert archive
+      assert_equal original.id, archive.id
+      assert_equal 'bar', archive.name
+      assert_kind_of Time, archive.deleted_at
+      assert (Time.now - archive.deleted_at) < 1.second
+      assert_equal 1, @target_class.all.size
+    end
+  end
+
+  class DependentDestroy < Base
+    desc 'model with dependent undestroy enabled models'
+
+    setup do
+      @fixtures = Undestroy::Test::Fixtures::ActiveRecordModels
+
+      @blog = @fixtures::Blog
+      @post = @fixtures::Post
+      @fixtures.add_blog_tables(@blog)
+
+      @archive_blog = @blog.undestroy_model_binding.config.target_class
+      @archive_post = @post.undestroy_model_binding.config.target_class
+    end
+
+    teardown do
+      @fixtures.remove_blog_tables(@blog)
+    end
+
+    should "archive orphan blog" do
+      blog = @blog.create!(:name => "Foo Blog")
+      assert @blog.first
+      blog.destroy
+      assert_not @blog.first
+      assert @archive_blog.first
+      assert_equal "Foo Blog", @archive_blog.first.name
+    end
+
+    should "archive post" do
+      blog = @blog.create!(:name => "Bar Blog")
+      post = @post.create!(:title => "Foo Post", :body => "text", :blog => blog)
+      assert blog and post
+      post.destroy
+      archive = @archive_post.first
+
+      assert_not @post.first
+      assert archive
+      assert_equal post.id, archive.id
+      assert_equal "text", archive.body
+      assert_equal "Foo Post", archive.title
+      assert_equal blog.id, archive.blog_id
+    end
+
+    should "remove all posts and archive them when the blog is destroyed" do
+      blog = @blog.create!(:name => "My Verbose Blog")
+      posts = (1..10).collect do |i|
+        @post.create!(:title => "Article #{i}", :body => "Some text", :blog => blog)
+      end
+      blog.destroy
+
+      assert_equal 0, @blog.all.size
+      assert_equal 0, @post.all.size
+      assert_equal 1, @archive_blog.all.size
+      assert_equal 10, @archive_post.all.size
+    end
+  end
+
+end

data/test/unit/archive_test.rb

@@ -0,0 +1,115 @@
+require 'assert'
+
+module Undestroy::Archive::Test
+  class Base < Undestroy::Test::Base
+    subject { Undestroy::Archive }
+    desc 'Undestroy::Archive class'
+
+    setup do
+      @default_init = {
+        :source => Undestroy::Test::Fixtures::ARFixture.construct(:id => 1, :name => "Foo"),
+        :config => Undestroy::Config.new
+      }
+    end
+
+    def archive_instance(args={})
+      Undestroy::Archive.new(@default_init.merge(args))
+    end
+  end
+
+  class BasicInstance < Base
+    subject { archive_instance }
+    desc 'basic instance'
+
+    should have_accessors :source, :config, :transfer
+  end
+
+  class InitMethod < Base
+    desc 'initialize method'
+
+    should "require :source and :config options in hash argument" do
+      assert_raises(ArgumentError) { subject.new }
+      assert_raises(ArgumentError) { subject.new :source => nil }
+      assert_raises(ArgumentError) { subject.new :config => nil }
+    end
+
+    should "set the source to source attr" do
+      obj = archive_instance :source => "foo"
+      assert_equal "foo", obj.source
+    end
+
+    should "set the config to config attr" do
+      obj = archive_instance :config => "foo"
+      assert_equal "foo", obj.config
+    end
+
+    should "set optional :transfer to transfer attr" do
+      obj = archive_instance :transfer => "foo"
+      assert_equal "foo", obj.transfer
+    end
+  end
+
+  class TransferMethod < BasicInstance
+    desc 'transfer method'
+
+    setup do
+      @archive = subject
+      @archive.config.target_class = Undestroy::Test::Fixtures::ARFixture
+    end
+
+    should "return instance of config.internals[:transfer]" do
+      assert_instance_of @archive.config.internals[:transfer], @archive.transfer
+    end
+
+    should "cache the created instance" do
+      assert_equal @archive.transfer.object_id, @archive.transfer.object_id
+    end
+
+    should "set fields on instance to config.fields.merge(source.attributes) with evaled procs" do
+      target = @archive.transfer.target
+      assert_instance_of @archive.config.target_class, @archive.transfer.target
+      assert_equal 1, target.attributes[:id]
+      assert_equal "Foo", target.attributes[:name]
+      assert_instance_of Time, target.attributes[:deleted_at]
+    end
+
+    should "eval lambdas with source instance as argument" do
+      val = nil
+      @archive.config.fields[:test] = proc { |arg| val = arg; "FOO" }
+      target = @archive.transfer.target
+      assert_equal @archive.source, val
+      assert_equal "FOO", target.attributes[:test]
+    end
+  end
+
+  class RunMethod < Base
+    desc 'run method'
+
+    should "exist" do
+      assert_respond_to :run, archive_instance
+    end
+
+    should "call run on the transfer model" do
+      foo = Class.new do
+        @@called = false
+        def initialize(options={})
+        end
+
+        def run
+          @@called = true
+        end
+
+        def self.called
+          @@called
+        end
+      end
+
+      archive = archive_instance(:transfer => foo.new)
+
+      assert !foo.called
+      archive.run
+      assert foo.called
+    end
+  end
+end
+