familia 2.0.0.pre5 → 2.0.0.pre7

data/try/models/customer_try.rb

@@ -43,7 +43,7 @@ Customer.find_by_id(ident).planid
 @customer.secrets_created.delete!
 @customer.secrets_created.increment
 @customer.secrets_created.value
-#=> '1'
+#=> 1
 
 ## Customer can add custom domain via add method
 @customer.custom_domains.add(@now, 'example.org')

data/try/validation/atomic_operations_try.rb.disabled

@@ -0,0 +1,320 @@
+# Validation testing for atomic operations and transaction boundaries
+
+require_relative '../helpers/test_helpers'
+require_relative '../../lib/familia/validation'
+
+extend Familia::Validation::TestHelpers
+
+# Test models for atomic validation
+class AtomicTestAccount < Familia::Horreum
+  identifier_field :account_id
+  field :account_id
+  field :balance
+  field :status
+
+  def transfer_to(target_account, amount)
+    # This should be atomic - but let's test both atomic and non-atomic versions
+    new_balance = balance.to_i - amount.to_i
+    target_new_balance = target_account.balance.to_i + amount.to_i
+
+    # Non-atomic version (should fail validation)
+    self.balance = new_balance.to_s
+    target_account.balance = target_new_balance.to_s
+    save
+    target_account.save
+  end
+
+  def atomic_transfer_to(target_account, amount)
+    # Proper atomic version using transaction
+    new_balance = balance.to_i - amount.to_i
+    target_new_balance = target_account.balance.to_i + amount.to_i
+
+    transaction do |conn|
+      conn.hset(dbkey, 'balance', new_balance.to_s)
+      conn.hset(target_account.dbkey, 'balance', target_new_balance.to_s)
+    end
+
+    # Update local state
+    self.balance = new_balance.to_s
+    target_account.balance = target_new_balance.to_s
+  end
+end
+
+class AtomicTestCounter < Familia::Horreum
+  identifier_field :name
+  field :name
+  field :value
+
+  def increment_by(amount)
+    transaction do |conn|
+      conn.hincrby(dbkey, 'value', amount)
+    end
+    self.value = (value.to_i + amount).to_s
+  end
+end
+
+extend Familia::Validation::TestHelpers
+setup_validation_test
+
+## Clean up any existing test data
+cleanup_keys = Familia.dbclient.keys("atomictestaccount:*")
+cleanup_keys.concat(Familia.dbclient.keys("atomictestcounter:*"))
+Familia.dbclient.del(*cleanup_keys) if cleanup_keys.any?
+true
+#=> true
+
+## Transaction expectations validate MULTI/EXEC boundaries
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestaccount:acc1:object", "balance", "900")
+      .hset("atomictestaccount:acc2:object", "balance", "1100")
+  end
+
+  # Execute atomic transfer
+  acc1 = AtomicTestAccount.new(account_id: "acc1", balance: "1000")
+  acc2 = AtomicTestAccount.new(account_id: "acc2", balance: "1000")
+  acc1.save
+  acc2.save
+
+  acc1.atomic_transfer_to(acc2, 100)
+end
+result.valid?
+#=> true
+
+## Non-atomic operations should fail strict atomicity validation
+validator = Familia::Validation::Validator.new(strict_atomicity: true)
+result = validator.validate do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestaccount:acc3:object", "balance", "800")
+      .hset("atomictestaccount:acc4:object", "balance", "1200")
+  end
+
+  # This will NOT use transaction, so should fail
+  acc3 = AtomicTestAccount.new(account_id: "acc3", balance: "1000")
+  acc4 = AtomicTestAccount.new(account_id: "acc4", balance: "1000")
+  acc3.save
+  acc4.save
+
+  acc3.transfer_to(acc4, 200)  # Non-atomic version
+end
+result.valid?
+#=> false
+
+## assert_atomic_operation helper works correctly
+account_a = AtomicTestAccount.new(account_id: "acc5", balance: "2000")
+account_b = AtomicTestAccount.new(account_id: "acc6", balance: "500")
+account_a.save
+account_b.save
+
+assert_atomic_operation do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestaccount:acc5:object", "balance", "1500")
+      .hset("atomictestaccount:acc6:object", "balance", "1000")
+  end
+
+  account_a.atomic_transfer_to(account_b, 500)
+end
+#=> true
+
+## assert_transaction_used helper works
+result = assert_transaction_used do
+  counter = AtomicTestCounter.new(name: "test_counter", value: "0")
+  counter.save
+  counter.increment_by(5)
+end
+result
+#=> true
+
+## assert_no_transaction_used helper works
+result = assert_no_transaction_used do
+  simple_account = AtomicTestAccount.new(account_id: "simple", balance: "100")
+  simple_account.save  # Just a save, no transaction needed
+end
+result
+#=> true
+
+## Transaction validation detects missing MULTI command
+commands = []
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "HSET", args: ["key", "field", "value"],
+  result: "OK", timestamp: Time.now, duration_us: 100
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "EXEC", args: [],
+  result: ["OK"], timestamp: Time.now, duration_us: 50
+)
+
+sequence = Familia::Validation::CommandRecorder::CommandSequence.new
+commands.each { |cmd| sequence.add_command(cmd) }
+
+atomicity_validator = Familia::Validation::AtomicityValidator.new(sequence)
+result = atomicity_validator.validate
+result.valid?
+#=> false
+
+## Transaction validation detects missing EXEC command
+commands = []
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "MULTI", args: [],
+  result: "OK", timestamp: Time.now, duration_us: 100
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "HSET", args: ["key", "field", "value"],
+  result: "QUEUED", timestamp: Time.now, duration_us: 50
+)
+
+sequence = Familia::Validation::CommandRecorder::CommandSequence.new
+commands.each { |cmd| sequence.add_command(cmd) }
+
+atomicity_validator = Familia::Validation::AtomicityValidator.new(sequence)
+result = atomicity_validator.validate
+result.valid?
+#=> false
+
+## Proper transaction structure passes validation
+commands = []
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "MULTI", args: [],
+  result: "OK", timestamp: Time.now, duration_us: 100,
+  context: { transaction: false }
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "HSET", args: ["key", "field", "value"],
+  result: "QUEUED", timestamp: Time.now, duration_us: 50,
+  context: { transaction: true }
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "INCR", args: ["counter"],
+  result: "QUEUED", timestamp: Time.now, duration_us: 30,
+  context: { transaction: true }
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "EXEC", args: [],
+  result: [1, 1], timestamp: Time.now, duration_us: 200,
+  context: { transaction: false }
+)
+
+sequence = Familia::Validation::CommandRecorder::CommandSequence.new
+sequence.start_transaction
+commands.each { |cmd| sequence.add_command(cmd) }
+sequence.end_transaction
+
+atomicity_validator = Familia::Validation::AtomicityValidator.new(sequence)
+result = atomicity_validator.validate
+result.valid?
+#=> true
+
+## batch_update operations should be atomic
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestaccount:batch1:object", "balance", "1500")
+      .hset("atomictestaccount:batch1:object", "status", "active")
+  end
+
+  account = AtomicTestAccount.new(account_id: "batch1", balance: "1000", status: "pending")
+  account.save
+
+  # batch_update should use transaction internally
+  account.batch_update(balance: "1500", status: "active")
+end
+result.valid?
+#=> true
+
+## Nested transaction detection works
+commands = []
+# Invalid nested transaction
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "MULTI", args: [], result: "OK",
+  timestamp: Time.now, duration_us: 100
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "MULTI", args: [], result: "ERR",
+  timestamp: Time.now, duration_us: 50
+)
+
+sequence = Familia::Validation::CommandRecorder::CommandSequence.new
+commands.each { |cmd| sequence.add_command(cmd) }
+
+atomicity_validator = Familia::Validation::AtomicityValidator.new(sequence)
+result = atomicity_validator.validate
+result.valid?
+#=> false
+
+## Empty transaction detection
+commands = []
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "MULTI", args: [], result: "OK",
+  timestamp: Time.now, duration_us: 100
+)
+commands << Familia::Validation::CommandRecorder::RecordedCommand.new(
+  command: "EXEC", args: [], result: [],
+  timestamp: Time.now, duration_us: 50
+)
+
+sequence = Familia::Validation::CommandRecorder::CommandSequence.new
+sequence.start_transaction
+commands.each { |cmd| sequence.add_command(cmd) }
+sequence.end_transaction
+
+result = Familia::Validation::AtomicityValidator.new(sequence).validate
+# Should be valid but with warning about empty transaction
+result.valid? && result.warning_messages.any?
+#=> true
+
+## Real Familia transaction usage validates correctly
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestcounter:familia_tx:object", "value", "10")
+  end
+
+  counter = AtomicTestCounter.new(name: "familia_tx", value: "5")
+  counter.save
+
+  # Use Familia.transaction directly
+  Familia.transaction do |conn|
+    conn.hset(counter.dbkey, "value", "10")
+  end
+end
+result.valid?
+#=> true
+
+## Multiple transactions in sequence validate correctly
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.transaction do |tx|
+    tx.hset("atomictestcounter:multi_tx_1:object", "value", "5")
+  end
+
+  expect.transaction do |tx|
+    tx.hset("atomictestcounter:multi_tx_2:object", "value", "10")
+  end
+
+  counter1 = AtomicTestCounter.new(name: "multi_tx_1", value: "0")
+  counter2 = AtomicTestCounter.new(name: "multi_tx_2", value: "0")
+  counter1.save
+  counter2.save
+
+  # Two separate transactions
+  Familia.transaction do |conn|
+    conn.hset(counter1.dbkey, "value", "5")
+  end
+
+  Familia.transaction do |conn|
+    conn.hset(counter2.dbkey, "value", "10")
+  end
+end
+result.valid?
+#=> true
+
+## Cleanup test environment
+teardown_validation_test
+
+## Clean up test data
+cleanup_keys = Familia.dbclient.keys("atomictestaccount:*")
+cleanup_keys.concat(Familia.dbclient.keys("atomictestcounter:*"))
+Familia.dbclient.del(*cleanup_keys) if cleanup_keys.any?
+true
+#=> true

data/try/validation/command_validation_try.rb.disabled

@@ -0,0 +1,207 @@
+# Validation testing for Redis command recording and expectation matching
+
+require_relative '../helpers/test_helpers'
+require_relative '../../lib/familia/validation'
+
+# Test class for validation testing
+class ValidationTestModel < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+  field :email
+  field :active
+end
+
+extend Familia::Validation::TestHelpers
+
+# Initialize validation framework
+setup_validation_test
+
+## Command recorder captures basic Redis commands
+Familia::Validation::CommandRecorder.start_recording
+ValidationTestModel.new(id: "test1", name: "John").save
+commands = Familia::Validation::CommandRecorder.stop_recording
+commands.command_count > 0
+#=> true
+
+## Command recorder captures command details
+Familia::Validation::CommandRecorder.start_recording
+Familia.dbclient.hset("test:key", "field", "value")
+commands = Familia::Validation::CommandRecorder.stop_recording
+first_command = commands.commands.first
+first_command ? [first_command.command, first_command.args] : "No commands recorded"
+#=> ["HSET", ["test:key", "field", "value"]]
+
+## Expectation DSL allows chaining commands
+expectations = Familia::Validation::CommandExpectations.new
+expectations.hset("user:123", "name", "John")
+           .hset("user:123", "email", "john@example.com")
+           .incr("counter")
+expectations.expected_commands.length
+#=> 3
+
+## Basic command validation passes with exact match
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.hset("validationtestmodel:test2:object", "name", "Jane")
+        .hset("validationtestmodel:test2:object", "id", "test2")
+
+  # Execute the actual operation
+  model = ValidationTestModel.new(id: "test2", name: "Jane")
+  model.save
+end
+result.valid?
+#=> true
+
+## Command validation fails with wrong command
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.get("wrong:key")  # This won't match actual operation
+
+  ValidationTestModel.new(id: "test3", name: "Bob").save
+end
+result.valid?
+#=> false
+
+## Command validation provides detailed error messages
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.hset("wrong:key", "field", "value")
+
+  ValidationTestModel.new(id: "test4").save
+end
+result.error_messages.length > 0
+#=> true
+
+## Pattern matching works for flexible validation
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.match_pattern(/^HSET validationtestmodel:test5:object/)
+
+  ValidationTestModel.new(id: "test5", name: "Alice").save
+end
+result.valid?
+#=> true
+
+## Any value matchers work correctly
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.hset("validationtestmodel:test6:object", "name", any_string)
+        .hset("validationtestmodel:test6:object", "id", "test6")
+
+  ValidationTestModel.new(id: "test6", name: "Charlie").save
+end
+result.valid?
+#=> true
+
+## Test helper assert_redis_commands works
+model = ValidationTestModel.new(id: "test7", name: "Dave")
+assert_redis_commands do |expect|
+  expect.hset("validationtestmodel:test7:object", "name", "Dave")
+        .hset("validationtestmodel:test7:object", "id", "test7")
+
+  model.save
+end
+#=> true
+
+## Test helper assert_command_count works
+result = assert_command_count(2) do
+  Familia.dbclient.hset("test:count", "field1", "value1")
+  Familia.dbclient.hset("test:count", "field2", "value2")
+end
+result
+#=> true
+
+## Test helper assert_no_redis_commands works
+result = assert_no_redis_commands do
+  # Just create object, don't save
+  ValidationTestModel.new(id: "test8", name: "Eve")
+end
+result
+#=> true
+
+## Flexible order validation works
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.strict_order(false)
+        .hset("validationtestmodel:test9:object", "name", any_string)
+        .hset("validationtestmodel:test9:object", "id", "test9")
+
+  # Save in any order should work
+  model = ValidationTestModel.new(id: "test9", name: "Frank")
+  model.save
+end
+result.valid?
+#=> true
+
+## Command sequence provides useful metadata
+Familia::Validation::CommandRecorder.start_recording
+ValidationTestModel.new(id: "test10", name: "Grace").save
+commands = Familia::Validation::CommandRecorder.stop_recording
+summary = {
+  command_count: commands.command_count,
+  has_commands: commands.commands.any?,
+  first_command_type: commands.commands.first&.command_type
+}
+summary[:command_count] > 0 && summary[:has_commands]
+#=> true
+
+## Performance tracking captures timing information
+validator = Familia::Validation::Validator.new(performance_tracking: true)
+result = validator.validate do |expect|
+  expect.match_pattern(/HSET/)
+
+  ValidationTestModel.new(id: "test11", name: "Henry").save
+end
+result.respond_to?(:performance_metrics) && result.performance_metrics[:total_commands] > 0
+#=> true
+
+## Validation result provides comprehensive summary
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.hset("validationtestmodel:test12:object", "name", "Iris")
+
+  ValidationTestModel.new(id: "test12", name: "Iris").save
+end
+summary = result.summary
+summary[:valid] == true && summary[:expected_commands] == 1
+#=> true
+
+## Complex validation with multiple operations
+class ComplexTestModel < Familia::Horreum
+  identifier_field :id
+  field :id, :name, :email
+  list :tags
+  set :categories
+end
+
+validator = Familia::Validation::Validator.new
+result = validator.validate do |expect|
+  expect.hset("complextestmodel:complex1:object", "name", "Complex")
+        .hset("complextestmodel:complex1:object", "id", "complex1")
+        .lpush("complextestmodel:complex1:tags", "tag1")
+        .sadd("complextestmodel:complex1:categories", "cat1")
+
+  model = ComplexTestModel.new(id: "complex1", name: "Complex")
+  model.save
+  model.tags.unshift("tag1")
+  model.categories.add("cat1")
+end
+result.valid?
+#=> true
+
+## Cleanup test environment
+begin
+  teardown_validation_test
+rescue => e
+  # Gracefully handle teardown issues during test development
+  puts "Teardown warning: #{e.message}"
+end
+
+## Clean up test data
+test_keys = Familia.dbclient.keys("validationtestmodel:*")
+test_keys.concat(Familia.dbclient.keys("complextestmodel:*"))
+test_keys.concat(Familia.dbclient.keys("test:*"))
+Familia.dbclient.del(*test_keys) if test_keys.any?
+true
+#=> true