ibm_db 5.6.1 → 5.7.0

data/test/cases/enum_test.rb

@@ -12,6 +12,44 @@ class EnumTest < ActiveRecord::TestCase
     @book = books(:awdr)
   end
 
+  test "type.cast" do
+    type = Book.type_for_attribute(:status)
+
+    assert_equal "proposed",  type.cast(0)
+    assert_equal "written",   type.cast(1)
+    assert_equal "published", type.cast(2)
+
+    assert_equal "proposed",  type.cast(:proposed)
+    assert_equal "written",   type.cast(:written)
+    assert_equal "published", type.cast(:published)
+
+    assert_equal "proposed",  type.cast("proposed")
+    assert_equal "written",   type.cast("written")
+    assert_equal "published", type.cast("published")
+
+    assert_equal :unknown,    type.cast(:unknown)
+    assert_equal "unknown",   type.cast("unknown")
+  end
+
+  test "type.serialize" do
+    type = Book.type_for_attribute(:status)
+
+    assert_equal 0, type.serialize(0)
+    assert_equal 1, type.serialize(1)
+    assert_equal 2, type.serialize(2)
+
+    assert_equal 0, type.serialize(:proposed)
+    assert_equal 1, type.serialize(:written)
+    assert_equal 2, type.serialize(:published)
+
+    assert_equal 0, type.serialize("proposed")
+    assert_equal 1, type.serialize("written")
+    assert_equal 2, type.serialize("published")
+
+    assert_nil type.serialize(:unknown)
+    assert_nil type.serialize("unknown")
+  end
+
   test "query state by predicate" do
     assert_predicate @book, :published?
     assert_not_predicate @book, :written?
@@ -32,6 +70,7 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal "visible", @book.author_visibility
     assert_equal "visible", @book.illustrator_visibility
     assert_equal "medium", @book.difficulty
+    assert_equal "soft", @book.cover
   end
 
   test "find via scope" do
@@ -70,6 +109,7 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_equal @book, Book.where(status: [written, written]).first
     assert_not_equal @book, Book.where.not(status: published).first
     assert_equal @book, Book.where.not(status: written).first
+    assert_equal @book, Book.where(cover: Book.covers[:soft]).first
   end
 
   test "find via where with symbols" do
@@ -80,6 +120,9 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_equal @book, Book.where.not(status: :published).first
     assert_equal @book, Book.where.not(status: :written).first
     assert_equal books(:ddd), Book.where(last_read: :forgotten).first
+    assert_nil Book.where(status: :prohibited).first
+    assert_equal @book, Book.where(cover: :soft).first
+    assert_equal @book, Book.where.not(cover: :hard).first
   end
 
   test "find via where with strings" do
@@ -90,11 +133,31 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_equal @book, Book.where.not(status: "published").first
     assert_equal @book, Book.where.not(status: "written").first
     assert_equal books(:ddd), Book.where(last_read: "forgotten").first
+    assert_nil Book.where(status: "prohibited").first
+  end
+
+  test "find via where with large number" do
+    assert_equal @book, Book.where(status: [2, 9223372036854775808]).first
+    assert_equal @book, Book.where(status: ["2", "9223372036854775808"]).first
+    assert_equal @book, Book.where(status: 2..9223372036854775808).first
+    assert_equal @book, Book.where(status: "2".."9223372036854775808").first
+  end
+
+  test "find via where should be type casted" do
+    book = Book.enabled.create!
+    assert_predicate book, :enabled?
+
+    enabled = Book.boolean_statuses[:enabled].to_s
+    assert_equal book, Book.where(boolean_status: enabled).last
+    assert_equal @book, Book.where(cover: "soft").first
+    assert_equal @book, Book.where.not(cover: "hard").first
   end
 
   test "build from scope" do
     assert_predicate Book.written.build, :written?
     assert_not_predicate Book.written.build, :proposed?
+    assert_predicate PublishedBook.hard.build, :hard?
+    assert_not_predicate PublishedBook.hard.build, :soft?
   end
 
   test "build from where" do
@@ -113,11 +176,15 @@ class EnumTest < ActiveRecord::TestCase
     assert_predicate @book, :in_english?
     @book.author_visibility_visible!
     assert_predicate @book, :author_visibility_visible?
+    @book.hard!
+    assert_predicate @book, :hard?
   end
 
   test "update by setter" do
     @book.update! status: :written
     assert_predicate @book, :written?
+    @book.update! cover: :hard
+    assert_predicate @book, :hard?
   end
 
   test "enum methods are overwritable" do
@@ -128,11 +195,15 @@ class EnumTest < ActiveRecord::TestCase
   test "direct assignment" do
     @book.status = :written
     assert_predicate @book, :written?
+    @book.cover = :hard
+    assert_predicate @book, :hard?
   end
 
   test "assign string value" do
     @book.status = "written"
     assert_predicate @book, :written?
+    @book.cover = "hard"
+    assert_predicate @book, :hard?
   end
 
   test "enum changed attributes" do
@@ -242,6 +313,44 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal "'unknown' is not a valid status", e.message
   end
 
+  test "validation with 'validate: true' option" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; "Book"; end
+      enum :status, [:proposed, :written], validate: true
+    end
+
+    valid_book = klass.new(status: "proposed")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: "written")
+    assert_predicate valid_book, :valid?
+
+    invalid_book = klass.new(status: nil)
+    assert_not_predicate invalid_book, :valid?
+
+    invalid_book = klass.new(status: "unknown")
+    assert_not_predicate invalid_book, :valid?
+  end
+
+  test "validation with 'validate: hash' option" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; "Book"; end
+      enum :status, [:proposed, :written], validate: { allow_nil: true }
+    end
+
+    valid_book = klass.new(status: "proposed")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: "written")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: nil)
+    assert_predicate valid_book, :valid?
+
+    invalid_book = klass.new(status: "unknown")
+    assert_not_predicate invalid_book, :valid?
+  end
+
   test "NULL values from database should be casted to nil" do
     Book.where(id: @book.id).update_all("status = NULL")
     assert_nil @book.reload.status
@@ -295,6 +404,7 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "creating new objects with enum scopes" do
+    skip "IBM_DB/DB2: composite UNIQUE index on (author_id, name) treats multiple all-NULL rows as duplicates (SQL0803N); creating several Books without author/name fails" if current_adapter?(:IBM_DBAdapter)
     assert_predicate Book.written.create, :written?
     assert_predicate Book.read.create, :read?
     assert_predicate Book.in_spanish.create, :in_spanish?
@@ -321,39 +431,83 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal "published", @book.status
   end
 
+  test "attributes_for_database" do
+    assert_equal 2, @book.attributes_for_database["status"]
+
+    @book.status = "published"
+
+    assert_equal 2, @book.attributes_for_database["status"]
+  end
+
   test "invalid definition values raise an ArgumentError" do
     e = assert_raises(ArgumentError) do
       Class.new(ActiveRecord::Base) do
         self.table_name = "books"
-        enum status: [proposed: 1, written: 2, published: 3]
+        enum :status
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum(:status, {}, **{})
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, []
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [proposed: 1, written: 2, published: 3]
+      end
+    end
+
+    assert_match(/must only contain symbols or strings\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, { "" => 1, "active" => 2 }
       end
     end
 
-    assert_match(/must be either a hash, an array of symbols, or an array of strings./, e.message)
+    assert_match(/must not contain a blank name\.$/, e.message)
 
     e = assert_raises(ArgumentError) do
       Class.new(ActiveRecord::Base) do
         self.table_name = "books"
-        enum status: { "" => 1, "active" => 2 }
+        enum :status, ["active", ""]
       end
     end
 
-    assert_match(/Enum label name must not be blank/, e.message)
+    assert_match(/must not contain a blank name\.$/, e.message)
 
     e = assert_raises(ArgumentError) do
       Class.new(ActiveRecord::Base) do
         self.table_name = "books"
-        enum status: ["active", ""]
+        enum :status, Object.new
       end
     end
 
-    assert_match(/Enum label name must not be blank/, e.message)
+    assert_match(/must be either a non-empty hash or an array\.$/, e.message)
   end
 
   test "reserved enum names" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published]
+      enum :status, [:proposed, :written, :published]
     end
 
     conflicts = [
@@ -364,16 +518,16 @@ class EnumTest < ActiveRecord::TestCase
 
     conflicts.each_with_index do |name, i|
       e = assert_raises(ArgumentError) do
-        klass.class_eval { enum name => ["value_#{i}"] }
+        klass.class_eval { enum name, ["value_#{i}"] }
       end
-      assert_match(/You tried to define an enum named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define an enum named "#{name}" on the model/, e.message)
     end
   end
 
   test "reserved enum values" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published]
+      enum :status, [:proposed, :written, :published]
     end
 
     conflicts = [
@@ -382,17 +536,28 @@ class EnumTest < ActiveRecord::TestCase
       :save,     # generates #save!, which conflicts with an AR method
       :proposed, # same value as an existing enum
       :public, :private, :protected, # some important methods on Module and Class
-      :name, :parent, :superclass
+      :name, :superclass,
+      :id        # conflicts with AR querying
     ]
 
     conflicts.each_with_index do |value, i|
       e = assert_raises(ArgumentError, "enum value `#{value}` should not be allowed") do
-        klass.class_eval { enum "status_#{i}" => [value] }
+        klass.class_eval { enum "status_#{i}", [value] }
       end
       assert_match(/You tried to define an enum named .* on the model/, e.message)
     end
   end
 
+  test "can use id as a value with a prefix or suffix" do
+    assert_nothing_raised do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status_1, [:id], prefix: true
+        enum :status_2, [:id], suffix: true
+      end
+    end
+  end
+
   test "reserved enum values for relation" do
     relation_method_samples = [
       :records,
@@ -404,7 +569,7 @@ class EnumTest < ActiveRecord::TestCase
       e = assert_raises(ArgumentError, "enum value `#{value}` should not be allowed") do
         Class.new(ActiveRecord::Base) do
           self.table_name = "books"
-          enum category: [:other, value]
+          enum :category, [:other, value]
         end
       end
       assert_match(/You tried to define an enum named .* on the model/, e.message)
@@ -421,7 +586,7 @@ class EnumTest < ActiveRecord::TestCase
           "do publish work..."
         end
 
-        enum status: [:proposed, :written, :published]
+        enum :status, [:proposed, :written, :published]
 
         def written!
           super
@@ -434,7 +599,7 @@ class EnumTest < ActiveRecord::TestCase
   test "validate uniqueness" do
     klass = Class.new(ActiveRecord::Base) do
       def self.name; "Book"; end
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
       validates_uniqueness_of :status
     end
     klass.delete_all
@@ -448,10 +613,9 @@ class EnumTest < ActiveRecord::TestCase
   test "validate inclusion of value in array" do
     klass = Class.new(ActiveRecord::Base) do
       def self.name; "Book"; end
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
       validates_inclusion_of :status, in: ["written"]
     end
-    klass.delete_all
     invalid_book = klass.new(status: "proposed")
     assert_not_predicate invalid_book, :valid?
     valid_book = klass.new(status: "written")
@@ -459,14 +623,15 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "enums are distinct per class" do
+    skip "IBM_DB/DB2: composite UNIQUE index on (author_id, name) treats multiple all-NULL rows as duplicates (SQL0803N); creating several Books without author/name fails" if current_adapter?(:IBM_DBAdapter)
     klass1 = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
     end
 
     klass2 = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:drafted, :uploaded]
+      enum :status, [:drafted, :uploaded]
     end
 
     book1 = klass1.proposed.create!
@@ -479,10 +644,11 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "enums are inheritable" do
+    skip "IBM_DB/DB2: composite UNIQUE index on (author_id, name) treats multiple all-NULL rows as duplicates (SQL0803N); creating several Books without author/name fails" if current_adapter?(:IBM_DBAdapter)
     subklass1 = Class.new(Book)
 
     subklass2 = Class.new(Book) do
-      enum status: [:drafted, :uploaded]
+      enum :status, [:drafted, :uploaded]
     end
 
     book1 = subklass1.proposed.create!
@@ -508,29 +674,13 @@ class EnumTest < ActiveRecord::TestCase
     assert_match(/can't modify frozen/, e.message)
   end
 
-  test "declare multiple enums at a time" do
+  test "declare multiple enums with prefix: true" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published],
-           nullable_status: [:single, :married]
-    end
 
-    book1 = klass.proposed.create!
-    assert_predicate book1, :proposed?
-
-    book2 = klass.single.create!
-    assert_predicate book2, :single?
-  end
-
-  test "declare multiple enums with { _prefix: true }" do
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = "books"
+      enum(:status, [:value_1], prefix: true)
 
-      enum(
-        status: [:value_1],
-        last_read: [:value_1],
-        _prefix: true
-      )
+      enum(:last_read, [:value_1], prefix: true)
     end
 
     instance = klass.new
@@ -538,15 +688,13 @@ class EnumTest < ActiveRecord::TestCase
     assert_respond_to instance, :last_read_value_1?
   end
 
-  test "declare multiple enums with { _suffix: true }" do
+  test "declare multiple enums with suffix: true" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
 
-      enum(
-        status: [:value_1],
-        last_read: [:value_1],
-        _suffix: true
-      )
+      enum(:status, [:value_1], suffix: true)
+
+      enum(:last_read, [:value_1], suffix: true)
     end
 
     instance = klass.new
@@ -558,7 +706,7 @@ class EnumTest < ActiveRecord::TestCase
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
       alias_attribute :aliased_status, :status
-      enum aliased_status: [:proposed, :written, :published]
+      enum :aliased_status, [:proposed, :written, :published]
     end
 
     book = klass.proposed.create!
@@ -622,8 +770,8 @@ class EnumTest < ActiveRecord::TestCase
 
   test "uses default status when no status is provided in fixtures" do
     book = books(:tlg)
-    assert book.proposed?, "expected fixture to default to proposed status"
-    assert book.in_english?, "expected fixture to default to english language"
+    assert_predicate book, :proposed?, "expected fixture to default to proposed status"
+    assert_predicate book, :in_english?, "expected fixture to default to english language"
   end
 
   test "uses default value from database on initialization" do
@@ -644,34 +792,137 @@ class EnumTest < ActiveRecord::TestCase
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
       attribute :status, default: 2
-      enum status: [:proposed, :written, :published]
+      enum :status, [:proposed, :written, :published]
     end
 
     assert_equal "published", klass.new.status
   end
 
-  test "overloaded default" do
+  test "overloaded default by :default" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published], _default: :published
+      enum :status, [:proposed, :written, :published], default: :published
     end
 
     assert_equal "published", klass.new.status
   end
 
-  test "scopes can be disabled" do
+  test ":_default is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _default: :published
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_default/, error.message)
+  end
+
+  test ":_prefix is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _prefix: true
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_prefix/, error.message)
+  end
+
+  test ":_suffix is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _suffix: true
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_suffix/, error.message)
+  end
+
+  test ":_scopes is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _scopes: false
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_scopes/, error.message)
+  end
+
+  test ":_instance_methods is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _instance_methods: false
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_instance_methods/, error.message)
+  end
+
+  test "scopes can be disabled by :scopes" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written], _scopes: false
+      enum :status, [:proposed, :written], scopes: false
     end
 
     assert_raises(NoMethodError) { klass.proposed }
   end
 
+  test "query state by predicate with :prefix" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, { proposed: 0, written: 1 }, prefix: true
+      enum :last_read, { unread: 0, reading: 1, read: 2 }, prefix: :being
+    end
+
+    book = klass.new
+    assert_respond_to book, :status_proposed?
+    assert_respond_to book, :being_unread?
+  end
+
+  test "query state by predicate with :suffix" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :cover, { hard: 0, soft: 1 }, suffix: true
+      enum :difficulty, { easy: 0, medium: 1, hard: 2 }, suffix: :to_read
+    end
+
+    book = klass.new
+    assert_respond_to book, :hard_cover?
+    assert_respond_to book, :easy_to_read?
+  end
+
+  test "enum labels as keyword arguments" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, active: 0, archived: 1
+    end
+
+    book = klass.new
+    assert_predicate book, :active?
+    assert_not_predicate book, :archived?
+  end
+
+  test "option names can be used as label" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, default: 0, scopes: 1, prefix: 2, suffix: 3
+    end
+
+    book = klass.new
+    assert_predicate book, :default?
+    assert_not_predicate book, :scopes?
+    assert_not_predicate book, :prefix?
+    assert_not_predicate book, :suffix?
+  end
+
   test "scopes are named like methods" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "cats"
-      enum breed: { "American Bobtail" => 0, "Balinese-Javanese" => 1 }
+      enum :breed, { "American Bobtail" => 0, "Balinese-Javanese" => 1 }
     end
 
     assert_respond_to klass, :American_Bobtail
@@ -679,9 +930,13 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "capital characters for enum names" do
+    # IBM_DB/DB2 normalizes identifiers to UPPERCASE; the adapter downcases column
+    # names on read-back, so the column is returned as 'extendedwarranty'.
+    # Declare the enum with the lowercase name so AR can find the column.
+    warranty_attr = current_adapter?(:IBM_DBAdapter) ? :extendedwarranty : :extendedWarranty
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "computers"
-      enum extendedWarranty: [:extendedSilver, :extendedGold]
+      enum warranty_attr, [:extendedSilver, :extendedGold]
     end
 
     computer = klass.extendedSilver.build
@@ -692,7 +947,7 @@ class EnumTest < ActiveRecord::TestCase
   test "unicode characters for enum names" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum language: [:🇺🇸, :🇪🇸, :🇫🇷]
+      enum :language, [:🇺🇸, :🇪🇸, :🇫🇷]
     end
 
     book = klass.🇺🇸.build
@@ -703,7 +958,7 @@ class EnumTest < ActiveRecord::TestCase
   test "mangling collision for enum names" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "computers"
-      enum timezone: [:"Etc/GMT+1", :"Etc/GMT-1"]
+      enum :timezone, [:"Etc/GMT+1", :"Etc/GMT-1"]
     end
 
     computer = klass.public_send(:"Etc/GMT+1").build
@@ -716,7 +971,7 @@ class EnumTest < ActiveRecord::TestCase
     written = Struct.new(:to_s).new("written")
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: { proposed => 0, written => 1 }
+      enum :status, { proposed => 0, written => 1 }
     end
 
     book = klass.create!(status: 0)
@@ -725,6 +980,31 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_predicate book, :written?
   end
 
+  test "serializable? with large number label" do
+    skip "IBM_DB/DB2: composite UNIQUE index on (author_id, name) treats multiple all-NULL rows as duplicates (SQL0803N); creating several Books without author/name fails" if current_adapter?(:IBM_DBAdapter)
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, ["9223372036854775808", "-9223372036854775809"]
+    end
+
+    type = klass.type_for_attribute(:status)
+
+    assert type.serializable?("9223372036854775808")
+    assert type.serializable?("-9223372036854775809")
+
+    assert_not type.serializable?(9223372036854775808)
+    assert_not type.serializable?(-9223372036854775809)
+
+    book1 = klass.create!(status: "9223372036854775808")
+    book2 = klass.create!(status: "-9223372036854775809")
+
+    assert_equal 0, book1.status_for_database
+    assert_equal 1, book2.status_for_database
+
+    assert_equal book1, klass.where(status: "9223372036854775808").last
+    assert_equal book2, klass.where(status: "-9223372036854775809").last
+  end
+
   test "enum logs a warning if auto-generated negative scopes would clash with other enum names" do
     old_logger = ActiveRecord::Base.logger
     logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
@@ -735,20 +1015,16 @@ class EnumTest < ActiveRecord::TestCase
       " This has caused a conflict with auto generated negative scopes."\
       " Avoid using enum elements starting with 'not' where the positive form is also an element."
 
-    # this message comes from ActiveRecord::Scoping::Named, but it's worth noting that both occur in this case
-    expected_message_2 = "Creating scope :not_sent. Overwriting existing method Book.not_sent."
-
     Class.new(ActiveRecord::Base) do
       def self.name
         "Book"
       end
       silence_warnings do
-        enum status: [:sent, :not_sent]
+        enum :status, [:sent, :not_sent]
       end
     end
 
     assert_includes(logger.logged(:warn), expected_message_1)
-    assert_includes(logger.logged(:warn), expected_message_2)
   ensure
     ActiveRecord::Base.logger = old_logger
   end
@@ -763,20 +1039,16 @@ class EnumTest < ActiveRecord::TestCase
       " This has caused a conflict with auto generated negative scopes."\
       " Avoid using enum elements starting with 'not' where the positive form is also an element."
 
-    # this message comes from ActiveRecord::Scoping::Named, but it's worth noting that both occur in this case
-    expected_message_2 = "Creating scope :not_sent. Overwriting existing method Book.not_sent."
-
     Class.new(ActiveRecord::Base) do
       def self.name
         "Book"
       end
       silence_warnings do
-        enum status: [:not_sent, :sent]
+        enum :status, [:not_sent, :sent]
       end
     end
 
     assert_includes(logger.logged(:warn), expected_message_1)
-    assert_includes(logger.logged(:warn), expected_message_2)
   ensure
     ActiveRecord::Base.logger = old_logger
   end
@@ -791,9 +1063,7 @@ class EnumTest < ActiveRecord::TestCase
       def self.name
         "Book"
       end
-      silence_warnings do
-        enum status: [:not_sent]
-      end
+      enum :status, [:not_sent]
     end
 
     assert_empty(logger.logged(:warn))
@@ -812,7 +1082,7 @@ class EnumTest < ActiveRecord::TestCase
         "Book"
       end
       silence_warnings do
-        enum status: [:not_sent, :sent], _scopes: false
+        enum :status, [:not_sent, :sent], scopes: false
       end
     end
 
@@ -820,4 +1090,36 @@ class EnumTest < ActiveRecord::TestCase
   ensure
     ActiveRecord::Base.logger = old_logger
   end
+
+  test "raises for attributes with undeclared type" do
+    klass = Class.new(Book) do
+    def self.name; "Book"; end
+    enum :typeless_genre, [:adventure, :comic]
+  end
+
+    error = assert_raises(RuntimeError) do
+      klass.type_for_attribute(:typeless_genre)
+    end
+    assert_match "Undeclared attribute type for enum 'typeless_genre' in Book", error.message
+  end
+
+  test "supports attributes declared with a explicit type" do
+    klass = Class.new(Book) do
+      attribute :my_genre, :integer
+      enum :my_genre, [:adventure, :comic]
+    end
+
+    assert_equal :integer, klass.type_for_attribute(:my_genre).type
+  end
+
+  test "default methods can be disabled by :instance_methods" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, [:proposed, :written], instance_methods: false
+    end
+
+    instance = klass.new
+    assert_raises(NoMethodError) { instance.proposed? }
+    assert_raises(NoMethodError) { instance.proposed! }
+  end
 end