acts_as_archival 1.1.1 → 1.2.0

data/test/fixtures/poly.rb

@@ -3,6 +3,8 @@
 # archive_number   - string
 # archived_at      - datetime
 class Poly < ActiveRecord::Base
+
   acts_as_archival
-  belongs_to :archiveable, :polymorphic => true
+  belongs_to :archiveable, polymorphic: true
+
 end

data/test/fixtures/readonly_when_archived.rb

@@ -2,5 +2,7 @@
 # archive_number - string
 # archived_at    - datetime
 class ReadonlyWhenArchived < ActiveRecord::Base
-  acts_as_archival :readonly_when_archived => true
+
+  acts_as_archival readonly_when_archived: true
+
 end

data/test/polymorphic_test.rb

@@ -1,6 +1,7 @@
 require_relative "test_helper"
 
 class PolymorphicTest < ActiveSupport::TestCase
+
   test "archive item with polymorphic association" do
     archival = Archival.create!
     poly = archival.polys.create!
@@ -12,8 +13,8 @@ class PolymorphicTest < ActiveSupport::TestCase
 
   test "unarchive item with polymorphic association" do
     archive_attributes = {
-      :archive_number => "test",
-      :archived_at    => Time.now
+      archive_number: "test",
+      archived_at: Time.now
     }
     archival = Archival.create!(archive_attributes)
     poly = archival.polys.create!(archive_attributes)
@@ -22,4 +23,5 @@ class PolymorphicTest < ActiveSupport::TestCase
     assert_not archival.reload.archived?
     assert_not poly.reload.archived?
   end
+
 end

data/test/readonly_when_archived_test.rb

@@ -1,8 +1,9 @@
 require_relative "test_helper"
 
 class ReadonlyWhenArchivedTest < ActiveSupport::TestCase
+
   test "acts_as_archival objects can normally be altered after archive" do
-    archival = Archival.create!(:name => "original")
+    archival = Archival.create!(name: "original")
     archival.archive
     archival.name = "updated"
     archival.save!
@@ -11,7 +12,7 @@ class ReadonlyWhenArchivedTest < ActiveSupport::TestCase
   end
 
   test "acts_as_archival marked as readonly_when_archived cannot be updated after archive" do
-    archival = ReadonlyWhenArchived.create!(:name => "original")
+    archival = ReadonlyWhenArchived.create!(name: "original")
     archival.archive
     archival.name = "updated"
 
@@ -19,4 +20,5 @@ class ReadonlyWhenArchivedTest < ActiveSupport::TestCase
     assert_equal "Cannot modify an archived record.",
                  archival.errors.full_messages.first
   end
+
 end

data/test/responds_test.rb

@@ -1,13 +1,31 @@
 require_relative "test_helper"
 
 class RespondsTest < ActiveSupport::TestCase
+
+  test "archival class responds correctly to 'archival?'" do
+    assert     Archival.archival?
+    assert_not Plain.archival?
+  end
+
+  test "archival object responds correctly to 'archival?'" do
+    assert     Archival.new.archival?
+    assert_not Plain.new.archival?
+  end
+
+  ### Deprecation Zone ###
+
   test "archival class responds correctly to 'is_archival?'" do
-    assert     Archival.is_archival?
-    assert_not Plain.is_archival?
+    ActiveSupport::Deprecation.silence do
+      assert     Archival.is_archival?
+      assert_not Plain.is_archival?
+    end
   end
 
   test "archival object responds correctly to 'is_archival?'" do
-    assert     Archival.new.is_archival?
-    assert_not Plain.new.is_archival?
+    ActiveSupport::Deprecation.silence do
+      assert     Archival.new.is_archival?
+      assert_not Plain.new.is_archival?
+    end
   end
+
 end

data/test/schema.rb

@@ -1,103 +1,83 @@
-# Rails 4.0 and before do not deal correctly with newer versions of mysql, so we're
-# gonna force a non-null primary ID for old versions of Rails just as new ones do.
-if (ActiveRecord.version <=> Gem::Version.new("4.1.0")) < 0
-  class ActiveRecord::ConnectionAdapters::Mysql2Adapter
-    NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
-  end
-end
-
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :archivals, :force => true do |t|
+ActiveRecord::Schema.define(version: 1) do
+  create_table :archivals, force: true do |t|
     t.column :name, :string
     t.column :archival_id, :integer
     t.column :archive_number, :string
     t.column :archived_at, :datetime
   end
 
-  create_table :exploders, :force => true do |t|
+  create_table :exploders, force: true do |t|
     t.column :archival_id, :integer
     t.column :archive_number, :string
     t.column :archived_at, :datetime
   end
 
-  ###
-  # The classes above are used to test database-specific
-  # things in PG and MySQL, and we don't need to do all
-  # the tests there.
-  if "SQLite" == ActiveRecord::Base.connection.adapter_name
-    create_table :archival_kids, :force => true do |t|
-      t.column :archival_id, :integer
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
-
-    create_table :archival_grandkids, :force => true do |t|
-      t.column :archival_kid_id, :integer
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :archival_kids, force: true do |t|
+    t.column :archival_id, :integer
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :independent_archivals, :force => true do |t|
-      t.column :name, :string
-      t.column :archival_id, :integer
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :archival_grandkids, force: true do |t|
+    t.column :archival_kid_id, :integer
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :plains, :force => true do |t|
-      t.column :name, :string
-      t.column :archival_id, :integer
-    end
+  create_table :independent_archivals, force: true do |t|
+    t.column :name, :string
+    t.column :archival_id, :integer
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :mass_attribute_protecteds, :force => true do |t|
-      t.column :name, :string
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :plains, force: true do |t|
+    t.column :name, :string
+    t.column :archival_id, :integer
+  end
 
-    create_table :readonly_when_archiveds, :force => true do |t|
-      t.column :name, :string
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :readonly_when_archiveds, force: true do |t|
+    t.column :name, :string
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :missing_archived_ats, :force => true do |t|
-      t.column :name,   :string
-      t.column :archive_number, :string
-    end
+  create_table :missing_archived_ats, force: true do |t|
+    t.column :name, :string
+    t.column :archive_number, :string
+  end
 
-    create_table :missing_archive_numbers, :force => true do |t|
-      t.column :name,   :string
-      t.column :archived_at, :datetime
-    end
+  create_table :missing_archive_numbers, force: true do |t|
+    t.column :name, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :polys, :force => true do |t|
-      t.references :archiveable, :polymorphic => true
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :polys, force: true do |t|
+    t.references :archiveable, polymorphic: true
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :legacy, :force => true do |t|
-      t.column :name, :string
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :legacy, force: true do |t|
+    t.column :name, :string
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :application_record_rows, :force => true do |t|
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :application_record_rows, force: true do |t|
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :callback_archival4s, :force => true do |t|
-      t.column :settable_field, :string
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :callback_archival4s, force: true do |t|
+    t.column :settable_field, :string
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 
-    create_table :callback_archival5s, :force => true do |t|
-      t.column :settable_field, :string
-      t.column :archive_number, :string
-      t.column :archived_at, :datetime
-    end
+  create_table :callback_archival5s, force: true do |t|
+    t.column :settable_field, :string
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
   end
 end

data/test/scope_test.rb

@@ -1,6 +1,7 @@
 require_relative "test_helper"
 
 class ScopeTest < ActiveSupport::TestCase
+
   test "simple unarchived scope" do
     Archival.create!
     Archival.create!
@@ -55,17 +56,19 @@ class ScopeTest < ActiveSupport::TestCase
              else
                "  "
              end
-    archived_sql = %Q{SELECT "legacy".* FROM "legacy"#{spaces}WHERE ("legacy"."archived_at" IS NOT NULL) AND ("legacy"."archive_number" IS NOT NULL)}
-    unarchived_sql = %Q{SELECT "legacy".* FROM "legacy"#{spaces}WHERE "legacy"."archived_at" IS NULL AND "legacy"."archive_number" IS NULL}
+    archived_sql = "SELECT \"legacy\".* FROM \"legacy\"#{spaces}" \
+        'WHERE ("legacy"."archived_at" IS NOT NULL) AND ("legacy"."archive_number" IS NOT NULL)'
+    unarchived_sql = "SELECT \"legacy\".* FROM \"legacy\"#{spaces}" \
+        'WHERE "legacy"."archived_at" IS NULL AND "legacy"."archive_number" IS NULL'
     assert_equal archived_sql, ArchivalTableName.archived.to_sql
     assert_equal unarchived_sql, ArchivalTableName.unarchived.to_sql
   end
 
   test "combines with other scope properly" do
-    Archival.create!(:name => "Robert")
-    Archival.create!(:name => "Bobby")
-    Archival.create!(:name => "Sue")
-    bob = Archival.create!(:name => "Bob")
+    Archival.create!(name: "Robert")
+    Archival.create!(name: "Bobby")
+    Archival.create!(name: "Sue")
+    bob = Archival.create!(name: "Bob")
     bob.archive
     assert_equal 3, Archival.bobs.count
     assert_equal 3, Archival.unarchived.count
@@ -85,4 +88,5 @@ class ScopeTest < ActiveSupport::TestCase
     assert_equal 1, parent.archivals.archived.count
     assert_equal 2, parent.archivals.unarchived.count
   end
+
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")
 require "bundler/setup"
 require "minitest/autorun"
+require "minitest/pride"
 
 require "active_record"
 require "assertions"
@@ -13,8 +14,7 @@ if ActiveSupport::TestCase.respond_to?(:test_order=)
 end
 
 def prepare_for_tests
-  setup_logging# if ENV["LOGGING_ENABLED"]
-  setup_active_record
+  setup_logging
   setup_database_cleaner
   create_test_tables
   require_test_classes
@@ -26,11 +26,6 @@ def setup_logging
   ActiveRecord::Base.logger = Logger.new(logfile)
 end
 
-def setup_active_record
-  dbconfig_file = File.dirname(__FILE__) + "/database.yml"
-  $dbconfig = YAML.load(File.read(dbconfig_file))
-end
-
 def setup_database_cleaner
   DatabaseCleaner.strategy = :truncation
   ActiveSupport::TestCase.send(:setup) do
@@ -38,48 +33,59 @@ def setup_database_cleaner
   end
 end
 
+def sqlite_config
+  {
+    adapter: "sqlite3",
+    database: "aaa_test.sqlite3",
+    pool: 5,
+    timeout: 5000
+  }
+end
+
 def create_test_tables
   schema_file = File.dirname(__FILE__) + "/schema.rb"
-  ["pg", "mysql", "sqlite"].each do |db|
-    puts "** Loading schema for #{db}"
-    ActiveRecord::Base.establish_connection($dbconfig[db])
-    load(schema_file) if File.exist?(schema_file)
-  end
+  puts "** Loading schema for SQLite"
+  ActiveRecord::Base.establish_connection(sqlite_config)
+  load(schema_file) if File.exist?(schema_file)
 end
 
+BASE_FIXTURE_CLASSES = [
+  :archival,
+  :archival_kid,
+  :archival_grandkid,
+  :archival_table_name,
+  :exploder,
+  :independent_archival,
+  :missing_archived_at,
+  :missing_archive_number,
+  :plain,
+  :poly,
+  :readonly_when_archived
+].freeze
+
+RAILS_4_FIXTURE_CLASSES = [
+  :callback_archival_4
+].freeze
+
+RAILS_5_FIXTURE_CLASSES = [
+  :application_record,
+  :application_record_row,
+  :callback_archival_5
+].freeze
+
 def require_test_classes
   ActiveSupport::Inflector.inflections do |inflect|
     inflect.irregular "poly", "polys"
   end
 
-  fixtures = []
-  $require_application_record = ActiveRecord.version >= Gem::Version.new("4.99.99")
-  if $require_application_record
-    fixtures += [:application_record, :application_record_row, :callback_archival_5]
-  else
-    fixtures += [:callback_archival_4]
-  end
+  fixtures = if ActiveRecord::VERSION::MAJOR >= 4
+               RAILS_5_FIXTURE_CLASSES + BASE_FIXTURE_CLASSES
+             else
+               RAILS_4_FIXTURE_CLASSES + BASE_FIXTURE_CLASSES
+             end
 
-  fixtures += [
-    :archival,
-    :archival_kid,
-    :archival_grandkid,
-    :archival_table_name,
-    :exploder,
-    :independent_archival,
-    :missing_archived_at,
-    :missing_archive_number,
-    :mysql_archival,
-    :mysql_exploder,
-    :plain,
-    :poly,
-    :pg_archival,
-    :pg_exploder,
-    :readonly_when_archived
-  ]
-  $require_mass_protection = ActiveModel.constants.include?(:MassAssignmentSecurity)
-  fixtures << :mass_attribute_protected if $require_mass_protection
-  fixtures.each {|test_class_file| require_relative "fixtures/#{test_class_file}"}
+  fixtures += BASE_FIXTURE_CLASSES
+  fixtures.each { |test_class_file| require_relative "fixtures/#{test_class_file}" }
 end
 
 prepare_for_tests

data/test/through_association_test.rb

@@ -1,6 +1,7 @@
 require_relative "test_helper"
 
 class ThroughAssociationTest < ActiveSupport::TestCase
+
   test "archive a through associated object whose 'bridge' is archival" do
     archival = Archival.create!
     bridge   = archival.archival_kids.create!
@@ -12,7 +13,7 @@ class ThroughAssociationTest < ActiveSupport::TestCase
     assert through.reload.archived?
   end
 
-  # TODO Make something like this pass
+  # TODO: Make something like this pass
   # test "archive a through associated object whose 'bridge' is not archival" do
   #   archival = Archival.create!
   #   bridge   = archival.independent_archival_kids.create!
@@ -22,4 +23,5 @@ class ThroughAssociationTest < ActiveSupport::TestCase
   #   assert archival.reload.archived?
   #   assert through.reload.archived?
   # end
+
 end