familia 2.0.0.pre4 → 2.0.0.pre6

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.trace :included, base, self, caller(1..1) if Familia.debug?
+    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.trace :INCLUDED, base, self, caller(1..1) if Familia.debug?
+    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.trace :feature_load, base, self, caller(1..1) if Familia.debug?
+    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

data/try/features/transient_fields/redacted_string_try.rb

@@ -0,0 +1,248 @@
+# try/features/transient_fields/redacted_string_try.rb
+
+require_relative '../../helpers/test_helpers'
+
+
+# Create sample sensitive values for testing
+@api_key = "sk-1234567890abcdef"
+@password = "super_secret_password_123!"
+@empty_secret = ""
+@long_secret = "a" * 100  # Test long string handling
+@special_chars = "päßwörd!@#$%^&*()"
+
+## TEST CASES
+
+## Basic initialization creates RedactedString instance
+redacted = RedactedString.new(@api_key)
+redacted.class
+#=> RedactedString
+
+## Initialization accepts various input types
+RedactedString.new("string").class
+#=> RedactedString
+
+RedactedString.new(123).class  # to_s conversion
+#=> RedactedString
+
+RedactedString.new(nil).class  # nil handling
+#=> RedactedString
+
+## Empty string handling
+empty_redacted = RedactedString.new(@empty_secret)
+empty_redacted.class
+#=> RedactedString
+
+## Long string handling
+long_redacted = RedactedString.new(@long_secret)
+long_redacted.class
+#=> RedactedString
+
+## Special characters handling
+special_redacted = RedactedString.new(@special_chars)
+special_redacted.class
+#=> RedactedString
+
+## Fresh instance is not cleared initially
+fresh_redacted = RedactedString.new(@api_key)
+fresh_redacted.cleared?
+#=> false
+
+## to_s always returns redacted placeholder
+redacted_for_to_s = RedactedString.new(@api_key)
+redacted_for_to_s.to_s
+#=> "[REDACTED]"
+
+## inspect returns same as to_s for security
+redacted_for_inspect = RedactedString.new(@password)
+redacted_for_inspect.inspect
+#=> "[REDACTED]"
+
+## String interpolation is redacted
+redacted_for_interpolation = RedactedString.new(@api_key)
+"Token: #{redacted_for_interpolation}"
+#=> "Token: [REDACTED]"
+
+## Array/Hash containing redacted strings show redacted values
+redacted_in_array = RedactedString.new(@password)
+[redacted_in_array].to_s.include?("[REDACTED]")
+#=> true
+
+## expose method requires block
+redacted_for_expose_check = RedactedString.new(@api_key)
+begin
+  redacted_for_expose_check.expose
+rescue ArgumentError => e
+  e.message
+end
+#=> "Block required"
+
+## expose method provides access to original value
+redacted_for_expose = RedactedString.new("sk-1234567890abcdef")
+result = nil
+redacted_for_expose.expose { |val| result = val.dup }
+result
+#=> "sk-1234567890abcdef"
+
+## expose method does not automatically clear after use
+redacted_single_use = RedactedString.new(@password)
+redacted_single_use.expose { |val| val.length }
+redacted_single_use.cleared?
+#=> false
+
+## expose method does not clear if exception occurs
+redacted_exception_test = RedactedString.new(@api_key)
+begin
+  redacted_exception_test.expose { |val| raise "test error" }
+rescue => e
+  # Exception occurred, but string should still be cleared
+end
+redacted_exception_test.cleared?
+#=> false
+
+## expose method on cleared string raises SecurityError
+cleared_redacted = RedactedString.new(@password)
+cleared_redacted.clear!
+begin
+  cleared_redacted.expose { |val| val }
+rescue SecurityError => e
+  e.message
+end
+#=> "Value already cleared"
+
+## clear! method marks string as cleared
+redacted_for_clear = RedactedString.new(@api_key)
+redacted_for_clear.clear!
+redacted_for_clear.cleared?
+#=> true
+
+## clear! method is safe to call multiple times
+redacted_multi_clear = RedactedString.new(@password)
+redacted_multi_clear.clear!
+redacted_multi_clear.clear!  # Second call
+redacted_multi_clear.cleared?
+#=> true
+
+## clear! method freezes the object
+redacted_freeze_test = RedactedString.new(@api_key)
+redacted_freeze_test.clear!
+redacted_freeze_test.frozen?
+#=> true
+
+## Equality comparison only true for same object (prevents timing attacks)
+redacted1 = RedactedString.new(@api_key)
+redacted2 = RedactedString.new(@api_key)
+redacted1 == redacted2
+#=> false
+
+## Same object equality returns true
+redacted_same = RedactedString.new(@password)
+redacted_same == redacted_same
+#=> true
+
+## eql? behaves same as ==
+redacted_eql1 = RedactedString.new(@api_key)
+redacted_eql2 = RedactedString.new(@api_key)
+redacted_eql1.eql?(redacted_eql2)
+#=> false
+
+## Same object eql? returns true
+redacted_eql_same = RedactedString.new(@password)
+redacted_eql_same.eql?(redacted_eql_same)
+#=> true
+
+## All instances have same hash (prevents hash-based timing attacks)
+redacted_hash1 = RedactedString.new(@api_key)
+redacted_hash2 = RedactedString.new(@password)
+redacted_hash1.hash == redacted_hash2.hash
+#=> true
+
+## Hash value is consistent with class hash
+redacted_hash_consistent = RedactedString.new(@api_key)
+redacted_hash_consistent.hash == RedactedString.hash
+#=> true
+
+## RedactedString cannot be used in string operations without expose
+redacted_no_concat = RedactedString.new(@api_key)
+begin
+  result = redacted_no_concat + "suffix"
+  false  # Should not reach here
+rescue => e
+  true   # Expected to raise error
+end
+#=> true
+
+## RedactedString is not a String subclass (security by design)
+redacted_type_check = RedactedString.new(@password)
+redacted_type_check.is_a?(String)
+#=> false
+
+## Working with empty strings
+empty_redacted_test = RedactedString.new("")
+result = nil
+empty_redacted_test.expose { |val| result = val }
+result
+#=> ""
+
+## Working with long strings preserves content
+long_redacted_test = RedactedString.new("a" * 100)
+result = nil
+long_redacted_test.expose { |val| result = val.length }
+result
+#=> 100
+
+## Special characters are preserved
+special_redacted_test = RedactedString.new("päßwörd!@#$%^&*()")
+result = nil
+special_redacted_test.expose { |val| result = val.dup }
+result
+#=> "päßwörd!@#$%^&*()"
+
+## Finalizer proc exists and is callable
+RedactedString.finalizer_proc.class
+#=> Proc
+
+## Cleared redacted string maintains redacted appearance
+cleared_appearance_test = RedactedString.new(@api_key)
+cleared_appearance_test.clear!
+cleared_appearance_test.to_s
+#=> "[REDACTED]"
+
+## Cleared redacted string inspect still redacted
+cleared_inspect_test = RedactedString.new(@password)
+cleared_inspect_test.clear!
+cleared_inspect_test.inspect
+#=> "[REDACTED]"
+
+## Object created from nil input
+nil_input_test = RedactedString.new(nil)
+result = nil
+nil_input_test.expose { |val| result = val.dup }
+result
+#=> ""
+
+## Numeric input converted to string
+numeric_input_test = RedactedString.new(42)
+result = nil
+numeric_input_test.expose { |val| result = val.dup }
+result
+#=> "42"
+
+## Symbol input converted to string
+symbol_input_test = RedactedString.new(:secret)
+result = nil
+symbol_input_test.expose { |val| result = val.dup }
+result
+#=> "secret"
+
+
+# TEARDOWN
+
+# Clean up any remaining test objects
+@api_key = nil
+@password = nil
+@empty_secret = nil
+@long_secret = nil
+@special_chars = nil
+
+# Force garbage collection to trigger any finalizers
+GC.start