familia 2.0.0.pre15 → 2.0.0.pre17

data/try/connection/transaction_mode_strict_try.rb

@@ -0,0 +1,98 @@
+# Transaction Mode: Strict Tryouts
+#
+# Tests strict transaction mode behavior where operations fail fast
+# when connection handlers don't support transactions.
+#
+# Strict mode: Raises OperationModeError when transaction unavailable
+
+require_relative '../helpers/test_helpers'
+
+# Test class for strict mode testing
+class StrictModeTestCustomer < Familia::Horreum
+  identifier_field :custid
+  field :custid
+  field :name
+end
+
+## Strict mode can be configured
+Familia.configure { |config| config.transaction_mode = :strict }
+Familia.transaction_mode
+#=> :strict
+
+## Strict mode raises error with CachedConnectionHandler
+
+# Force CachedConnectionHandler
+StrictModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+customer = StrictModeTestCustomer.new(custid: 'strict_test')
+customer.transaction do |conn|
+  conn.hset(customer.dbkey, 'name', 'Should Not Work')
+end
+
+#=:> Familia::OperationModeError
+#=~> /Cannot start transaction with/
+#=~> /CachedConnectionHandler/
+
+## Clear the dbclient instance var
+StrictModeTestCustomer.remove_instance_variable(:@dbclient)
+#=*>
+
+## Strict mode raises error with FiberConnectionHandler
+begin
+  # Simulate middleware connection
+  Fiber[:familia_connection] = [Customer.create_dbclient, Familia.middleware_version]
+  Fiber[:familia_connection_handler_class] = Familia::Connection::FiberConnectionHandler
+  customer = StrictModeTestCustomer.new(custid: 'fiber_test')
+  customer.transaction { |conn| conn.set('test', 'value') }
+  false
+rescue Familia::OperationModeError => e
+  e.message.include?('FiberConnectionHandler')
+ensure
+  Fiber[:familia_connection] = nil
+  Fiber[:familia_connection_handler_class] = nil
+end
+#=> true
+
+## Strict mode allows normal transactions with CreateConnectionHandler
+begin
+  customer = StrictModeTestCustomer.new(custid: 'normal_test')
+  result = customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'type', 'normal transaction')
+    conn.hget(customer.dbkey, 'type')
+  end
+  result.is_a?(MultiResult) && result.results.last == 'normal transaction'
+end
+#=> true
+
+## Strict mode works with ProviderConnectionHandler
+original_provider = Familia.connection_provider
+begin
+  Familia.connection_provider = ->(uri) { Redis.new(url: uri) }
+  customer = StrictModeTestCustomer.new(custid: 'provider_test')
+  result = customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'source', 'provider')
+    conn.hget(customer.dbkey, 'source')
+  end
+  result.is_a?(MultiResult) && result.results.last == 'provider'
+ensure
+  Familia.connection_provider = original_provider
+end
+#=> true
+
+## Global transactions respect strict mode with cached connections
+begin
+  # Set a cached connection on the Familia module itself would be complex
+  # Instead test that cached connections on models affect their transactions
+  StrictModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = StrictModeTestCustomer.new(custid: 'global_strict_test')
+  customer.transaction do |conn|
+    conn.set('should_fail', 'value')
+  end
+  false
+rescue Familia::OperationModeError
+  true
+ensure
+  StrictModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true

data/try/connection/transaction_mode_warn_try.rb

@@ -0,0 +1,131 @@
+# Transaction Mode: Warn Tryouts
+#
+# Tests warn transaction mode behavior where operations log a warning
+# and execute commands individually when transactions are unavailable.
+#
+# Warn mode: Logs warning and uses IndividualCommandProxy for fallback
+
+require_relative '../helpers/test_helpers'
+
+# Test class for warn mode testing
+class WarnModeTestCustomer < Familia::Horreum
+  identifier_field :custid
+  field :custid
+  field :name
+  field :email
+end
+
+## Warn mode can be configured
+Familia.configure { |config| config.transaction_mode = :warn }
+Familia.transaction_mode
+#=> :warn
+
+## Warn mode executes individual commands with CachedConnectionHandler
+begin
+  # Force CachedConnectionHandler
+  WarnModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = WarnModeTestCustomer.new(custid: 'warn_test')
+  result = customer.transaction do |conn|
+    # Should be IndividualCommandProxy
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'name', 'Warn Mode Works') &&
+    conn.hget(customer.dbkey, 'name')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'Warn Mode Works'
+ensure
+  WarnModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Warn mode executes individual commands with FiberConnectionHandler
+begin
+  # Simulate middleware connection
+  Fiber[:familia_connection] = [Customer.create_dbclient, Familia.middleware_version]
+  Fiber[:familia_connection_handler_class] = Familia::Connection::FiberConnectionHandler
+  customer = WarnModeTestCustomer.new(custid: 'fiber_warn_test')
+
+  result = customer.transaction do |conn|
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'source', 'fiber_warn') &&
+    conn.hget(customer.dbkey, 'source')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'fiber_warn'
+ensure
+  Fiber[:familia_connection] = nil
+  Fiber[:familia_connection_handler_class] = nil
+end
+#=> true
+
+## Warn mode still uses normal transactions with CreateConnectionHandler
+begin
+  customer = WarnModeTestCustomer.new(custid: 'normal_warn_test')
+  result = customer.transaction do |conn|
+    # Should be Redis::MultiConnection for normal transactions
+    conn.class == Redis::MultiConnection &&
+    conn.hset(customer.dbkey, 'type', 'normal in warn mode') &&
+    conn.hget(customer.dbkey, 'type')
+  end
+  result.is_a?(MultiResult) && result.results.last == 'normal in warn mode'
+end
+#=> true
+
+## IndividualCommandProxy collects results correctly in warn mode
+begin
+  WarnModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = WarnModeTestCustomer.new(custid: 'proxy_warn_test')
+  result = customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'field1', 'value1')
+    conn.hset(customer.dbkey, 'field2', 'value2')
+    conn.hget(customer.dbkey, 'field1')
+    conn.hget(customer.dbkey, 'field2')
+  end
+
+  # Check that results are collected properly
+  result.is_a?(MultiResult) &&
+  result.results.size == 4 &&
+  result.results.include?('value1') &&
+  result.results.include?('value2')
+ensure
+  WarnModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Save operations work in warn mode with fallback
+begin
+  WarnModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = WarnModeTestCustomer.new(
+    custid: 'save_warn_test',
+    name: 'Save Test User',
+    email: 'save@example.com'
+  )
+
+  # Save should work using individual commands
+  save_result = customer.save
+  save_result && customer.exists?
+ensure
+  WarnModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Model transactions respect warn mode with cached connections
+begin
+  # Test that cached connections on models respect warn mode
+  WarnModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = WarnModeTestCustomer.new(custid: 'model_warn_test')
+  result = customer.transaction do |conn|
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'mode', 'warn_fallback') &&
+    conn.hget(customer.dbkey, 'mode')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'warn_fallback'
+ensure
+  WarnModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true

data/try/connection/transaction_modes_try.rb

@@ -0,0 +1,249 @@
+# Transaction Modes Tryouts
+#
+# Tests the configurable transaction mode system that provides graceful fallback
+# when connection handlers don't support transactions. Three modes available:
+#
+# - :strict (default): Raise OperationModeError when transaction unavailable
+# - :warn: Log warning and execute commands individually with IndividualCommandProxy
+# - :permissive: Silently execute commands individually
+#
+# The IndividualCommandProxy executes Redis commands immediately instead of queuing
+# them in a transaction, maintaining the same MultiResult interface for consistency.
+
+require_relative '../helpers/test_helpers'
+
+# Setup - ensure clean state
+@original_transaction_mode = Familia.transaction_mode
+@test_customer_class = nil
+
+# Create a test customer class for isolation
+class TransactionModeTestCustomer < Familia::Horreum
+  identifier_field :custid
+  field :custid
+  field :name
+  field :email
+end
+
+## Default transaction mode is warn (user-friendly)
+Familia.transaction_mode
+#=> :warn
+
+## Transaction mode can be configured to warn
+Familia.configure do |config|
+  config.transaction_mode = :warn
+end
+Familia.transaction_mode
+#=> :warn
+
+## Transaction mode can be configured to permissive
+Familia.configure do |config|
+  config.transaction_mode = :permissive
+end
+Familia.transaction_mode
+#=> :permissive
+
+## Reset to strict mode for remaining tests
+Familia.configure { |config| config.transaction_mode = :strict }
+
+## Strict mode raises error with CachedConnectionHandler
+begin
+  # Ensure we're in strict mode first
+  Familia.configure { |config| config.transaction_mode = :strict }
+
+  # Force CachedConnectionHandler by setting @dbclient
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'strict_test')
+  customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'name', 'Should Not Work')
+  end
+  false  # Should not reach here
+rescue Familia::OperationModeError => e
+  e.message.include?('Cannot start transaction with') && e.message.include?('CachedConnectionHandler')
+ensure
+  # Clean up cached connection
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Warn mode logs warning and executes individual commands
+begin
+  Familia.configure { |config| config.transaction_mode = :warn }
+
+  # Force CachedConnectionHandler
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'warn_test')
+
+  # Capture log output would be ideal, but test the core functionality
+  result = customer.transaction do |conn|
+    # This should be an IndividualCommandProxy
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'name', 'Warn Mode Works') &&
+    conn.hget(customer.dbkey, 'name')
+  end
+
+  # Should return MultiResult with individual command results
+  result.is_a?(MultiResult) && result.results.last == 'Warn Mode Works'
+ensure
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Permissive mode silently executes individual commands
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # Force CachedConnectionHandler
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'permissive_test')
+
+  result = customer.transaction do |conn|
+    # Should be IndividualCommandProxy
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'email', 'permissive@example.com') &&
+    conn.hget(customer.dbkey, 'email')
+  end
+
+  # Should return MultiResult
+  result.is_a?(MultiResult) && result.results.last == 'permissive@example.com'
+ensure
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Normal transactions still work with CreateConnectionHandler
+begin
+  customer = TransactionModeTestCustomer.new(custid: 'normal_test')
+
+  result = customer.transaction do |conn|
+    # Should be Redis::MultiConnection for normal transactions
+    conn.class == Redis::MultiConnection &&
+    conn.hset(customer.dbkey, 'type', 'normal transaction') &&
+    conn.hget(customer.dbkey, 'type')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'normal transaction'
+end
+#=> true
+
+## IndividualCommandProxy collects results correctly
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'proxy_test')
+
+  result = customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'field1', 'value1')
+    conn.hget(customer.dbkey, 'field1')
+  end
+
+  # Check that results are collected and it's a MultiResult
+  result.is_a?(MultiResult) && result.results.size >= 2
+ensure
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## MultiResult success detection works with individual commands
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'success_test')
+
+  result = customer.transaction do |conn|
+    conn.hset(customer.dbkey, 'status', 'active')  # Returns 1
+  end
+
+  # Should be successful since 1 is considered success
+  result.successful?
+ensure
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Global transaction methods also respect transaction modes
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # Force a handler that doesn't support transactions
+  original_provider = Familia.connection_provider
+  test_connection = Familia.create_dbclient
+  Familia.connection_provider = ->(_uri) { test_connection }
+
+  # Global transaction should also fallback
+  result = Familia.transaction do |conn|
+    conn.set('global_test_key', 'global_test_value')
+    conn.get('global_test_key')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'global_test_value'
+ensure
+  Familia.connection_provider = original_provider
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Transaction fallback preserves connection context
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # Test with logical database setting
+  class DatabaseTestCustomer < Familia::Horreum
+    logical_database 5
+    identifier_field :custid
+    field :custid
+  end
+
+  DatabaseTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+  customer = DatabaseTestCustomer.new(custid: 'db_test')
+
+  result = customer.transaction do |conn|
+    # Commands should execute on the correct database
+    conn.set('db_test_key', 'db_test_value')
+    conn.get('db_test_key')
+  end
+
+  result.results.last == 'db_test_value'
+ensure
+  DatabaseTestCustomer.remove_instance_variable(:@dbclient) if DatabaseTestCustomer.instance_variable_defined?(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Transaction modes work with nested calls
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  TransactionModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = TransactionModeTestCustomer.new(custid: 'nested_test')
+
+  # Test that nested transactions work
+  outer_result = customer.transaction do |outer_conn|
+    outer_conn.hset(customer.dbkey, 'outer', 'value')
+
+    inner_result = customer.transaction do |inner_conn|
+      inner_conn.hset(customer.dbkey, 'inner', 'nested')
+    end
+
+    # Inner transaction should return MultiResult
+    inner_result.is_a?(MultiResult)
+  end
+
+  # Outer transaction should also return MultiResult
+  outer_result.is_a?(MultiResult)
+ensure
+  TransactionModeTestCustomer.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+# Cleanup - restore original transaction mode
+Familia.configure { |config| config.transaction_mode = @original_transaction_mode }

data/try/core/autoloader_try.rb

@@ -1,10 +1,30 @@
 # try/core/autoloader_try.rb
 
+# Tests for Familia::Features::Autoloader
+#
+# TESTING STRATEGY:
+# Autoloading is inherently tricky to test because:
+# 1. Files are loaded once and cached by Ruby's require system
+# 2. We need to simulate different directory structures
+# 3. We need to verify that files are actually loaded (not just found)
+#
+# SOLUTION:
+# Use temporary directories with Dir.mktmpdir to create isolated test
+# environments and write test files that set global variables when
+# loaded ($test_feature_loaded = true). Globals are reset before each
+# test and FileUtils.rm_rf to clean up temp directories after each test.
+#
+# This approach allows us to:
+# - Test actual file loading behavior (not just glob patterns) that verify
+# the directory patterns that autoloader.included generates and also the
+# exclusion logic works correctly.
+
 require_relative '../../lib/familia'
 require 'fileutils'
 require 'tmpdir'
 
-# Create test directory structure for Autoloader testing
+# SETUP: Create test directory structure for basic autoloader testing
+# This simulates the lib/familia/features/ directory structure
 @test_dir = Dir.mktmpdir('familia_autoloader_test')
 @features_dir = File.join(@test_dir, 'features')
 @test_file1 = File.join(@features_dir, 'test_feature1.rb')
@@ -52,6 +72,7 @@ $test_feature1_loaded && $test_feature2_loaded
 #=> true
 
 ## Test that autoload_files respects exclusions (using fresh files)
+# Create a separate test environment to avoid conflicts with cached requires
 @exclude_test_dir = Dir.mktmpdir('familia_autoloader_exclude_test')
 @exclude_features_dir = File.join(@exclude_test_dir, 'features')
 @include_file = File.join(@exclude_features_dir, 'include_me.rb')
@@ -74,6 +95,7 @@ $include_me_loaded && !$exclude_me_loaded
 #=> true
 
 ## Test autoload_files with array of patterns (using fresh files)
+# Test that multiple glob patterns can be processed in a single call
 @pattern_test_dir = Dir.mktmpdir('familia_autoloader_pattern_test')
 @pattern_dir1 = File.join(@pattern_test_dir, 'dir1')
 @pattern_dir2 = File.join(@pattern_test_dir, 'dir2')
@@ -102,11 +124,107 @@ $pattern1_loaded && $pattern2_loaded
   include Familia::Features::Autoloader
 end
 
-# The Features module already includes Autoloader, so test indirectly
+## The Features module already includes Autoloader, so test indirectly
 Familia::Features.ancestors.include?(Familia::Features::Autoloader)
 #=> true
 
+## Test normalize_to_config_name method exists
+# This method was added to fix issues with namespaced classes after commit d319d9d
+# moved the namespace splitting logic from snake_case to config_name
+Familia::Features::Autoloader.respond_to?(:normalize_to_config_name)
+#=> true
+
+## Test normalize_to_config_name with simple class name
+Familia::Features::Autoloader.normalize_to_config_name('Customer')
+#=> 'customer'
+
+## Test normalize_to_config_name with PascalCase class name
+Familia::Features::Autoloader.normalize_to_config_name('ApiTestUser')
+#=> 'api_test_user'
+
+## Test normalize_to_config_name with namespaced class name (single level)
+Familia::Features::Autoloader.normalize_to_config_name('V2::Customer')
+#=> 'customer'
+
+## Test normalize_to_config_name with deeply namespaced class name
+Familia::Features::Autoloader.normalize_to_config_name('My::Deep::Nested::Module::ApiTestUser')
+#=> 'api_test_user'
+
+## Test normalize_to_config_name with leading double colon
+Familia::Features::Autoloader.normalize_to_config_name('::Customer')
+#=> 'customer'
+
+## Test normalize_to_config_name handles edge case with anonymous class representation
+Familia::Features::Autoloader.normalize_to_config_name('#<Class:0x0001991a8>::ApiTestUser')
+#=> 'api_test_user'
+
+## Test that autoloader directory patterns work with namespaced classes
+# This tests the core fix: ensuring that namespaced classes like TestNamespace::ApiTestModule
+# correctly generate directory patterns using only the demodularized name (api_test_module)
+# rather than the full namespaced name
+# Create a test directory structure that simulates what would happen
+# when a namespaced class includes the autoloader
+@namespace_pattern_test_dir = Dir.mktmpdir('familia_autoloader_namespace_test')
+@base_path = @namespace_pattern_test_dir
+@config_name = 'api_test_module'  # This would be the result of normalize_to_config_name
+
+# Create directory structure for different patterns
+@features_global_dir = File.join(@base_path, 'features')
+@features_config_dir = File.join(@base_path, @config_name, 'features')
+@features_file = File.join(@base_path, @config_name, 'features.rb')
+
+FileUtils.mkdir_p(@features_global_dir)
+FileUtils.mkdir_p(@features_config_dir)
+
+# Write test files for each pattern
+@global_feature = File.join(@features_global_dir, 'global_feature.rb')
+@config_feature = File.join(@features_config_dir, 'config_feature.rb')
+
+File.write(@global_feature, '$global_feature_loaded = true')
+File.write(@config_feature, '$config_feature_loaded = true')
+File.write(@features_file, '$features_file_loaded = true')
+
+# These are the exact patterns that autoloader.included generates:
+# 1. Global features dir: base_path/features/*.rb
+# 2. Config-specific features dir: base_path/config_name/features/*.rb
+# 3. Config-specific features file: base_path/config_name/features.rb
+@dir_patterns = [
+  File.join(@base_path, 'features', '*.rb'),
+  File.join(@base_path, @config_name, 'features', '*.rb'),
+  File.join(@base_path, @config_name, 'features.rb'),
+]
+# Verify all three patterns are correctly constructed
+@dir_patterns.length
+#=> 3
+
+# Reset test flags - critical for testing actual file loading behavior
+$global_feature_loaded = false
+$config_feature_loaded = false
+$features_file_loaded = false
+
+## Test that global features pattern matches correctly
+Dir.glob(@dir_patterns[0]).length
+#=> 1
+
+## Test that config-specific features pattern matches correctly
+Dir.glob(@dir_patterns[1]).length
+#=> 1
+
+## Test that config-specific features.rb file exists
+File.exist?(@dir_patterns[2])
+#=> true
+
+## Test loading all patterns simulates autoloader.included behavior
+# This simulates what happens when a class includes Familia::Features::Autoloader
+# All three file patterns should be processed and their contents loaded
+Familia::Features::Autoloader.autoload_files(@dir_patterns)
+
+# Verify all three test files were actually loaded (not just found)
+$global_feature_loaded && $config_feature_loaded && $features_file_loaded
+#=> true
+
 # Cleanup test files and directories
 FileUtils.rm_rf(@test_dir)
 FileUtils.rm_rf(@exclude_test_dir)
 FileUtils.rm_rf(@pattern_test_dir)
+FileUtils.rm_rf(@namespace_pattern_test_dir)

data/try/core/connection_try.rb

@@ -12,31 +12,31 @@ Familia.uri
 
 ## Default URI points to localhost database server
 Familia.uri.to_s
-#=> "redis://127.0.0.1"
+#=> "redis://127.0.0.1:2525"
 
 ## Can parse URI from string
-uri = URI.parse('redis://localhost:6379/1')
+uri = URI.parse('redis://localhost:2525/1')
 uri.host
 #=> "localhost"
 
 ## Can establish Database connection
+Familia.create_dbclient
+#=:> Redis
+
+## Can establish Database connection with deprecated method
 Familia.connect
 #=:> Redis
 
-## Can connect to different URI
+## Can create connection to different URI
 ## Doesn't confirm the logical DB number, dbclient.options raises an error?
-test_uri = 'redis://localhost:6379/2'
-Familia.connect(test_uri)
+test_uri = 'redis://localhost:2525/2'
+Familia.create_dbclient(test_uri)
 #=:> Redis
 
 ## Database client responds to basic commands
 Familia.dbclient.ping
 #=> "PONG"
 
-## Multiple connections are managed separately
-Familia.database_clients.size >= 1
-#=> true
-
 ## Can enable Database logging
 Familia.enable_database_logging = true
 Familia.enable_database_logging
@@ -48,7 +48,7 @@ Familia.enable_database_counter
 #=> true
 
 ## Middleware gets registered when enabled
-dbclient = Familia.connect('redis://localhost:6379/3')
+dbclient = Familia.create_dbclient('redis://localhost:2525/2')
 dbclient.ping
 #=> "PONG"