familia 2.0.0.pre14 → 2.0.0.pre16

data/try/features/relationships/relationships_edge_cases_try.rb

@@ -24,13 +24,10 @@ class EdgeTestDomain < Familia::Horreum
   field :created_at
   field :score_value
 
-  # Test different score calculation methods - simplified
-  tracked_in EdgeTestCustomer, :domains, score: :created_at, on_destroy: :remove
-
-  # Test different collection types for membership
-  member_of EdgeTestCustomer, :domains, type: :sorted_set
-  member_of EdgeTestCustomer, :simple_domains, type: :set
-  member_of EdgeTestCustomer, :domain_list, type: :list
+  # Test different score calculation methods and collection types - simplified
+  participates_in EdgeTestCustomer, :domains, score: :created_at, type: :sorted_set
+  participates_in EdgeTestCustomer, :simple_domains, type: :set
+  participates_in EdgeTestCustomer, :domain_list, type: :list
 
   def calculated_score
     (score_value || 0) * 2
@@ -58,19 +55,19 @@ end
 # Score encoding edge cases
 
 ## Score encoding handles maximum metadata value
-max_score = @domain1.encode_score(Time.now, 255)
+max_score = @domain1.encode_score(Familia.now, 255)
 decoded = @domain1.decode_score(max_score)
 decoded[:permissions]
 #=> 255
 
 ## Score encoding handles zero metadata
-zero_score = @domain1.encode_score(Time.now, 0)
+zero_score = @domain1.encode_score(Familia.now, 0)
 decoded_zero = @domain1.decode_score(zero_score)
 decoded_zero[:permissions]
 #=> 0
 
 ## Permission encoding handles unknown permission levels
-unknown_perm_score = @domain1.permission_encode(Time.now, :unknown_permission)
+unknown_perm_score = @domain1.permission_encode(Familia.now, :unknown_permission)
 decoded_unknown = @domain1.permission_decode(unknown_perm_score)
 decoded_unknown[:permission_list]
 #=> []
@@ -90,7 +87,7 @@ decoded_large[:permissions]
 #=> 123
 
 ## Permission encoding maps correctly
-read_score = @domain1.permission_encode(Time.now, :read)
+read_score = @domain1.permission_encode(Familia.now, :read)
 decoded_read = @domain1.permission_decode(read_score)
 decoded_read[:permission_list].include?(:read)
 #=> true
@@ -102,7 +99,7 @@ decoded_epoch[:permissions]
 #=> 42
 
 ## Boundary score values work correctly
-boundary_score = @domain1.encode_score(Time.now, 255)
+boundary_score = @domain1.encode_score(Familia.now, 255)
 decoded_boundary = @domain1.decode_score(boundary_score)
 decoded_boundary[:permissions] <= 255
 #=> true
@@ -112,22 +109,22 @@ decoded_boundary[:permissions] <= 255
 ## Method score calculation works with saved objects
 @customer1.save
 @domain1.save
-@domain1.add_to_edgetestcustomer_domains(@customer1)
-method_score = @domain1.score_in_edgetestcustomer_domains(@customer1)
+@domain1.add_to_edge_test_customer_domains(@customer1)
+method_score = @domain1.score_in_edge_test_customer_domains(@customer1)
 method_score.is_a?(Float) && method_score > 0
 #=> true
 
 ## Sorted set membership works
-@domain1.in_edgetestcustomer_domains?(@customer1)
+@domain1.in_edge_test_customer_domains?(@customer1)
 #=> true
 
 ## Score methods respond correctly
-@domain1.respond_to?(:score_in_edgetestcustomer_domains)
+@domain1.respond_to?(:score_in_edge_test_customer_domains)
 #=> true
 
 ## Basic relationship cleanup works
-@domain1.remove_from_edgetestcustomer_domains(@customer1)
-@domain1.in_edgetestcustomer_domains?(@customer1)
+@domain1.remove_from_edge_test_customer_domains(@customer1)
+@domain1.in_edge_test_customer_domains?(@customer1)
 #=> false
 
 # Clean up test data

data/try/features/relationships/relationships_performance_minimal_try.rb

@@ -44,7 +44,7 @@ save_time = Benchmark.realtime do
   @domains.each do |domain|
     domain.save
     # Use numeric scores for sorted sets
-    MinimalDomain.all_domains.add(domain.priority_score.to_f, domain.identifier)
+    MinimalDomain.all_domains.add(domain.identifier, domain.priority_score.to_f)
     MinimalDomain.active_domains.add(domain.identifier)
     MinimalDomain.domain_history.push(domain.identifier)
     MinimalDomain.domain_lookup[domain.display_domain] = domain.identifier
@@ -105,7 +105,7 @@ end
 large_time = Benchmark.realtime do
   @large_domains.each do |domain|
     domain.save
-    MinimalDomain.all_domains.add(domain.priority_score.to_f, domain.identifier)
+    MinimalDomain.all_domains.add(domain.identifier, domain.priority_score.to_f)
   end
 end
 

data/try/features/relationships/relationships_performance_simple_try.rb

@@ -30,7 +30,7 @@ class SimplePerfDomain < Familia::Horreum
   class_hashkey :domain_lookup
 
   # Define tracking relationships for testing
-  tracked_in SimplePerfCustomer, :simple_domains, score: :created_at
+  participates_in SimplePerfCustomer, :simple_domains, score: :created_at
 end
 
 # =============================================
@@ -46,7 +46,7 @@ end
   SimplePerfDomain.new(
     domain_id: "simple_perf_domain_#{i}",
     display_domain: "simple#{i}.example.com",
-    created_at: Time.now.to_i + i,
+    created_at: Familia.now.to_i + i,
     priority_score: rand(100)
   )
 end
@@ -58,15 +58,15 @@ save_time = Benchmark.realtime do
     # Manually add to collections for testing (ensure numeric score)
     # Convert created_at to float, handling nil case
     score = if domain.created_at.nil?
-              Time.now.to_f
+              Familia.now
             elsif domain.created_at.is_a?(Time)
               domain.created_at.to_f
             else
-              domain.created_at.to_f
-            end
-    SimplePerfDomain.all_domains.add(score, domain.identifier)
-    SimplePerfDomain.domain_lookup[domain.display_domain] = domain.identifier
-  end
+            domain.created_at.to_f
+          end
+  SimplePerfDomain.all_domains.add(domain.identifier, score)
+  SimplePerfDomain.domain_lookup[domain.display_domain] = domain.identifier
+end
 end
 
 # Should complete in reasonable time

data/try/features/relationships/relationships_performance_try.rb

@@ -39,7 +39,7 @@ class PerfDomain < Familia::Horreum
   class_hashkey :id_lookup
 
   # Define tracking relationships for testing
-  tracked_in PerfCustomer, :domains, score: :created_at
+  participates_in PerfCustomer, :domains, score: :created_at
 end
 
 # Integration test with other features
@@ -73,7 +73,7 @@ end
 # =============================================
 
 ## Create test objects for performance testing
-@customer = PerfCustomer.new(custid: 'perf_customer', name: 'Performance Test', created_at: Time.now.to_i)
+@customer = PerfCustomer.new(custid: 'perf_customer', name: 'Performance Test', created_at: Familia.now.to_i)
 @customer.save
 
 # Create multiple domains for bulk operations
@@ -81,7 +81,7 @@ end
   PerfDomain.new(
     domain_id: "perf_domain_#{i}",
     display_domain: "perf#{i}.example.com",
-    created_at: Time.now.to_i + i,
+    created_at: Familia.now.to_i + i,
     priority_score: rand(100),
     customer_id: @customer.custid
   )
@@ -93,8 +93,8 @@ save_time = Benchmark.realtime do
     domain.save
     # Manually populate collections for testing
     score = domain.created_at.is_a?(Time) ? domain.created_at.to_f : domain.created_at.to_f
-    PerfDomain.all_domains.add(score, domain.identifier)
-    PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+    PerfDomain.all_domains.add(domain.identifier, score)
+    PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
     PerfDomain.active_domains.add(domain.identifier)
     PerfDomain.domain_history.push(domain.identifier)
     PerfDomain.domain_lookup[domain.display_domain] = domain.identifier
@@ -153,7 +153,7 @@ instances = 100.times.map { |i| PerfDomain.new(domain_id: "mem_test_#{i}") }
 after_instances = ObjectSpace.count_objects[:T_OBJECT]
 
 # Should not have created excessive objects (relationship metadata is shared)
-(after_instances - before_instances) < 200  # Allow for reasonable overhead
+(after_instances - before_instances) < 250  # Allow for reasonable, 2.5x overhead
 #=> true
 
 ## Class-level relationship metadata should be constant size
@@ -203,19 +203,19 @@ operation_threads = 3.times.map do |i|
       domain = PerfDomain.new(
         domain_id: "thread_test_#{i}",
         display_domain: "thread#{i}.test.com",
-        created_at: Time.now.to_i + i,
+        created_at: Familia.now.to_i + i,
         priority_score: i * 10
       )
       domain.save
 
       # Add to collections manually
-      PerfDomain.all_domains.add(domain.created_at.to_f, domain.identifier)
-      PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+      PerfDomain.all_domains.add(domain.identifier, domain.created_at.to_f)
+      PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
       domain.save
 
       # Manually add to collections for thread test
-      PerfDomain.all_domains.add(domain.created_at.to_f, domain.identifier)
-      PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+      PerfDomain.all_domains.add(domain.identifier, domain.created_at.to_f)
+      PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
 
       # Verify the domain was added to collections
       in_all = PerfDomain.all_domains.member?(domain.identifier)
@@ -244,7 +244,7 @@ thread_results.all? { |result| result == [true, true] }
 # =============================================
 
 ## Integration with safe_dump (if available)
-integration_model = IntegrationTestModel.new(id: 'integration_test', data: 'test_data', created_at: Time.now.to_i)
+integration_model = IntegrationTestModel.new(id: 'integration_test', data: 'test_data', created_at: Familia.now.to_i)
 
 if integration_model.respond_to?(:safe_dump)
   integration_model.save
@@ -260,7 +260,7 @@ end
 #=:> String
 
 ## Integration with expiration (if available)
-integration_model2 = IntegrationTestModel.new(id: 'integration_test2', data: 'test_data2', created_at: Time.now.to_i)
+integration_model2 = IntegrationTestModel.new(id: 'integration_test2', data: 'test_data2', created_at: Familia.now.to_i)
 if integration_model2.respond_to?(:default_expiration)
   # Test that expiration works with relationship collections
   if integration_model2.class.respond_to?(:all_items)
@@ -315,15 +315,15 @@ stress_time < 0.1
 test_domain = PerfDomain.new(
   domain_id: 'atomic_test',
   display_domain: 'atomic.test.com',
-  created_at: Time.now.to_i,
+  created_at: Familia.now.to_i,
   priority_score: 50
 )
 
 # Save should succeed and add to all collections
 test_domain.save
 # Manually add to collections
-PerfDomain.all_domains.add(test_domain.created_at.to_f, test_domain.identifier)
-PerfDomain.priority_queue.add(test_domain.priority_score, test_domain.identifier)
+PerfDomain.all_domains.add(test_domain.identifier, test_domain.created_at.to_f)
+PerfDomain.priority_queue.add(test_domain.identifier, test_domain.priority_score)
 PerfDomain.active_domains.add(test_domain.identifier)
 PerfDomain.domain_history.push(test_domain.identifier)
 
@@ -337,14 +337,14 @@ all_collections_have_domain
 #=> true
 
 ## Partial failures should not leave inconsistent state
-# This would require more complex testing infrastructure to simulate Redis failures
+# This would require more complex testing infrastructure to simulate Valkey/Redis failures
 
-## Recovery from Redis connection issues
+## Recovery from Valkey/Redis connection issues
 begin
-  # Test graceful handling of Redis errors during relationship operations
+  # Test graceful handling of Valkey/Redis errors during relationship operations
   dead_domain = PerfDomain.new(domain_id: 'dead_test')
 
-  # This test would require mocking Redis to fail, which is complex in this context
+  # This test would require mocking Valkey/Redis to fail, which is complex in this context
   # For now, just verify that normal operations work
   dead_domain.save
   dead_domain.destroy!

data/try/features/relationships/relationships_try.rb

@@ -25,14 +25,11 @@ class TestDomain < Familia::Horreum
   field :created_at
   field :permission_level
 
-  # Basic tracking with simplified score
-  tracked_in TestCustomer, :domains, score: :created_at
-  class_tracked_in :all_domains, score: :created_at
+  # Basic participation with simplified score
+  participates_in TestCustomer, :domains, score: :created_at
+  class_participates_in :all_domains, score: :created_at
 
   # Note: Indexing features removed for stability
-
-  # Basic membership
-  member_of TestCustomer, :domains
 end
 
 class TestTag < Familia::Horreum
@@ -42,8 +39,8 @@ class TestTag < Familia::Horreum
   field :name
   field :created_at
 
-  # Global tracking
-  class_tracked_in :all_tags, score: :created_at
+  # Global participation
+  class_participates_in :all_tags, score: :created_at
 end
 
 # Setup
@@ -51,10 +48,10 @@ end
 @domain = TestDomain.new(
   domain_id: 'dom_789',
   display_domain: 'example.com',
-  created_at: Time.now.to_i,
+  created_at: Familia.now.to_i,
   permission_level: :write
 )
-@tag = TestTag.new(name: 'important', created_at: Time.now.to_i)
+@tag = TestTag.new(name: 'important', created_at: Familia.now.to_i)
 
 # =============================================
 # 1. V2 Feature Integration Tests
@@ -72,10 +69,6 @@ TestDomain.included_modules.map(&:name).include?('Familia::Features::Relationshi
 @domain.respond_to?(:permission_encode)
 #=> true
 
-## Redis operations functionality is available
-@domain.respond_to?(:atomic_operation)
-#=> true
-
 ## Identifier method works (wraps identifier_field)
 TestDomain.identifier_field
 #=> :domain_id
@@ -89,7 +82,7 @@ TestDomain.identifier_field
 # =============================================
 
 ## Permission encoding creates proper score
-@score = @domain.permission_encode(Time.now, :write)
+@score = @domain.permission_encode(Familia.now, :write)
 @score.to_s.match?(/\d+\.\d+/)
 #=> true
 
@@ -99,16 +92,16 @@ decoded[:permission_list].include?(:write)
 #=> true
 
 ## Score encoding preserves timestamp ordering
-@early_score = @domain.encode_score(Time.now - 3600, 100)  # 1 hour ago
-@late_score = @domain.encode_score(Time.now, 100)
+@early_score = @domain.encode_score(Familia.now - 3600, 100)  # 1 hour ago
+@late_score = @domain.encode_score(Familia.now, 100)
 @late_score > @early_score
 #=> true
 
 # =============================================
-# 3. Tracking Relationships (tracked_in)
+# 3. Participation Relationships (participates_in)
 # =============================================
 
-## Save operation manages tracking relationships
+## Save operation manages participation relationships
 @customer.save
 @domain.save
 
@@ -129,24 +122,24 @@ decoded[:permission_list].include?(:write)
 #=> true
 
 ## Domain can check membership in customer domains (collision-free naming)
-@domain.respond_to?(:in_testcustomer_domains?)
+@domain.respond_to?(:in_test_customer_domains?)
 #=> true
 
 ## Domain can add itself to customer domains (collision-free naming)
-@domain.respond_to?(:add_to_testcustomer_domains)
+@domain.respond_to?(:add_to_test_customer_domains)
 #=> true
 
 ## Domain can remove itself from customer domains (collision-free naming)
-@domain.respond_to?(:remove_from_testcustomer_domains)
+@domain.respond_to?(:remove_from_test_customer_domains)
 #=> true
 
 ## Add domain to customer collection
-@domain.add_to_testcustomer_domains(@customer)
-@domain.in_testcustomer_domains?(@customer)
+@domain.add_to_test_customer_domains(@customer)
+@domain.in_test_customer_domains?(@customer)
 #=> true
 
 ## Score is properly encoded
-score = @domain.score_in_testcustomer_domains(@customer)
+score = @domain.score_in_test_customer_domains(@customer)
 score.is_a?(Float) && score > 0
 #=> true
 
@@ -154,8 +147,8 @@ score.is_a?(Float) && score > 0
 # 4. Basic Functionality Verification
 # =============================================
 
-## Domain tracking methods work correctly
-@domain.respond_to?(:score_in_testcustomer_domains)
+## Domain participation methods work correctly
+@domain.respond_to?(:score_in_test_customer_domains)
 #=> true
 
 ## Score calculation methods are available
@@ -163,23 +156,23 @@ score.is_a?(Float) && score > 0
 #=> true
 
 # =============================================
-# 5. Basic Membership Relationships (member_of)
+# 5. Bidirectional Participation Methods
 # =============================================
 
-## Member_of generates collision-free methods with collection names
-@domain.respond_to?(:add_to_testcustomer_domains)
+## participates_in generates collision-free bidirectional methods with collection names
+@domain.respond_to?(:add_to_test_customer_domains)
 #=> true
 
-## Basic membership operations work
-@domain.remove_from_testcustomer_domains(@customer)
-@domain.in_testcustomer_domains?(@customer)
+## Basic bidirectional participation operations work
+@domain.remove_from_test_customer_domains(@customer)
+@domain.in_test_customer_domains?(@customer)
 #=> false
 
 # =============================================
 # 6. Basic Global Tag Tracking Test
 # =============================================
 
-## Tag can be tracked globally
+## Tag can be participating globally
 @tag.save
 @tag.respond_to?(:add_to_class_all_tags)
 #=> true
@@ -213,10 +206,6 @@ temp_key = @domain.create_temp_key("test_operation", 60)
 temp_key.start_with?("temp:")
 #=> true
 
-## Batch operations are available
-@domain.respond_to?(:batch_zadd)
-#=> true
-
 ## Score range queries work
 @domain.respond_to?(:score_range)
 #=> true

data/try/features/safe_dump/safe_dump_advanced_try.rb

@@ -17,8 +17,8 @@ Customer.safe_dump_fields
 @cust.custid = 'test@example.com'
 @cust.role = 'user'
 @cust.verified = true
-@cust.created = Time.now.to_i
-@cust.updated = Time.now.to_i
+@cust.created = Familia.now.to_i
+@cust.updated = Familia.now.to_i
 @safe_dump = @cust.safe_dump
 @safe_dump.keys.sort
 #=> [:active, :created, :custid, :role, :secrets_created, :updated, :verified]

data/try/features/transient_fields/refresh_reset_try.rb

@@ -94,7 +94,7 @@ SecretService.fields.sort
 @service.endpoint_url
 #=> "https://api.example.com"
 
-## Set transient fields again after refresh
+## UnsortedSet transient fields again after refresh
 @service.api_key = 'new-api-key-after-refresh'
 @service.password = 'new-password-after-refresh'
 @service.token = 'new-token-after-refresh'

data/try/features/transient_fields/simple_refresh_test.rb

@@ -14,7 +14,7 @@ class Customer
   transient_field :temp_data
 end
 
-# Set some values
+# UnsortedSet some values
 service.name = 'Test Customer'
 service.temp_data = 'secret-info'
 

data/try/helpers/test_cleanup.rb

@@ -0,0 +1,86 @@
+# Test cleanup helper for managing anonymous classes and test isolation
+#
+# This module provides utilities to create and cleanup test classes that
+# inherit from Familia classes. Without proper cleanup, anonymous classes
+# pollute the Familia.members registry causing test failures.
+
+module TestCleanup
+  @test_classes = []
+
+  class << self
+    attr_reader :test_classes
+
+    # Create a test class that inherits from the given base class.
+    # The created class is automatically tracked for cleanup.
+    #
+    # @param base_class [Class] The class to inherit from (e.g., Familia::Horreum)
+    # @param block [Proc] Block to define the class body
+    # @return [Class] The created test class
+    def create_test_class(base_class, &block)
+      test_class = Class.new(base_class, &block)
+      track_test_class(test_class)
+      test_class
+    end
+
+    # Track a test class for cleanup. Use this when you create test classes
+    # directly with Class.new instead of using create_test_class.
+    #
+    # @param klass [Class] The test class to track
+    # @return [Class] The tracked class
+    def track_test_class(klass)
+      @test_classes << klass unless @test_classes.include?(klass)
+      klass
+    end
+
+    # Remove all tracked test classes from Familia.members and clear
+    # the tracking array. This should be called in test teardown.
+    #
+    # @return [Array<Class>] The classes that were removed
+    def cleanup_test_classes
+      removed_classes = []
+
+      @test_classes.each do |test_class|
+        if Familia.members.include?(test_class)
+          Familia.unload_member(test_class)
+          removed_classes << test_class
+        end
+      end
+
+      @test_classes.clear
+      removed_classes
+    end
+
+    # Clean up all anonymous classes from Familia.members.
+    # This is a more aggressive cleanup that removes any class with nil name.
+    #
+    # @return [Array<Class>] The anonymous classes that were removed
+    def cleanup_anonymous_classes
+      Familia.clear_anonymous_members
+    end
+
+    # Perform complete test cleanup - both tracked and anonymous classes
+    #
+    # @return [Hash] Summary of cleanup performed
+    def complete_cleanup
+      tracked_removed = cleanup_test_classes
+      anonymous_removed = cleanup_anonymous_classes
+
+      {
+        tracked_classes_removed: tracked_removed.size,
+        anonymous_classes_removed: anonymous_removed.size,
+        total_removed: tracked_removed.size + anonymous_removed.size
+      }
+    end
+  end
+end
+
+# Automatically perform cleanup if we're in test mode
+# This ensures cleanup happens even if tests don't explicitly call it
+at_exit do
+  if Familia.test_mode? && TestCleanup.test_classes.any?
+    cleanup_result = TestCleanup.complete_cleanup
+    if cleanup_result[:total_removed] > 0
+      puts "[TestCleanup] Cleaned up #{cleanup_result[:total_removed]} test classes on exit"
+    end
+  end
+end

data/try/helpers/test_helpers.rb

@@ -65,7 +65,7 @@ class Customer < Familia::Horreum
   # We use a callable here since `:active?` is not a valid method symbol.
   safe_dump_field :active, ->(cust) { cust.active? }
 
-  class_sorted_set :values, key: 'onetime:customer'
+  class_sorted_set :values, key: 'familia:customer'
   class_hashkey :domains
 
   hashkey :stripe_customer
@@ -91,9 +91,9 @@ class Customer < Familia::Horreum
   field :reset_requested #=> Boolean
 
   hashkey :password_reset #=> Familia::HashKey
-  list :sessions #=> Familia::List
+  list :sessions #=> Familia::ListKey
 
-  class_list :customers, suffix: []
+  class_list :all_customers, suffix: [] # no suffix
   class_string :message
 
   class_zset :instances, class: self, reference: true

data/try/horreum/base_try.rb

@@ -52,7 +52,7 @@ Familia.debug = false
 #=> true
 
 ## Horreum object fields have a fast attribute method (1 of 2)
-Familia.trace :LOAD, @customer.dbclient, @customer.uri, caller if Familia.debug?
+Familia.trace :LOAD, nil, @customer.uri if Familia.debug?
 @customer.name! 'Jane Doe'
 #=> true
 
@@ -69,7 +69,8 @@ Familia.trace :LOAD, @customer.dbclient, @customer.uri, caller if Familia.debug?
 
 ## Horreum objects can be destroyed
 @customer.destroy!
-#=> true
+#=:> MultiResult
+#==> result.successful?
 
 ## All horrerum objects have a key field
 @customer.identifier

data/try/horreum/commands_try.rb

@@ -1,4 +1,4 @@
-# Test Horreum Redis commands
+# Test Horreum Valkey/Redis commands
 
 require_relative '../helpers/test_helpers'