familia 2.0.0.pre19 → 2.0.0.pre22

data/try/integration/relationships_persistence_round_trip_try.rb

@@ -1,5 +1,7 @@
 # try/integration/relationships_persistence_round_trip_try.rb
 #
+# frozen_string_literal: true
+
 # CRITICAL PRIORITY: Full Persistence Round-Trip Testing for Relationships
 #
 # PURPOSE:
@@ -113,22 +115,23 @@ class ::RTPDomain < Familia::Horreum
 end
 
 # Setup - create test data with known values
-@test_user_id = "rtp_user_#{Familia.now.to_i}"
-@test_email = "roundtrip@example.com"
-@test_name = "Alice Roundtrip"
+@test_run_id = Familia.now.to_i
+@test_user_id = "rtp_user_#{@test_run_id}"
+@test_email = "roundtrip-#{@test_run_id}@example.com"
+@test_name = "Alice Roundtrip #{@test_run_id}"
 @test_age = 30
 
-@test_company_id = "rtp_comp_#{Familia.now.to_i}"
+@test_company_id = "rtp_comp_#{@test_run_id}"
 @test_company_name = "Acme Corp"
 @test_industry = "Technology"
 
-@test_emp_id = "rtp_emp_#{Familia.now.to_i}"
-@test_emp_email = "employee@acme.com"
+@test_emp_id = "rtp_emp_#{@test_run_id}"
+@test_emp_email = "employee-#{@test_run_id}@acme.com"
 @test_department = "engineering"
-@test_badge = "BADGE_RTP_001"
+@test_badge = "BADGE_RTP_#{@test_run_id}"
 @test_hire_date = Time.now.to_i
 
-@test_domain_id = "rtp_dom_#{Familia.now.to_i}"
+@test_domain_id = "rtp_dom_#{@test_run_id}"
 @test_domain_name = "example.com"
 @test_domain_created = Familia.now.to_i
 
@@ -291,10 +294,10 @@ RTPEmployee.exists?(@test_emp_id)
 
 ## Multiple employees in same department
 @emp2_id = "rtp_emp2_#{Familia.now.to_i}"
-@emp2_badge = "BADGE_RTP_002"
+@emp2_badge = "BADGE_RTP_002_#{@test_run_id}"
 @emp2 = RTPEmployee.new(
   emp_id: @emp2_id,
-  email: "emp2@acme.com",
+  email: "emp2-#{@test_run_id}@acme.com",
   department: @test_department,
   badge_number: @emp2_badge
 )
@@ -323,7 +326,7 @@ RTPDomain.exists?(@test_domain_id)
 #=> true
 
 ## Add domain to company participation collection
-@company.add_domain(@domain)
+@company.add_domains_instance(@domain)
 @company.domains.size
 #=> 1
 
@@ -377,7 +380,7 @@ RTPDomain.all_domains.size
 #=> @new_age
 
 ## Update email and verify index updates
-@new_email = "newemail@example.com"
+@new_email = "newemail-#{@test_run_id}@example.com"
 @old_email = @user.email
 @user.email = @new_email
 @user.save
@@ -396,8 +399,8 @@ RTPUser.find_by_email(@old_email)
 ## User with nil field saves correctly
 @user_nil_age = RTPUser.new(
   user_id: "rtp_nil_#{Familia.now.to_i}",
-  email: "nil@example.com",
-  name: "Nil Tester",
+  email: "nil-#{@test_run_id}@example.com",
+  name: "Nil Tester #{@test_run_id}",
   age: nil
 )
 @user_nil_age.save

data/try/integration/save_methods_consistency_try.rb

@@ -0,0 +1,241 @@
+# try/integration/save_methods_consistency_try.rb
+#
+# frozen_string_literal: true
+
+# Test coverage for save and save_if_not_exists consistency improvements
+#
+# This test verifies that both save and save_if_not_exists! produce identical
+# results when creating new objects, including:
+# - Timestamp updates (created/updated)
+# - Unique index validation
+# - Class-level index updates
+# - Instance collection tracking
+
+require_relative '../support/helpers/test_helpers'
+
+# Model with timestamps to verify timestamp handling
+class TimestampedModel < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  field :created
+  field :updated
+
+  zset :instances
+end
+
+# Model with unique indexes to verify validation
+class UniqueIndexModel < Familia::Horreum
+  feature :relationships
+  include Familia::Features::Relationships::Indexing
+
+  identifier_field :id
+  field :id
+  field :email
+
+  unique_index :email, :email_lookup
+  zset :instances
+end
+
+# Clean up any existing test data
+cleanup_keys = Familia.dbclient.keys('timestampedmodel:*') +
+               Familia.dbclient.keys('uniqueindexmodel:*') +
+               Familia.dbclient.keys('*:email_lookup:*')
+Familia.dbclient.del(*cleanup_keys) if cleanup_keys.any?
+
+@test_counter = 0
+def next_id
+  @test_counter += 1
+  "test-#{Familia.now.to_i}-#{@test_counter}"
+end
+
+# =============================================
+# 1. Timestamp Consistency Tests
+# =============================================
+
+## save sets created and updated timestamps
+@save_model = TimestampedModel.new(id: next_id, name: 'Save Test')
+@save_model.save
+[@save_model.created.nil?, @save_model.updated.nil?]
+#=> [false, false]
+
+## save_if_not_exists! sets created and updated timestamps
+@sine_model = TimestampedModel.new(id: next_id, name: 'SINE Test')
+@sine_model.save_if_not_exists!
+[@sine_model.created.nil?, @sine_model.updated.nil?]
+#=> [false, false]
+
+## Both methods set timestamps to the same approximate time
+time_diff = (@save_model.created - @save_model.updated).abs
+time_diff < 1  # Should be within 1 second
+#=> true
+
+## save_if_not_exists! timestamps match save behavior
+sine_time_diff = (@sine_model.created - @sine_model.updated).abs
+sine_time_diff < 1
+#=> true
+
+# =============================================
+# 2. Instance Collection Consistency
+# =============================================
+
+## save adds object to instances collection
+@inst_save = TimestampedModel.new(id: next_id, name: 'Instance Save')
+@inst_save.save
+TimestampedModel.instances.members.include?(@inst_save.identifier)
+#=> true
+
+## save_if_not_exists! adds object to instances collection
+@inst_sine = TimestampedModel.new(id: next_id, name: 'Instance SINE')
+@inst_sine.save_if_not_exists!
+TimestampedModel.instances.members.include?(@inst_sine.identifier)
+#=> true
+
+## Both methods produce identical instance collection state
+[@inst_save, @inst_sine].all? { |obj| TimestampedModel.instances.members.include?(obj.identifier) }
+#=> true
+
+# =============================================
+# 3. Unique Index Validation Consistency
+# =============================================
+
+## save validates unique indexes
+@unique_email_1 = "save-#{next_id}@test.com"
+@unique_save = UniqueIndexModel.new(id: next_id, email: @unique_email_1)
+@unique_save.save
+@unique_save.exists?
+#=> true
+
+## save raises RecordExistsError for duplicate unique index
+@unique_dup_save = UniqueIndexModel.new(id: next_id, email: @unique_email_1)
+@unique_dup_save.save
+#=!> Familia::RecordExistsError
+
+## save_if_not_exists! validates unique indexes
+@unique_email_2 = "sine-#{next_id}@test.com"
+@unique_sine = UniqueIndexModel.new(id: next_id, email: @unique_email_2)
+@unique_sine.save_if_not_exists!
+@unique_sine.exists?
+#=> true
+
+## save_if_not_exists! raises RecordExistsError for duplicate unique index
+@unique_dup_sine = UniqueIndexModel.new(id: next_id, email: @unique_email_2)
+@unique_dup_sine.save_if_not_exists!
+#=!> Familia::RecordExistsError
+
+# =============================================
+# 4. Return Value Consistency
+# =============================================
+
+## save returns true for successful save
+@ret_save = TimestampedModel.new(id: next_id, name: 'Return Test Save')
+result_save = @ret_save.save
+result_save
+#=> true
+
+## save_if_not_exists! returns true for successful save
+@ret_sine = TimestampedModel.new(id: next_id, name: 'Return Test SINE')
+result_sine = @ret_sine.save_if_not_exists!
+result_sine
+#=> true
+
+## save_if_not_exists returns true for new object
+@ret_sine_safe = TimestampedModel.new(id: next_id, name: 'Return Safe SINE')
+result = @ret_sine_safe.save_if_not_exists
+result
+#=> true
+
+## save_if_not_exists returns false for existing object
+@ret_existing = TimestampedModel.new(id: next_id, name: 'Existing')
+@ret_existing.save
+@ret_dup = TimestampedModel.new(id: @ret_existing.identifier, name: 'Duplicate')
+result = @ret_dup.save_if_not_exists
+result
+#=> false
+
+# =============================================
+# 5. Data Persistence Consistency
+# =============================================
+
+## save persists all fields
+@data_save = TimestampedModel.new(id: next_id, name: 'Data Save Test')
+@data_save.save
+@data_save.refresh
+@data_save.name
+#=> 'Data Save Test'
+
+## save_if_not_exists! persists all fields
+@data_sine = TimestampedModel.new(id: next_id, name: 'Data SINE Test')
+@data_sine.save_if_not_exists!
+@data_sine.refresh
+@data_sine.name
+#=> 'Data SINE Test'
+
+## Both methods produce identical persistence
+[@data_save.name, @data_sine.name]
+#=> ['Data Save Test', 'Data SINE Test']
+
+# =============================================
+# 6. Expiration Handling Consistency
+# =============================================
+
+## save with update_expiration: true handles TTL
+@exp_save = TimestampedModel.new(id: next_id, name: 'Exp Save')
+@exp_save.save(update_expiration: true)
+# No default expiration set, so TTL is -1 (no expiration)
+@exp_save.ttl == -1
+#=> true
+
+## save_if_not_exists! with update_expiration: true handles TTL
+@exp_sine = TimestampedModel.new(id: next_id, name: 'Exp SINE')
+@exp_sine.save_if_not_exists!(update_expiration: true)
+# No default expiration set, so TTL is -1 (no expiration)
+@exp_sine.ttl == -1
+#=> true
+
+# =============================================
+# 7. OptimisticLockError Behavior
+# =============================================
+
+## save_if_not_exists allows OptimisticLockError to propagate
+# Note: This is difficult to test reliably without mocking, but we can
+# verify the method signature and rescue clause structure through the API
+
+## save_if_not_exists rescues only RecordExistsError
+@opt_test = TimestampedModel.new(id: next_id, name: 'Opt Test')
+@opt_test.save
+@opt_dup = TimestampedModel.new(id: @opt_test.identifier, name: 'Opt Dup')
+# This should return false, not raise
+result = @opt_dup.save_if_not_exists
+result
+#=> false
+
+# =============================================
+# 8. Edge Cases
+# =============================================
+
+## save works with nil field values
+@nil_save = TimestampedModel.new(id: next_id, name: nil)
+@nil_save.save
+@nil_save.exists?
+#=> true
+
+## save_if_not_exists! works with nil field values
+@nil_sine = TimestampedModel.new(id: next_id, name: nil)
+@nil_sine.save_if_not_exists!
+@nil_sine.exists?
+#=> true
+
+## Both methods handle empty strings
+@empty_save = TimestampedModel.new(id: next_id, name: '')
+@empty_save.save
+@empty_sine = TimestampedModel.new(id: next_id, name: '')
+@empty_sine.save_if_not_exists!
+[@empty_save.exists?, @empty_sine.exists?]
+#=> [true, true]
+
+# Cleanup
+cleanup_keys = Familia.dbclient.keys('timestampedmodel:*') +
+               Familia.dbclient.keys('uniqueindexmodel:*') +
+               Familia.dbclient.keys('*:email_lookup:*')
+Familia.dbclient.del(*cleanup_keys) if cleanup_keys.any?

data/try/integration/scenarios_try.rb

@@ -1,3 +1,7 @@
+# try/integration/scenarios_try.rb
+#
+# frozen_string_literal: true
+
 # Comprehensive configuration scenarios
 
 require_relative '../support/helpers/test_helpers'

data/try/integration/secure_identifier_try.rb

@@ -1,3 +1,7 @@
+# try/integration/secure_identifier_try.rb
+#
+# frozen_string_literal: true
+
 # try/core/secure_identifier_try.rb
 
 # Test Familia::SecureIdentifier methods

data/try/integration/transaction_safety_core_try.rb

@@ -0,0 +1,176 @@
+# try/integration/transaction_safety_core_try.rb
+#
+# frozen_string_literal: true
+
+# Core Transaction Safety Tests
+#
+# Tests the fundamental transaction safety rules from docs/transaction_safety.md
+# Focuses on the most critical safety mechanisms.
+#
+
+require_relative '../support/helpers/test_helpers'
+
+# Simple test model for transaction safety
+class ::SafetyTestCustomer < Familia::Horreum
+  identifier_field :email
+  field :email
+  field :login_count
+  field :status
+
+  list :orders
+end
+
+# Helper for unique test IDs
+def safety_test_id(prefix = 'test')
+  "#{prefix}_#{Time.now.to_i}_#{rand(1000000)}"
+end
+
+## save raises OperationModeError inside transaction
+error_raised = false
+SafetyTestCustomer.transaction do
+  customer = SafetyTestCustomer.new(email: "#{safety_test_id}@example.com")
+  begin
+    customer.save
+  rescue Familia::OperationModeError => e
+    error_raised = true
+  end
+end
+error_raised
+#=> true
+
+## save_if_not_exists! raises OperationModeError inside transaction
+error_raised_conditional = false
+SafetyTestCustomer.transaction do
+  customer = SafetyTestCustomer.new(email: "#{safety_test_id}@example.com")
+  begin
+    customer.save_if_not_exists!
+  rescue Familia::OperationModeError => e
+    error_raised_conditional = true
+  end
+end
+error_raised_conditional
+#=> true
+
+## create! raises OperationModeError inside transaction
+error_raised_create = false
+SafetyTestCustomer.transaction do
+  begin
+    SafetyTestCustomer.create!(email: "#{safety_test_id}@example.com")
+  rescue Familia::OperationModeError => e
+    error_raised_create = true
+  end
+end
+error_raised_create
+#=> true
+
+## correct pattern save before transaction works
+@correct_customer = SafetyTestCustomer.new(email: "#{safety_test_id('correct')}@example.com")
+@correct_customer.save
+#=> true
+
+## operations work inside transaction after save
+@correct_customer.transaction do
+  @correct_customer.hset(:login_count, '1')
+  @correct_customer.hset(:status, 'active')
+end
+@correct_customer.hget(:login_count).to_i >= 1
+#=> true
+
+## write-only operations work inside transactions
+@write_customer = SafetyTestCustomer.new(email: "#{safety_test_id('write')}@example.com")
+@write_customer.save
+
+@write_result = @write_customer.transaction do |conn|
+  conn.hset(@write_customer.dbkey, 'status', 'premium')
+  conn.hset(@write_customer.dbkey, 'login_count', '5')
+  conn.expire(@write_customer.dbkey, 3600)
+end
+@write_result.class.name
+#=> "MultiResult"
+
+## nested transactions reuse same connection
+@nested_customer = SafetyTestCustomer.new(email: "#{safety_test_id('nested')}@example.com")
+@nested_customer.save
+
+@outer_conn_id = nil
+@inner_conn_id = nil
+
+SafetyTestCustomer.transaction do |outer_conn|
+  @outer_conn_id = outer_conn.object_id
+  @nested_customer.hset(:login_count, '1')
+
+  @nested_customer.transaction do |inner_conn|
+    @inner_conn_id = inner_conn.object_id
+    @nested_customer.hset(:status, 'nested')
+  end
+end
+
+@outer_conn_id == @inner_conn_id
+#=> true
+
+## read operations return Future objects inside transaction
+@read_customer = SafetyTestCustomer.new(email: "#{safety_test_id('read')}@example.com")
+@read_customer.save
+
+@future_object = nil
+@read_customer.transaction do |conn|
+  @future_object = conn.hget(@read_customer.dbkey, 'email')
+end
+@future_object.class.name.include?('Future')
+#=> true
+
+## exists check returns Future inside transaction always truthy
+@pitfall_customer = SafetyTestCustomer.new(email: "#{safety_test_id('pitfall')}@example.com")
+
+@wrong_result = nil
+SafetyTestCustomer.transaction do |conn|
+  existence = conn.exists?(@pitfall_customer.dbkey)
+  @wrong_result = if existence
+    'always_executed'
+  else
+    'never_executed'
+  end
+end
+@wrong_result
+#=> 'always_executed'
+
+## create with success callback works
+@callback_executed = false
+SafetyTestCustomer.create!(email: "#{safety_test_id('callback')}@example.com") do |customer|
+  @callback_executed = true
+  customer.hset(:login_count, '1')
+end
+@callback_executed
+#=> true
+
+## multi-object atomic updates work
+@order_customer = SafetyTestCustomer.new(email: "#{safety_test_id('order')}@example.com")
+@order_customer.save
+
+@multi_result = SafetyTestCustomer.transaction do
+  @order_customer.hset(:status, 'confirmed')
+  @order_customer.orders.push('order123')
+  @order_customer.hset(:login_count, '1')
+end
+@multi_result.successful?
+#=> true
+
+## watch pattern for optimistic locking works
+@watch_customer = SafetyTestCustomer.new(email: "#{safety_test_id('watch')}@example.com")
+@watch_customer.save
+@watch_customer.hset(:balance, '1000')
+
+@success = @watch_customer.watch do
+  current_balance = @watch_customer.hget(:balance).to_i
+
+  if current_balance >= 100
+    @watch_customer.transaction do
+      @watch_customer.hset(:balance, (current_balance - 100).to_s)
+      @watch_customer.hset(:purchases, '1')
+    end
+  end
+end
+
+@new_balance = @watch_customer.hget(:balance).to_i
+@new_balance <= 900
+#=> true