familia 2.0.0.pre4 → 2.0.0.pre6

data/lib/familia/version.rb

@@ -3,6 +3,6 @@
 module Familia
   # Version information for the Familia
   unless defined?(Familia::VERSION)
-    VERSION = '2.0.0.pre4'
+    VERSION = '2.0.0.pre6'
   end
 end

data/lib/familia.rb

@@ -73,13 +73,14 @@ module Familia
   require_relative 'familia/utils'
 
   extend SecureIdentifier
-  extend Logging
   extend Connection
   extend Settings
+  extend Logging
   extend Utils
 end
 
 require_relative 'familia/base'
 require_relative 'familia/features'
-require_relative 'familia/datatype'
+require_relative 'familia/data_type'
 require_relative 'familia/horreum'
+require_relative 'familia/encryption'

data/try/core/base_enhancements_try.rb

@@ -0,0 +1,115 @@
+# try/core/base_enhancements_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Base class provides default UUID generation
+class BaseUuidTest < Familia::Horreum
+  identifier_field :id
+  field :id
+end
+
+# Empty class still has base functionality
+class EmptyBaseTest < Familia::Horreum
+end
+
+@base_uuid = BaseUuidTest.new(id: 'uuid_test_1')
+
+## UUID generation creates unique identifiers
+@uuid1 = @base_uuid.uuid
+@uuid1
+#=:> String
+
+## UUID is properly formatted
+@uuid1
+#=~>/\A[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i
+
+## UUID is memoized (same value on repeated calls)
+@uuid2 = @base_uuid.uuid
+@uuid1 == @uuid2
+#=> true
+
+## Different instances get different UUIDs
+@base_uuid2 = BaseUuidTest.new(id: 'uuid_test_2')
+@base_uuid.uuid != @base_uuid2.uuid
+#=> true
+
+## Base class provides ID generation
+@generated_id1 = @base_uuid.generate_id
+@generated_id1
+#=:> String
+
+## Generated ID is memoized
+@generated_id2 = @base_uuid.generate_id
+@generated_id1 == @generated_id2
+#=> true
+
+## Base class to_s method returns identifier
+@base_uuid.to_s
+#=> "uuid_test_1"
+
+## Feature registry is accessible
+Familia::Base.features_available
+#=:> Hash
+
+## Feature definitions registry is accessible
+Familia::Base.feature_definitions
+#=:> Hash
+
+## Base class includes proper modules
+BaseUuidTest.ancestors.include?(Familia::Base)
+#=> true
+
+## Feature methods are accessible through the class
+BaseUuidTest.respond_to?(:feature)
+#=> true
+
+## Class instance variables are properly initialized
+BaseUuidTest.instance_variable_get(:@fields)
+#=:> Array
+
+## Field definitions are properly initialized
+BaseUuidTest.instance_variable_get(:@field_types)
+#=:> Hash
+
+## Feature system is properly integrated
+BaseUuidTest.respond_to?(:feature)
+#=> true
+
+## Feature registration methods are available
+Familia::Base.respond_to?(:add_feature)
+#=> true
+
+## Valid identifiers work correctly
+@base_uuid.identifier
+#=> "uuid_test_1"
+
+## Empty class has base methods available
+EmptyBaseTest.ancestors.include?(Familia::Base)
+#=> true
+
+## Empty class can use feature system
+EmptyBaseTest.respond_to?(:feature)
+#=> true
+
+## Test Base module constants are defined
+Familia::Base.features_available
+#=:> Hash
+
+## Dump and load methods are set
+Familia::Base.dump_method
+#=> :to_json
+
+## Load method is set correctly
+Familia::Base.load_method
+#=> :from_json
+
+## Base module provides inspect with class name
+@base_uuid.inspect.include?('BaseUuidTest')
+#=> true
+
+@base_uuid.destroy! rescue nil
+@base_uuid2.destroy! rescue nil
+@base_uuid = nil
+@base_uuid2 = nil

data/try/core/connection_try.rb

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

data/try/core/create_method_try.rb

@@ -0,0 +1,240 @@
+# try/core/create_method_try.rb
+#
+# Comprehensive test coverage for the create method
+# Tests the correct exception type and error message handling
+
+require_relative '../helpers/test_helpers'
+
+# Test class for create method behavior
+class CreateTestModel < 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('createtestmodel:*')
+  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
+  "create-test-#{Time.now.to_i}-#{@test_id_counter}"
+end
+
+# =============================================
+# 1. Basic create method functionality
+# =============================================
+
+## create method successfully creates new object
+@test_id = next_test_id
+@created_obj = CreateTestModel.create(id: @test_id, name: 'Created Object', value: 'test_value')
+[@created_obj.class, @created_obj.exists?, @created_obj.name]
+#=> [CreateTestModel, true, 'Created Object']
+
+## create method returns the created object
+@created_obj.is_a?(CreateTestModel)
+#=> true
+
+## create method persists object fields
+@created_obj.refresh!
+[@created_obj.name, @created_obj.value]
+#=> ['Created Object', 'test_value']
+
+# =============================================
+# 2. Duplicate creation error handling
+# =============================================
+
+## create method raises RecordExistsError for duplicate
+begin
+  CreateTestModel.create(id: @test_id, name: 'Duplicate Attempt')
+  false  # Should not reach here
+rescue => e
+  e.class
+end
+#=> Familia::RecordExistsError
+
+## RecordExistsError includes the dbkey in the message
+begin
+  CreateTestModel.create(id: @test_id, name: 'Another Duplicate')
+  false  # Should not reach here
+rescue Familia::RecordExistsError => e
+  expected_dbkey = "createtestmodel:#{@test_id}:object"
+  e.message.include?(expected_dbkey)
+end
+#=> true
+
+## RecordExistsError message follows consistent format
+begin
+  CreateTestModel.create(id: @test_id, name: 'Yet Another Duplicate')
+  false  # Should not reach here
+rescue Familia::RecordExistsError => e
+  e.message.start_with?('Key already exists:')
+end
+#=> true
+
+## RecordExistsError exposes key property for programmatic access
+@final_test_id = next_test_id
+CreateTestModel.create(id: @final_test_id, name: 'Setup for Key Test')
+
+begin
+  CreateTestModel.create(id: @final_test_id, name: 'Key Test Duplicate')
+  false  # Should not reach here
+rescue Familia::RecordExistsError => e
+  # Key should be accessible and contain the identifier
+  [e.respond_to?(:key), e.key.include?(@final_test_id)]
+end
+#=> [true, true]
+
+# =============================================
+# 3. Edge cases and error conditions
+# =============================================
+
+## create with empty identifier raises NoIdentifier error
+CreateTestModel.create(id: '')
+#=!> Familia::NoIdentifier
+
+## create with nil identifier raises NoIdentifier error
+CreateTestModel.create(id: nil)
+#=!> Familia::NoIdentifier
+
+## create with only some fields set
+@partial_id = next_test_id
+@partial_obj = CreateTestModel.create(id: @partial_id, name: 'Partial Object')
+[@partial_obj.exists?, @partial_obj.name, @partial_obj.value]
+#=> [true, 'Partial Object', nil]
+
+## create with no additional fields (only identifier)
+@minimal_id = next_test_id
+@minimal_obj = CreateTestModel.create(id: @minimal_id)
+[@minimal_obj.exists?, @minimal_obj.id]
+#=> [true, @minimal_id]
+
+# =============================================
+# 4. Concurrency and transaction behavior
+# =============================================
+
+## create is atomic - no partial state on failure
+@concurrent_id = next_test_id
+@first_obj = CreateTestModel.create(id: @concurrent_id, name: 'First')
+
+# Verify first object exists
+first_exists = @first_obj.exists?
+
+# Attempt to create duplicate should not affect existing object
+begin
+  CreateTestModel.create(id: @concurrent_id, name: 'Concurrent Attempt')
+  false  # Should not reach here
+rescue Familia::RecordExistsError
+  # Original object should be unchanged
+  @first_obj.refresh!
+  @first_obj.name == 'First'
+end
+#=> true
+
+## create failure doesn't leave partial data
+before_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+begin
+  CreateTestModel.create(id: @concurrent_id, name: 'Should Fail')
+rescue Familia::RecordExistsError
+  # Should not create any additional keys
+  after_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+  after_failed_create == before_failed_create
+end
+#=> true
+
+# =============================================
+# 5. Consistency with save_if_not_exists
+# =============================================
+
+## Both create and save_if_not_exists raise same error type for duplicates
+@consistency_id = next_test_id
+@consistency_obj = CreateTestModel.create(id: @consistency_id, name: 'Consistency Test')
+
+# Test create raises RecordExistsError
+create_error_class = begin
+  CreateTestModel.create(id: @consistency_id, name: 'Create Duplicate')
+  nil
+rescue => e
+  e.class
+end
+
+# Test save_if_not_exists raises RecordExistsError
+sine_error_class = begin
+  duplicate_obj = CreateTestModel.new(id: @consistency_id, name: 'SINE Duplicate')
+  duplicate_obj.save_if_not_exists
+  nil
+rescue => e
+  e.class
+end
+
+[create_error_class, sine_error_class]
+#=> [Familia::RecordExistsError, Familia::RecordExistsError]
+
+## Both methods have similar error message patterns
+@error_comparison_id = next_test_id
+CreateTestModel.create(id: @error_comparison_id, name: 'Error Comparison')
+
+create_error_msg = begin
+  CreateTestModel.create(id: @error_comparison_id, name: 'Create Error')
+  nil
+rescue => e
+  e.message
+end
+
+sine_error_msg = begin
+  CreateTestModel.new(id: @error_comparison_id, name: 'SINE Error').save_if_not_exists
+  nil
+rescue => e
+  e.message
+end
+
+# Both should reference the same key concept
+[create_error_msg.include?('already exists'), sine_error_msg.include?('already exists')]
+#=> [true, true]
+
+# =============================================
+# 6. Integration with different field types
+# =============================================
+
+## create works with complex field values
+@complex_id = next_test_id
+@complex_obj = CreateTestModel.create(
+  id: @complex_id,
+  name: 'Complex Object',
+  value: { nested: 'data', array: [1, 2, 3] }
+)
+[@complex_obj.exists?, @complex_obj.value[:nested]]
+#=> [true, 'data']
+
+# =============================================
+# 7. Class vs instance method consistency
+# =============================================
+
+## Class.create and instance.save_if_not_exists have consistent existence checking
+@consistency_check_id = next_test_id
+
+# Create via class method
+@class_created = CreateTestModel.create(id: @consistency_check_id, name: 'Class Created')
+
+# Both class and instance methods should see the object as existing
+class_sees_exists = CreateTestModel.exists?(@consistency_check_id)
+instance_sees_exists = @class_created.exists?
+
+[class_sees_exists, instance_sees_exists]
+#=> [true, true]
+
+# =============================================
+# Cleanup
+# =============================================
+
+# Clean up all test data
+test_keys = Familia.dbclient.keys('createtestmodel:*')
+Familia.dbclient.del(*test_keys) if test_keys.any?

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?