familia 2.0.0.pre4 → 2.0.0.pre6

data/try/core/errors_try.rb

@@ -1,6 +1,5 @@
 # try/core/errors_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false
@@ -73,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_extended_try.rb

@@ -2,7 +2,6 @@
 
 require 'time'
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 ## Has all datatype relativess
@@ -11,15 +10,15 @@ registered_types.collect(&:to_s).sort
 #=> ["counter", "hash", "hashkey", "list", "lock", "set", "sorted_set", "string", "zset"]
 
 ## Familia created class methods for datatype list class
-Familia::Horreum::ClassMethods.public_method_defined? :list?
+Familia::Horreum::DefinitionMethods.public_method_defined? :list?
 #=> true
 
 ## Familia created class methods for datatype list class
-Familia::Horreum::ClassMethods.public_method_defined? :list
+Familia::Horreum::DefinitionMethods.public_method_defined? :list
 #=> true
 
 ## Familia created class methods for datatype list class
-Familia::Horreum::ClassMethods.public_method_defined? :lists
+Familia::Horreum::DefinitionMethods.public_method_defined? :lists
 #=> true
 
 ## A Familia object knows its datatype relatives

data/try/core/familia_try.rb

@@ -1,11 +1,10 @@
 # try/core/familia_try.rb
 
-require_relative '../../lib/familia'
 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?

data/try/core/pools_try.rb

@@ -30,7 +30,7 @@ end
 class PoolTestAccount < Familia::Horreum
   identifier_field :account_id
   field :account_id
-  field :balance
+  field :balance, on_conflict: :skip
   field :holder_name
 
   def init
@@ -83,7 +83,7 @@ class PoolTestAccountDB1 < Familia::Horreum
   self.logical_database = 1
   identifier_field :account_id
   field :account_id
-  field :balance
+  field :balance, on_conflict: :skip
   field :holder_name
 
   def init

data/try/core/secure_identifier_try.rb

@@ -2,7 +2,6 @@
 
 # Test Familia::SecureIdentifier methods
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

data/try/core/settings_try.rb

@@ -1,6 +1,5 @@
 # try/core/settings_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

data/try/core/utils_try.rb

@@ -1,6 +1,5 @@
 # try/core/utils_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

data/try/{datatypes → data_types}/boolean_try.rb

@@ -1,6 +1,5 @@
-# try/datatypes/boolean_try.rb
+# try/data_types/boolean_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

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/{datatypes → data_types}/datatype_base_try.rb

@@ -1,6 +1,5 @@
-# try/datatypes/base_try.rb
+# try/data_types/base_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 @limiter1 = Limiter.new :requests
@@ -64,6 +63,6 @@ p [@limiter1.counter.parent.default_expiration, @limiter2.counter.parent.default
 #=> 3600.0
 
 ## Check current_expiration
-sleep 1 # Database default_expirations are in seconds so we can't wait any less time than this (without mocking)
+sleep 1 # NOTE: Mocking time would be foolish in life, but helpful here
 @limiter1.counter.current_expiration
 #=> 3600-1

data/try/{datatypes → data_types}/hash_try.rb

@@ -1,6 +1,5 @@
-# try/datatypes/hash_try.rb
+# try/data_types/hash_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 @a = Bone.new 'atoken'

data/try/{datatypes → data_types}/list_try.rb

@@ -1,6 +1,5 @@
-# try/datatypes/list_try.rb
+# try/data_types/list_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 @a = Bone.new 'atoken'

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!