familia 2.0.0.pre4 → 2.0.0.pre5

data/try/features/encryption_fields/nonce_uniqueness_try.rb

@@ -0,0 +1,54 @@
+# try/features/encryption_fields/nonce_uniqueness_try.rb
+
+require 'base64'
+require 'set'
+
+require_relative '../../helpers/test_helpers'
+
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class NonceTest < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+## Multiple encryptions produce unique nonces
+model = NonceTest.new(id: 'nonce-test')
+nonces = Set.new
+
+10.times do
+  model.secret = 'same-value'
+  cipher = JSON.parse(model.instance_variable_get(:@secret))
+  nonces.add(cipher['nonce'])
+end
+
+nonces.size == 10
+#=> true
+
+## Each encryption generates a unique nonce even for identical data
+@model2 = NonceTest.new(id: 'nonce-test-2')
+
+# Encrypt same value twice
+@model2.secret = 'duplicate-test'
+@cipher1 = JSON.parse(@model2.instance_variable_get(:@secret))
+
+@model2.secret = 'duplicate-test'
+@cipher2 = JSON.parse(@model2.instance_variable_get(:@secret))
+
+# Nonces should be different
+@cipher1['nonce'] != @cipher2['nonce']
+#=> true
+
+## Ciphertexts are also different due to different nonces
+@cipher1['ciphertext'] != @cipher2['ciphertext']
+#=> true
+
+# Cleanup
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil

data/try/features/encryption_fields/thread_safety_try.rb

@@ -0,0 +1,199 @@
+# try/features/encryption_fields/thread_safety_try.rb
+
+require 'concurrent'
+require 'base64'
+
+require_relative '../../helpers/test_helpers'
+
+# Setup encryption keys for testing
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+  v2: Base64.strict_encode64('b' * 32)
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class ThreadTest < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+# Thread-safe debug logging helper
+@debug_mutex = Mutex.new
+def debug(msg)
+  return unless ENV['FAMILIA_DEBUG']
+  @debug_mutex.synchronize { puts "DEBUG: #{msg}" }
+end
+
+## Concurrent encryption operations maintain counter integrity
+Familia::Encryption.reset_derivation_count!
+@results = Concurrent::Array.new
+@errors = Concurrent::Array.new
+
+debug "Starting 10 threads for concurrent operations..."
+
+@threads = 10.times.map do |i|
+  Thread.new do
+    begin
+      model = ThreadTest.new(id: "thread-#{i}")
+      5.times do |j|
+        model.secret = "secret-#{i}-#{j}"  # encrypt (derivation)
+        retrieved = model.secret           # decrypt (derivation)
+        @results << retrieved
+      end
+      debug "Thread #{i} completed successfully"
+    rescue => e
+      debug "Thread #{i} failed: #{e.class}: #{e.message}"
+      @errors << e
+    end
+  end
+end
+
+@threads.each(&:join)
+
+debug "All threads joined. Results: #{@results.size}, Errors: #{@errors.size}"
+debug "Derivation count: #{Familia::Encryption.derivation_count.value}"
+
+if @errors.any?
+  debug "Error details:"
+  @errors.each_with_index { |e, i| debug "  #{i+1}. #{e.class}: #{e.message}" }
+end
+
+@errors.empty?
+#=> true
+
+## All expected results collected (10 threads × 5 operations = 50 results)
+@results.size
+#=> 50
+
+## Each thread did 5 write + 5 read = 10 derivations
+# Total: 10 threads * 10 derivations = 100
+Familia::Encryption.derivation_count.value
+#=> 100
+
+## Key rotation operations work safely under concurrent access
+debug "Starting key rotation test with 4 threads..."
+
+@rotation_errors = Concurrent::Array.new
+@rotation_results = Concurrent::Array.new
+
+@rotation_threads = 4.times.map do |i|
+  Thread.new do
+    begin
+      # Each thread alternates between v1 and v2
+      thread_version = i.even? ? :v1 : :v2
+
+      10.times do |j|
+        debug "Thread #{i}, iteration #{j}, using version #{thread_version}"
+
+        # Temporarily switch key version for this operation
+        original_version = Familia.config.current_key_version
+        Familia.config.current_key_version = thread_version
+
+        begin
+          model = ThreadTest.new(id: "race-#{i}-#{j}")
+          model.secret = "test-#{i}-#{j}"   # encrypt
+          retrieved = model.secret          # decrypt
+          @rotation_results << retrieved
+          debug "Thread #{i}, iteration #{j} completed"
+        ensure
+          # Restore original version
+          Familia.config.current_key_version = original_version
+        end
+      end
+    rescue => e
+      debug "Rotation thread #{i} failed: #{e.class}: #{e.message}"
+      @rotation_errors << e
+    end
+  end
+end
+
+@rotation_threads.each(&:join)
+
+debug "Key rotation test completed. Results: #{@rotation_results.size}, Errors: #{@rotation_errors.size}"
+
+if @rotation_errors.any?
+  debug "Rotation error details:"
+  @rotation_errors.each_with_index { |e, i| debug "  #{i+1}. #{e.class}: #{e.message}" }
+end
+
+@rotation_errors.empty?
+#=> true
+
+## All rotation operations completed successfully (4 threads × 10 operations = 40 results)
+@rotation_results.size
+#=> 40
+
+## Atomic counter maintains accuracy under maximum contention
+debug "Starting atomic counter test with 20 threads..."
+debug "Count before reset: #{Familia::Encryption.derivation_count.value}"
+
+Familia::Encryption.reset_derivation_count!
+sleep(0.01) # Minimal delay to ensure reset takes effect
+
+debug "Count after reset: #{Familia::Encryption.derivation_count.value}"
+
+barrier = Concurrent::CyclicBarrier.new(20)
+@counter_errors = Concurrent::Array.new
+
+counter_threads = 20.times.map do |i|
+  Thread.new do
+    begin
+      barrier.wait # Synchronize start for maximum contention
+      model = ThreadTest.new(id: "counter-test-#{i}")
+      model.secret = 'test'  # Single encrypt operation (1 derivation)
+      debug "Counter thread #{i} completed"
+    rescue => e
+      debug "Counter thread #{i} failed: #{e.class}: #{e.message}"
+      @counter_errors << e
+    end
+  end
+end
+
+counter_threads.each(&:join)
+
+debug "Atomic counter test completed. Final count: #{Familia::Encryption.derivation_count.value}"
+
+@counter_errors.empty?
+#=> true
+
+## Exactly 20 derivations, no lost increments
+Familia::Encryption.derivation_count.value
+#=> 20
+
+## Concurrent encryption operations maintain counter integrity
+class ThreadTest2 < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+Familia::Encryption.reset_derivation_count!
+errors = Concurrent::Array.new
+barrier = Concurrent::CyclicBarrier.new(10)
+
+threads = 10.times.map do |i|
+  Thread.new do
+    barrier.wait # Synchronize start
+    model = ThreadTest.new(id: "thread-#{i}")
+    begin
+      5.times { |j|
+        model.secret = "value-#{i}-#{j}"
+        model.secret # decrypt
+      }
+    rescue => e
+      errors << e
+    end
+  end
+end
+
+threads.each(&:join)
+errors.empty? && Familia::Encryption.derivation_count.value == 100
+#=> true
+
+# Cleanup
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil

data/try/features/expiration_try.rb

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

data/try/features/feature_dependencies_try.rb

@@ -0,0 +1,159 @@
+# try/features/feature_dependencies_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Create test features with dependencies for testing
+module TestFeatureA
+  def self.included(base)
+    Familia.ld "[#{base}] Loaded #{self}"
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def test_feature_a_method
+      "feature_a_active"
+    end
+  end
+
+  def test_feature_a_instance
+    "instance_feature_a"
+  end
+end
+
+module TestFeatureB
+  def self.included(base)
+    Familia.ld "[#{base}] Loaded #{self}"
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def test_feature_b_method
+      "feature_b_active"
+    end
+  end
+
+  def test_feature_b_instance
+    "instance_feature_b"
+  end
+end
+
+module TestFeatureCWithDeps
+  def self.included(base)
+    Familia.ld "[#{base}] Loaded #{self}"
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def test_feature_c_method
+      "feature_c_with_deps_active"
+    end
+  end
+
+  def test_feature_c_instance
+    "instance_feature_c_with_deps"
+  end
+end
+
+# Register test features manually
+Familia::Base.add_feature TestFeatureA, :test_feature_a
+Familia::Base.add_feature TestFeatureB, :test_feature_b
+Familia::Base.add_feature TestFeatureCWithDeps, :test_feature_c, depends_on: [:test_feature_a, :test_feature_b]
+
+## Feature definitions are created correctly
+Familia::Base.feature_definitions.key?(:test_feature_a)
+#=> true
+
+## Feature definitions store dependencies correctly
+Familia::Base.feature_definitions[:test_feature_c].depends_on
+#=> [:test_feature_a, :test_feature_b]
+
+## Features without dependencies have empty depends_on array
+Familia::Base.feature_definitions[:test_feature_a].depends_on
+#=> []
+
+## Feature definitions store name correctly
+Familia::Base.feature_definitions[:test_feature_c].name
+#=> :test_feature_c
+
+## Successfully enable feature without dependencies
+class NoDepsTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :test_feature_a
+end
+@nodeps = NoDepsTest.new(id: 'test1')
+@nodeps.test_feature_a_instance
+#=> "instance_feature_a"
+
+## Successfully enable multiple features in correct order
+class MultiFeatureTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :test_feature_a
+  feature :test_feature_b
+  feature :test_feature_c
+end
+@multitest = MultiFeatureTest.new(id: 'test2')
+@multitest.test_feature_c_instance
+#=> "instance_feature_c_with_deps"
+
+## Class methods from dependent features are available
+MultiFeatureTest.test_feature_c_method
+#=> "feature_c_with_deps_active"
+
+## All prerequisite features are available in features_enabled
+MultiFeatureTest.features_enabled.include?(:test_feature_a)
+#=> true
+
+## All prerequisite features are available
+MultiFeatureTest.features_enabled.include?(:test_feature_b)
+#=> true
+
+## Dependent feature is available
+MultiFeatureTest.features_enabled.include?(:test_feature_c)
+#=> true
+
+## Feature dependency validation fails when dependencies missing
+class MissingDepsTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :test_feature_c  # Missing dependencies should cause error
+end
+#=!> Familia::Problem
+
+## Partial dependencies cause validation failure
+class PartialDepsTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :test_feature_a  # Only one of two required dependencies
+  feature :test_feature_c
+end
+#=!> Familia::Problem
+
+## Invalid feature name raises appropriate error
+class InvalidFeatureTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :nonexistent_feature
+end
+#=!> Familia::Problem
+
+## Duplicate feature inclusion gives warning but continues
+class DuplicateFeatureTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :test_feature_a
+  feature :test_feature_a  # Duplicate should warn
+end
+@duplicate_test = DuplicateFeatureTest.new(id: 'dup1')
+@duplicate_test.test_feature_a_instance
+#=> "instance_feature_a"
+
+@nodeps.destroy! rescue nil
+@multitest.destroy! rescue nil
+@duplicate_test.destroy! rescue nil
+@nodeps = nil
+@multitest = nil
+@duplicate_test = nil

data/try/features/quantization_try.rb

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

data/try/features/real_feature_integration_try.rb

@@ -0,0 +1,148 @@
+# try/features/real_feature_integration_try.rb
+
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+# Real feature integration: expiration feature works with new system
+class ExpirationIntegrationTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  feature :expiration
+end
+
+# Safe dump feature integration with field categories
+class SafeDumpCategoryTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :public_name, category: :persistent
+  field :email, category: :encrypted
+  field :tryouts_cache_data, category: :transient
+
+  feature :safe_dump
+
+  @safe_dump_fields = [
+    :id,
+    :public_name,
+    :email
+  ]
+end
+
+# Combined features work together
+class CombinedFeaturesTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name, category: :persistent
+  field :temp_data, category: :transient
+
+  feature :expiration
+  feature :safe_dump
+
+  @safe_dump_fields = [:id, :name]
+end
+
+# Test that individual features can be queried
+class QueryFeaturesTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :expiration
+end
+
+# Empty features list for class without features
+class NoFeaturesTest < Familia::Horreum
+  identifier_field :id
+  field :id
+end
+
+# Error handling for duplicate feature includes
+class DuplicateFeatureHandling < Familia::Horreum
+  identifier_field :id
+  field :id
+  feature :expiration
+  # This should generate a warning but not error
+  feature :expiration
+end
+
+@expiration_test = ExpirationIntegrationTest.new(id: 'exp_test_1', name: 'Test')
+
+@safedump_test = SafeDumpCategoryTest.new(
+  id: 'safe_test_1',
+  public_name: 'Public Name',
+  email: 'test@example.com',
+  tryouts_cache_data: 'temporary'
+)
+
+@combined_test = CombinedFeaturesTest.new(id: 'combined_1', name: 'Combined', temp_data: 'temp')
+
+## Expiration feature is properly registered
+Familia::Base.features_available.key?(:expiration)
+#=> true
+
+## Feature enabled correctly
+ExpirationIntegrationTest.features_enabled.include?(:expiration)
+#=> true
+
+## Expiration methods are available
+@expiration_test.respond_to?(:update_expiration)
+#=> true
+
+## Class methods from expiration feature work
+ExpirationIntegrationTest.respond_to?(:default_expiration)
+#=> true
+
+## Safe dump feature loaded correctly
+SafeDumpCategoryTest.features_enabled.include?(:safe_dump)
+#=> true
+
+## Safe dump works with field categories
+@safedump_result = @safedump_test.safe_dump
+@safedump_result.keys.sort
+#=> [:email, :id, :public_name]
+
+## Safe dump respects safe_dump_fields configuration
+@safedump_result.key?(:tryouts_cache_data)
+#=> false
+
+## Both features are enabled
+CombinedFeaturesTest.features_enabled.include?(:expiration)
+#=> true
+
+## Safe dump feature also enabled
+CombinedFeaturesTest.features_enabled.include?(:safe_dump)
+#=> true
+
+## Combined functionality works correctly
+@combined_test.safe_dump
+#=> { id: "combined_1", name: "Combined" }
+
+## Expiration functionality still available
+@combined_test.respond_to?(:update_expiration)
+#=> true
+
+## Test that feature() method returns current features when called with no args
+CombinedFeaturesTest.feature
+#=> [:expiration, :safe_dump]
+
+## Test that features_enabled() method returns the same results as feature() method
+CombinedFeaturesTest.feature
+#=> [:expiration, :safe_dump]
+
+## Features list is accessible
+QueryFeaturesTest.feature
+#=> [:expiration]
+
+## No features returns empty array
+NoFeaturesTest.feature
+#=> []
+
+## Duplicate features handled gracefully
+DuplicateFeatureHandling.features_enabled
+#=> [:expiration]
+
+@expiration_test.destroy! rescue nil
+@safedump_test.destroy! rescue nil
+@combined_test.destroy! rescue nil
+@expiration_test = nil
+@safedump_test = nil
+@combined_test = nil

data/try/features/relatable_objects_try.rb

@@ -2,7 +2,6 @@
 
 # Test RelatableObject feature functionality
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 Familia.debug = false

data/try/features/safe_dump_advanced_try.rb

@@ -2,7 +2,6 @@
 
 # These tryouts test the safe dumping functionality.
 
-require_relative '../../lib/familia'
 require_relative '../helpers/test_helpers'
 
 ## By default Familia::Base has no safe_dump_fields method

data/try/features/safe_dump_try.rb

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