Add tests to ensure that hidden changes don't affect the u-case

Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'u-case', '~> 4.0'
+
 activemodel_version = ENV.fetch('ACTIVEMODEL_VERSION', '6.1')
 
 activemodel = case activemodel_version

lib/micro/attributes/macros.rb

@@ -55,7 +55,9 @@ def __call_after_attribute_assign__(attr_name, options); end
 
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_set_after_inherit__(arg)
-        arg.each { |key, val| __attribute_assign(key, true, default: val) }
+        arg.each do |key, val|
+          __attribute_assign(key, true, val ? { default: val } : {})
+        end
       end
 
       def attribute?(name)

test/micro/case_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+class Micro::AttributesTest < Minitest::Test
+  class Add < Micro::Case
+    attributes 'a', :b
+
+    def call!
+      Success result: { number: a + b }
+    end
+  end
+
+  def test_add
+    result = Add.call(a: 1, 'b' => 2)
+
+    assert_predicate result, :success?
+    assert_equal 3, result[:number]
+  end
+
+  class Subtract1 < Micro::Case
+    attribute :a, required: true
+    attribute 'b', default: 1
+
+    def call!
+      Success result: { number: a - b }
+    end
+  end
+
+  def test_subtract1
+    err = assert_raises(ArgumentError) { Subtract1.call }
+    assert_equal('missing keyword: :a', err.message )
+
+    # --
+
+    result1 = Subtract1.call(a: 3, b: 2)
+
+    assert_predicate result1, :success?
+    assert_equal 1, result1[:number]
+
+    result2 = Subtract1.call(a: 3)
+
+    assert_predicate result2, :success?
+    assert_equal 2, result2[:number]
+  end
+
+  class Subtract2 < Micro::Case::Strict
+    attribute :a
+    attribute 'b', default: 2
+
+    def call!
+      Success result: { number: a - b }
+    end
+  end
+
+  def test_subtract2
+    err = assert_raises(ArgumentError) { Subtract2.call }
+    assert_equal('missing keyword: :a', err.message )
+
+    # --
+
+    result1 = Subtract2.call(a: 3, b: 1)
+
+    assert_predicate result1, :success?
+    assert_equal 2, result1[:number]
+
+    result2 = Subtract2.call(a: 3)
+
+    assert_predicate result2, :success?
+    assert_equal 1, result2[:number]
+  end
+
+  class Multiply1 < Micro::Case
+    attribute :a, required: true
+    attribute 'b', required: true
+
+    def call!
+      Success result: { number: a * b }
+    end
+  end
+
+  def test_multiply1
+    err1 = assert_raises(ArgumentError) { Multiply1.call }
+    assert_equal('missing keywords: :a, :b', err1.message )
+
+    err2 = assert_raises(ArgumentError) { Multiply1.call(a: 1) }
+    assert_equal('missing keyword: :b', err2.message )
+
+    err3 = assert_raises(ArgumentError) { Multiply1.call(b: 1) }
+    assert_equal('missing keyword: :a', err3.message )
+  end
+
+  class Multiply2 < Micro::Case::Strict
+    attribute :a
+    attribute 'b'
+
+    def call!
+      Success result: { number: a * b }
+    end
+  end
+
+  def test_multiply2
+    err1 = assert_raises(ArgumentError) { Multiply2.call }
+    assert_equal('missing keywords: :a, :b', err1.message )
+
+    err2 = assert_raises(ArgumentError) { Multiply2.call(a: 1) }
+    assert_equal('missing keyword: :b', err2.message )
+
+    err3 = assert_raises(ArgumentError) { Multiply2.call(b: 1) }
+    assert_equal('missing keyword: :a', err3.message )
+  end
+
+  class Multiply3 < Micro::Case::Strict
+    attributes :a, 'b'
+
+    def call!
+      Success result: { number: a * b }
+    end
+  end
+
+  def test_multiply3
+    err1 = assert_raises(ArgumentError) { Multiply3.call }
+    assert_equal('missing keywords: :a, :b', err1.message )
+
+    err2 = assert_raises(ArgumentError) { Multiply3.call(a: 1) }
+    assert_equal('missing keyword: :b', err2.message )
+
+    err3 = assert_raises(ArgumentError) { Multiply3.call(b: 1) }
+    assert_equal('missing keyword: :a', err3.message )
+  end
+
+  class Multiply4 < Multiply2
+  end
+
+  def test_multiply4
+    err1 = assert_raises(ArgumentError) { Multiply4.call }
+    assert_equal('missing keywords: :a, :b', err1.message )
+
+    err2 = assert_raises(ArgumentError) { Multiply4.call(a: 1) }
+    assert_equal('missing keyword: :b', err2.message )
+
+    err3 = assert_raises(ArgumentError) { Multiply4.call(b: 1) }
+    assert_equal('missing keyword: :a', err3.message )
+  end
+
+  class Multiply5 < Multiply3
+  end
+
+  def test_multiply5
+    err1 = assert_raises(ArgumentError) { Multiply5.call }
+    assert_equal('missing keywords: :a, :b', err1.message )
+
+    err2 = assert_raises(ArgumentError) { Multiply5.call(a: 1) }
+    assert_equal('missing keyword: :b', err2.message )
+
+    err3 = assert_raises(ArgumentError) { Multiply5.call(b: 1) }
+    assert_equal('missing keyword: :a', err3.message )
+  end
+end

test/test_helper.rb

@@ -6,11 +6,19 @@
   enable_coverage :branch if RUBY_VERSION >= '2.5.0'
 end
 
-if ENV.fetch('ACTIVEMODEL_VERSION', '6.1') < '4.1'
-  require 'minitest/unit'
+require 'u-case'
 
-  module Minitest
-    Test = MiniTest::Unit::TestCase
+if activemodel_version = ENV['ACTIVEMODEL_VERSION']
+  if activemodel_version < '4.1'
+    require 'minitest/unit'
+
+    module Minitest
+      Test = MiniTest::Unit::TestCase
+    end
+  end
+
+  Micro::Case.config do |config|
+    config.enable_activemodel_validation = true
   end
 end