class Tryouts::ExpectationEvaluators::Base

Base class for all expectation evaluators

def self.handles?(expectation_type)

Returns:
  • (Boolean) - whether this evaluator can handle the given expectation type

Parameters:
  • expectation_type (Symbol) -- the type of expectation to check 
def self.handles?(expectation_type)
  raise NotImplementedError, "#{self} must implement handles? class method"
end

def build_result(passed:, actual:, expected:, expectation: @expectation.content, error: nil) 

def build_result(passed:, actual:, expected:, expectation: @expectation.content, error: nil)
  result         = {
    passed: passed,
    actual: actual,
    expected: expected,
    expectation: expectation,
  }
  result[:error] = error if error
  result
end

def eval_expectation_content(content, expectation_result = nil)

Returns:
  • (Object) - the result of evaluating the content

Parameters:
  • expectation_result (ExpectationResult) -- container with actual_result and timing data
  • content (String) -- the expectation code to evaluate 
def eval_expectation_content(content, expectation_result = nil)
  path  = @test_case.path
  range = @test_case.line_range
  if expectation_result
    # For performance expectations, timing data takes precedence for result/_
    if expectation_result.execution_time_ns
      timing_ms = expectation_result.execution_time_ms
      @context.define_singleton_method(:result) { timing_ms }
      @context.define_singleton_method(:_) { timing_ms }
    elsif expectation_result.actual_result
      # For regular expectations, use actual_result
      @context.define_singleton_method(:result) { expectation_result.actual_result }
      @context.define_singleton_method(:_) { expectation_result.actual_result }
    end
  end
  @context.instance_eval(content, path, range.first + 1)
end

def evaluate(actual_result = nil)

Returns:
  • (Hash) - evaluation result with passed status and details

Parameters:
  • actual_result (Object) -- the result to evaluate against the expectation 
def evaluate(actual_result = nil)
  raise NotImplementedError, "#{self.class} must implement evaluate method"
end

def handle_evaluation_error(error, actual_result) 

def handle_evaluation_error(error, actual_result)
  build_result(
    passed: false,
    actual: actual_result,
    expected: "EXPECTED: #{error.message}",
    expectation: @expectation.content,
    error: error,
  )
end

def initialize(expectation, test_case, context)

Parameters:
  • context (Object) -- the context in which to evaluate expectations
  • test_case (Object) -- the test case being evaluated
  • expectation (Object) -- the expectation object containing content and metadata 
def initialize(expectation, test_case, context)
  @expectation = expectation
  @test_case   = test_case
  @context     = context
end