familia 2.0.0.pre15 → 2.0.0.pre16

data/try/core/create_method_try.rb

@@ -16,7 +16,7 @@ end
 # Clean up any existing test data
 cleanup_keys = []
 begin
-  existing_test_keys = Familia.dbclient.keys('createtestmodel:*')
+  existing_test_keys = Familia.dbclient.keys('create_test_model:*')
   cleanup_keys.concat(existing_test_keys)
   Familia.dbclient.del(*existing_test_keys) if existing_test_keys.any?
 rescue => e
@@ -26,16 +26,18 @@ end
 @test_id_counter = 0
 def next_test_id
   @test_id_counter += 1
-  "create-test-#{Time.now.to_i}-#{@test_id_counter}"
+  identifier = "create-test-#{Familia.now.to_i}-#{@test_id_counter}"
+  identifier
 end
 
+@first_test_id = next_test_id
+
 # =============================================
 # 1. Basic create method functionality
 # =============================================
 
 ## create method successfully creates new object
-@test_id = next_test_id
-@created_obj = CreateTestModel.create(id: @test_id, name: 'Created Object', value: 'test_value')
+@created_obj = CreateTestModel.create(id: @first_test_id, name: 'Created Object', value: 'test_value')
 [@created_obj.class, @created_obj.exists?, @created_obj.name]
 #=> [CreateTestModel, true, 'Created Object']
 
@@ -53,27 +55,17 @@ end
 # =============================================
 
 ## create method raises RecordExistsError for duplicate
-begin
-  CreateTestModel.create(id: @test_id, name: 'Duplicate Attempt')
-  false  # Should not reach here
-rescue => e
-  e.class
-end
-#=> Familia::RecordExistsError
+CreateTestModel.create(id: @first_test_id, name: 'Duplicate Attempt')
+#=!> Familia::RecordExistsError
 
 ## RecordExistsError includes the dbkey in the message
-begin
-  CreateTestModel.create(id: @test_id, name: 'Another Duplicate')
-  false  # Should not reach here
-rescue Familia::RecordExistsError => e
-  expected_dbkey = "createtestmodel:#{@test_id}:object"
-  e.message.include?(expected_dbkey)
-end
-#=> true
+CreateTestModel.create(id: @first_test_id, name: 'Another Duplicate')
+#=!> Familia::RecordExistsError
+#==> !!error.message.match(/create_test_model:#{@first_test_id}:object/)
 
 ## RecordExistsError message follows consistent format
 begin
-  CreateTestModel.create(id: @test_id, name: 'Yet Another Duplicate')
+  CreateTestModel.create(id: @first_test_id, name: 'Yet Another Duplicate')
   false  # Should not reach here
 rescue Familia::RecordExistsError => e
   e.message.start_with?('Key already exists:')
@@ -140,12 +132,12 @@ end
 #=> true
 
 ## create failure doesn't leave partial data
-before_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+before_failed_create = Familia.dbclient.keys("create_test_model:#{@concurrent_id}:*").length
 begin
   CreateTestModel.create(id: @concurrent_id, name: 'Should Fail')
 rescue Familia::RecordExistsError
   # Should not create any additional keys
-  after_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+  after_failed_create = Familia.dbclient.keys("create_test_model:#{@concurrent_id}:*").length
   after_failed_create == before_failed_create
 end
 #=> true
@@ -236,5 +228,5 @@ instance_sees_exists = @class_created.exists?
 # =============================================
 
 # Clean up all test data
-test_keys = Familia.dbclient.keys('createtestmodel:*')
+test_keys = Familia.dbclient.keys('create_test_model:*')
 Familia.dbclient.del(*test_keys) if test_keys.any?

data/try/core/database_consistency_try.rb

@@ -28,14 +28,14 @@ end
 @test_id_counter = 0
 def next_test_id
   @test_id_counter += 1
-  "consistency-#{Time.now.to_i}-#{@test_id_counter}"
+  "consistency-#{Familia.now.to_i}-#{@test_id_counter}"
 end
 
 # =============================================
 # 1. Database Consistency Verification
 # =============================================
 
-## Redis key structure follows expected pattern
+## Valkey/Redis key structure follows expected pattern
 @key_test = ConsistencyTestModel.new(id: next_test_id, name: 'Key Test')
 @key_test.save
 dbkey = @key_test.dbkey
@@ -139,7 +139,7 @@ end
 @empty_hash.save
 
 # Manually remove all fields to create an empty hash
-# First add a temp field then remove it, which creates empty hash in some Redis versions
+# First add a temp field then remove it, which creates empty hash in some Valkey/Redis versions
 Familia.dbclient.hset(@empty_hash.dbkey, 'temp_field', 'temp_value')
 Familia.dbclient.hdel(@empty_hash.dbkey, 'temp_field')
 # Now remove all remaining fields to create truly empty hash
@@ -159,17 +159,17 @@ obj_exists_without_check = @empty_hash.exists?(check_size: false)
 @tx_test = ConsistencyTestModel.new(id: next_test_id, name: 'Transaction Test')
 @tx_test.save
 
-# Verify transaction doesn't interfere with exists? calls
-result = @tx_test.transaction do |conn|
-  # During transaction, exists? should still work
-  exists_in_tx = @tx_test.exists?
+# Verify transaction works and doesn't corrupt object state
+exists_before_tx = @tx_test.exists?
+multi_result = @tx_test.transaction do |conn|
+  # Update a field within transaction
   conn.hset(@tx_test.dbkey, 'active', 'true')
-  exists_in_tx
+  conn.hset(@tx_test.dbkey, 'processed', 'true')
 end
 
 exists_after_tx = @tx_test.exists?
-[result, exists_after_tx]
-#=> [[0], true]
+[exists_before_tx, multi_result.successful?, exists_after_tx]
+#=> [true, true, true]
 
 # =============================================
 # 4. Performance Consistency

data/try/core/errors_try.rb

@@ -26,21 +26,18 @@ rescue Familia::NonUniqueKey => e
 end
 #=> Familia::NonUniqueKey
 
-## HighRiskFactor error stores value
+## NotDistinguishableError error stores value
 begin
-  raise Familia::HighRiskFactor.new('dangerous_value')
-rescue Familia::HighRiskFactor => e
+  raise Familia::NotDistinguishableError.new('dangerous_value')
+rescue Familia::NotDistinguishableError => e
   e.value
 end
 #=> "dangerous_value"
 
-## HighRiskFactor error has custom message
-begin
-  raise Familia::HighRiskFactor.new(123)
-rescue Familia::HighRiskFactor => e
-  e.message.include?('High risk factor')
-end
-#=> true
+## NotDistinguishableError error has custom message
+raise Familia::NotDistinguishableError, 'A customized message'
+#=:> Familia::NotDistinguishableError
+#=~> /A customized message/
 
 ## NotConnected error stores URI
 test_uri = URI.parse('redis://localhost:6379')
@@ -105,7 +102,7 @@ Familia::RecordExistsError.superclass
 [
   Familia::NoIdentifier,
   Familia::NonUniqueKey,
-  Familia::HighRiskFactor,
+  Familia::NotDistinguishableError,
   Familia::NotConnected,
   Familia::KeyNotFoundError,
   Familia::RecordExistsError

data/try/core/familia_extended_try.rb

@@ -7,7 +7,7 @@ require_relative '../helpers/test_helpers'
 ## Has all datatype relativess
 registered_types = Familia::DataType.registered_types.keys
 registered_types.collect(&:to_s).sort
-#=> ["counter", "hash", "hashkey", "list", "lock", "set", "sorted_set", "string", "zset"]
+#=> ["counter", "hash", "hashkey", "list", "listkey", "lock", "set", "sorted_set", "string", "stringkey", "unsorted_set", "zset"]
 
 ## Familia created class methods for datatype list class
 Familia::Horreum::DefinitionMethods.public_method_defined? :list?
@@ -36,7 +36,7 @@ Bone.list? :owners
 ## A Familia object can get a specific datatype relatives def
 definition = Bone.list :owners
 definition.klass
-#=> Familia::List
+#=> Familia::ListKey
 
 ## Familia.now
 parsed_time = Familia.now(Time.parse('2011-04-10 20:56:20 UTC').utc)

data/try/core/familia_members_methods_try.rb

@@ -0,0 +1,76 @@
+# try/core/familia_members_methods_try.rb
+
+require_relative '../helpers/test_helpers'
+
+# Tests for new methods: demodularize, familia_name, and resolve_class
+
+# Use the testable methods from the refactored module
+String.include(Familia::Refinements::StylizeWordsMethods)
+
+## demodularize removes module namespace from simple class name
+'Customer'.demodularize
+#=> 'Customer'
+
+## demodularize removes module namespace from nested class name
+'V2::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize handles deep nesting
+'My::Deep::Nested::Module::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize handles single colon edge case
+'::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize returns original string when no modules
+'SimpleClass'.demodularize
+#=> 'SimpleClass'
+
+## familia_name returns demodularized class name for Customer
+Customer.familia_name
+#=> 'Customer'
+
+## familia_name returns demodularized class name for Session
+Session.familia_name
+#=> 'Session'
+
+## familia_name returns demodularized class name for Bone
+Bone.familia_name
+#=> 'Bone'
+
+## resolve_class returns the same class when given a Class
+Familia.resolve_class(Customer)
+#=> Customer
+
+## resolve_class finds class by string name
+Familia.resolve_class('Customer')
+#=> Customer
+
+## resolve_class finds class by symbol name
+Familia.resolve_class(:Customer)
+#=> Customer
+
+## resolve_class handles CamelCase string conversion
+Familia.resolve_class('CustomDomain')
+#=> CustomDomain
+
+## resolve_class handles snake_case symbol conversion
+Familia.resolve_class(:CustomDomain)
+#=> CustomDomain
+
+## resolve_class raises error for invalid input
+begin
+  Familia.resolve_class(123)
+rescue ArgumentError => e
+  e.message
+end
+#=> "Expected Class, String, or Symbol, got Integer"
+
+## resolve_class returns nil for unknown class name
+Familia.resolve_class('NonExistentClass')
+#=> nil
+
+## resolve_class returns nil for unknown symbol
+Familia.resolve_class(:NonExistentClass)
+#=> nil

data/try/core/isolated_dbclient_try.rb

@@ -0,0 +1,165 @@
+# try/core/isolated_dbclient_try.rb
+
+# Tryouts: Isolated connection functionality
+#
+# Tests for isolated database connections that don't interfere
+# with the cached connection pool or existing model connections.
+
+require_relative '../helpers/test_helpers'
+
+# Clean up any existing test data in all test databases
+(0..15).each do |db|
+  Familia.with_isolated_dbclient(db) do |client|
+    client.flushdb
+  end
+end
+
+## isolated_dbclient creates a new uncached connection
+client1 = Familia.isolated_dbclient(0)
+client2 = Familia.isolated_dbclient(0)
+different_objects = client1.object_id != client2.object_id
+client1.close
+client2.close
+different_objects
+#=> true
+
+## isolated_dbclient connects to the correct database
+Familia.with_isolated_dbclient(5) do |client|
+  client.set("test_key", "test_value")
+end
+
+# Verify the key was set in database 5
+found_in_db5 = Familia.with_isolated_dbclient(5) do |client|
+  client.get("test_key") == "test_value"
+end
+
+# Verify the key is NOT in database 0
+not_found_in_db0 = Familia.with_isolated_dbclient(0) do |client|
+  client.get("test_key").nil?
+end
+
+found_in_db5 && not_found_in_db0
+#=> true
+
+## isolated_dbclient doesn't affect cached connections
+# Set up a cached connection
+regular_client = Familia.dbclient(0)
+regular_client.set("cached_key", "cached_value")
+
+# Use isolated connection on same database
+isolated_result = Familia.with_isolated_dbclient(0) do |client|
+  client.set("isolated_key", "isolated_value")
+  client.get("cached_key")
+end
+
+# Both keys should be accessible
+cached_accessible = regular_client.get("cached_key") == "cached_value"
+isolated_accessible = regular_client.get("isolated_key") == "isolated_value"
+
+cached_accessible && isolated_accessible && isolated_result == "cached_value"
+#=> true
+
+## with_isolated_dbclient properly manages connection lifecycle
+# Test by verifying functionality rather than relying on GC/ObjectSpace
+captured_clients = []
+
+5.times do |i|
+  Familia.with_isolated_dbclient(i) do |client|
+    captured_clients << client
+    client.set("temp_key_#{i}", "temp_value_#{i}")
+    # Verify connection works inside block
+    client.ping
+  end
+end
+
+# Verify all connections worked and created distinct objects
+all_worked = captured_clients.size == 5
+all_distinct = captured_clients.map(&:object_id).uniq.size == 5
+keys_set = Familia.with_isolated_dbclient(0) { |c| c.exists?("temp_key_0") }
+
+all_worked && all_distinct && keys_set
+#=> true
+
+## with_isolated_dbclient handles exceptions gracefully
+exception_raised = false
+database_state_correct = false
+
+begin
+  Familia.with_isolated_dbclient(0) do |client|
+    client.set("before_error", "value")
+    raise "Test exception"
+    # This line should not be reached
+    client.set("after_error", "should_not_be_set")
+  end
+rescue => e
+  exception_raised = (e.message == "Test exception")
+end
+
+# Verify the database state after the exception was caught
+if exception_raised
+  database_state_correct = Familia.with_isolated_dbclient(0) do |client|
+    client.get("before_error") == "value" && client.get("after_error").nil?
+  end
+end
+
+exception_raised && database_state_correct
+#=> true
+
+## isolated connections don't interfere with model connections
+class TestModel < Familia::Horreum
+  logical_database 3
+  identifier_field :name
+  field :name
+end
+
+# Create a model instance
+test_model = TestModel.new(name: "test")
+test_model.save
+
+# Use isolated connection to scan a different database
+scan_result = Familia.with_isolated_dbclient(5) do |client|
+  client.keys("*")
+end
+
+# Model should still work correctly
+model_accessible = test_model.exists? && test_model.name == "test"
+# Don't rely on database 5 being empty since previous tests may have written to it
+# Just verify the model still works correctly
+scan_result_valid = scan_result.is_a?(Array)
+
+model_accessible && scan_result_valid
+#=> true
+
+# Clean up test model and class
+test_model.delete!
+Familia.unload_member(TestModel)
+
+## isolated_dbclient with Integer argument
+client = Familia.isolated_dbclient(7)
+client.set("db_test", "seven")
+result = client.get("db_test")
+client.close
+result
+#=> "seven"
+
+## isolated_dbclient with String URI argument
+client = Familia.isolated_dbclient("redis://localhost:6379/8")
+client.set("uri_test", "eight")
+result = client.get("uri_test")
+client.close
+result
+#=> "eight"
+
+## isolated_dbclient with nil uses default
+default_db = Familia.uri.db || 0
+client = Familia.isolated_dbclient(nil)
+client.set("default_test", "default_value")
+
+# Verify it's in the expected database
+verification = Familia.with_isolated_dbclient(default_db) do |verify_client|
+  verify_client.get("default_test")
+end
+
+client.close
+verification
+#=> "default_value"

data/try/core/middleware_try.rb

@@ -1,11 +1,11 @@
 # try/core/middleware_try.rb
 
-# Test Redis middleware components
-# Mock Redis client with middleware for testing
+# Test Valkey/Redis middleware components
+# Mock Valkey/Redis client with middleware for testing
 
 require_relative '../helpers/test_helpers'
 
-class MockRedis
+class MockDatabase
   attr_reader :logged_commands
 
   def initialize
@@ -19,40 +19,40 @@ class MockRedis
   private
 
   def log_command(cmd, *args)
-    start_time = Time.now
+    start_time = Familia.now
     result = yield
-    duration = Time.now - start_time
+    duration = Familia.now - start_time
     @logged_commands << { command: cmd, args: args, duration: duration }
     result
   end
 end
 
-## MockRedis can log commands with timing
-redis = MockRedis.new
-result = redis.get("test_key")
-[result, redis.logged_commands.length, redis.logged_commands.first[:command]]
+## MockDatabase can log commands with timing
+dbclient = MockDatabase.new
+result = dbclient.get("test_key")
+[result, dbclient.logged_commands.length, dbclient.logged_commands.first[:command]]
 #=> ["test_value", 1, "GET"]
 
-## RedisCommandCounter tracks command metrics (if available)
+## DatabaseCommandCounter tracks command metrics (if available)
 begin
-  counter = RedisCommandCounter.new
+  counter = DatabaseCommandCounter.new
   counter.increment("GET")
   counter.increment("SET")
   counter.increment("GET")
   [counter.count("GET"), counter.count("SET"), counter.total]
 rescue NameError
-  # Skip if RedisCommandCounter not available
+  # Skip if DatabaseCommandCounter not available
   [2, 1, 3]
 end
 #=> [2, 1, 3]
 
 ## Command counting utility works (if available)
 begin
-  redis = Familia.dbclient
+  dbclient = Familia.dbclient
   count = count_commands do
-    redis.set("test_key", "value")
-    redis.get("test_key")
-    redis.del("test_key")
+    dbclient.set("test_key", "value")
+    dbclient.get("test_key")
+    dbclient.del("test_key")
   end
   count >= 3
 rescue NameError, NoMethodError

data/try/core/persistence_operations_try.rb

@@ -26,7 +26,7 @@ end
 @test_id_counter = 0
 def next_test_id
   @test_id_counter += 1
-  "test-#{Time.now.to_i}-#{@test_id_counter}"
+  "test-#{Familia.now.to_i}-#{@test_id_counter}"
 end
 
 # =============================================
@@ -95,11 +95,11 @@ second_save = @idempotent_obj.save
 
 ## Save with partial field data
 @partial_obj = PersistenceTestModel.new(id: next_test_id)
-@partial_obj.name = 'Only Name Set'
+@partial_obj.name = 'Only Name UnsortedSet'
 # value field is nil/unset
 result = @partial_obj.save
 [result, @partial_obj.exists?, @partial_obj.name]
-#=> [true, true, 'Only Name Set']
+#=> [true, true, 'Only Name UnsortedSet']
 
 # =============================================
 # 3. save_if_not_exists Method Coverage
@@ -141,7 +141,7 @@ end
 # 4. create Method Coverage (MISSING from current tests)
 # =============================================
 
-# NOTE: create method tests disabled due to Redis::Future bug
+# NOTE: create method tests disabled due to Valkey/Redis::Future bug
 # This would be high-priority coverage but needs the create method bug fixed first
 
 ## create method alternative: manual creation simulation

data/try/core/pools_try.rb

@@ -51,10 +51,28 @@ class PoolTestSession < Familia::Horreum
 
   def init
     @session_id ||= SecureRandom.hex(8)
-    @created_at ||= Time.now.to_i
+    @created_at ||= Familia.now.to_i
   end
 end
 
+class PoolTestAccountDB1 < Familia::Horreum
+  logical_database 1
+  identifier_field :account_id
+  field :account_id
+  field :balance, on_conflict: :skip
+  field :holder_name
+
+  def init
+    @account_id ||= SecureRandom.hex(6)
+    @balance = @balance.to_f if @balance
+  end
+
+  def balance
+    @balance&.to_f
+  end
+end
+
+
 ## Clean up before tests
 PoolTestAccount.dbclient.flushdb
 #=> "OK"
@@ -79,23 +97,6 @@ Familia.connection_provider.is_a?(Proc)
 #=> true
 
 ## Test 5: Account in DB 1 via class configuration
-class PoolTestAccountDB1 < Familia::Horreum
-  self.logical_database = 1
-  identifier_field :account_id
-  field :account_id
-  field :balance, on_conflict: :skip
-  field :holder_name
-
-  def init
-    @account_id ||= SecureRandom.hex(6)
-    @balance = @balance.to_f if @balance
-  end
-
-  def balance
-    @balance&.to_f
-  end
-end
-
 @account_db1 = PoolTestAccountDB1.new(balance: 750, holder_name: "Charlie")
 @account_db1.save
 #=> true
@@ -140,8 +141,8 @@ threads.each(&:join)
   # Test that transaction connection is available
   conn.ping
 end
-# Transaction returns array with results
-@transfer_result.first
+# Transaction returns MultiResult with success status and results
+@transfer_result.results.first
 #=> "PONG"
 
 ## Test 12: Transaction block executes properly
@@ -149,19 +150,19 @@ end
 [@account_a.balance, @account_b.balance]
 #=> [1000.0, 500.0]
 
-## Test 13: with_connection method
-@connection_test_result = Familia.with_connection do |conn|
+## Test 13: with_dbclient method
+@connection_test_result = Familia.with_dbclient do |conn|
   conn.set("test_key_#{SecureRandom.hex(4)}", "test_value")
 end
 @connection_test_result
 #=> "OK"
 
 ## Test 14: Pipeline operations with connection pool
-@pipeline_results = Familia.pipeline do |conn|
+@pipeline_results = Familia.pipelined do |conn|
   conn.ping
 end
 # Pipeline executes successfully
-@pipeline_results.first
+@pipeline_results.results.first
 #=> "PONG"
 
 ## Test 15: Multi/EXEC operations with connection pool
@@ -169,7 +170,7 @@ end
   conn.ping
 end
 # Multi/EXEC executes successfully
-@multi_results.first
+@multi_results.results.first
 #=> "PONG"
 
 ## Test 16: Error handling in transactions
@@ -208,7 +209,7 @@ timeout_mutex = Mutex.new
 3.times do |i|
   timeout_threads << Thread.new do
     begin
-      result = Familia.with_connection do |conn|
+      result = Familia.with_dbclient do |conn|
         sleep(0.1)  # Brief hold
         conn.ping
       end
@@ -270,4 +271,19 @@ Familia.connection_provider = original_provider
 @captured_uris.any? { |uri| uri.include?('redis://') }
 #=> true
 
+## Check PoolTestAccountDB1 config name
+PoolTestAccountDB1.config_name
+#=> 'pool_test_account_db1'
+
+
 puts "Connection pool tests completed successfully!"
+
+# Teardown
+Familia.connection_provider = nil
+Fiber[:familia_connection] = nil
+Fiber[:familia_connection_handler_class] = nil
+Fiber[:familia_transaction] = nil
+Fiber[:familia_pipeline] = nil
+Fiber[:familia_key_cache] = nil
+Fiber[:familia_request_cache] = nil
+Fiber[:familia_request_cache_enabled] = nil