familia 2.0.0.pre5 → 2.0.0.pre6

data/try/debugging/debug_encrypted_json_check.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing encrypted_json? method..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+field_type = TestModel.field_types[:secret]
+
+# Test with actual encrypted JSON from the load path
+encrypted_json = '{"algorithm":"xchacha20poly1305","nonce":"RDK0GSY3Vbrbv7OAgol10bHOmderAExt","ciphertext":"uo8j6Pm6tV68BcvqK5maXQ==","auth_tag":"5Cr1QgTnajnWIji0fsQP0g==","key_version":"v1"}'
+
+puts "Testing encrypted JSON: #{encrypted_json[0..80]}..."
+puts "String class: #{encrypted_json.class}"
+puts "Is string?: #{encrypted_json.is_a?(String)}"
+
+puts "\nManual JSON parsing:"
+begin
+  parsed = JSON.parse(encrypted_json)
+  puts "Parsed successfully: #{parsed.class}"
+  puts "Is hash?: #{parsed.is_a?(Hash)}"
+  puts "Has algorithm key?: #{parsed.key?('algorithm')}"
+  puts "Algorithm value: #{parsed['algorithm']}"
+rescue => e
+  puts "JSON parse error: #{e.class}: #{e.message}"
+end
+
+puts "\nTesting field_type.encrypted_json? method:"
+result = field_type.encrypted_json?(encrypted_json)
+puts "encrypted_json? result: #{result}"
+
+puts "\nTesting with symbol keys:"
+begin
+  parsed_sym = JSON.parse(encrypted_json, symbolize_names: true)
+  puts "Parsed with symbols: #{parsed_sym.class}"
+  puts "Has :algorithm key?: #{parsed_sym.key?(:algorithm)}"
+  puts "Has 'algorithm' key?: #{parsed_sym.key?('algorithm')}"
+rescue => e
+  puts "Symbol parse error: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_encrypted_json_step_by_step.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Step-by-step debugging of encrypted_json? method..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+field_type = TestModel.field_types[:secret]
+
+# Monkey patch the encrypted_json? method to add debugging
+class Familia::EncryptedFieldType
+  def encrypted_json?(data)
+    puts "\n=== encrypted_json? DEBUG ==="
+    puts "Input data: #{data}"
+    puts "Data class: #{data.class}"
+    puts "Is String?: #{data.is_a?(String)}"
+
+    return false unless data.is_a?(String)
+    puts "Passed String check"
+
+    begin
+      puts "Attempting JSON.parse..."
+      parsed = JSON.parse(data)
+      puts "Parsed result: #{parsed}"
+      puts "Parsed class: #{parsed.class}"
+      puts "Is Hash?: #{parsed.is_a?(Hash)}"
+
+      if parsed.is_a?(Hash)
+        puts "Hash keys: #{parsed.keys}"
+        puts "Has 'algorithm' key?: #{parsed.key?('algorithm')}"
+        result = parsed.key?('algorithm')
+        puts "Final result: #{result}"
+        return result
+      else
+        puts "Not a hash, returning false"
+        return false
+      end
+    rescue JSON::ParserError => e
+      puts "JSON parse error: #{e.message}"
+      false
+    end
+  end
+end
+
+encrypted_json = '{"algorithm":"xchacha20poly1305","nonce":"RDK0GSY3Vbrbv7OAgol10bHOmderAExt","ciphertext":"uo8j6Pm6tV68BcvqK5maXQ==","auth_tag":"5Cr1QgTnajnWIji0fsQP0g==","key_version":"v1"}'
+
+puts "Calling field_type.encrypted_json?..."
+result = field_type.encrypted_json?(encrypted_json)
+puts "\nFINAL RESULT: #{result}"

data/try/debugging/debug_exists_lifecycle.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Investigating exists? lifecycle..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Clean database
+Familia.dbclient.flushdb
+
+# Override the exists? method to add logging
+class TestModel
+  alias_method :original_exists?, :exists?
+  def exists?
+    result = original_exists?
+    puts "EXISTS? called - result: #{result} (identifier: #{identifier})" if ENV['TEST']
+    result
+  end
+end
+
+puts "\n=== CREATION AND SAVE ==="
+model = TestModel.new(id: 'test1')
+puts "After new - exists?: #{model.exists?}"
+model.secret = 'plaintext-secret'
+puts "After setting secret - exists?: #{model.exists?}"
+model.save
+puts "After save - exists?: #{model.exists?}"
+
+puts "\n=== LOAD FROM DATABASE ==="
+puts "About to load..."
+loaded_model = TestModel.load('test1')
+puts "After load - exists?: #{loaded_model.exists?}"
+
+puts "\n=== TRYING TO ACCESS SECRET ==="
+begin
+  loaded_model.secret.reveal do |plaintext|
+    puts "Successfully revealed: #{plaintext}"
+  end
+rescue => e
+  puts "Failed to reveal: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_field_decrypt.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing field-level decryption path..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Clean database
+Familia.dbclient.flushdb
+
+puts "\n=== FIELD-LEVEL DECRYPTION PATH ==="
+
+# Create and save model
+model = TestModel.new(id: 'test1')
+model.secret = 'plaintext-secret'
+model.save
+
+# Load model from database
+loaded_model = TestModel.load('test1')
+
+# Get the field type and test direct decryption
+puts "Available field types: #{TestModel.field_types.inspect}"
+secret_field_type = TestModel.field_types[:secret]
+puts "Field type class: #{secret_field_type.class}"
+
+# Get the raw encrypted data
+raw_encrypted = Familia.dbclient.hget('testmodel:test1:object', 'secret')
+puts "Raw encrypted from DB: #{raw_encrypted}"
+
+puts "\n=== DIRECT FIELD TYPE DECRYPTION ==="
+
+# Test the field type decrypt_value method directly
+puts "Testing field_type.decrypt_value with loaded model..."
+begin
+  direct_decrypted = secret_field_type.decrypt_value(loaded_model, raw_encrypted)
+  puts "Direct field decrypt result: #{direct_decrypted}"
+  puts "Result class: #{direct_decrypted.class}"
+rescue => e
+  puts "Direct field decrypt ERROR: #{e.class}: #{e.message}"
+  puts e.backtrace.first(5)
+end
+
+puts "\n=== AAD INVESTIGATION ==="
+puts "loaded_model.exists?: #{loaded_model.exists?}"
+puts "loaded_model.identifier: #{loaded_model.identifier}"
+
+# Build the same context and AAD that the field type would use
+context = "TestModel:secret:#{loaded_model.identifier}"
+puts "Context: #{context}"
+
+# Build AAD using the same logic as EncryptedFieldType#build_aad
+aad = loaded_model.exists? ? loaded_model.identifier : nil
+puts "AAD: #{aad.inspect}"
+
+puts "\n=== MANUAL FAMILIA::ENCRYPTION CALL ==="
+begin
+  manual_decrypted = Familia::Encryption.decrypt(raw_encrypted, context: context, additional_data: aad)
+  puts "Manual decrypt result: #{manual_decrypted}"
+rescue => e
+  puts "Manual decrypt ERROR: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_fresh_cross_context.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing cross-context validation with fresh encryption after AAD fix..."
+
+# Setup encryption keys
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class FreshModelA < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+class FreshModelB < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+# Clean database
+Familia.dbclient.flushdb
+
+model_a = FreshModelA.new(id: 'same-id')
+model_b = FreshModelB.new(id: 'same-id')
+
+puts "=== Fresh Encryption Test ==="
+model_a.api_key = 'secret-key'
+model_b.api_key = 'secret-key'
+
+cipher_a = model_a.instance_variable_get(:@api_key)
+cipher_b = model_b.instance_variable_get(:@api_key)
+
+puts "cipher_a encrypted: #{cipher_a.encrypted_value}"
+puts "cipher_b encrypted: #{cipher_b.encrypted_value}"
+
+# Now try cross-context access
+puts "\n=== Cross-context test ==="
+model_a.instance_variable_set(:@api_key, cipher_b)
+puts "Set cipher_b into model_a"
+
+begin
+  result = model_a.api_key
+  puts "Got result: #{result.class}"
+
+  # Try to reveal it - this should fail now
+  result.reveal do |plaintext|
+    puts "ERROR: Successfully revealed: #{plaintext} - should have failed!"
+  end
+rescue Familia::EncryptionError => e
+  puts "SUCCESS: Got expected encryption error: #{e.message}"
+rescue => e
+  puts "Got unexpected error: #{e.class}: #{e.message}"
+end
+
+puts "\n=== Same-context test (should work) ==="
+begin
+  model_a.instance_variable_set(:@api_key, cipher_a) # Back to original
+  result = model_a.api_key
+  result.reveal do |plaintext|
+    puts "SUCCESS: Same-context decryption worked: #{plaintext}"
+  end
+rescue => e
+  puts "ERROR: Same-context failed: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_load_path.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing load path and setter behavior..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Clean database
+Familia.dbclient.flushdb
+
+puts "\n=== TRACING THE SETTER DURING LOAD ==="
+
+# First, let's monkey-patch the setter to see what's being called
+original_setter = TestModel.instance_method(:secret=)
+TestModel.define_method(:secret=) do |value|
+  puts "\n--- SETTER CALLED ---"
+  puts "Setting secret to: #{value}"
+  puts "Value class: #{value.class}"
+  puts "Record exists?: #{exists?}"
+  puts "Record identifier: #{identifier}"
+
+  if value.is_a?(String) && !value.nil?
+    puts "Checking if value is encrypted JSON..."
+    field_type = TestModel.field_types[:secret]
+    is_encrypted = field_type.encrypted_json?(value)
+    puts "encrypted_json? result: #{is_encrypted}"
+
+    if is_encrypted
+      puts "Path: Creating ConcealedString WITHOUT re-encryption"
+    else
+      puts "Path: Will ENCRYPT value and create ConcealedString"
+    end
+  end
+  puts "--- END SETTER ---\n"
+
+  # Call original setter
+  original_setter.bind(self).call(value)
+end
+
+puts "\nCreating and saving model..."
+model = TestModel.new(id: 'test1')
+puts "Setting secret on in-memory model..."
+model.secret = 'plaintext-secret'
+
+puts "\nSaving model..."
+model.save
+
+puts "\nRaw data in database:"
+raw_data = Familia.dbclient.hget('testmodel:test1:object', 'secret')
+puts "Raw encrypted in DB: #{raw_data[0..100]}..." # Truncate for readability
+
+puts "\n=== LOADING MODEL ==="
+loaded_model = TestModel.load('test1')

data/try/debugging/debug_method_definition.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+
+puts "Checking method definition..."
+
+field_type = Familia::EncryptedFieldType.new(:test)
+puts "Method source location: #{field_type.method(:encrypted_json?).source_location}"
+
+# Check if the method exists
+puts "Method exists?: #{field_type.respond_to?(:encrypted_json?)}"
+
+# Get the method object and examine it
+method_obj = field_type.method(:encrypted_json?)
+puts "Method object: #{method_obj}"
+puts "Method owner: #{method_obj.owner}"
+
+# Call with debugging
+puts "\nCalling method..."
+result = method_obj.call('{"algorithm":"test"}')
+puts "Result: #{result}"
+
+# Let's also check the class directly
+puts "\nChecking class method..."
+class_result = Familia::EncryptedFieldType.new(:test2).encrypted_json?('{"algorithm":"test"}')
+puts "Class result: #{class_result}"
+
+# Try to define the method inline to see if it works
+puts "\nDefining method inline..."
+field_type.define_singleton_method(:test_encrypted_json?) do |data|
+  puts "Inline method called with: #{data}"
+  begin
+    parsed = JSON.parse(data)
+    result = parsed.is_a?(Hash) && parsed.key?('algorithm')
+    puts "Inline result: #{result}"
+    return result
+  rescue => e
+    puts "Inline error: #{e}"
+    return false
+  end
+end
+
+inline_result = field_type.test_encrypted_json?('{"algorithm":"test"}')
+puts "Inline method result: #{inline_result}"

data/try/debugging/debug_method_resolution.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing method resolution for encrypted_json?..."
+
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+field_type = TestModel.field_types[:secret]
+encrypted_json = '{"algorithm":"xchacha20poly1305","nonce":"test","ciphertext":"test","auth_tag":"test","key_version":"v1"}'
+
+puts "Field type class: #{field_type.class}"
+puts "Field type method location: #{field_type.method(:encrypted_json?).source_location}"
+
+# Test the method directly
+puts "\nDirect method test:"
+puts "Result: #{field_type.encrypted_json?(encrypted_json)}"
+
+# Test with a fresh instance
+puts "\nCreating fresh EncryptedFieldType instance:"
+fresh_field_type = Familia::EncryptedFieldType.new(:test)
+puts "Fresh field type method location: #{fresh_field_type.method(:encrypted_json?).source_location}"
+puts "Fresh instance result: #{fresh_field_type.encrypted_json?(encrypted_json)}"
+
+# Test with simple JSON
+simple_json = '{"algorithm":"test"}'
+puts "\nTesting with simple JSON: #{simple_json}"
+puts "Field type result: #{field_type.encrypted_json?(simple_json)}"
+puts "Fresh instance result: #{fresh_field_type.encrypted_json?(simple_json)}"

data/try/debugging/debug_minimal.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+require 'familia'
+
+# Minimal test
+field_type = Familia::EncryptedFieldType.new(:test)
+json = '{"algorithm":"test"}'
+
+puts "Testing: #{json}"
+puts "Result: #{field_type.encrypted_json?(json)}"
+
+# Manual implementation
+puts "\nManual check:"
+begin
+  parsed = JSON.parse(json)
+  puts "Parsed: #{parsed}"
+  puts "Is hash?: #{parsed.is_a?(Hash)}"
+  puts "Has algorithm?: #{parsed.key?('algorithm')}"
+  result = parsed.is_a?(Hash) && parsed.key?('algorithm')
+  puts "Manual result: #{result}"
+rescue => e
+  puts "Error: #{e}"
+end

data/try/debugging/debug_provider.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'  # Mark as test environment
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Testing provider-level decryption..."
+
+# Setup
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Simulate the conditions during encryption vs decryption
+class TestModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+# Clean database
+Familia.dbclient.flushdb
+
+puts "\n=== DIRECT ENCRYPTION/DECRYPTION TEST ==="
+
+# Test direct encryption/decryption with different AAD values
+plaintext = "test-secret"
+context = "TestModel:secret:test1"
+
+# Scenario 1: Encrypt with AAD = nil (before save)
+puts "Encrypting with AAD = nil..."
+encrypted_json_1 = Familia::Encryption.encrypt(plaintext, context: context, additional_data: nil)
+puts "Encrypted: #{encrypted_json_1}"
+
+# Try to decrypt with AAD = nil
+puts "Decrypting with AAD = nil..."
+decrypted_1 = Familia::Encryption.decrypt(encrypted_json_1, context: context, additional_data: nil)
+puts "Decrypted: #{decrypted_1}"
+
+# Try to decrypt with AAD = "test1" (what happens after load)
+puts "Decrypting with AAD = 'test1'..."
+begin
+  decrypted_2 = Familia::Encryption.decrypt(encrypted_json_1, context: context, additional_data: "test1")
+  puts "Decrypted: #{decrypted_2}"
+rescue => e
+  puts "Decryption failed: #{e.class}: #{e.message}"
+end
+
+# Scenario 2: Encrypt with AAD = "test1" (after save)
+puts "\nEncrypting with AAD = 'test1'..."
+encrypted_json_2 = Familia::Encryption.encrypt(plaintext, context: context, additional_data: "test1")
+puts "Encrypted: #{encrypted_json_2}"
+
+# Try to decrypt with AAD = "test1"
+puts "Decrypting with AAD = 'test1'..."
+decrypted_3 = Familia::Encryption.decrypt(encrypted_json_2, context: context, additional_data: "test1")
+puts "Decrypted: #{decrypted_3}"
+
+# Try to decrypt with AAD = nil
+puts "Decrypting with AAD = nil..."
+begin
+  decrypted_4 = Familia::Encryption.decrypt(encrypted_json_2, context: context, additional_data: nil)
+  puts "Decrypted: #{decrypted_4}"
+rescue => e
+  puts "Decryption failed: #{e.class}: #{e.message}"
+end

data/try/debugging/debug_secure_behavior.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+require_relative 'try/helpers/test_helpers'
+
+puts "Debugging secure_by_default_behavior test failure..."
+
+# Setup encryption keys for testing
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class DebugSecureUserAccount < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  field :username
+  field :email
+  encrypted_field :password_hash
+  encrypted_field :api_secret
+  encrypted_field :recovery_key
+end
+
+# Patch for debugging
+class Familia::EncryptedFieldType
+  alias_method :original_encrypt_value, :encrypt_value
+  alias_method :original_decrypt_value, :decrypt_value
+
+  def encrypt_value(record, value)
+    aad = build_aad(record)
+    puts "[ENCRYPT] #{record.class}##{@name}: exists=#{record.exists?}, AAD=#{aad}"
+    original_encrypt_value(record, value)
+  end
+
+  def decrypt_value(record, encrypted)
+    aad = build_aad(record)
+    puts "[DECRYPT] #{record.class}##{@name}: exists=#{record.exists?}, AAD=#{aad}"
+    original_decrypt_value(record, encrypted)
+  end
+end
+
+# Clean database
+Familia.dbclient.flushdb
+
+puts "\n=== CREATION AND ENCRYPTION ==="
+user = DebugSecureUserAccount.new(id: "user123")
+puts "After new: exists=#{user.exists?}"
+
+user.username = "john_doe"
+user.email = "john@example.com"
+user.password_hash = "bcrypt$2a$12$abcdef..."
+user.api_secret = "secret-api-key-12345"
+
+puts "\n=== SAVE TO DATABASE ==="
+result = user.save
+puts "Save result: #{result}"
+puts "After save: exists=#{user.exists?}"
+
+puts "\n=== FRESH LOAD FROM DATABASE ==="
+fresh_user = DebugSecureUserAccount.load("user123")
+puts "Fresh user loaded: exists=#{fresh_user.exists?}"
+
+puts "\n=== DECRYPTION ATTEMPT ==="
+begin
+  fresh_user.password_hash.reveal do |plaintext|
+    puts "SUCCESS: Decrypted password_hash: #{plaintext}"
+  end
+rescue => e
+  puts "ERROR: #{e.class}: #{e.message}"
+  puts "This suggests AAD mismatch between save and load"
+end

data/try/debugging/debug_string_class.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+ENV['TEST'] = 'true'
+require 'familia'
+
+puts "Investigating the string class issue..."
+
+field_type = Familia::EncryptedFieldType.new(:test)
+json = '{"algorithm":"test"}'
+
+puts "Testing string object:"
+puts "json: #{json}"
+puts "json.class: #{json.class}"
+puts "json.is_a?(String): #{json.is_a?(String)}"
+puts "json.kind_of?(String): #{json.kind_of?(String)}"
+puts "json.class == String: #{json.class == String}"
+puts "json.class.ancestors: #{json.class.ancestors}"
+
+# Let's test with various string types
+frozen_string = '{"algorithm":"test"}'.freeze
+puts "\nTesting frozen string:"
+puts "frozen.class: #{frozen_string.class}"
+puts "frozen.is_a?(String): #{frozen_string.is_a?(String)}"
+
+# Test with different string creation methods
+string_new = String.new('{"algorithm":"test"}')
+puts "\nTesting String.new:"
+puts "string_new.class: #{string_new.class}"
+puts "string_new.is_a?(String): #{string_new.is_a?(String)}"
+
+# Let's inspect what the method actually receives
+puts "\nTesting what the method actually receives..."
+field_type.define_singleton_method(:debug_encrypted_json?) do |data|
+  puts "Received data: #{data.inspect}"
+  puts "Data class: #{data.class}"
+  puts "Data class ancestors: #{data.class.ancestors}"
+  puts "Is String?: #{data.is_a?(String)}"
+  puts "Kind of String?: #{data.kind_of?(String)}"
+  puts "Equals String class?: #{data.class == String}"
+  puts "Responds to string methods?: #{data.respond_to?(:upcase)}"
+  return "debug_complete"
+end
+
+result = field_type.debug_encrypted_json?(json)
+puts "Debug result: #{result}"