familia 2.0.0.pre14 → 2.0.0.pre16

data/try/horreum/destroy_related_fields_cleanup_try.rb

@@ -0,0 +1,330 @@
+# Horreum destroy! Related Fields Cleanup Tryouts
+#
+# Tests that when a Horreum instance is destroyed, all its related fields
+# (lists, sets, sorted sets, hashes, etc.) are also properly cleaned up
+# to prevent orphaned Redis keys.
+#
+# This addresses the bug where destroy! only deleted the main object key
+# but left related field keys in the database.
+
+require_relative '../helpers/test_helpers'
+
+MANY_FIELD_MULTIPLIER = 10
+
+# Test model with various related fields
+class ::DestroyTestUser < Familia::Horreum
+  identifier_field :user_id
+  field :user_id
+  field :name
+  field :email
+
+  # Various DataType relations to test cleanup
+  list :activity_log
+  set :tags
+  zset :scores
+  hashkey :settings
+  string :status_message
+end
+
+class ::CustomOptionsUser < Familia::Horreum
+  identifier_field :user_id
+  field :user_id
+
+  # Related fields with various options
+  list :custom_log, ttl: 3600
+  set :custom_tags, default: ['default_tag']
+  zset :custom_scores, class: self
+end
+
+class ::ParentModel < Familia::Horreum
+  identifier_field :parent_id
+  field :parent_id
+  list :children_ids
+  set :child_tags
+end
+
+class ::ChildModel < Familia::Horreum
+  identifier_field :child_id
+  field :child_id
+  field :parent_id
+  list :child_activities
+end
+
+class ::ManyFieldsModel < Familia::Horreum
+  identifier_field :model_id
+  field :model_id
+
+  # Create many different types of related fields
+  MANY_FIELD_MULTIPLIER.times do |i|
+    list :"list_#{i}"
+    set :"set_#{i}"
+    zset :"zset_#{i}"
+    hashkey :"hash_#{i}"
+  end
+end
+
+# From transaction_fallback_integration_try.rb for bug verification test
+class ::IntegrationTestUser < Familia::Horreum
+  identifier_field :user_id
+  field :user_id
+  field :name
+  field :email
+  field :status
+  list :activity_log
+  set :tags
+  zset :scores
+end
+
+## Related fields are cleaned up when instance is destroyed
+user = DestroyTestUser.new(user_id: 'cleanup_test_001', name: 'Test User')
+
+# Populate related fields with data
+user.activity_log.add('login')
+user.activity_log.add('profile_update')
+
+user.tags.add('premium')
+user.tags.add('verified')
+
+user.scores.add('game_score', 100)
+user.scores.add('quiz_score', 85)
+
+user.settings['theme'] = 'dark'
+user.settings['notifications'] = 'enabled'
+
+user.status_message.value = 'Online'
+
+user.save
+
+# Verify data exists before destruction
+keys_before = [
+  user.dbkey,
+  user.activity_log.dbkey,
+  user.tags.dbkey,
+  user.scores.dbkey,
+  user.settings.dbkey,
+  user.status_message.dbkey,
+]
+
+keys_exist_before = keys_before.all? { |key| user.dbclient.exists(key) > 0 }
+
+# Destroy the user
+destroy_result = user.destroy!
+
+# Verify all keys are cleaned up after destruction
+keys_exist_after = keys_before.any? { |key| user.dbclient.exists(key) > 0 }
+
+# Should successfully destroy and clean up all related keys
+destroy_result && keys_exist_before && !keys_exist_after
+#=> true
+
+## Class-level destroy! also cleans up related fields
+
+user = DestroyTestUser.new(user_id: 'class_destroy_test_001')
+
+# Add some related field data
+user.activity_log.add('created')
+user.tags.add('new_user')
+user.scores.add('initial_score', 0)
+user.save
+
+# Verify keys exist
+keys_before = [
+  user.dbkey,
+  user.activity_log.dbkey,
+  user.tags.dbkey,
+  user.scores.dbkey,
+]
+keys_exist_before = keys_before.all? { |key| user.dbclient.exists(key) > 0 }
+
+# Use class-level destroy!
+destroy_result = DestroyTestUser.destroy!('class_destroy_test_001')
+
+# Verify all keys are cleaned up
+keys_exist_after = keys_before.any? { |key| user.dbclient.exists(key) > 0 }
+
+destroy_result && keys_exist_before && !keys_exist_after
+#=> true
+
+## Empty related fields don't cause errors during cleanup
+user = DestroyTestUser.new(user_id: 'empty_fields_test_001')
+user.save
+
+# Don't add any data to related fields - they should be empty
+
+# Destroy should work without errors even with empty related fields
+result = user.destroy!
+
+# Verify main key is gone
+main_key_gone = user.dbclient.exists(user.dbkey) == 0
+
+result && main_key_gone
+#=> true
+
+## Related fields with custom options are handled properly
+user = CustomOptionsUser.new(user_id: 'custom_options_test_001')
+
+# Add data to custom related fields
+user.custom_log.add('custom_event')
+user.custom_tags.add('custom_tag')
+user.custom_scores.add('custom_score', 50)
+user.save
+
+# Verify keys exist
+keys_before = [
+  user.dbkey,
+  user.custom_log.dbkey,
+  user.custom_tags.dbkey,
+  user.custom_scores.dbkey,
+]
+keys_exist_before = keys_before.all? { |key| user.dbclient.exists(key) > 0 }
+
+# Destroy and verify cleanup
+destroy_result = user.destroy!
+keys_exist_after = keys_before.any? { |key| user.dbclient.exists(key) > 0 }
+
+# Clean up the test class to avoid pollution
+Object.send(:remove_const, :CustomOptionsUser) if Object.const_defined?(:CustomOptionsUser)
+
+destroy_result && keys_exist_before && !keys_exist_after
+#=> true
+
+## Nested destruction handles complex related field hierarchies
+
+parent = ParentModel.new(parent_id: 'parent_001')
+child1 = ChildModel.new(child_id: 'child_001', parent_id: 'parent_001')
+child2 = ChildModel.new(child_id: 'child_002', parent_id: 'parent_001')
+
+# Set up relationships
+parent.children_ids.add('child_001')
+parent.children_ids.add('child_002')
+parent.child_tags.add('family_tag')
+
+child1.child_activities.add('child1_activity')
+child2.child_activities.add('child2_activity')
+
+parent.save
+child1.save
+child2.save
+
+# Verify all keys exist
+all_keys = [
+  parent.dbkey, parent.children_ids.dbkey, parent.child_tags.dbkey,
+  child1.dbkey, child1.child_activities.dbkey,
+  child2.dbkey, child2.child_activities.dbkey
+]
+keys_exist_before = all_keys.all? { |key| parent.dbclient.exists(key) > 0 }
+
+# Destroy parent - should clean up all parent's related fields
+parent_destroy_result = parent.destroy!
+
+# Parent and its related fields should be gone
+parent_keys = [parent.dbkey, parent.children_ids.dbkey, parent.child_tags.dbkey]
+parent_keys_gone = parent_keys.none? { |key| parent.dbclient.exists(key) > 0 }
+
+# Child objects should still exist (they're separate objects)
+child_keys = [child1.dbkey, child1.child_activities.dbkey, child2.dbkey, child2.child_activities.dbkey]
+child_keys_exist = child_keys.all? { |key| child1.dbclient.exists(key) > 0 }
+
+# Clean up children
+child1.destroy!
+child2.destroy!
+
+# Clean up test classes
+Object.send(:remove_const, :ParentModel) if Object.const_defined?(:ParentModel)
+Object.send(:remove_const, :ChildModel) if Object.const_defined?(:ChildModel)
+
+parent_destroy_result && keys_exist_before && parent_keys_gone && child_keys_exist
+#=> true
+
+## Performance check - destroying object with many related fields
+model = ManyFieldsModel.new(model_id: 'many_fields_001')
+
+# Add data to some of the fields
+MANY_FIELD_MULTIPLIER.times do |i|
+  model.send(:"list_#{i}").add("item_#{i}")
+  model.send(:"set_#{i}").add("tag_#{i}")
+  model.send(:"zset_#{i}").add("score_#{i}", i * 10)
+  model.send(:"hash_#{i}")["key_#{i}"] = "value_#{i}"
+end
+
+model.save
+
+destroy_result = model.destroy!
+
+# Should result in success and also complete in a reasonable amount of
+# time (under 100ms for this test). I acknowledge this is flaky.
+[destroy_result.class, destroy_result.successful?, destroy_result.results.size]
+#=> [MultiResult, true, 41]
+#=%> 100
+
+## Verify transaction_fallback_integration_try.rb bug is fixed
+# Recreate the scenario from the failing test
+user = IntegrationTestUser.new(user_id: 'bugfix_test_001')
+
+# Add data to related fields like the original test
+user.activity_log.add('user_created')
+user.activity_log.add('profile_updated')
+user.tags.add('premium')
+user.tags.add('verified')
+user.scores.add('game_score', 100)
+user.scores.add('quiz_score', 85)
+
+# Save the user so the main object key exists
+user.save
+
+# Verify keys exist before destruction
+keys_before = [
+  user.dbkey,
+  user.activity_log.dbkey,
+  user.tags.dbkey,
+  user.scores.dbkey,
+]
+keys_exist_before = keys_before.all? { |key| user.dbclient.exists(key) > 0 }
+
+# The original destroy! call that was leaving orphaned keys
+destroy_result = user.destroy!
+
+# Now all related keys should be properly cleaned up
+keys_exist_after = keys_before.any? { |key| user.dbclient.exists(key) > 0 }
+
+Object.send(:remove_const, :ManyFieldsModel) if Object.const_defined?(:ManyFieldsModel)
+
+destroy_result && keys_exist_before && !keys_exist_after
+#=> true
+
+## Test destroy! with init hook that depends on identifier
+# This verifies that the temp instance initialization fix works correctly
+class TestModelWithInit < Familia::Horreum
+  identifier_field :user_id
+  field :user_id
+  field :region
+  list :activities
+
+  def init(*args, **kwargs)
+    # Set region based on user_id (simulates real-world logic)
+    self.region = user_id.split('-').first if user_id
+  end
+end
+
+# Create object - init should set region based on user_id
+init_obj = TestModelWithInit.new(user_id: "us-west-123")
+init_obj.save
+init_obj.activities << "login"
+init_obj.activities << "purchase"
+
+# Verify init worked and region is set
+region_set_correctly = init_obj.region == "us"
+
+# Verify related field key includes region (would be nil without fix)
+activities_key = init_obj.activities.dbkey
+
+# Destroy using class method - temp instance init should execute with identifier
+TestModelWithInit.destroy!("us-west-123")
+
+# Verify all keys are cleaned up (including activities with correct key)
+activities_cleaned = TestModelWithInit.dbclient.exists(activities_key).zero?
+
+Object.send(:remove_const, :TestModelWithInit) if Object.const_defined?(:TestModelWithInit)
+
+region_set_correctly && activities_cleaned
+#=> true

data/try/horreum/initialization_try.rb

@@ -10,9 +10,9 @@ Familia.debug = false
 #=> ["tryouts-29@test.com", "John Doe"]
 
 ## Keyword argument initialization works (order independent)
-@customer2 = Customer.new(name: 'Jane Smith', custid: 'jane@test.com', email: 'jane@example.com')
+@customer2 = Customer.new(name: 'Jane Windows', custid: 'jane@test.com', email: 'jane@example.com')
 [@customer2.custid, @customer2.name, @customer2.email]
-#=> ["jane@test.com", "Jane Smith", "jane@example.com"]
+#=> ["jane@test.com", "Jane Windows", "jane@example.com"]
 
 ## Keyword arguments are order independent (different order, same result)
 @customer3 = Customer.new(email: 'bob@example.com', custid: 'bob@test.com', name: 'Bob Jones')
@@ -50,11 +50,11 @@ Familia.debug = false
 
 ## to_h works correctly with keyword-initialized objects
 @customer2.to_h["name"]
-#=> "Jane Smith"
+#=> "Jane Windows"
 
 ## to_a works correctly with keyword-initialized objects
 @customer2.to_a[4] # name field should be the fifth field defined in the class
-#=> "Jane Smith"
+#=> "Jane Windows"
 
 ## Session has limited fields (only sessid defined)
 @session1 = Session.new('sess123')
@@ -103,12 +103,16 @@ Familia.debug = false
 [@customer6, @complex].map(&:delete!)
 #=> [true, true]
 
-## "Cleaning up" test objects that were never saved returns false.
+## "Cleaning up" test objects that were never saved returns true regardless
+## b/c it takes place in a transaction and it's the transaction's success
+## that successful? is based on. If you look at the MultiResult#results,
+## it's an array of 0s, except for the @customer1 that had been saved.
+## That's b/c DEL command returns the number of keys deleted.
 @customer1.save
 [
   @customer1, @customer2, @customer3, @customer4, @customer6, @customer7,
   @session1, @session2, @session3,
   @domain1, @domain2,
   @partial, @complex
-].map(&:destroy!)
-#=> [true, false, false, false, false, false, false, false, false, false, false, false, false]
+].map(&:destroy!).map(&:areyouhappynow?)
+#==> result.all?(true)

data/try/horreum/relations_try.rb

@@ -56,7 +56,7 @@ tags = @test_user.tags
 scores = @test_user.scores
 prefs = @test_user.preferences
 [sessions.class.name, tags.class.name, scores.class.name, prefs.class.name]
-#=> ["Familia::List", "Familia::Set", "Familia::SortedSet", "Familia::HashKey"]
+#=> ["Familia::ListKey", "Familia::UnsortedSet", "Familia::SortedSet", "Familia::HashKey"]
 
 ## Database types use correct dbkeys
 @test_user.sessions.dbkey
@@ -72,7 +72,7 @@ prefs = @test_user.preferences
 @test_user.sessions.size
 #=> 2
 
-## Can work with Set Database type
+## Can work with UnsortedSet Database type
 @test_user.tags.clear
 @test_user.tags.add('ruby', 'valkey', 'web')
 @test_user.tags.size
@@ -80,8 +80,8 @@ prefs = @test_user.preferences
 
 ## Can work with SortedSet Database type
 @test_user.scores.clear
-@test_user.scores.add(100, 'level1')
-@test_user.scores.add(200, 'level2')
+@test_user.scores.add('level1', 100)
+@test_user.scores.add('level2', 200)
 @test_user.scores.size
 #=> 2
 
@@ -108,16 +108,21 @@ prefs = @test_user.preferences
 @test_product.views.value
 #=> 6
 
-## Database types maintain parent reference
-@test_user.sessions.parent == @test_user
-#=> true
+## Database types maintain ParentDefinition reference, not the parent itself
+@test_user.sessions.parent
+#=/> @test_user
+#=:> Familia::Horreum::ParentDefinition
+
+## Database types maintain ParentDefinition reference, not the parent itself
+@test_user.sessions.parent
+#=> Familia::Horreum::ParentDefinition.from_parent(@test_user)
 
 ## Database types know their field name
 @test_user.tags.keystring
 #=> :tags
 
 ## Can check if Database types exist
-@test_user.scores.add(50, 'test')
+@test_user.scores.add('test', 50)
 before_exists = @test_user.scores.exists?
 @test_user.scores.clear
 after_exists = @test_user.scores.exists?
@@ -130,15 +135,18 @@ after_exists = @test_user.scores.exists?
 @test_user.preferences.exists?
 #=> false
 
-## Parent object destruction does not clean up relations
-@test_user.sessions.add('cleanup_test')
+## Parent object destruction DOES clean up relations (since v2.0.0.pre16)
+@test_user.sessions.push('cleanup_test')
 @test_user.destroy!
 @test_user.sessions.exists?
-#=> true
+#=> false
 
 ## If the parent instance is still in memory, can use it
 ## to access and clear the child field.
-@test_user.sessions.clear
-#=> true
+@test_user.sessions.add(Familia.now)
+@test_user.sessions.size
+#=> 1
+
+@test_user.sessions.delete!
 
 @test_product.destroy!

data/try/horreum/serialization_try.rb

@@ -13,8 +13,8 @@ Familia.debug = false
 #=> true
 
 ## save_if_not_exists saves new customer successfully
-Familia.dbclient.set('debug:starting_save_if_not_exists_tests', Time.now.to_s)
-@test_id = "#{Time.now.to_i}-#{rand(1000)}"
+Familia.dbclient.set('debug:starting_save_if_not_exists_tests', Familia.now.to_s)
+@test_id = "#{Familia.now.to_i}-#{rand(1000)}"
 @new_customer = Customer.new "new-customer-#{@test_id}@test.com"
 @new_customer.name = 'New Customer'
 @new_customer.save_if_not_exists
@@ -34,7 +34,7 @@ Familia.dbclient.set('debug:starting_save_if_not_exists_tests', Time.now.to_s)
 #=> true
 
 ## End of save_if_not_exists tests
-Familia.dbclient.set('debug:ending_save_if_not_exists_tests', Time.now.to_s)
+Familia.dbclient.set('debug:ending_save_if_not_exists_tests', Familia.now.to_s)
 
 ## save_if_not_exists persists data correctly
 @another_new_customer.refresh!
@@ -62,7 +62,7 @@ Familia.dbclient.set('debug:ending_save_if_not_exists_tests', Time.now.to_s)
 #=> "John Doe"
 
 ## batch_update can update multiple fields atomically, to_h
-@result = @customer.batch_update(name: 'Jane Smith', email: 'jane@example.com')
+@result = @customer.batch_update(name: 'Jane Windows', email: 'jane@example.com')
 @result.to_h
 #=> {:success=>true, :results=>[0, 0]}
 
@@ -80,12 +80,12 @@ Familia.dbclient.set('debug:ending_save_if_not_exists_tests', Time.now.to_s)
 
 ## batch_update updates object fields in memory, confirm fields changed
 [@customer.name, @customer.email]
-#=> ["Jane Smith", "jane@example.com"]
+#=> ["Jane Windows", "jane@example.com"]
 
-## batch_update persists to Redis
+## batch_update persists to Valkey/Redis
 @customer.refresh!
 [@customer.name, @customer.email]
-#=> ["Jane Smith", "jane@example.com"]
+#=> ["Jane Windows", "jane@example.com"]
 
 ## batch_update with update_expiration: false works
 @customer.batch_update(name: 'Bob Jones', update_expiration: false)
@@ -139,7 +139,7 @@ end
 result.size
 #=> 2
 
-## refresh! reloads from Redis
+## refresh! reloads from Valkey/Redis
 @customer.refresh!
 @customer.hget('temp_field')
 #=> "temp_value"
@@ -151,13 +151,14 @@ result.successful?
 
 ## destroy! removes object from Database (1 of 2)
 @customer.destroy!
-#=> true
+#=:> MultiResult
+#==> result.successful?
 
 ## After destroy!, dbkey no longer exists (2 of 2)
 @customer.exists?
 #=> false
 
-## destroy! removes object from Redis, not the in-memory object (2 of 2)
+## destroy! removes object from Valkey/Redis, not the in-memory object (2 of 2)
 @customer.refresh!
 @customer.name
 #=> "Bob Jones"
@@ -183,7 +184,7 @@ result.successful?
 [@fresh_customer.role, @fresh_customer.planid]
 #=> ["admin", "premium"]
 
-## Fresh customer changes persist to Redis
+## Fresh customer changes persist to Valkey/Redis
 @fresh_customer.refresh!
 [@fresh_customer.role, @fresh_customer.planid]
 #=> ["admin", "premium"]

data/try/integration/cross_component_try.rb

@@ -3,7 +3,7 @@
 require_relative '../helpers/test_helpers'
 
 class TestUser < Familia::Horreum
-  using Familia::Refinements::SnakeCase
+  using Familia::Refinements::StylizeWords
 
   identifier_field :email
   field :email
@@ -40,14 +40,14 @@ end
 user_class.prefix
 #=!> Familia::Problem
 
-## RedisType relations with Horreum expiration
+## DataType relations with Horreum expiration
 user_class = TestUser
 
 user = user_class.new(email: "test@example.com")
 user.save
 user.expire(1800)
 
-# Create related RedisType
+# Create related DataType
 tags = user.tags
 tags << "ruby" << "redis"
 

data/try/memory/memory_basic_test.rb

@@ -8,7 +8,7 @@ require_relative '../helpers/test_helpers'
 class MemorySecurityTester
   def self.test_redacted_string
     results = {
-      timestamp: Time.now,
+      timestamp: Familia.now,
       tests: []
     }
 

data/try/memory/memory_docker_ruby_dump.sh

@@ -5,7 +5,7 @@
 #
 # See example output at end.
 
-# Set CONTAINER_ID to $CONTAINER_ID or the first argument
+# UnsortedSet CONTAINER_ID to $CONTAINER_ID or the first argument
 CONTAINER_ID=${CONTAINER_ID:-$1}
 
 if [ -z "$CONTAINER_ID" ]; then

data/try/models/customer_safe_dump_try.rb

@@ -3,7 +3,7 @@
 require_relative '../helpers/test_helpers'
 
 # Setup
-@now = Time.now.to_i
+@now = Familia.now.to_i
 @customer = Customer.new
 @customer.custid = 'test+customer_safedump@example.com'
 @customer.email = 'test+customer_safedump@example.com'

data/try/models/customer_try.rb

@@ -46,7 +46,7 @@ Customer.find_by_id(ident).planid
 #=> 1
 
 ## Customer can add custom domain via add method
-@customer.custom_domains.add(@now, 'example.org')
+@customer.custom_domains.add('example.org', @now)
 @customer.custom_domains.members.include?('example.org')
 #=> true
 
@@ -69,7 +69,7 @@ Customer.find_by_id(ident).planid
 #=> true
 
 ## Customer can be added to class-level sorted set
-Customer.instances << @customer
+Customer.instances.add(@customer.identifier)
 Customer.instances.member?(@customer)
 #=> true
 
@@ -89,15 +89,17 @@ Customer.instances.member?(@customer)
 #=> "reset123"
 
 ## Customer can be destroyed
-ret = @customer.destroy!
+multi_result = @customer.destroy!
 cust = Customer.find_by_id('test@example.com')
 exists = Customer.exists?('test@example.com')
-[ret, cust.nil?, exists]
-#=> [true, true, false]
+[multi_result.results, cust.nil?, exists]
+#=> [[1, 0, 1, 1, 1, 1, 1], true, false]
 
 ## Customer.destroy! can be called on an already destroyed object
 @customer.destroy!
-#=> false
+#=:> MultiResult
+#==> result.successful?
+#=*> result.results
 
 ## Customer.logical_database returns the correct database number
 Customer.logical_database
@@ -123,10 +125,6 @@ Customer.logical_database
 Customer.uri
 #=> nil
 
-## Customer.destroy! makes only one call to Redis
-DatabaseCommandCounter.count_commands { @customer.destroy! }
-#=> 1
-
 ## Customer.logical_database returns the correct database number
 Customer.instances.logical_database
 #=> nil

data/try/models/datatype_base_try.rb

@@ -35,8 +35,8 @@ stripe_customer.class.name
 #=> "Familia::HashKey"
 
 ## DataType instances know their owner
-@sample_obj.timeline.parent == @sample_obj
-#=> true
+@sample_obj.timeline.parent.class
+#=> Familia::Horreum::ParentDefinition
 
 ## DataType instances know their field name
 @sample_obj.timeline.keystring
@@ -54,7 +54,7 @@ stripe_customer.class.name
 #==> _.respond_to?(:exists?)
 #=/=> _.respond_to?(:destroy!)
 
-## Can check if DataType exists in Redis
+## Can check if DataType exists in Valkey/Redis
 timeline = @sample_obj.timeline
 exists_before = timeline.exists?
 [exists_before.class, [true, false].include?(exists_before)]