familia 2.0.0.pre17 → 2.0.0.pre19

data/try/integration/data_types/datatype_transactions_try.rb

@@ -0,0 +1,247 @@
+# DataType Transaction Support Tryouts
+#
+# Tests transaction support for DataType objects, covering both parent-owned
+# DataTypes (delegating to parent) and standalone DataTypes (managing their
+# own connections). Validates atomic operations, connection context handling,
+# and integration with the transaction mode system.
+
+require_relative '../../support/helpers/test_helpers'
+
+# Setup - Create test model with various DataType fields
+class TransactionTestUser < Familia::Horreum
+  logical_database 2
+  identifier_field :userid
+  field :userid
+  field :name
+  field :email
+
+  # Instance-level DataTypes
+  sorted_set :scores
+  hashkey :profile
+  set :tags
+  list :activity
+  counter :visits
+  string :bio
+end
+
+@user = TransactionTestUser.new(userid: 'txn_user_001')
+@user.name = 'Transaction Tester'
+@user.save
+
+## Parent-owned SortedSet can execute transaction
+result = @user.scores.transaction do |conn|
+  conn.zadd(@user.scores.dbkey, 100, 'level1')
+  conn.zadd(@user.scores.dbkey, 200, 'level2')
+  conn.zadd(@user.scores.dbkey, 300, 'level3')
+end
+[result.is_a?(MultiResult), @user.scores.members.sort]
+#=> [true, ["level1", "level2", "level3"]]
+
+## Parent-owned HashKey can execute transaction
+result = @user.profile.transaction do |conn|
+  conn.hset(@user.profile.dbkey, 'city', 'San Francisco')
+  conn.hset(@user.profile.dbkey, 'country', 'USA')
+  conn.hget(@user.profile.dbkey, 'city')
+end
+[result.is_a?(MultiResult), result.results.last, @user.profile['country']]
+#=> [true, "San Francisco", "USA"]
+
+## Parent-owned UnsortedSet can execute transaction
+result = @user.tags.transaction do |conn|
+  conn.sadd(@user.tags.dbkey, 'ruby')
+  conn.sadd(@user.tags.dbkey, 'redis')
+  conn.scard(@user.tags.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last, @user.tags.members.sort]
+#=> [true, 2, ["redis", "ruby"]]
+
+## Parent-owned List can execute transaction
+result = @user.activity.transaction do |conn|
+  conn.rpush(@user.activity.dbkey, 'login')
+  conn.rpush(@user.activity.dbkey, 'view_profile')
+  conn.rpush(@user.activity.dbkey, 'logout')
+  conn.llen(@user.activity.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last, @user.activity.members]
+#=> [true, 3, ["login", "view_profile", "logout"]]
+
+## Parent-owned Counter can execute transaction
+result = @user.visits.transaction do |conn|
+  conn.set(@user.visits.dbkey, 0)
+  conn.incr(@user.visits.dbkey)
+  conn.incr(@user.visits.dbkey)
+  conn.get(@user.visits.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last.to_i, @user.visits.value]
+#=> [true, 2, 2]
+
+## Parent-owned StringKey can execute transaction
+result = @user.bio.transaction do |conn|
+  conn.set(@user.bio.dbkey, 'Ruby developer')
+  conn.append(@user.bio.dbkey, ' and Redis enthusiast')
+  conn.get(@user.bio.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last, @user.bio.value]
+#=> [true, "Ruby developer and Redis enthusiast", "Ruby developer and Redis enthusiast"]
+
+## Standalone SortedSet can execute transaction
+leaderboard = Familia::SortedSet.new('game:leaderboard')
+leaderboard.delete!
+result = leaderboard.transaction do |conn|
+  conn.zadd(leaderboard.dbkey, 500, 'player1')
+  conn.zadd(leaderboard.dbkey, 600, 'player2')
+  conn.zadd(leaderboard.dbkey, 450, 'player3')
+  conn.zcard(leaderboard.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last, leaderboard.members.size]
+#=> [true, 3, 3]
+
+## Standalone HashKey can execute transaction
+cache = Familia::HashKey.new('app:cache')
+cache.delete!
+result = cache.transaction do |conn|
+  conn.hset(cache.dbkey, 'key1', 'value1')
+  conn.hset(cache.dbkey, 'key2', 'value2')
+  conn.hkeys(cache.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last.sort, cache.keys.sort]
+#=> [true, ["key1", "key2"], ["key1", "key2"]]
+
+## Standalone UnsortedSet can execute transaction
+global_tags = Familia::UnsortedSet.new('app:tags')
+global_tags.delete!
+result = global_tags.transaction do |conn|
+  conn.sadd(global_tags.dbkey, 'tag1')
+  conn.sadd(global_tags.dbkey, 'tag2')
+  conn.smembers(global_tags.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last.sort, global_tags.members.sort]
+#=> [true, ["tag1", "tag2"], ["tag1", "tag2"]]
+
+## Standalone StringKey can execute transaction
+session_data = Familia::StringKey.new('session:abc123')
+session_data.delete!
+result = session_data.transaction do |conn|
+  conn.set(session_data.dbkey, '{"user_id": 123}')
+  conn.expire(session_data.dbkey, 3600)
+  conn.get(session_data.dbkey)
+end
+[result.is_a?(MultiResult), result.results.last, session_data.value]
+#=> [true, "{\"user_id\": 123}", "{\"user_id\": 123}"]
+
+## Transaction with logical_database option works
+custom_cache = Familia::HashKey.new('custom:cache', logical_database: 3)
+custom_cache.delete!
+result = custom_cache.transaction do |conn|
+  conn.hset(custom_cache.dbkey, 'setting', 'enabled')
+  conn.hget(custom_cache.dbkey, 'setting')
+end
+[result.is_a?(MultiResult), result.results.last]
+#=> [true, "enabled"]
+
+## Transaction provides correct connection object type
+conn_class = nil
+@user.scores.transaction do |conn|
+  conn_class = conn.class.name
+end
+conn_class
+#=> "Redis::MultiConnection"
+
+## Transaction with direct_access works correctly
+result = @user.profile.transaction do |trans_conn|
+  trans_conn.hset(@user.profile.dbkey, 'status', 'active')
+
+  # direct_access should use the same transaction connection
+  @user.profile.direct_access do |conn, key|
+    conn.object_id == trans_conn.object_id &&
+    conn.hset(key, 'verified', 'true')
+  end
+end
+[@user.profile['status'], @user.profile['verified']]
+#=> ["active", "true"]
+
+## Transaction atomicity - all commands succeed or none
+test_zset = Familia::SortedSet.new('atomic:test')
+test_zset.delete!
+test_zset.add('initial', 1)
+
+begin
+  test_zset.transaction do |conn|
+    conn.zadd(test_zset.dbkey, 100, 'member1')
+    conn.zadd(test_zset.dbkey, 200, 'member2')
+    raise 'Intentional error to test rollback'
+  end
+rescue => e
+  # Transaction should have rolled back
+  test_zset.members
+end
+#=> ["initial"]
+
+## Nested transactions with parent-owned DataTypes work
+outer_result = @user.scores.transaction do |outer_conn|
+  outer_conn.zadd(@user.scores.dbkey, 999, 'outer_member')
+
+  inner_result = @user.tags.transaction do |inner_conn|
+    inner_conn.sadd(@user.tags.dbkey, 'nested_tag')
+  end
+
+  inner_result.is_a?(MultiResult)
+end
+[outer_result.is_a?(MultiResult), @user.tags.member?('nested_tag')]
+#=> [true, true]
+
+## Transaction respects transaction modes (permissive)
+begin
+  original_mode = Familia.transaction_mode
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # Force a cached connection to trigger fallback
+  @user.class.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  result = @user.scores.transaction do |conn|
+    # Should be IndividualCommandProxy in fallback mode
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.zadd(@user.scores.dbkey, 888, 'fallback_test')
+  end
+
+  result.is_a?(MultiResult)
+ensure
+  @user.class.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = original_mode }
+end
+#=> true
+
+## Transaction with empty block returns empty MultiResult
+result = @user.scores.transaction { |conn| }
+[result.is_a?(MultiResult), result.results.empty?]
+#=> [true, true]
+
+## Transaction connection uses parent's logical_database
+# TransactionTestUser has logical_database 2
+# Parent-owned DataType delegates to parent, verify via class setting
+@user.scores.delete!
+@user.scores.transaction do |conn|
+  conn.zadd(@user.scores.dbkey, 1, 'test_member')
+end
+TransactionTestUser.logical_database
+#=> 2
+
+## Multiple DataType types in single transaction
+result = @user.scores.transaction do |conn|
+  # Can operate on different DataTypes using same connection
+  conn.zadd(@user.scores.dbkey, 777, 'multi_test')
+  conn.hset(@user.profile.dbkey, 'multi', 'yes')
+  conn.sadd(@user.tags.dbkey, 'multi_tag')
+  conn.rpush(@user.activity.dbkey, 'multi_action')
+end
+[
+  result.is_a?(MultiResult),
+  @user.scores.member?('multi_test'),
+  @user.profile['multi'],
+  @user.tags.member?('multi_tag'),
+  @user.activity.members.include?('multi_action')
+]
+#=> [true, true, "yes", true, true]
+
+# Cleanup
+@user.destroy!

data/try/{core → integration}/database_consistency_try.rb

@@ -3,7 +3,7 @@
 # Database consistency verification and edge case testing
 # Complements persistence_operations_try.rb with deeper consistency checks
 
-require_relative '../helpers/test_helpers'
+require_relative '../support/helpers/test_helpers'
 
 # Test class with different field types for consistency verification
 class ConsistencyTestModel < Familia::Horreum
@@ -55,15 +55,18 @@ key_parts = dbkey.split(':')
 # Refresh and verify data integrity
 @serial_test.refresh!
 [@serial_test.name, @serial_test.active, @serial_test.metadata]
-#=> ['Serialization Test', 'true', {:key=>'value', :array=>[1, 2, 3]}]
+#=> ["Serialization Test", true, {"key"=>"value", "array"=>[1, 2, 3]}]
 
 ## Hash field count matches object field count
+@serial_test = ConsistencyTestModel.new(id: next_test_id)
+@serial_test.save
 expected_fields = @serial_test.class.persistent_fields.length
 redis_field_count = Familia.dbclient.hlen(@serial_test.dbkey)
 actual_object_fields = @serial_test.to_h.keys.length
-# All should match (redis may have fewer due to nil exclusion)
-[expected_fields >= redis_field_count, redis_field_count, actual_object_fields]
-#=> [true, 5, 5]
+# The JSON Serializer stores all fields (including nil as "null")
+# Expected fields (5) >= redis count (5) >= to_h count (5, even though email is nil)
+[expected_fields, redis_field_count, actual_object_fields]
+#=> [5, 5, 5]
 
 ## Memory vs persistence state consistency after save
 @consistency_obj = ConsistencyTestModel.new(id: next_test_id, name: 'Memory Test', email: 'test@example.com')
@@ -73,9 +76,9 @@ actual_object_fields = @serial_test.to_h.keys.length
 memory_name = @consistency_obj.name
 memory_email = @consistency_obj.email
 
-# Get persistence state
-redis_name = Familia.dbclient.hget(@consistency_obj.dbkey, 'name')
-redis_email = Familia.dbclient.hget(@consistency_obj.dbkey, 'email')
+# Get persistence state (deserialize from JSON storage)
+redis_name = @consistency_obj.deserialize_value(Familia.dbclient.hget(@consistency_obj.dbkey, 'name'))
+redis_email = @consistency_obj.deserialize_value(Familia.dbclient.hget(@consistency_obj.dbkey, 'email'))
 
 [memory_name == redis_name, memory_email == redis_email]
 #=> [true, true]

data/try/{core → integration}/familia_extended_try.rb

@@ -2,7 +2,7 @@
 
 require 'time'
 
-require_relative '../helpers/test_helpers'
+require_relative '../support/helpers/test_helpers'
 
 ## Has all datatype relativess
 registered_types = Familia::DataType.registered_types.keys

data/try/{core → integration}/familia_members_methods_try.rb

@@ -1,6 +1,6 @@
 # try/core/familia_members_methods_try.rb
 
-require_relative '../helpers/test_helpers'
+require_relative '../support/helpers/test_helpers'
 
 # Tests for new methods: demodularize, familia_name, and resolve_class
 

data/try/{models → integration/models}/customer_safe_dump_try.rb

@@ -1,6 +1,6 @@
 # try/models/customer_safedump_try.rb
 
-require_relative '../helpers/test_helpers'
+require_relative '../../support/helpers/test_helpers'
 
 # Setup
 @now = Familia.now.to_i
@@ -39,7 +39,11 @@ require_relative '../helpers/test_helpers'
 
 ## Safe dump includes correct updated timestamp
 @safe_dump[:updated]
-#=> @now
+#=:> Float
+
+## Safe dump includes correct updated timestamp
+@safe_dump[:updated].to_i
+#=> @now.to_i
 
 ## Safe dump includes correct secrets_created count
 @customer.secrets_created.increment

data/try/{models → integration/models}/customer_try.rb

@@ -1,7 +1,7 @@
 # try/models/customer_try.rb
 
 # Customer Tryouts
-require_relative '../helpers/test_helpers'
+require_relative '../../support/helpers/test_helpers'
 
 # Setup
 @now = Time.now.to_f

data/try/{models → integration/models}/datatype_base_try.rb

@@ -2,7 +2,7 @@
 
 # Test DataType base functionality
 
-require_relative '../helpers/test_helpers'
+require_relative '../../support/helpers/test_helpers'
 
 Familia.debug = false
 

data/try/{models → integration/models}/familia_object_try.rb

@@ -1,6 +1,6 @@
 # try/models/familia_object_try.rb
 
-require_relative '../helpers/test_helpers'
+require_relative '../../support/helpers/test_helpers'
 
 Familia.debug = false
 
@@ -71,7 +71,7 @@ Customer.all_customers.size
 
 ## Familia class clear
 Customer.all_customers.delete!
-#=> true
+#=> 1
 
 ## Familia class replace 1 of 4
 Customer.message.value = 'msg1'

data/try/{core → integration}/persistence_operations_try.rb

@@ -3,7 +3,7 @@
 # Comprehensive test coverage for core persistence methods: exists?, save, save_if_not_exists, create
 # This test addresses gaps that allowed the exists? bug to go undetected
 
-require_relative '../helpers/test_helpers'
+require_relative '../support/helpers/test_helpers'
 
 # Use a simple test class to isolate persistence behavior
 class PersistenceTestModel < Familia::Horreum
@@ -13,6 +13,27 @@ class PersistenceTestModel < Familia::Horreum
   field :value
 end
 
+# Create model with expiration feature for save_fields testing
+class ExpirationPersistenceTest < Familia::Horreum
+  feature :expiration
+  identifier_field :id
+  field :id
+  field :name
+  field :email
+  field :status
+  field :metadata
+
+  default_expiration 3600  # 1 hour
+end
+
+# Simple model without expiration feature
+class SimpleModel < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  field :value
+end
+
 # Clean up any existing test data
 cleanup_keys = []
 begin
@@ -111,9 +132,9 @@ result = @sine_new.save_if_not_exists
 [result, @sine_new.exists?]
 #=> [true, true]
 
-## save_if_not_exists raises error for existing object
+## save_if_not_exists! raises error for existing object
 @sine_duplicate = PersistenceTestModel.new(id: @sine_new.identifier, name: 'Duplicate')
-@sine_duplicate.save_if_not_exists
+@sine_duplicate.save_if_not_exists!
 #=!> Familia::RecordExistsError
 
 ## save_if_not_exists with update_expiration: false
@@ -128,14 +149,10 @@ original_name = 'Original Name'
 @sine_fail_test.save_if_not_exists
 # Now create duplicate and verify state doesn't change on failure
 @sine_fail_duplicate = PersistenceTestModel.new(id: @sine_fail_test.identifier, name: 'Changed Name')
-begin
-  @sine_fail_duplicate.save_if_not_exists
-  false # Should not reach here
-rescue Familia::RecordExistsError
-  # State should be unchanged
-  @sine_fail_duplicate.name == 'Changed Name'
-end
-#=> true
+result = @sine_fail_duplicate.save_if_not_exists
+# save_if_not_exists returns false on failure, state should be unchanged
+[result == false, @sine_fail_duplicate.name == 'Changed Name']
+#=> [true, true]
 
 # =============================================
 # 4. create Method Coverage (MISSING from current tests)
@@ -291,7 +308,142 @@ actual_key = @key_obj.dbkey
 # Cleanup
 # =============================================
 
+# =============================================
+# 8. save_fields Method Coverage
+# =============================================
+
+## save_fields basic functionality with specified fields
+@save_fields_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Original Name', email: 'test@example.com', status: 'active')
+@save_fields_obj.save
+# Modify fields locally
+@save_fields_obj.name = 'Updated Name'
+@save_fields_obj.status = 'inactive'
+@save_fields_obj.metadata = { updated: true }
+# Save only specific fields
+result = @save_fields_obj.save_fields(:name, :metadata)
+[result.class == ExpirationPersistenceTest, @save_fields_obj.exists?]
+#=> [true, true]
+
+## Verify only specified fields were saved
+@save_fields_obj.refresh!
+[@save_fields_obj.name, @save_fields_obj.status, @save_fields_obj.metadata]
+#=> ['Updated Name', 'active', { 'updated' => true }]
+
+## save_fields with update_expiration: true (default)
+@exp_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Expiration Test')
+@exp_obj.save
+original_ttl = @exp_obj.ttl
+# Wait a moment to ensure TTL decreases
+sleep 0.1
+@exp_obj.name = 'Updated with TTL'
+@exp_obj.save_fields(:name)  # Should update expiration by default
+new_ttl = @exp_obj.ttl
+# TTL should be refreshed (closer to default_expiration)
+# Allow for small timing variations
+new_ttl >= (ExpirationPersistenceTest.default_expiration - 10)
+#=> true
+
+## save_fields with update_expiration: false
+@no_exp_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'No Exp Update')
+@no_exp_obj.save
+# Wait briefly and get TTL
+sleep 0.1
+original_ttl = @no_exp_obj.ttl
+@no_exp_obj.name = 'Updated without TTL'
+@no_exp_obj.save_fields(:name, update_expiration: false)
+new_ttl = @no_exp_obj.ttl
+# TTL should be approximately the same (slightly less due to time passing)
+(new_ttl - original_ttl).abs < 2
+#=> true
+
+## save_fields with multiple fields
+@multi_fields_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Multi', email: 'multi@test.com')
+@multi_fields_obj.save
+@multi_fields_obj.name = 'Multi Updated'
+@multi_fields_obj.email = 'updated@test.com'
+@multi_fields_obj.status = 'new_status'
+result = @multi_fields_obj.save_fields(:name, :email, :status)
+@multi_fields_obj.refresh!
+[@multi_fields_obj.name, @multi_fields_obj.email, @multi_fields_obj.status]
+#=> ['Multi Updated', 'updated@test.com', 'new_status']
+
+## save_fields with string field names
+@string_fields_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'String Fields')
+@string_fields_obj.save
+@string_fields_obj.name = 'Updated via String'
+result = @string_fields_obj.save_fields('name')  # String instead of symbol
+@string_fields_obj.refresh!
+@string_fields_obj.name
+#=> 'Updated via String'
+
+## save_fields error handling - empty fields
+@empty_fields_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Empty Test')
+@empty_fields_obj.save
+@empty_fields_obj.save_fields()
+#=!> ArgumentError
+
+## save_fields error handling - unknown field
+@unknown_field_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Unknown Field')
+@unknown_field_obj.save
+@unknown_field_obj.save_fields(:nonexistent_field)
+#=!> ArgumentError
+
+## save_fields with nil values
+@nil_values_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Nil Values', status: 'initial')
+@nil_values_obj.save
+@nil_values_obj.status = nil
+@nil_values_obj.save_fields(:status)
+@nil_values_obj.refresh!
+@nil_values_obj.status
+#=> nil
+
+## save_fields with complex data types (Hash, Array)
+@complex_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Complex')
+@complex_obj.save
+@complex_obj.metadata = {
+  tags: ['ruby', 'redis'],
+  config: { timeout: 30, retries: 3 },
+  enabled: true
+}
+@complex_obj.save_fields(:metadata)
+@complex_obj.refresh!
+expected_metadata = {
+  'tags' => ['ruby', 'redis'],
+  'config' => { 'timeout' => 30, 'retries' => 3 },
+  'enabled' => true
+}
+@complex_obj.metadata == expected_metadata
+#=> true
+
+## save_fields transactional behavior
+@transaction_obj = ExpirationPersistenceTest.new(id: next_test_id, name: 'Transaction Test')
+@transaction_obj.save
+@transaction_obj.name = 'Updated in Transaction'
+@transaction_obj.email = 'transaction@test.com'
+# All fields should be saved atomically
+@transaction_obj.save_fields(:name, :email)
+@transaction_obj.refresh!
+[@transaction_obj.name, @transaction_obj.email]
+#=> ['Updated in Transaction', 'transaction@test.com']
+
+## save_fields performance with model without expiration feature
+
+@simple_obj = SimpleModel.new(id: next_test_id, name: 'Simple', value: 'test')
+@simple_obj.save
+@simple_obj.name = 'Simple Updated'
+# Should work without expiration feature (update_expiration param ignored)
+result = @simple_obj.save_fields(:name, update_expiration: true)
+@simple_obj.refresh!
+@simple_obj.name
+#=> 'Simple Updated'
+
+# =============================================
+# Cleanup
+# =============================================
+
 # Clean up test data
 test_keys = Familia.dbclient.keys('persistencetestmodel:*')
 test_keys.concat(Familia.dbclient.keys('encryptedpersistencetest:*')) if defined?(EncryptedPersistenceTest)
+test_keys.concat(Familia.dbclient.keys('expirationpersistencetest:*'))
+test_keys.concat(Familia.dbclient.keys('simplemodel:*'))
 Familia.dbclient.del(*test_keys) if test_keys.any?