familia 2.0.0.pre19 → 2.0.0.pre21

data/try/unit/horreum/optimized_loading_try.rb

@@ -0,0 +1,156 @@
+# try/unit/horreum/optimized_loading_try.rb
+#
+# frozen_string_literal: true
+
+# Test optimized loading methods with check_exists parameter and pipelined bulk loading
+
+require_relative '../../support/helpers/test_helpers'
+
+OptimizedUser = Class.new(Familia::Horreum) do
+  identifier_field :user_id
+  field :user_id
+  field :name
+  field :email
+  field :age
+end
+
+# Setup: Create test users
+setup_user1 = OptimizedUser.new(user_id: 'opt_user_1', name: 'Alice', email: 'alice@example.com', age: 30)
+setup_user1.save
+
+setup_user2 = OptimizedUser.new(user_id: 'opt_user_2', name: 'Bob', email: 'bob@example.com', age: 25)
+setup_user2.save
+
+setup_user3 = OptimizedUser.new(user_id: 'opt_user_3', name: 'Charlie', email: 'charlie@example.com', age: 35)
+setup_user3.save
+
+## find_by_dbkey with check_exists: true (default) returns object for existing key
+found_user = OptimizedUser.find_by_dbkey(OptimizedUser.dbkey('opt_user_1'))
+found_user.name
+#=> 'Alice'
+
+## find_by_dbkey with check_exists: true (default) returns nil for non-existent key
+OptimizedUser.find_by_dbkey(OptimizedUser.dbkey('nonexistent'))
+#=> nil
+
+## find_by_dbkey with check_exists: false returns object for existing key
+found_user_fast = OptimizedUser.find_by_dbkey(OptimizedUser.dbkey('opt_user_1'), check_exists: false)
+found_user_fast.name
+#=> 'Alice'
+
+## find_by_dbkey with check_exists: false returns nil for non-existent key
+OptimizedUser.find_by_dbkey(OptimizedUser.dbkey('nonexistent'), check_exists: false)
+#=> nil
+
+## find_by_dbkey with check_exists: false correctly deserializes all fields
+fast_loaded = OptimizedUser.find_by_dbkey(OptimizedUser.dbkey('opt_user_2'), check_exists: false)
+[fast_loaded.user_id, fast_loaded.name, fast_loaded.email, fast_loaded.age]
+#=> ['opt_user_2', 'Bob', 'bob@example.com', 25]
+
+## find_by_identifier with check_exists: true (default) returns object
+OptimizedUser.find_by_identifier('opt_user_1').name
+#=> 'Alice'
+
+## find_by_identifier with check_exists: false returns object
+OptimizedUser.find_by_identifier('opt_user_1', check_exists: false).name
+#=> 'Alice'
+
+## find_by_identifier with check_exists: false returns nil for non-existent
+OptimizedUser.find_by_identifier('nonexistent', check_exists: false)
+#=> nil
+
+## find_by_id alias works with check_exists parameter
+OptimizedUser.find_by_id('opt_user_2', check_exists: false).email
+#=> 'bob@example.com'
+
+## find alias works with check_exists parameter
+OptimizedUser.find('opt_user_3', check_exists: false).age
+#=> 35
+
+## load alias works with check_exists parameter
+OptimizedUser.load('opt_user_1', check_exists: false).user_id
+#=> 'opt_user_1'
+
+## load_multi loads multiple existing objects
+users = OptimizedUser.load_multi(['opt_user_1', 'opt_user_2', 'opt_user_3'])
+users.map(&:name)
+#=> ['Alice', 'Bob', 'Charlie']
+
+## load_multi returns nils for non-existent objects in correct positions
+users_mixed = OptimizedUser.load_multi(['opt_user_1', 'nonexistent', 'opt_user_3'])
+[users_mixed[0]&.name, users_mixed[1], users_mixed[2]&.name]
+#=> ['Alice', nil, 'Charlie']
+
+## load_multi with compact filters out nils
+users_compact = OptimizedUser.load_multi(['opt_user_1', 'nonexistent', 'opt_user_2']).compact
+users_compact.map(&:name)
+#=> ['Alice', 'Bob']
+
+## load_multi preserves order of identifiers
+users_ordered = OptimizedUser.load_multi(['opt_user_3', 'opt_user_1', 'opt_user_2'])
+users_ordered.map(&:user_id)
+#=> ['opt_user_3', 'opt_user_1', 'opt_user_2']
+
+## load_multi handles empty array
+OptimizedUser.load_multi([])
+#=> []
+
+## load_multi handles all non-existent identifiers
+all_missing = OptimizedUser.load_multi(['missing1', 'missing2'])
+all_missing.compact
+#=> []
+
+## load_multi correctly deserializes all field types
+multi_loaded = OptimizedUser.load_multi(['opt_user_2']).first
+[multi_loaded.user_id, multi_loaded.name, multi_loaded.email, multi_loaded.age]
+#=> ['opt_user_2', 'Bob', 'bob@example.com', 25]
+
+## load_batch alias works
+batch_users = OptimizedUser.load_batch(['opt_user_1', 'opt_user_2'])
+batch_users.map(&:name)
+#=> ['Alice', 'Bob']
+
+## load_multi_by_keys loads by full dbkeys
+keys = [OptimizedUser.dbkey('opt_user_1'), OptimizedUser.dbkey('opt_user_2')]
+keyed_users = OptimizedUser.load_multi_by_keys(keys)
+keyed_users.map(&:name)
+#=> ['Alice', 'Bob']
+
+## load_multi_by_keys returns nil for non-existent keys
+keys_mixed = [OptimizedUser.dbkey('opt_user_1'), OptimizedUser.dbkey('nonexistent')]
+keyed_mixed = OptimizedUser.load_multi_by_keys(keys_mixed)
+[keyed_mixed[0]&.name, keyed_mixed[1]]
+#=> ['Alice', nil]
+
+## load_multi_by_keys handles empty array
+OptimizedUser.load_multi_by_keys([])
+#=> []
+
+## load_multi_by_keys handles empty/nil keys and maintains position alignment
+keys_with_empty = [OptimizedUser.dbkey('opt_user_1'), '', OptimizedUser.dbkey('opt_user_2'), nil]
+mixed_keys = OptimizedUser.load_multi_by_keys(keys_with_empty)
+[mixed_keys[0]&.name, mixed_keys[1], mixed_keys[2]&.name, mixed_keys[3]]
+#=> ['Alice', nil, 'Bob', nil]
+
+## load_multi handles nil identifiers gracefully
+users_with_nils = OptimizedUser.load_multi(['opt_user_1', nil, 'opt_user_2'])
+[users_with_nils[0]&.name, users_with_nils[1], users_with_nils[2]&.name]
+#=> ['Alice', nil, 'Bob']
+
+## load_multi handles empty string identifiers
+users_with_empty = OptimizedUser.load_multi(['opt_user_1', '', 'opt_user_2'])
+[users_with_empty[0]&.name, users_with_empty[1], users_with_empty[2]&.name]
+#=> ['Alice', nil, 'Bob']
+
+## find_by_identifier works with suffix as keyword parameter
+OptimizedUser.find_by_identifier('opt_user_1', suffix: :object)&.name
+#=> 'Alice'
+
+## find_by_identifier works with both keyword parameters
+OptimizedUser.find_by_identifier('opt_user_1', suffix: :object, check_exists: false)&.name
+#=> 'Alice'
+
+# Teardown: Clean up test data
+OptimizedUser.destroy!('opt_user_1')
+OptimizedUser.destroy!('opt_user_2')
+OptimizedUser.destroy!('opt_user_3')

data/try/unit/horreum/relations_try.rb

@@ -1,3 +1,7 @@
+# try/unit/horreum/relations_try.rb
+#
+# frozen_string_literal: true
+
 # try/horreum/relations_try.rb
 # Test Horreum Database type relations functionality
 

data/try/unit/horreum/serialization_persistent_fields_try.rb

@@ -1,3 +1,7 @@
+# try/unit/horreum/serialization_persistent_fields_try.rb
+#
+# frozen_string_literal: true
+
 # try/horreum/serialization_persistent_fields_try.rb
 
 require_relative '../../support/helpers/test_helpers'

data/try/unit/horreum/serialization_try.rb

@@ -1,3 +1,7 @@
+# try/unit/horreum/serialization_try.rb
+#
+# frozen_string_literal: true
+
 # try/horreum/serialization_try.rb
 
 require_relative '../../support/helpers/test_helpers'

data/try/unit/horreum/settings_try.rb

@@ -1,3 +1,7 @@
+# try/unit/horreum/settings_try.rb
+#
+# frozen_string_literal: true
+
 # try/horreum/settings_try.rb
 
 # Test Horreum settings

data/try/unit/horreum/unique_index_edge_cases_try.rb

@@ -1,3 +1,7 @@
+# try/unit/horreum/unique_index_edge_cases_try.rb
+#
+# frozen_string_literal: true
+
 # Testing edge cases for unique index validation
 # lib/familia/features/relationships/indexing/unique_index_generators.rb
 # lib/familia/horreum/persistence.rb

data/try/unit/horreum/unique_index_guard_validation_try.rb

@@ -1,4 +1,6 @@
 # try/unit/horreum/unique_index_guard_validation_try.rb
+#
+# frozen_string_literal: true
 
 #
 # Unique index guard validation tests

data/try/unit/middleware/database_command_counter_methods_try.rb

@@ -0,0 +1,139 @@
+# try/unit/middleware/database_command_counter_methods_try.rb
+#
+# frozen_string_literal: true
+
+# Test DatabaseCommandCounter non-command methods and utilities
+#
+# This test file covers utility methods, configuration methods,
+# and state management methods that don't involve command execution.
+#
+# Covers:
+# - Counter methods (count, reset, increment, count_commands)
+# - Configuration (skip_commands)
+# - Utility methods (skip_command?)
+# - Thread safety of atomic counter
+
+require_relative '../../support/helpers/test_helpers'
+require 'concurrent-ruby'
+
+@original_count = DatabaseCommandCounter.count
+
+# Clear initial state
+DatabaseCommandCounter.reset
+
+## count returns the current command count
+DatabaseCommandCounter.reset
+DatabaseCommandCounter.count
+#=> 0
+
+## reset sets count to zero
+DatabaseCommandCounter.increment
+DatabaseCommandCounter.increment
+DatabaseCommandCounter.reset
+DatabaseCommandCounter.count
+#=> 0
+
+## reset returns zero
+result = DatabaseCommandCounter.reset
+result
+#=> 0
+
+## increment increases the count by 1
+DatabaseCommandCounter.reset
+DatabaseCommandCounter.increment
+DatabaseCommandCounter.count
+#=> 1
+
+## increment returns the new count
+DatabaseCommandCounter.reset
+result = DatabaseCommandCounter.increment
+result
+#=> 1
+
+## increment can be called multiple times
+DatabaseCommandCounter.reset
+3.times { DatabaseCommandCounter.increment }
+DatabaseCommandCounter.count
+#=> 3
+
+## skip_commands returns a Set with default skipped commands
+DatabaseCommandCounter.skip_commands.class
+#=> Set
+
+## skip_commands includes SELECT by default
+DatabaseCommandCounter.skip_commands.include?("SELECT")
+#=> true
+
+## skip_commands is frozen for immutability
+DatabaseCommandCounter.skip_commands.frozen?
+#=> true
+
+## skip_command? returns true for commands in skip_commands
+DatabaseCommandCounter.skip_command?(["SELECT", "0"])
+#=> true
+
+## skip_command? returns false for commands not in skip_commands
+DatabaseCommandCounter.skip_command?(["SET", "key", "value"])
+#=> false
+
+## skip_command? handles command array properly
+DatabaseCommandCounter.skip_command?(["GET", "key"])
+#=> false
+
+## skip_command? is case insensitive
+DatabaseCommandCounter.skip_command?(["select", "0"])
+#=> true
+
+## count_commands captures count difference in block
+DatabaseCommandCounter.reset
+initial_count = DatabaseCommandCounter.count
+commands_executed = DatabaseCommandCounter.count_commands do
+  5.times { DatabaseCommandCounter.increment }
+end
+commands_executed
+#=> 5
+
+## count_commands works with empty block
+DatabaseCommandCounter.reset
+commands_executed = DatabaseCommandCounter.count_commands do
+  # No commands
+end
+commands_executed
+#=> 0
+
+## count_commands captures count difference with existing count
+DatabaseCommandCounter.reset
+5.times { DatabaseCommandCounter.increment }  # Existing commands
+commands_executed = DatabaseCommandCounter.count_commands do
+  3.times { DatabaseCommandCounter.increment }  # New commands in block
+end
+commands_executed
+#=> 3
+
+## Thread safety: increment is thread-safe with concurrent access
+DatabaseCommandCounter.reset
+threads = 10.times.map do |i|
+  Thread.new do
+    10.times { DatabaseCommandCounter.increment }
+  end
+end
+
+threads.each(&:join)
+DatabaseCommandCounter.count
+#=> 100
+
+## Thread safety: count_commands is thread-safe
+DatabaseCommandCounter.reset
+result = DatabaseCommandCounter.count_commands do
+  threads = 5.times.map do
+    Thread.new do
+      10.times { DatabaseCommandCounter.increment }
+    end
+  end
+  threads.each(&:join)
+end
+result
+#=> 50
+
+# Restore original state (if needed)
+DatabaseCommandCounter.reset

data/try/unit/middleware/database_logger_methods_try.rb

@@ -0,0 +1,251 @@
+# try/unit/middleware/database_logger_methods_try.rb
+#
+# frozen_string_literal: true
+
+# Test DatabaseLogger non-command methods and utilities
+#
+# This test file covers utility methods, configuration methods,
+# and state management methods that don't involve command execution.
+#
+# Covers:
+# - Configuration getters/setters (logger, max_commands, structured_logging, sample_rate)
+# - Command storage methods (clear_commands, append_command, capture_commands)
+# - Utility methods (index, now_in_μs, should_log?)
+# - State introspection (commands, process_start)
+# - Thread safety of command storage
+
+require_relative '../../support/helpers/test_helpers'
+require 'logger'
+require 'stringio'
+require 'concurrent-ruby'
+
+@original_logger = DatabaseLogger.logger
+@original_max_commands = DatabaseLogger.max_commands
+@original_structured_logging = DatabaseLogger.structured_logging
+@original_sample_rate = DatabaseLogger.sample_rate
+
+# Clear initial state
+DatabaseLogger.clear_commands
+DatabaseLogger.logger = nil
+DatabaseLogger.max_commands = 10_000
+DatabaseLogger.structured_logging = false
+DatabaseLogger.sample_rate = nil
+
+## logger getter returns the current logger instance
+test_logger = Logger.new(StringIO.new)
+DatabaseLogger.logger = test_logger
+DatabaseLogger.logger == test_logger
+#=> true
+
+## logger can be set to nil
+DatabaseLogger.logger = nil
+DatabaseLogger.logger
+#=> nil
+
+## max_commands getter returns the current max commands value
+DatabaseLogger.max_commands = 5_000
+DatabaseLogger.max_commands
+#=> 5000
+
+## max_commands can be set to different values
+DatabaseLogger.max_commands = 1_000
+DatabaseLogger.max_commands
+#=> 1000
+
+## structured_logging getter returns the current structured logging mode
+DatabaseLogger.structured_logging = true
+DatabaseLogger.structured_logging
+#=> true
+
+## structured_logging can be toggled
+DatabaseLogger.structured_logging = false
+DatabaseLogger.structured_logging
+#=> false
+
+## sample_rate getter returns the current sample rate
+DatabaseLogger.sample_rate = 0.5
+DatabaseLogger.sample_rate
+#=> 0.5
+
+## sample_rate can be set to nil
+DatabaseLogger.sample_rate = nil
+DatabaseLogger.sample_rate
+#=> nil
+
+## commands getter returns the captured commands array
+DatabaseLogger.clear_commands
+commands = DatabaseLogger.commands
+commands.class
+#=> Concurrent::Array
+
+## commands array is initially empty after clear
+DatabaseLogger.clear_commands
+DatabaseLogger.commands.empty?
+#=> true
+
+## process_start returns a float timestamp
+DatabaseLogger.process_start.class
+#=> Float
+
+## process_start is frozen
+DatabaseLogger.process_start.frozen?
+#=> true
+
+## clear_commands returns nil and empties the commands array
+DatabaseLogger.instance_variable_get(:@commands) << "test"
+result = DatabaseLogger.clear_commands
+[result, DatabaseLogger.commands.empty?]
+#=> [nil, true]
+
+## index returns the current count of commands
+DatabaseLogger.clear_commands
+DatabaseLogger.index
+#=> 0
+
+## index increases as commands are added
+DatabaseLogger.clear_commands
+msg = DatabaseLogger::CommandMessage.new("TEST", 100, 0.001)
+DatabaseLogger.append_command(msg)
+DatabaseLogger.index
+#=> 1
+
+## append_command adds a message to the commands array
+DatabaseLogger.clear_commands
+msg = DatabaseLogger::CommandMessage.new("SET key value", 500, 0.002)
+result = DatabaseLogger.append_command(msg)
+[DatabaseLogger.commands.size, result.last == msg]
+#=> [1, true]
+
+## append_command respects max_commands limit by shifting oldest
+DatabaseLogger.max_commands = 3
+DatabaseLogger.clear_commands
+msg1 = DatabaseLogger::CommandMessage.new("CMD1", 100, 0.001)
+msg2 = DatabaseLogger::CommandMessage.new("CMD2", 200, 0.002)
+msg3 = DatabaseLogger::CommandMessage.new("CMD3", 300, 0.003)
+msg4 = DatabaseLogger::CommandMessage.new("CMD4", 400, 0.004)
+
+DatabaseLogger.append_command(msg1)
+DatabaseLogger.append_command(msg2)
+DatabaseLogger.append_command(msg3)
+DatabaseLogger.append_command(msg4)
+
+[DatabaseLogger.commands.size, DatabaseLogger.commands.first == msg2]
+#=> [3, true]
+
+## now_in_μs returns current time in microseconds
+time1 = DatabaseLogger.now_in_μs
+sleep(0.001)
+time2 = DatabaseLogger.now_in_μs
+time2 > time1
+#=> true
+
+## now_in_microseconds is an alias for now_in_μs
+DatabaseLogger.method(:now_in_microseconds) == DatabaseLogger.method(:now_in_μs)
+#=> true
+
+## capture_commands yields and returns captured commands
+DatabaseLogger.clear_commands
+commands = DatabaseLogger.capture_commands do
+  msg = DatabaseLogger::CommandMessage.new("GET key", 150, 0.001)
+  DatabaseLogger.append_command(msg)
+  msg2 = DatabaseLogger::CommandMessage.new("SET key2 value", 200, 0.002)
+  DatabaseLogger.append_command(msg2)
+end
+commands.size
+#=> 2
+
+## capture_commands clears commands before capturing
+DatabaseLogger.clear_commands
+msg_before = DatabaseLogger::CommandMessage.new("BEFORE", 100, 0.001)
+DatabaseLogger.append_command(msg_before)
+
+commands = DatabaseLogger.capture_commands do
+  msg = DatabaseLogger::CommandMessage.new("DURING", 150, 0.002)
+  DatabaseLogger.append_command(msg)
+end
+
+[commands.size, commands.first.command]
+#=> [1, "DURING"]
+
+## capture_commands returns array snapshot, not live reference
+DatabaseLogger.clear_commands
+commands = DatabaseLogger.capture_commands do
+  msg = DatabaseLogger::CommandMessage.new("TEST", 100, 0.001)
+  DatabaseLogger.append_command(msg)
+end
+
+# Add another command after capture
+msg2 = DatabaseLogger::CommandMessage.new("AFTER", 200, 0.002)
+DatabaseLogger.append_command(msg2)
+
+[commands.size, DatabaseLogger.commands.size]
+#=> [1, 2]
+
+## should_log? returns true when sample_rate is nil
+DatabaseLogger.sample_rate = nil
+DatabaseLogger.logger = Logger.new(StringIO.new)
+DatabaseLogger.should_log?
+#=> true
+
+## should_log? returns false when logger is nil regardless of sample_rate
+DatabaseLogger.sample_rate = 1.0
+DatabaseLogger.logger = nil
+DatabaseLogger.should_log?
+#=> false
+
+## should_log? uses atomic counter for thread-safe sampling
+DatabaseLogger.sample_rate = 0.5  # 50% sampling
+DatabaseLogger.logger = Logger.new(StringIO.new)
+DatabaseLogger.instance_variable_set(:@sample_counter, Concurrent::AtomicFixnum.new(0))
+
+# Test deterministic sampling pattern
+results = 10.times.map { DatabaseLogger.should_log? }
+results.count(true)
+#=> 5
+
+## should_log? sampling is deterministic and consistent
+DatabaseLogger.sample_rate = 0.25  # 25% sampling (every 4th)
+DatabaseLogger.instance_variable_set(:@sample_counter, Concurrent::AtomicFixnum.new(0))
+
+results = 12.times.map { DatabaseLogger.should_log? }
+results.count(true)
+#=> 3
+
+## CommandMessage can be created with command, duration, timeline
+msg = DatabaseLogger::CommandMessage.new("SET key value", 1500, 0.123456)
+[msg.command, msg.μs, msg.timeline]
+#=> ["SET key value", 1500, 0.123456]
+
+## CommandMessage.inspect formats nicely
+msg = DatabaseLogger::CommandMessage.new("GET key", 2500, 1.234567)
+msg.inspect
+#=> "1.234567 2500μs > GET key"
+
+## CommandMessage.to_a returns deconstructed array
+msg = DatabaseLogger::CommandMessage.new("DEL key1 key2", 750, 2.345678)
+msg.to_a
+#=> ["DEL key1 key2", 750, 2.345678]
+
+## Thread safety: append_command is thread-safe with concurrent access
+# Reset max_commands to allow all 100 commands
+DatabaseLogger.max_commands = 1000
+DatabaseLogger.clear_commands
+threads = 10.times.map do |i|
+  Thread.new do
+    10.times do |j|
+      msg = DatabaseLogger::CommandMessage.new("THREAD#{i}_CMD#{j}", 100, 0.001)
+      DatabaseLogger.append_command(msg)
+    end
+  end
+end
+
+threads.each(&:join)
+DatabaseLogger.commands.size
+#=> 100
+
+# Restore original state
+DatabaseLogger.logger = @original_logger
+DatabaseLogger.max_commands = @original_max_commands
+DatabaseLogger.structured_logging = @original_structured_logging
+DatabaseLogger.sample_rate = @original_sample_rate
+DatabaseLogger.clear_commands

data/try/unit/refinements/dear_json_array_methods_try.rb

@@ -1,3 +1,7 @@
+# try/unit/refinements/dear_json_array_methods_try.rb
+#
+# frozen_string_literal: true
+
 # try/refinements/dear_json_array_methods_try.rb
 
 require_relative '../../support/helpers/test_helpers'

data/try/unit/refinements/dear_json_hash_methods_try.rb

@@ -1,3 +1,7 @@
+# try/unit/refinements/dear_json_hash_methods_try.rb
+#
+# frozen_string_literal: true
+
 # try/refinements/dear_json_hash_methods_try.rb
 
 require_relative '../../support/helpers/test_helpers'

data/try/unit/refinements/time_literals_numeric_methods_try.rb

@@ -1,3 +1,7 @@
+# try/unit/refinements/time_literals_numeric_methods_try.rb
+#
+# frozen_string_literal: true
+
 # try/refinements/time_literals_numeric_methods_try.rb
 
 require_relative '../../support/helpers/test_helpers'

data/try/unit/refinements/time_literals_string_methods_try.rb

@@ -1,3 +1,7 @@
+# try/unit/refinements/time_literals_string_methods_try.rb
+#
+# frozen_string_literal: true
+
 # try/refinements/time_literals_string_methods_try.rb
 
 require_relative '../../support/helpers/test_helpers'