familia 2.0.0.pre18 → 2.0.0.pre21

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'

data/try/unit/thread_safety_monitor_try.rb

@@ -0,0 +1,149 @@
+# try/unit/thread_safety_monitor_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety monitoring tests
+#
+# Tests basic monitoring functionality without complex concurrency
+
+# setup
+Familia.stop_monitoring! if Familia.thread_safety_monitor.enabled
+Familia.thread_safety_monitor.reset_metrics
+
+## Monitor starts and stops correctly
+Familia.start_monitoring!
+started = Familia.thread_safety_monitor.enabled
+Familia.stop_monitoring!
+stopped = !Familia.thread_safety_monitor.enabled
+started && stopped
+#=> true
+
+## Monitor tracks contentions
+Familia.start_monitoring!
+Familia.thread_safety_monitor.record_contention('test_location')
+Familia.thread_safety_monitor.record_contention('test_location')
+report = Familia.thread_safety_report
+report[:summary][:mutex_contentions]
+#=> 2
+
+## Monitor tracks different locations
+Familia.thread_safety_monitor.reset_metrics
+Familia.thread_safety_monitor.record_contention('location_a')
+Familia.thread_safety_monitor.record_contention('location_b')
+Familia.thread_safety_monitor.record_contention('location_a')
+report = Familia.thread_safety_report
+report[:hot_spots].size
+#=> 2
+
+## Monitor tracks race conditions
+Familia.thread_safety_monitor.reset_metrics
+Familia.thread_safety_monitor.record_race_condition('test', 'details')
+report = Familia.thread_safety_report
+report[:summary][:race_detections]
+#=> 1
+
+## Monitor exports metrics
+Familia.thread_safety_monitor.reset_metrics
+Familia.thread_safety_monitor.record_contention('test')
+metrics = Familia.thread_safety_metrics
+metrics['familia.thread_safety.mutex_contentions']
+#=> 1
+
+## Health score starts at maximum
+Familia.thread_safety_monitor.reset_metrics
+report = Familia.thread_safety_report
+report[:health]
+#=> 100
+
+## InstrumentedMutex is used for connection chain
+conn_mutex = Familia.instance_variable_get(:@connection_chain_mutex)
+conn_mutex.is_a?(Familia::ThreadSafety::InstrumentedMutex)
+#=> true
+
+## InstrumentedMutex tracks basic operations
+mutex = Familia::ThreadSafety::InstrumentedMutex.new('test')
+mutex.synchronize { 'work' }
+stats = mutex.stats
+stats[:lock_count]
+#=> 1
+
+## Monitor time_critical_section works
+Familia.thread_safety_monitor.reset_metrics
+result = Familia.thread_safety_monitor.time_critical_section('test') { 37 }
+result
+#=> 37
+
+## Critical sections are tracked
+report = Familia.thread_safety_report
+report[:summary][:critical_sections]
+#=> 1
+
+## Monitor uses microsecond timing for precision
+Familia.thread_safety_monitor.reset_metrics
+start_μs = Familia.now_in_μs
+Familia.thread_safety_monitor.time_critical_section('timing_test') do
+  sleep 0.005  # 5ms sleep
+end
+end_μs = Familia.now_in_μs
+duration_μs = end_μs - start_μs
+# Should be at least 5000 microseconds (5ms)
+duration_μs >= 5000
+#=> true
+
+## Wait time tracking uses microsecond precision
+mutex = Familia::ThreadSafety::InstrumentedMutex.new('timing_mutex')
+Familia.thread_safety_monitor.reset_metrics
+
+# Create intentional contention with timing
+t1_ready = false
+t2_ready = false
+
+t1 = Thread.new do
+  mutex.synchronize do
+    t1_ready = true
+    sleep 0.01 while !t2_ready  # Wait for t2 to be waiting
+    sleep 0.005  # Hold lock for 5ms
+  end
+end
+
+t2 = Thread.new do
+  sleep 0.001 while !t1_ready  # Wait for t1 to acquire lock
+  t2_ready = true
+  mutex.synchronize { 'got lock' }
+end
+
+t1.join
+t2.join
+
+stats = mutex.stats
+# Should show contention occurred due to intentional delay
+stats[:contention_count] > 0
+#=> true
+
+## Monitor preserves microsecond precision
+Familia.thread_safety_monitor.reset_metrics
+Familia.thread_safety_monitor.record_contention('precision_test', 1500)  # 1500μs = 1.5ms
+
+report = Familia.thread_safety_report
+hot_spot = report[:hot_spots].first
+# Should preserve microsecond precision, not convert to seconds
+hot_spot[:avg_wait_μs]
+#=> 1500
+
+## Critical section timing uses microseconds
+Familia.thread_safety_monitor.reset_metrics
+result = Familia.thread_safety_monitor.time_critical_section('precision_timing') do
+  sleep 0.003  # 3ms
+  37
+end
+
+report = Familia.thread_safety_report
+section_perf = report[:section_performance].first
+# Total time should be in microseconds (≥3000μs for 3ms sleep)
+section_perf[:total_time_μs] >= 3000
+#=> true
+
+# teardown
+Familia.stop_monitoring!