active_snapshot 0.1.0

data/test/generators/active_snapshot/install_generator_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+require File.expand_path("../../../lib/generators/active_snapshot/install/install_generator", __dir__)
+
+class InstallGeneratorTest < Rails::Generators::TestCase
+  tests ActiveSnapshot::InstallGenerator
+  destination File.expand_path("tmp", __dir__)
+
+  setup do
+    prepare_destination # cleanup the tmp directory
+    run_generator
+  end
+
+  teardown do
+    ### Disable during debugging
+    prepare_destination # cleanup the tmp directory
+  end
+
+  def test_should_add_migration
+    run_generator
+
+    relative_path = "db/migrate/create_snapshots_tables.rb"
+
+    assert_migration(relative_path) do |content|
+      assert_match(/create_table :snapshots/, content)
+      assert_match(/create_table :snapshot_items/, content)
+    end
+
+    ### Test for syntax errors in file
+    require send(:migration_file_name, relative_path)
+  end
+end

data/test/models/snapshot_item_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class SnapshotItemTest < ActiveSupport::TestCase
+
+  def setup
+    @snapshot_klass = ActiveSnapshot::Snapshot
+    @snapshot_item_klass = ActiveSnapshot::SnapshotItem
+  end
+
+  def teardown
+  end
+
+  def test_relationships
+    instance = @snapshot_item_klass.new
+
+    assert instance.snapshot.nil?
+    assert instance.item.nil?
+
+    assert_raises do
+      instance.snapshot = instance
+    end
+
+    instance.snapshot = ActiveSnapshot::Snapshot.new
+
+    instance.item = instance
+
+    assert_not instance.snapshot.nil?
+    assert_not instance.item.nil?
+  end
+
+  def test_validations
+    instance = @snapshot_item_klass.new
+      
+    instance.valid?
+
+    [:item_id, :item_type, :snapshot_id].each do |attr|
+      assert instance.errors[attr].present? ### presence error
+    end
+
+    shared_post = DATA[:shared_post]
+    snapshot = shared_post.snapshots.first
+
+    instance = @snapshot_item_klass.new(item: snapshot.item, snapshot: snapshot)
+
+    instance.valid?
+
+    assert instance.errors[:item_id].present? ### uniq error
+    assert instance.errors[:item_type].present? ### uniq error
+
+    instance = @snapshot_item_klass.new(item_id: 1, item_type: 'Foobar', snapshot: snapshot)
+
+    assert instance.valid?
+  end
+
+  def test_object
+    @snapshot = @snapshot_klass.includes(:snapshot_items).first
+
+    @snapshot_item = @snapshot.snapshot_items.first
+
+    assert @snapshot_item.object.is_a?(HashWithIndifferentAccess)
+
+    @snapshot_item.object = {foo: :bar}
+
+    assert 'bar', @snapshot_item.object['foo']
+  end
+
+  def test_restore_item!
+    @snapshot = @snapshot_klass.includes(:snapshot_items).first
+
+    @snapshot_item = @snapshot.snapshot_items.first
+
+    @snapshot_item.restore_item!
+  end
+
+end

data/test/models/snapshot_test.rb

@@ -0,0 +1,109 @@
+require "test_helper"
+
+class SnapshotTest < ActiveSupport::TestCase
+
+  def setup
+    @snapshot_klass = ActiveSnapshot::Snapshot
+  end
+
+  def teardown
+  end
+
+  def test_relationships
+    shared_post = DATA[:shared_post]
+
+    instance = @snapshot_klass.new
+
+    assert instance.user.nil?
+    assert instance.item.nil?
+    assert instance.snapshot_items.empty?
+
+    instance.user = instance
+    instance.item = instance
+
+    assert_raises do
+      instance.snapshot_items << instance
+    end
+
+    instance.snapshot_items << ActiveSnapshot::SnapshotItem.new
+
+    assert_not instance.user.nil?
+    assert_not instance.item.nil?
+    assert_not instance.snapshot_items.empty?
+
+    instance = @snapshot_klass.new(item: shared_post, user: shared_post)
+
+    assert instance.item.id, shared_post.id
+    assert instance.user.id, shared_post.id
+  end
+
+  def test_validations
+    shared_post = DATA[:shared_post]
+    snapshot = shared_post.snapshots.first
+
+    instance = @snapshot_klass.new
+      
+    instance.valid?
+
+    [:item_id, :item_type, :identifier].each do |attr|
+      assert instance.errors[attr].present? ### presence error
+    end
+
+    instance = @snapshot_klass.new(item: snapshot.item, identifier: snapshot.identifier)
+
+    instance.valid?
+
+    assert instance.errors[:identifier].present? ### uniq error
+
+    instance = @snapshot_klass.new(item: snapshot.item, identifier: 'random')
+
+    assert instance.valid?
+  end
+
+  def test_metadata
+    @snapshot = @snapshot_klass.first
+
+    assert @snapshot.metadata.is_a?(HashWithIndifferentAccess)
+
+    @snapshot.metadata = {foo: :bar}
+
+    assert_equal 'bar', @snapshot.metadata['foo']
+  end
+
+  def test_build_snapshot_item
+    @snapshot = @snapshot_klass.first
+
+    snapshot_item = @snapshot.build_snapshot_item(Post.first)
+
+    assert snapshot_item.is_a?(ActiveSnapshot::SnapshotItem)
+
+    assert snapshot_item.new_record?
+
+    assert_equal @snapshot.id, snapshot_item.snapshot_id
+
+    @snapshot.build_snapshot_item(Post.first, child_group_name: :foobar)
+  end
+
+  def test_restore
+    @snapshot = @snapshot_klass.first
+
+    @snapshot.restore!
+  end
+
+  def test_fetch_reified_items
+    @snapshot = @snapshot_klass.first
+
+    reified_items = @snapshot.fetch_reified_items
+
+    assert reified_items.is_a?(Array)
+
+    assert reified_items.first.readonly?
+
+    children_hash = reified_items.last
+
+    assert children_hash.is_a?(HashWithIndifferentAccess)
+
+    assert children_hash.all?{|k,v| v.all?{|x| x.readonly?} }
+  end
+
+end

data/test/models/snapshots_concern_test.rb

@@ -0,0 +1,111 @@
+require "test_helper"
+
+class SnapshotsConcernTest < ActiveSupport::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_relationships
+    instance = Post.new
+
+    assert instance.snapshots.empty?
+    assert instance.snapshot_items.empty?
+
+    assert_raises do
+      instance.snapshots << instance
+    end
+
+    instance.snapshots << ActiveSnapshot::Snapshot.new
+
+    assert_raises do
+      instance.snapshot_items << instance
+    end
+
+    instance.snapshot_items << ActiveSnapshot::SnapshotItem.new
+
+    assert_not instance.snapshots.empty?
+    assert_not instance.snapshot_items.empty?
+  end
+
+  def test_create_snapshot!
+    @post = Post.first
+
+    #@user = User.first
+
+    snapshot = @post.create_snapshot!("foobar 1", user: @user, metadata: {foo: :bar})
+    assert_not snapshot.new_record?
+
+    snapshot = @post.create_snapshot!("foobar 2", user: @user)
+    assert_not snapshot.new_record?
+
+    snapshot = @post.create_snapshot!("foobar 3")
+    assert_not snapshot.new_record?
+
+    assert_raise do
+      @post.create_snapshot!("foobar 3")
+    end
+  end
+
+  def test_has_snapshot_children
+    klass = VolatilePost
+    
+    assert_raise ArgumentError do
+      klass.has_snapshot_children
+    end
+
+    klass.has_snapshot_children do
+      {}
+    end
+
+    assert klass.instance_variable_get(:@snapshot_children_proc).is_a?(Proc)
+
+    klass.new.children_to_snapshot
+
+    invalid = [
+      "foobar",
+      true,
+      false,
+      nil,
+      "",
+      [],
+      [:foobar, 123],
+      {foo: :bar},
+      {foo: {}},
+      {foo: {records: 'bar', delete_method: 'bar'}},
+    ]
+
+    invalid.each do |x|
+      klass.has_snapshot_children do
+        x
+      end
+
+      assert_raise ArgumentError do
+        klass.new.children_to_snapshot
+      end
+    end
+
+    valid = [
+      {},
+      {foo: []},
+      {foo: [:foobar, 123]},
+      {foo: {record: 'bar'}},
+      {foo: {records: 'bar'}},
+      {foo: {record: Post.limit(1) }},
+      {foo: {records: Post.limit(1) }},
+      {foo: {records: [], delete_method: ->(){} }},
+      {foo: {records: [], delete_method: proc{} }},
+    ]
+
+    valid.each do |x|
+      klass.has_snapshot_children do
+        x
+      end
+
+      klass.new.children_to_snapshot
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,71 @@
+#$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+ENV["RAILS_ENV"] = "test"
+
+require "active_snapshot"
+
+begin
+  require 'warning'
+
+  Warning.ignore(
+    %r{mail/parsers/address_lists_parser}, ### Hide mail gem warnings
+  )
+rescue LoadError
+  # Do nothing
+end
+
+### Instantiates Rails
+require File.expand_path("../dummy_app/config/environment.rb",  __FILE__)
+
+require "rails/test_help"
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+  fixtures :all
+end
+
+Rails.backtrace_cleaner.remove_silencers!
+
+require 'minitest/reporters'
+Minitest::Reporters.use!(
+  Minitest::Reporters::DefaultReporter.new,
+  ENV,
+  Minitest.backtrace_filter
+)
+
+require "minitest/autorun"
+
+# Run any available migration
+if ActiveRecord.gem_version >= Gem::Version.new("6.0")
+  ActiveRecord::MigrationContext.new(File.expand_path("dummy_app/db/migrate/", __dir__), ActiveRecord::SchemaMigration).migrate
+elsif ActiveRecord.gem_version >= Gem::Version.new("5.2")
+  ActiveRecord::MigrationContext.new(File.expand_path("dummy_app/db/migrate/", __dir__)).migrate
+else
+  ActiveRecord::Migrator.migrate File.expand_path("dummy_app/db/migrate/", __dir__)
+end
+
+klasses = [
+  Post,
+  ActiveSnapshot::Snapshot,
+  ActiveSnapshot::SnapshotItem,
+]
+
+klasses.each do |klass|
+  if defined?(SQLite3)
+    ActiveRecord::Base.connection.execute("DELETE FROM #{klass.table_name};")
+    ActiveRecord::Base.connection.execute("UPDATE `sqlite_sequence` SET `seq` = 0 WHERE `name` = '#{klass.table_name}';")
+  else
+    ActiveRecord::Base.connection.execute("TRUNCATE TABLE #{klass.table_name}")
+  end
+end
+
+DATA = {}.with_indifferent_access
+
+DATA[:shared_post] = Post.find_or_create_by!(a: 1, b: 3)
+DATA[:shared_post].create_snapshot!('v1')
+DATA[:shared_post].update_columns(a: 2, b: 4)
+DATA[:shared_post].create_snapshot!('v2')
+
+def assert_time_match(a, b)
+  format = "%d-%m-%Y %h:%M:%S.%L" ### MUST LIMIT THE MILLISECONDS TO 3 decimal places of accuracy, the rest are dropped
+  assert_equal a.strftime(format), b.strftime(format)
+end

data/test/unit/active_snapshot_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+
+class ActiveSnapshotTest < ActiveSupport::TestCase
+
+  def test_exposes_main_module
+    assert ActiveSnapshot.is_a?(Module)
+  end
+
+  def test_exposes_version
+    assert ActiveSnapshot::VERSION
+  end
+
+  def test_snapshot_lifecycle
+    identifier = "snapshot-1"
+
+    klass = Post
+
+    parent = klass.first
+
+    original_parent_updated_at = parent.updated_at
+
+    child = parent.comments.create!(content: :foo)
+    original_child_updated_at = child.updated_at
+
+    orig_comments_size = parent.children_to_snapshot[:comments][:records].count
+
+    assert_difference ->{ ActiveSnapshot::Snapshot.count }, 1 do
+      assert_difference ->{ ActiveSnapshot::SnapshotItem.count }, (orig_comments_size+1) do
+        @snapshot = parent.create_snapshot!(identifier)
+      end
+    end
+
+    assert_equal (orig_comments_size+1), @snapshot.snapshot_items.size
+
+    parent.update_columns(updated_at: 1.day.from_now)
+
+    parent.update_columns(updated_at: 1.day.from_now)
+
+    child.destroy!
+
+    parent.comments.create!(content: :foo)
+    parent.comments.create!(content: :bar)
+
+    assert_no_difference ->{ ActiveSnapshot::Snapshot.count } do
+      assert_no_difference ->{ ActiveSnapshot::SnapshotItem.count } do
+        @snapshot.restore!
+      end
+    end
+
+    assert_equal 1, ActiveSnapshot::Snapshot.where(identifier: identifier).count
+
+    parent.reload
+
+    assert_equal orig_comments_size, parent.children_to_snapshot[:comments][:records].count
+
+    ### Test Data Chang
+    assert_time_match original_parent_updated_at, parent.updated_at
+    assert_time_match original_child_updated_at, parent.children_to_snapshot[:comments][:records].first.updated_at
+  end
+end