Class: Tryouts::ExpectationEvaluators::Regular

Inherits:
Base
  • Object
show all
Defined in:
lib/tryouts/expectation_evaluators/regular.rb

Overview

Evaluator for standard equality expectations using syntax: #=> expression

PURPOSE:

  • Validates that test result equals the evaluated expectation expression
  • Provides the fundamental equality-based testing mechanism
  • Serves as the default and most commonly used expectation type

SYNTAX: #=> expression Examples:

1 + 1         #=> 2                        # Pass: 2 == 2
[1, 2, 3]     #=> result.length            # Pass: [1,2,3] == 3 (fails, different types)
[1, 2, 3]     #=> [1, 2, 3]               # Pass: array equality
"hello"       #=> "hello"                 # Pass: string equality
[1, 2, 3]     #=> result.sort              # Pass: [1,2,3] == [1,2,3]
{ a: 1 }      #=> { a: 1 }                # Pass: hash equality
1 + 1         #=> result                  # Pass: 2 == 2 (result variable access)

EQUALITY SEMANTICS:

  • Uses Ruby's == operator for equality comparison
  • Supports all Ruby types: primitives, collections, objects
  • Type-sensitive: 2 != "2", [1] != 1, nil != false
  • Reference-independent: compares values not object identity

IMPLEMENTATION DETAILS:

  • Expression has access to result and _ variables (actual_result)
  • Expected display shows the evaluated expression result (not raw content)
  • Actual display shows the test result value
  • Most flexible evaluator supporting arbitrary Ruby expressions

DESIGN DECISIONS:

  • Standard equality provides intuitive testing behavior
  • Expression evaluation enables dynamic expectations (result.length, etc.)
  • Uses #=> syntax as the canonical expectation notation
  • Evaluated expected display prevents confusion with literal text content
  • Part of unified #= prefix convention for all expectation types
  • Serves as fallback when no specialized evaluator applies

VARIABLE ACCESS:

  • result: contains the actual test result value
  • _: shorthand alias for the same actual result value
  • Enables expectations like: #=> result.upcase, #=> _.first, #=> result * 2

Instance Attribute Summary

Attributes inherited from Base

#context, #expectation, #test_case

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#initialize

Constructor Details

This class inherits a constructor from Tryouts::ExpectationEvaluators::Base

Class Method Details

.handles?(expectation_type) ⇒ Boolean

Returns:



51
52
53
 
# File 'lib/tryouts/expectation_evaluators/regular.rb', line 51

def self.handles?(expectation_type)
  expectation_type == :regular
end

Instance Method Details

#evaluate(actual_result = nil) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/tryouts/expectation_evaluators/regular.rb', line 55

def evaluate(actual_result = nil)
  expectation_result = ExpectationResult.from_result(actual_result)
  expected_value     = eval_expectation_content(@expectation.content, expectation_result)

  build_result(
    passed: actual_result == expected_value,
    actual: actual_result,
    expected: expected_value,
  )
rescue StandardError => ex
  handle_evaluation_error(ex, actual_result)
end