familia 2.0.0.pre5 → 2.0.0.pre7

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?

data/try/data_types/counter_try.rb

@@ -0,0 +1,93 @@
+# try/data_types/counter_try.rb
+
+require_relative '../helpers/test_helpers'
+
+@a = Bone.new(token: 'atoken3')
+
+## Bone#dbkey
+@a.dbkey
+#=> 'bone:atoken3:object'
+
+## Familia::Counter should have default value of 0
+@a.counter.value
+#=> 0
+
+## Familia::Counter#value=
+@a.counter.value = 42
+#=> 42
+
+## Familia::Counter#to_i
+@a.counter.to_i
+#=> 42
+
+## Familia::Counter#to_s
+@a.counter.to_s
+#=> '42'
+
+## Familia::Counter#increment
+@a.counter.increment
+#=> 43
+
+## Familia::Counter#incrementby
+@a.counter.incrementby(10)
+#=> 53
+
+## Familia::Counter#decrement
+@a.counter.decrement
+#=> 52
+
+## Familia::Counter#decrementby
+@a.counter.decrementby(5)
+#=> 47
+
+## Familia::Counter#reset with value
+@a.counter.reset(100)
+#=> true
+
+## Familia::Counter#reset without value (defaults to 0)
+@a.counter.reset
+@a.counter.reset
+@a.counter.value
+#=> 0
+
+## Familia::Counter#atomic_increment_and_get
+@a.counter.atomic_increment_and_get(25)
+#=> 25
+
+## Familia::Counter#increment_if_less_than (success case)
+@a.counter.increment_if_less_than(50, 10)
+#=> true
+
+## Familia::Counter#value after conditional increment
+@a.counter.to_i
+#=> 35
+
+## Familia::Counter#increment_if_less_than (failure case)
+@a.counter.increment_if_less_than(30, 10)
+#=> false
+
+## Familia::Counter#value unchanged after failed conditional increment
+@a.counter.to_i
+#=> 35
+
+## Familia::Counter.new standalone
+@counter = Familia::Counter.new 'test:counter'
+@counter.dbkey
+#=> 'test:counter'
+
+## Standalone counter starts at 0
+@counter.value
+#=> 0
+
+## Standalone counter increment
+@counter.increment
+#=> 1
+
+## Standalone counter set string value gets coerced to integer
+@counter.value = "123"
+@counter.to_i
+#=> 123
+
+# Cleanup
+@a.counter.delete!
+@counter.delete!

data/try/data_types/lock_try.rb

@@ -0,0 +1,133 @@
+# try/data_types/lock_try.rb
+
+require_relative '../helpers/test_helpers'
+
+@a = Bone.new(token: 'atoken4')
+
+## Bone#dbkey
+@a.dbkey
+#=> 'bone:atoken4:object'
+
+## Familia::Lock should start unlocked
+@a.lock.locked?
+#=> false
+
+## Familia::Lock#value should be nil when unlocked
+@a.lock.value
+#=> nil
+
+## Familia::Lock#acquire returns token when successful
+@token1 = @a.lock.acquire
+@token1.class
+#=> String
+
+## Familia::Lock#locked? after acquire
+@a.lock.locked?
+#=> true
+
+## Familia::Lock#held_by? with correct token
+@a.lock.held_by?(@token1)
+#=> true
+
+## Familia::Lock#held_by? with wrong token
+@a.lock.held_by?('wrong-token')
+#=> false
+
+## Familia::Lock#acquire when already locked returns false
+@a.lock.acquire
+#=> false
+
+## Familia::Lock#release with correct token
+@a.lock.release(@token1)
+#=> true
+
+## Familia::Lock#locked? after release
+@a.lock.locked?
+#=> false
+
+## Familia::Lock#release with wrong token (lock not held)
+@a.lock.release('wrong-token')
+#=> false
+
+## Familia::Lock#acquire with custom token
+@custom_token = 'my-custom-token-123'
+@result = @a.lock.acquire(@custom_token)
+@result
+#=> 'my-custom-token-123'
+
+## Familia::Lock#held_by? with custom token
+@a.lock.held_by?(@custom_token)
+#=> true
+
+## Familia::Lock#force_unlock!
+@a.lock.force_unlock!
+#=> true
+
+## Familia::Lock#locked? after force unlock
+@a.lock.locked?
+#=> false
+
+## Familia::Lock.new standalone
+@lock = Familia::Lock.new 'test:lock'
+@lock.dbkey
+#=> 'test:lock'
+
+## Standalone lock starts unlocked
+@lock.locked?
+#=> false
+
+## Standalone lock acquire
+@standalone_token = @lock.acquire
+@standalone_token.class
+#=> String
+
+## Standalone lock is now locked
+@lock.locked?
+#=> true
+
+## Standalone lock acquire with TTL
+@lock.force_unlock!
+@ttl_token = @lock.acquire('ttl-token', ttl: 1)
+@ttl_token
+#=> 'ttl-token'
+
+## Wait for TTL expiration and check if lock auto-expires
+# Note: This test might be flaky in fast test runs
+sleep 2
+@lock.locked?
+#=> false
+
+## Acquire with zero TTL should return false
+@lock2 = Familia::Lock.new 'test:lock2'
+@lock2.acquire('zero-ttl', ttl: 0)
+#=> false
+
+## Lock should not be held after zero TTL rejection
+@lock2.locked?
+#=> false
+
+## Acquire with negative TTL should return false
+@lock2.acquire('neg-ttl', ttl: -5)
+#=> false
+
+## Lock should not be held after negative TTL rejection
+@lock2.locked?
+#=> false
+
+## Acquire with nil TTL should work (no expiration)
+@nil_ttl_token = @lock2.acquire('no-expiry', ttl: nil)
+@nil_ttl_token
+#=> 'no-expiry'
+
+## Lock with nil TTL should be held
+@lock2.locked?
+#=> true
+
+## Lock with nil TTL should not have expiration
+@lock2.current_expiration
+#=> -1
+
+## Cleanup
+@a.lock.delete!
+@lock.delete!
+@lock2.delete!

data/try/debugging/debug_aad_process.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Debugging AAD during encrypt/decrypt process..."
+
+# Setup encryption keys
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class DebugModelA < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+class DebugModelB < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+# Patch the EncryptedFieldType to add debug output
+class Familia::EncryptedFieldType
+  alias_method :original_encrypt_value, :encrypt_value
+  alias_method :original_decrypt_value, :decrypt_value
+  alias_method :original_build_aad, :build_aad
+
+  def encrypt_value(record, value)
+    context = build_context(record)
+    aad = build_aad(record)
+    puts "[ENCRYPT] Class: #{record.class}, ID: #{record.identifier}, Context: #{context}, AAD: #{aad}"
+    original_encrypt_value(record, value)
+  end
+
+  def decrypt_value(record, encrypted)
+    context = build_context(record)
+    aad = build_aad(record)
+    puts "[DECRYPT] Class: #{record.class}, ID: #{record.identifier}, Context: #{context}, AAD: #{aad}"
+    original_decrypt_value(record, encrypted)
+  end
+
+  def build_aad(record)
+    aad = original_build_aad(record)
+    puts "[BUILD_AAD] Class: #{record.class}, ID: #{record.identifier}, AAD: #{aad}"
+    aad
+  end
+end
+
+# Clean database
+Familia.dbclient.flushdb
+
+model_a = DebugModelA.new(id: 'same-id')
+model_b = DebugModelB.new(id: 'same-id')
+
+puts "\n=== ENCRYPTION PHASE ==="
+puts "Encrypting for ModelA:"
+model_a.api_key = 'secret-key'
+cipher_a = model_a.instance_variable_get(:@api_key)
+
+puts "\nEncrypting for ModelB:"
+model_b.api_key = 'secret-key'
+cipher_b = model_b.instance_variable_get(:@api_key)
+
+puts "\n=== DECRYPTION PHASE - Same Context ==="
+puts "Decrypting ModelA with ModelA context:"
+model_a.api_key.reveal { |plain| puts "Result: #{plain}" }
+
+puts "\n=== DECRYPTION PHASE - Cross Context ==="
+puts "Setting ModelB cipher into ModelA and trying to decrypt:"
+model_a.instance_variable_set(:@api_key, cipher_b)
+begin
+  model_a.api_key.reveal { |plain| puts "ERROR: Cross-context worked: #{plain}" }
+rescue => e
+  puts "SUCCESS: Cross-context failed as expected: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_concealed_internal.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing ConcealedString internal call chain..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Clean database
+Familia.dbclient.flushdb
+
+puts "\n=== CONCEALED STRING INTERNAL DEBUGGING ==="
+
+# Create and save model
+model = TestModel.new(id: 'test1')
+model.secret = 'plaintext-secret'
+model.save
+
+# Load model from database
+loaded_model = TestModel.load('test1')
+concealed_string = loaded_model.secret
+
+# Access internal ConcealedString components
+puts "ConcealedString @encrypted_data: #{concealed_string.instance_variable_get(:@encrypted_data)}"
+puts "ConcealedString @record: #{concealed_string.instance_variable_get(:@record)}"
+puts "ConcealedString @field_type: #{concealed_string.instance_variable_get(:@field_type)}"
+
+record = concealed_string.instance_variable_get(:@record)
+field_type = concealed_string.instance_variable_get(:@field_type)
+encrypted_data = concealed_string.instance_variable_get(:@encrypted_data)
+
+puts "\n=== STEP BY STEP DECRYPTION ==="
+puts "Record class: #{record.class}"
+puts "Record identifier: #{record.identifier}"
+puts "Record exists?: #{record.exists?}"
+puts "Field type class: #{field_type.class}"
+
+# Test the exact same call that ConcealedString.reveal makes
+puts "\nCalling field_type.decrypt_value(record, encrypted_data)..."
+begin
+  result = field_type.decrypt_value(record, encrypted_data)
+  puts "decrypt_value result: #{result}"
+  puts "Result class: #{result.class}"
+rescue => e
+  puts "decrypt_value ERROR: #{e.class}: #{e.message}"
+  puts e.backtrace.first(10)
+end