familia 2.0.0.pre3 → 2.0.0.pre5

data/try/horreum/enhanced_conflict_handling_try.rb

@@ -0,0 +1,176 @@
+# try/horreum/enhanced_conflict_handling_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+## Valid strategies are defined correctly
+Familia::VALID_STRATEGIES.include?(:raise)
+#=> true
+
+## Valid strategies include all expected options
+Familia::VALID_STRATEGIES
+#=> [:raise, :skip, :warn, :overwrite]
+
+## Overwrite strategy removes existing method and defines new one
+class OverwriteStrategyTest < Familia::Horreum
+  identifier_field :id
+  field :id
+
+  def conflicting_method
+    "original_method"
+  end
+
+  field :conflicting_method, on_conflict: :overwrite
+end
+@overwrite_test = OverwriteStrategyTest.new(id: 'overwrite1')
+@overwrite_test.conflicting_method = "new_value"
+@overwrite_test.conflicting_method
+#=> "new_value"
+
+## Overwrite strategy works with fast methods too
+@overwrite_test.save
+@overwrite_test.conflicting_method! "fast_value"
+#=> true
+
+## Invalid conflict strategy raises error during field definition
+class InvalidStrategyTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :test_field, on_conflict: :invalid_strategy
+end
+#=!> ArgumentError
+
+## Method conflict detection works with instance methods
+class ConflictDetectionTest < Familia::Horreum
+  identifier_field :id
+  field :id
+
+  def existing_method
+    "exists"
+  end
+
+  field :existing_method, on_conflict: :raise
+end
+#=!> ArgumentError
+
+## Conflict detection provides helpful error message
+begin
+  class ConflictMessageTest < Familia::Horreum
+    identifier_field :id
+    field :id
+
+    def another_method
+      "exists"
+    end
+
+    field :another_method, on_conflict: :raise
+  end
+rescue ArgumentError => e
+  e.message.include?("another_method")
+end
+#=> true
+
+## Method location information in error message when possible
+
+class LocationInfoTest < Familia::Horreum
+  identifier_field :id
+  field :id
+
+  def location_test_method
+    "exists"
+  end
+
+  field :location_test_method, on_conflict: :raise
+end
+#=!> ArgumentError
+#==> error.message.include?("already defined")
+
+## Skip strategy silently ignores conflicts
+class SkipStrategyTest < Familia::Horreum
+  identifier_field :id
+  field :id
+
+  def skip_method
+    "original"
+  end
+
+  field :skip_method, on_conflict: :skip
+end
+@skip_test = SkipStrategyTest.new(id: 'skip1')
+@skip_test.skip_method
+#=> "original"
+
+## Skip strategy doesn't create accessor methods when method exists
+@skip_test.respond_to?(:skip_method=)
+#=> false
+
+## Warn strategy shows warning but continues with definition
+class WarnStrategyTest < Familia::Horreum
+  identifier_field :id
+  field :id
+
+  def warn_method
+    "original"
+  end
+
+  field :warn_method, on_conflict: :warn
+end
+#=2> /WARNING/
+@warn_test = WarnStrategyTest.new(id: 'warn1')
+@warn_test.warn_method = "new_value"
+@warn_test.warn_method
+#=> "new_value"
+
+## Fast method names must end with exclamation mark
+class InvalidFastMethodTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :test_field, fast_method: :invalid_name
+end
+#=!> ArgumentError
+
+## Fast method validation works with custom names
+class ValidFastMethodTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :score, fast_method: :update_score_now!
+end
+@valid_fast = ValidFastMethodTest.new(id: 'valid1')
+@valid_fast.respond_to?(:update_score_now!)
+#=> true
+
+## Method added hook detects conflicts after field definition
+class MethodAddedHookTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :hook_test, on_conflict: :warn
+
+  def hook_test
+    "redefined_after"
+  end
+end
+#=2> /WARNING/
+#=2> /hook_test/
+#=2> /redefined after field definition/
+
+## Method added hook works with raise strategy too
+class MethodAddedRaiseTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :raise_hook_test, on_conflict: :raise
+
+  def raise_hook_test
+    "redefined"
+  end
+end
+#=!> ArgumentError
+
+@overwrite_test.destroy! rescue nil
+@skip_test.destroy! rescue nil
+@warn_test.destroy! rescue nil
+@valid_fast.destroy! rescue nil
+@overwrite_test = nil
+@skip_test = nil
+@warn_test = nil
+@valid_fast = nil

data/try/horreum/field_categories_try.rb

@@ -0,0 +1,118 @@
+# try/horreum/field_categories_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Define test class with various field categories
+class FieldCategoryTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name                           # default category (:field)
+  field :email, category: :encrypted    # encrypted category
+  field :tryouts_cache_data, category: :transient # transient category
+  field :description, category: :persistent # explicit persistent category
+  field :settings, category: nil        # nil category (defaults to :field)
+end
+
+# Test class with multiple transient fields
+class MultiTransientTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :permanent_data
+  field :temp1, category: :transient
+  field :temp2, category: :transient
+  field :temp3, category: :transient
+end
+
+# Field categories work with field aliasing
+class AliasedCategoryTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :internal_temp, as: :temp, category: :transient
+  field :internal_perm, as: :perm, category: :persistent
+end
+
+# Test edge case with all transient fields
+class AllTransientTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :temp1, category: :transient
+  field :temp2, category: :transient
+end
+
+## Field types are stored correctly
+@test_obj = FieldCategoryTest.new(id: 'test123')
+FieldCategoryTest.field_types.size
+#=> 6
+
+## Default category field has correct category
+FieldCategoryTest.field_types[:name].category
+#=> :field
+
+## Encrypted category field has correct category
+FieldCategoryTest.field_types[:email].category
+#=> :encrypted
+
+## Transient category field has correct category
+FieldCategoryTest.field_types[:tryouts_cache_data].category
+#=> :transient
+
+## Explicit persistent category field has correct category
+FieldCategoryTest.field_types[:description].category
+#=> :persistent
+
+## Nil category field defaults to :field
+FieldCategoryTest.field_types[:settings].category
+#=> :field
+
+## persistent_fields excludes transient fields
+FieldCategoryTest.persistent_fields
+#=> [:id, :name, :email, :description, :settings]
+
+## persistent_fields includes encrypted and persistent fields
+FieldCategoryTest.persistent_fields.include?(:email)
+#=> true
+
+## persistent_fields includes default category fields
+FieldCategoryTest.persistent_fields.include?(:name)
+#=> true
+
+## persistent_fields excludes transient fields
+FieldCategoryTest.persistent_fields.include?(:tryouts_cache_data)
+#=> false
+
+## Field definitions map provides backward compatibility
+FieldCategoryTest.field_method_map[:name]
+#=> :name
+
+## Field definitions map works for all fields
+FieldCategoryTest.field_method_map[:email]
+#=> :email
+
+## Multiple transient fields are handled correctly
+MultiTransientTest.persistent_fields
+#=> [:id, :permanent_data]
+
+## Aliased transient field is excluded from persistent_fields
+AliasedCategoryTest.persistent_fields.include?(:internal_temp)
+#=> false
+
+## Aliased persistent field is included in persistent_fields
+AliasedCategoryTest.persistent_fields.include?(:internal_perm)
+#=> true
+
+## Field type stores original field name, not alias
+AliasedCategoryTest.field_types[:internal_temp].name
+#=> :internal_temp
+
+## Field type stores alias as method name
+AliasedCategoryTest.field_types[:internal_temp].method_name
+#=> :temp
+
+## persistent_fields with mostly transient fields
+AllTransientTest.persistent_fields
+#=> [:id]
+
+@test_obj.destroy! rescue nil
+@test_obj = nil

data/try/horreum/field_definition_try.rb

@@ -0,0 +1,96 @@
+# try/horreum/field_definition_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Create a custom field type for testing with category support
+class TestFieldType < Familia::FieldType
+  def initialize(name, category: :field, **kwargs)
+    super(name, **kwargs)
+    @category = category
+  end
+
+  def category
+    @category || :field
+  end
+
+  def persistent?
+    category != :transient
+  end
+
+  def transient?
+    !persistent?
+  end
+end
+
+# Setup a test field type (replacing the old FieldDefinition)
+@field_type = TestFieldType.new(
+  :email,
+  as: :email,
+  fast_method: :email!,
+  on_conflict: :raise,
+  category: :encrypted
+)
+
+## FieldType holds field name correctly
+@field_type.name
+#=> :email
+
+## FieldType holds method name correctly
+@field_type.method_name
+#=> :email
+
+## FieldType holds fast method name correctly
+@field_type.fast_method_name
+#=> :email!
+
+## FieldType holds conflict strategy correctly
+@field_type.on_conflict
+#=> :raise
+
+## FieldType holds category correctly
+@field_type.category
+#=> :encrypted
+
+## FieldType returns generated methods list
+@field_type.generated_methods
+#=> [:email, :email!]
+
+## FieldType with nil category defaults to :field
+@basic_field = TestFieldType.new(
+  :name,
+  as: :name,
+  fast_method: :name!,
+  on_conflict: :skip,
+  category: nil
+)
+@basic_field.category
+#=> :field
+
+## FieldType persistent? returns true for non-transient fields
+@field_type.persistent?
+#=> true
+
+## FieldType persistent? returns false for transient fields
+@transient_field = TestFieldType.new(
+  :temp_data,
+  as: :temp_data,
+  fast_method: :temp_data!,
+  on_conflict: :raise,
+  category: :transient
+)
+@transient_field.persistent?
+#=> false
+
+## FieldType to_s includes all attributes
+@field_type.to_s
+#=~>/#<.*TestFieldType name=email method_name=email fast_method_name=email! on_conflict=raise category=encrypted>/
+
+## FieldType inspect is same as to_s
+@field_type.inspect
+#=~>/#<.*TestFieldType name=email method_name=email fast_method_name=email! on_conflict=raise category=encrypted>/
+
+@field_type = nil
+@basic_field = nil
+@transient_field = nil

data/try/horreum/initialization_try.rb

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

data/try/horreum/relations_try.rb

@@ -1,7 +1,6 @@
 # try/horreum/relations_try.rb
 # Test Horreum Database type relations functionality
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

data/try/horreum/serialization_persistent_fields_try.rb

@@ -0,0 +1,165 @@
+# try/horreum/serialization_persistent_fields_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Test class with mixed field categories for serialization
+class SerializationCategoryTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name                           # persistent by default
+  field :email, category: :encrypted    # persistent, encrypted category
+  field :tryouts_cache_data, category: :transient # should be excluded from serialization
+  field :description, category: :persistent # explicitly persistent
+  field :temp_settings, category: :transient # should be excluded
+  field :metadata, category: :persistent # explicitly persistent
+end
+
+# Class with all transient fields
+class AllTransientSerializationTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :temp1, category: :transient
+  field :temp2, category: :transient
+end
+
+# Mixed categories with aliased fields
+class AliasedSerializationTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :internal_name, as: :display_name, category: :persistent
+  field :temp_cache, as: :cache, category: :transient
+  field :user_data, as: :data, category: :encrypted
+end
+
+# Setup test instance with all field types
+@serialization_test = SerializationCategoryTest.new(
+  id: 'serialize_test_1',
+  name: 'Test User',
+  email: 'test@example.com',
+  tryouts_cache_data: 'temporary_cache_value',
+  description: 'A test user description',
+  temp_settings: { theme: 'dark', cache: true },
+  metadata: { version: 1, last_login: '2025-01-01' }
+)
+
+@all_transient = AllTransientSerializationTest.new(
+  id: 'transient_test_1',
+  temp1: 'value1',
+  temp2: 'value2'
+)
+
+@aliased_test = AliasedSerializationTest.new(
+  id: 'aliased_test_1',
+  display_name: 'Display Name',
+  cache: 'cache_value',
+  data: { key: 'value' }
+)
+
+## to_h excludes transient fields
+@hash_result = @serialization_test.to_h
+@hash_result.keys.sort
+#=> [:description, :email, :id, :metadata, :name]
+
+## to_h includes all persistent fields
+@hash_result.key?(:name)
+#=> true
+
+## to_h includes encrypted persistent fields
+@hash_result.key?(:email)
+#=> true
+
+## to_h includes explicitly persistent fields
+@hash_result.key?(:description)
+#=> true
+
+## to_h excludes transient fields from serialization
+@hash_result.key?(:tryouts_cache_data)
+#=> false
+
+## to_h excludes all transient fields
+@hash_result.key?(:temp_settings)
+#=> false
+
+## to_h serializes complex values correctly
+@hash_result[:metadata]
+#=:> String
+
+## to_a excludes transient fields
+@array_result = @serialization_test.to_a
+@array_result.size
+#=> 5
+
+## to_a maintains field order for persistent fields only
+SerializationCategoryTest.persistent_fields
+#=> [:id, :name, :email, :description, :metadata]
+
+## Save operation only persists persistent fields
+@serialization_test.save
+#=> true
+
+## Refresh loads only persistent fields
+@serialization_test.refresh!
+@serialization_test.name
+#=> "Test User"
+
+## Transient field values are not persisted in redis
+@serialization_test.tryouts_cache_data
+#=> nil
+
+## When refreshed, transient fields do not retain their in-memory values
+@serialization_test.refresh!
+@serialization_test.tryouts_cache_data  # Should still be in memory but not from redis
+#=> nil
+
+## Field definitions are preserved during serialization
+SerializationCategoryTest.field_types[:tryouts_cache_data].category
+#=> :transient
+
+## Persistent fields filtering works correctly
+SerializationCategoryTest.persistent_fields.include?(:tryouts_cache_data)
+#=> false
+
+## All persistent fields are included in persistent_fields
+SerializationCategoryTest.persistent_fields.include?(:email)
+#=> true
+
+## to_h with only id field when all others are transient
+@all_transient.to_h
+#=> { id: "transient_test_1" }
+
+## to_a with only id field when all others are transient
+@all_transient.to_a
+#=> ["transient_test_1"]
+
+## Aliased fields serialization uses original field names
+@aliased_hash = @aliased_test.to_h
+@aliased_hash.keys.sort
+#=> [:id, :internal_name, :user_data]
+
+## Aliased transient fields are excluded
+@aliased_hash.key?(:temp_cache)
+#=> false
+
+## Serialization works with accessor methods through aliases
+@aliased_test.display_name = 'Updated Name'
+@aliased_test.to_h[:internal_name]
+#=> "Updated Name"
+
+## Clear fields respects field method map
+@serialization_test.clear_fields!
+@serialization_test.name
+#=> nil
+
+## Clear fields affects aliased methods correctly
+@aliased_test.clear_fields!
+@aliased_test.display_name
+#=> nil
+
+@serialization_test.destroy! rescue nil
+@all_transient.destroy! rescue nil
+@aliased_test.destroy! rescue nil
+@serialization_test = nil
+@all_transient = nil
+@aliased_test = nil

data/try/horreum/serialization_try.rb

@@ -1,11 +1,10 @@
 # try/horreum/serialization_try.rb
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false
 
-@identifier = 'tryouts-28@onetimesecret.com'
+@identifier = 'tryouts-28@onetimesecret.dev'
 @customer = Customer.new @identifier
 
 ## Basic save functionality works
@@ -23,7 +22,7 @@ Familia.debug = false
 
 ## to_h includes the custid field (using symbol keys)
 @customer.to_h[:custid]
-#=> "tryouts-28@onetimesecret.com"
+#=> "tryouts-28@onetimesecret.dev"
 
 ## to_a returns field array in definition order
 @customer.to_a.class

data/try/memory/memory_basic_test.rb

@@ -0,0 +1,73 @@
+# try/edge_cases/memory_try.rb
+
+require 'tempfile'
+require 'json'
+
+require_relative '../helpers/test_helpers'
+
+class MemorySecurityTester
+  def self.test_redacted_string
+    results = {
+      timestamp: Time.now,
+      tests: []
+    }
+
+    # Test 1: Basic string search
+    secret = "SENSITIVE_#{rand(999999)}"
+    redacted = RedactedString.new(secret)
+
+    # Dump all strings to file
+    Tempfile.create('strings') do |f|
+      ObjectSpace.each_object(String) do |str|
+        f.puts str.inspect rescue nil
+      end
+      f.flush
+
+      # Check if secret appears
+      f.rewind
+      content = f.read
+      results[:tests] << {
+        name: "Basic string search",
+        passed: !content.include?(secret),
+        details: content.include?(secret) ? "Found secret in object space" : "Secret not found"
+      }
+    end
+
+    # Test 2: Memory after GC
+    redacted.clear!
+    GC.start(full_mark: true, immediate_sweep: true)
+    sleep 0.1
+
+    found = false
+    ObjectSpace.each_object(String) do |str|
+      found = true if str.include?(secret) rescue false
+    end
+
+    results[:tests] << {
+      name: "After clear and GC",
+      passed: !found,
+      details: found ? "Secret persists after clear" : "Secret cleared"
+    }
+
+    # Test 3: Check /proc/self/mem directly
+    begin
+      mem_content = File.read("/proc/self/mem", 1024*1024*10) rescue ""
+      results[:tests] << {
+        name: "Direct memory read",
+        passed: !mem_content.include?(secret),
+        details: mem_content.include?(secret) ? "Found in /proc/self/mem" : "Not in readable memory"
+      }
+    rescue => e
+      results[:tests] << {
+        name: "Direct memory read",
+        passed: nil,
+        details: "Could not read: #{e}"
+      }
+    end
+
+    puts JSON.pretty_generate(results)
+  end
+end
+
+# Run the test
+MemorySecurityTester.test_redacted_string