familia 2.0.0.pre5 → 2.0.0.pre6

data/try/core/database_consistency_try.rb

@@ -0,0 +1,299 @@
+# try/core/database_consistency_try.rb
+#
+# Database consistency verification and edge case testing
+# Complements persistence_operations_try.rb with deeper consistency checks
+
+require_relative '../helpers/test_helpers'
+
+# Test class with different field types for consistency verification
+class ConsistencyTestModel < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  field :email
+  field :active
+  field :metadata  # For complex data types
+end
+
+# Clean up existing test data
+cleanup_keys = []
+begin
+  existing_test_keys = Familia.dbclient.keys('consistencytestmodel:*')
+  cleanup_keys.concat(existing_test_keys)
+  Familia.dbclient.del(*existing_test_keys) if existing_test_keys.any?
+rescue => e
+  # Ignore cleanup errors
+end
+
+@test_id_counter = 0
+def next_test_id
+  @test_id_counter += 1
+  "consistency-#{Time.now.to_i}-#{@test_id_counter}"
+end
+
+# =============================================
+# 1. Database Consistency Verification
+# =============================================
+
+## Redis key structure follows expected pattern
+@key_test = ConsistencyTestModel.new(id: next_test_id, name: 'Key Test')
+@key_test.save
+dbkey = @key_test.dbkey
+key_parts = dbkey.split(':')
+# Should have pattern: [prefix, identifier, suffix]
+[key_parts.length >= 3, key_parts.include?(@key_test.identifier), key_parts.last]
+#=> [true, true, 'object']
+
+## Field serialization/deserialization roundtrips correctly
+@serial_test = ConsistencyTestModel.new(id: next_test_id)
+# Test different data types
+@serial_test.name = 'Serialization Test'
+@serial_test.active = true
+@serial_test.metadata = { key: 'value', array: [1, 2, 3] }
+@serial_test.save
+
+# 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]}]
+
+## Hash field count matches object field count
+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]
+
+## Memory vs persistence state consistency after save
+@consistency_obj = ConsistencyTestModel.new(id: next_test_id, name: 'Memory Test', email: 'test@example.com')
+@consistency_obj.save
+
+# Get memory state
+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')
+
+[memory_name == redis_name, memory_email == redis_email]
+#=> [true, true]
+
+# =============================================
+# 2. Concurrent Modification Detection
+# =============================================
+
+## Multiple objects with same identifier maintain consistency
+obj1 = ConsistencyTestModel.new(id: next_test_id, name: 'Object 1')
+obj1.save
+obj1_id = obj1.identifier
+
+# Create second object with same ID (simulating concurrent access)
+obj2 = ConsistencyTestModel.new(id: obj1_id, name: 'Object 2')
+obj2.save  # This overwrites obj1's data
+
+# Both objects should now see the updated data when refreshed
+obj1.refresh!
+obj2.refresh!
+[obj1.name == obj2.name, obj1.name]
+#=> [true, 'Object 2']
+
+## exists? consistency under concurrent modifications
+@concurrent_mod = ConsistencyTestModel.new(id: next_test_id, name: 'Concurrent')
+@concurrent_mod.save
+before_modify = @concurrent_mod.exists?
+
+# Simulate external modification
+Familia.dbclient.hset(@concurrent_mod.dbkey, 'name', 'Modified Externally')
+after_modify = @concurrent_mod.exists?
+
+# exists? should still return true regardless of field changes
+[before_modify, after_modify]
+#=> [true, true]
+
+# =============================================
+# 3. Edge Cases and Error Conditions
+# =============================================
+
+## Corrupted data handling (malformed JSON in complex fields)
+@corrupt_test = ConsistencyTestModel.new(id: next_test_id)
+@corrupt_test.save
+
+# Manually insert malformed JSON
+Familia.dbclient.hset(@corrupt_test.dbkey, 'metadata', '{"invalid": json}')
+
+# Object should handle corrupted data gracefully
+begin
+  @corrupt_test.refresh!
+  # metadata should be returned as string since JSON parsing failed
+  @corrupt_test.metadata.class
+rescue => e
+  "Error: #{e.class}"
+end
+#=> String
+
+## Empty hash object edge case (critical for check_size parameter)
+@empty_hash = ConsistencyTestModel.new(id: next_test_id)
+# Save creates the hash with identifier
+@empty_hash.save
+
+# Manually remove all fields to create an empty hash
+# First add a temp field then remove it, which creates empty hash in some Redis versions
+Familia.dbclient.hset(@empty_hash.dbkey, 'temp_field', 'temp_value')
+Familia.dbclient.hdel(@empty_hash.dbkey, 'temp_field')
+# Now remove all remaining fields to create truly empty hash
+all_fields = Familia.dbclient.hkeys(@empty_hash.dbkey)
+Familia.dbclient.hdel(@empty_hash.dbkey, *all_fields) if all_fields.any?
+
+# exists? behavior with empty hash
+key_exists_raw = Familia.dbclient.exists(@empty_hash.dbkey) > 0
+hash_length = Familia.dbclient.hlen(@empty_hash.dbkey)
+obj_exists_with_check = @empty_hash.exists?(check_size: true)
+obj_exists_without_check = @empty_hash.exists?(check_size: false)
+
+[key_exists_raw, hash_length, obj_exists_without_check, obj_exists_with_check]
+#=> [false, 0, false, false]
+
+## Transaction isolation verification
+@tx_test = ConsistencyTestModel.new(id: next_test_id, name: 'Transaction Test')
+@tx_test.save
+
+# Verify transaction doesn't interfere with exists? calls
+result = @tx_test.transaction do |conn|
+  # During transaction, exists? should still work
+  exists_in_tx = @tx_test.exists?
+  conn.hset(@tx_test.dbkey, 'active', 'true')
+  exists_in_tx
+end
+
+exists_after_tx = @tx_test.exists?
+[result, exists_after_tx]
+#=> [[0], true]
+
+# =============================================
+# 4. Performance Consistency
+# =============================================
+
+## exists? performance is consistent regardless of object size
+@small_obj = ConsistencyTestModel.new(id: next_test_id, name: 'Small')
+@small_obj.save
+
+@large_obj = ConsistencyTestModel.new(id: next_test_id)
+@large_obj.name = 'Large Object'
+@large_obj.email = 'large@example.com'
+@large_obj.metadata = { large_data: 'x' * 1000 }
+@large_obj.save
+
+# exists? should work equally fast for both
+small_exists = @small_obj.exists?
+large_exists = @large_obj.exists?
+
+[small_exists, large_exists]
+#=> [true, true]
+
+## Batch operations maintain consistency
+@batch_obj = ConsistencyTestModel.new(id: next_test_id, name: 'Original Batch')
+@batch_obj.save
+
+# Batch update multiple fields
+batch_result = @batch_obj.batch_update(
+  name: 'Updated Batch',
+  email: 'batch@example.com',
+  active: true
+)
+
+# Verify exists? still works correctly after batch operations
+exists_after_batch = @batch_obj.exists?
+[@batch_obj.name, batch_result.successful?, exists_after_batch]
+#=> ['Updated Batch', true, true]
+
+# =============================================
+# 5. Integration Consistency with Features
+# =============================================
+
+## Transient fields don't affect exists? behavior
+class TransientConsistencyTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  transient_field :temp_value
+end
+
+@transient_obj = TransientConsistencyTest.new(id: next_test_id, name: 'Transient Test')
+@transient_obj.temp_value = 'This should not persist'
+@transient_obj.save
+
+# exists? should work normally despite transient fields
+exists_with_transient = @transient_obj.exists?
+
+@transient_obj.refresh!
+# Transient field should be nil after refresh, but exists? should still work
+transient_nil = @transient_obj.temp_value.nil?
+exists_after_refresh = @transient_obj.exists?
+
+[exists_with_transient, transient_nil, exists_after_refresh]
+#=> [true, true, true]
+
+# =============================================
+# 6. Database Command Consistency
+# =============================================
+
+## save/exists?/destroy lifecycle is consistent
+@lifecycle_obj = ConsistencyTestModel.new(id: next_test_id, name: 'Lifecycle Test')
+
+# Initial state
+initial_exists = @lifecycle_obj.exists?
+
+# After save
+@lifecycle_obj.save
+saved_exists = @lifecycle_obj.exists?
+
+# After modification
+@lifecycle_obj.name = 'Modified Lifecycle'
+@lifecycle_obj.save
+modified_exists = @lifecycle_obj.exists?
+
+# After destroy
+@lifecycle_obj.destroy!
+destroyed_exists = @lifecycle_obj.exists?
+
+[initial_exists, saved_exists, modified_exists, destroyed_exists]
+#=> [false, true, true, false]
+
+## Field removal doesn't break exists?
+@field_removal = ConsistencyTestModel.new(id: next_test_id, name: 'Field Removal')
+@field_removal.save
+
+# Remove a field manually
+Familia.dbclient.hdel(@field_removal.dbkey, 'name')
+
+# exists? should still work
+exists_after_field_removal = @field_removal.exists?
+remaining_fields = Familia.dbclient.hlen(@field_removal.dbkey)
+
+[exists_after_field_removal, remaining_fields > 0]
+#=> [true, true]
+
+## Class vs instance exists? always consistent
+@class_instance_test = ConsistencyTestModel.new(id: next_test_id, name: 'Class Instance Test')
+@class_instance_test.save
+
+# Multiple checks should always be consistent
+results = 5.times.map do
+  class_result = ConsistencyTestModel.exists?(@class_instance_test.identifier)
+  instance_result = @class_instance_test.exists?
+  class_result == instance_result
+end
+
+results.all?
+#=> true
+
+# =============================================
+# Cleanup
+# =============================================
+
+# Clean up all test data
+test_keys = Familia.dbclient.keys('consistencytestmodel:*')
+test_keys.concat(Familia.dbclient.keys('transientconsistencytest:*'))
+Familia.dbclient.del(*test_keys) if test_keys.any?

data/try/core/errors_try.rb

@@ -72,21 +72,42 @@ end
 begin
   raise Familia::KeyNotFoundError.new('test:key')
 rescue Familia::KeyNotFoundError => e
-  e.message.include?('Key not found in Redis')
+  e.message.include?('Key not found')
 end
 #=> true
 
 ## KeyNotFoundError has custom message again
 raise Familia::KeyNotFoundError.new('test:key')
-#=!> error.message.include?("Key not found in Redis")
+#=!> error.message.include?("Key not found")
 #=!> error.class == Familia::KeyNotFoundError
 
+## RecordExistsError stores key
+begin
+  raise Familia::RecordExistsError.new('existing:key')
+rescue Familia::RecordExistsError => e
+  e.key
+end
+#=> "existing:key"
+
+## RecordExistsError has custom message
+begin
+  raise Familia::RecordExistsError.new('existing:key')
+rescue Familia::RecordExistsError => e
+  e.message.include?('Key already exists')
+end
+#=> true
+
+## RecordExistsError inherits from NonUniqueKey
+Familia::RecordExistsError.superclass
+#=> Familia::NonUniqueKey
+
 ## All error classes inherit from Problem
 [
   Familia::NoIdentifier,
   Familia::NonUniqueKey,
   Familia::HighRiskFactor,
   Familia::NotConnected,
-  Familia::KeyNotFoundError
-].all? { |klass| klass.superclass == Familia::Problem }
+  Familia::KeyNotFoundError,
+  Familia::RecordExistsError
+].all? { |klass| klass.superclass == Familia::Problem || klass.superclass.superclass == Familia::Problem }
 ##=> true

data/try/core/familia_try.rb

@@ -4,7 +4,7 @@ require_relative '../helpers/test_helpers'
 
 ## Check for help class
 Bone.related_fields.keys # consistent b/c hashes are ordered
-#=> [:owners, :tags, :metrics, :props, :value]
+#=> [:owners, :tags, :metrics, :props, :value, :counter, :lock]
 
 ## Familia has a uri
 Familia.uri

data/try/core/persistence_operations_try.rb

@@ -0,0 +1,297 @@
+# try/core/persistence_operations_try.rb
+#
+# 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'
+
+# Use a simple test class to isolate persistence behavior
+class PersistenceTestModel < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  field :value
+end
+
+# Clean up any existing test data
+cleanup_keys = []
+begin
+  existing_test_keys = Familia.dbclient.keys('persistencetestmodel:*')
+  cleanup_keys.concat(existing_test_keys)
+  Familia.dbclient.del(*existing_test_keys) if existing_test_keys.any?
+rescue => e
+  # Ignore cleanup errors
+end
+
+@test_id_counter = 0
+def next_test_id
+  @test_id_counter += 1
+  "test-#{Time.now.to_i}-#{@test_id_counter}"
+end
+
+# =============================================
+# 1. exists? Method Coverage - The Critical Bug
+# =============================================
+
+## New object does not exist (both variants)
+@new_obj = PersistenceTestModel.new(id: next_test_id, name: 'New Object')
+[@new_obj.exists?, @new_obj.exists?(check_size: false)]
+#=> [false, false]
+
+## Object exists after save (both variants)
+@new_obj.save
+[@new_obj.exists?, @new_obj.exists?(check_size: false)]
+#=> [true, true]
+
+## Class-level and instance-level exists? consistency
+class_exists = PersistenceTestModel.exists?(@new_obj.identifier)
+instance_exists = @new_obj.exists?
+[class_exists, instance_exists]
+#=> [true, true]
+
+## Empty object exists check (critical edge case)
+@empty_obj = PersistenceTestModel.new(id: next_test_id)
+@empty_obj.save  # Save with no fields set
+# Should return true with check_size: false (key exists)
+# Should return false with check_size: true (but fields exist due to id)
+[@empty_obj.exists?(check_size: false), @empty_obj.exists?(check_size: true)]
+#=> [true, true]
+
+## Object with only nil fields edge case
+@nil_fields_obj = PersistenceTestModel.new(id: next_test_id, name: nil, value: nil)
+@nil_fields_obj.save
+# Should handle nil fields correctly
+[@nil_fields_obj.exists?(check_size: false), @nil_fields_obj.exists?(check_size: true)]
+#=> [true, true]
+
+## Object destroyed does not exist (both variants)
+@new_obj.destroy!
+[@new_obj.exists?, @new_obj.exists?(check_size: false)]
+#=> [false, false]
+
+# =============================================
+# 2. save Method Coverage
+# =============================================
+
+## Basic save functionality
+@save_test = PersistenceTestModel.new(id: next_test_id, name: 'Save Test', value: 'data')
+result = @save_test.save
+[result, @save_test.exists?]
+#=> [true, true]
+
+## Save with update_expiration: false
+@save_no_exp = PersistenceTestModel.new(id: next_test_id, name: 'No Expiration')
+result = @save_no_exp.save(update_expiration: false)
+[result, @save_no_exp.exists?]
+#=> [true, true]
+
+## Save operation idempotency (multiple saves)
+@idempotent_obj = PersistenceTestModel.new(id: next_test_id, name: 'Idempotent')
+first_save = @idempotent_obj.save
+@idempotent_obj.name = 'Modified'
+second_save = @idempotent_obj.save
+[first_save, second_save, @idempotent_obj.exists?]
+#=> [true, true, true]
+
+## Save with partial field data
+@partial_obj = PersistenceTestModel.new(id: next_test_id)
+@partial_obj.name = 'Only Name Set'
+# value field is nil/unset
+result = @partial_obj.save
+[result, @partial_obj.exists?, @partial_obj.name]
+#=> [true, true, 'Only Name Set']
+
+# =============================================
+# 3. save_if_not_exists Method Coverage
+# =============================================
+
+## save_if_not_exists saves new object successfully
+@sine_new = PersistenceTestModel.new(id: next_test_id, name: 'Save If Not Exists New')
+result = @sine_new.save_if_not_exists
+[result, @sine_new.exists?]
+#=> [true, true]
+
+## 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
+#=!> Familia::RecordExistsError
+
+## save_if_not_exists with update_expiration: false
+@sine_no_exp = PersistenceTestModel.new(id: next_test_id, name: 'No Exp SINE')
+result = @sine_no_exp.save_if_not_exists(update_expiration: false)
+[result, @sine_no_exp.exists?]
+#=> [true, true]
+
+## Object state unchanged after save_if_not_exists failure
+original_name = 'Original Name'
+@sine_fail_test = PersistenceTestModel.new(id: next_test_id, 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
+
+# =============================================
+# 4. create Method Coverage (MISSING from current tests)
+# =============================================
+
+# NOTE: create method tests disabled due to Redis::Future bug
+# This would be high-priority coverage but needs the create method bug fixed first
+
+## create method alternative: manual creation simulation
+@manual_created = PersistenceTestModel.new(id: next_test_id, name: 'Manual Created', value: 'manual')
+before_create = @manual_created.exists?
+if @manual_created.exists?
+  raise Familia::Problem, "Object already exists"
+else
+  @manual_created.save
+end
+after_create = @manual_created.exists?
+[before_create, after_create, @manual_created.name]
+#=> [false, true, 'Manual Created']
+
+## create duplicate prevention simulation
+@duplicate_test = PersistenceTestModel.new(id: @manual_created.identifier, name: 'Duplicate Attempt')
+begin
+  if @duplicate_test.exists?
+    raise Familia::Problem, "Object already exists"
+  else
+    @duplicate_test.save
+  end
+  false  # Should not reach here
+rescue Familia::Problem
+  true   # Expected
+end
+#=> true
+
+# =============================================
+# 5. State Transition Testing (Critical Gap)
+# =============================================
+
+## NEW → SAVED: Verify exists? changes from false to true
+@state_obj = PersistenceTestModel.new(id: next_test_id, name: 'State Transition')
+@before_save = @state_obj.exists?
+@state_obj.save
+@after_save = @state_obj.exists?
+[@before_save, @after_save]
+#=> [false, true]
+
+## SAVED → DESTROYED: Verify exists? changes from true to false
+# Use the same state object from previous test
+@state_obj.destroy!
+@after_destroy = @state_obj.exists?
+[@after_save, @after_destroy]  # Use instance variables
+#=> [true, false]
+
+## SAVED → MODIFIED → SAVED: State consistency through updates
+@mod_obj = PersistenceTestModel.new(id: next_test_id, name: 'Original', value: 'original_val')
+@mod_obj.save
+original_exists = @mod_obj.exists?
+@mod_obj.name = 'Modified'
+@mod_obj.value = 'modified_val'
+@mod_obj.save
+modified_exists = @mod_obj.exists?
+# Refresh to verify persistence
+@mod_obj.refresh!
+persisted_name = @mod_obj.name
+[original_exists, modified_exists, persisted_name]
+#=> [true, true, 'Modified']
+
+## Field persistence across state changes
+@field_obj = PersistenceTestModel.new(id: next_test_id)
+# Start with no name
+@field_obj.save
+@field_obj.name = 'Added Later'
+@field_obj.save
+@field_obj.refresh!
+@field_obj.name
+#=> 'Added Later'
+
+# =============================================
+# 6. Integration with Features
+# =============================================
+
+## exists? behavior with encrypted fields (if available)
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class EncryptedPersistenceTest < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  field :email
+  encrypted_field :secret_value
+end
+
+@enc_obj = EncryptedPersistenceTest.new(id: next_test_id, email: 'test@example.com')
+before_save = @enc_obj.exists?
+@enc_obj.save
+@enc_obj.secret_value = 'encrypted_data'
+@enc_obj.save
+after_save = @enc_obj.exists?
+
+# Clean up encryption config
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil
+
+[before_save, after_save]
+#=> [false, true]
+
+# =============================================
+# 7. Error Handling & Edge Cases
+# =============================================
+
+## Empty identifier handling
+begin
+  empty_id_obj = PersistenceTestModel.new(id: '')
+  PersistenceTestModel.exists?('')
+  false  # Should not reach here
+rescue Familia::NoIdentifier
+  true   # Expected error
+end
+#=> true
+
+## nil identifier handling
+begin
+  nil_id_obj = PersistenceTestModel.new(id: nil)
+  PersistenceTestModel.exists?(nil)
+  false  # Should not reach here
+rescue Familia::NoIdentifier
+  true   # Expected error
+end
+#=> true
+
+## Concurrent exists? checks are consistent
+@concurrent_obj = PersistenceTestModel.new(id: next_test_id, name: 'Concurrent Test')
+@concurrent_obj.save
+
+# Multiple exists? calls should be consistent
+results = 3.times.map { @concurrent_obj.exists? }
+results.uniq.length
+#=> 1
+
+## Database key structure validation
+@key_obj = PersistenceTestModel.new(id: next_test_id)
+@key_obj.save
+expected_suffix = ":#{@key_obj.identifier}:object"
+actual_key = @key_obj.dbkey
+[actual_key.include?(expected_suffix), @key_obj.exists?]
+#=> [true, true]
+
+# =============================================
+# Cleanup
+# =============================================
+
+# Clean up test data
+test_keys = Familia.dbclient.keys('persistencetestmodel:*')
+test_keys.concat(Familia.dbclient.keys('encryptedpersistencetest:*')) if defined?(EncryptedPersistenceTest)
+Familia.dbclient.del(*test_keys) if test_keys.any?