decision_agent 0.2.0 → 0.3.0

data/lib/decision_agent/dmn/testing.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require_relative "../testing/test_scenario"
+require_relative "../evaluators/dmn_evaluator"
+require_relative "parser"
+
+module DecisionAgent
+  module Dmn
+    # DMN Testing Framework
+    # Provides testing capabilities for DMN models
+    class DmnTester
+      attr_reader :model, :test_scenarios, :test_results
+
+      def initialize(model)
+        @model = model
+        @test_scenarios = []
+        @test_results = []
+      end
+
+      # Add a test scenario
+      def add_scenario(decision_id:, inputs:, expected_output:, description: nil)
+        scenario = {
+          decision_id: decision_id,
+          inputs: inputs,
+          expected_output: expected_output,
+          description: description || "Test #{@test_scenarios.size + 1}"
+        }
+
+        @test_scenarios << scenario
+        scenario
+      end
+
+      # Run all test scenarios
+      def run_all_tests
+        @test_results = []
+
+        @test_scenarios.each_with_index do |scenario, idx|
+          result = run_test(scenario, idx)
+          @test_results << result
+        end
+
+        generate_test_report
+      end
+
+      # Run a single test scenario
+      # rubocop:disable Metrics/MethodLength
+      def run_test(scenario, index = nil)
+        decision = @model.find_decision(scenario[:decision_id])
+
+        unless decision
+          return {
+            index: index,
+            scenario: scenario,
+            status: :error,
+            error: "Decision '#{scenario[:decision_id]}' not found",
+            passed: false
+          }
+        end
+
+        begin
+          # Create evaluator for this decision
+          evaluator = Evaluators::DmnEvaluator.new(
+            dmn_model: @model,
+            decision_id: scenario[:decision_id]
+          )
+
+          # Evaluate with test inputs
+          context = Context.new(scenario[:inputs])
+          result = evaluator.evaluate(context: context)
+
+          # Compare result with expected output
+          actual_output = result.decision
+          expected_output = scenario[:expected_output]
+
+          passed = outputs_match?(actual_output, expected_output)
+
+          {
+            index: index,
+            scenario: scenario,
+            status: :completed,
+            actual_output: actual_output,
+            expected_output: expected_output,
+            passed: passed,
+            result: result
+          }
+        rescue StandardError => e
+          {
+            index: index,
+            scenario: scenario,
+            status: :error,
+            error: e.message,
+            passed: false
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      # Generate test coverage report
+      # rubocop:disable Metrics/AbcSize
+      def generate_coverage_report
+        coverage = {
+          total_decisions: @model.decisions.size,
+          tested_decisions: Set.new,
+          untested_decisions: [],
+          decision_coverage: {}
+        }
+
+        # Track which decisions are tested
+        @test_scenarios.each do |scenario|
+          coverage[:tested_decisions].add(scenario[:decision_id])
+        end
+
+        # Find untested decisions
+        @model.decisions.each do |decision|
+          coverage[:untested_decisions] << decision.id unless coverage[:tested_decisions].include?(decision.id)
+
+          # Calculate coverage for each decision
+          decision_tests = @test_scenarios.select { |s| s[:decision_id] == decision.id }
+          coverage[:decision_coverage][decision.id] = {
+            test_count: decision_tests.size,
+            tested: !decision_tests.empty?
+          }
+
+          # For decision tables, calculate rule coverage
+          if decision.decision_table
+            rule_coverage = calculate_rule_coverage(decision, decision_tests)
+            coverage[:decision_coverage][decision.id][:rule_coverage] = rule_coverage
+          end
+        end
+
+        coverage[:coverage_percentage] = if coverage[:total_decisions].positive?
+                                           (coverage[:tested_decisions].size.to_f / coverage[:total_decisions] * 100).round(2)
+                                         else
+                                           0
+                                         end
+
+        coverage
+      end
+
+      # Import test scenarios from CSV
+      def import_scenarios_from_csv(file_path)
+        require "csv"
+
+        CSV.foreach(file_path, headers: true) do |row|
+          inputs = {}
+          row.headers.each do |header|
+            next if %w[decision_id expected_output description].include?(header)
+
+            inputs[header] = parse_value(row[header])
+          end
+
+          add_scenario(
+            decision_id: row["decision_id"],
+            inputs: inputs,
+            expected_output: parse_value(row["expected_output"]),
+            description: row["description"]
+          )
+        end
+
+        @test_scenarios.size
+      end
+
+      # Export test scenarios to CSV
+      def export_scenarios_to_csv(file_path)
+        require "csv"
+
+        return if @test_scenarios.empty?
+
+        # Collect all unique input keys
+        input_keys = @test_scenarios.flat_map { |s| s[:inputs].keys }.uniq.sort
+
+        CSV.open(file_path, "w") do |csv|
+          # Write headers
+          headers = ["decision_id"] + input_keys + %w[expected_output description]
+          csv << headers
+
+          # Write scenarios
+          @test_scenarios.each do |scenario|
+            row = [scenario[:decision_id]]
+            input_keys.each { |key| row << scenario[:inputs][key] }
+            row << scenario[:expected_output]
+            row << scenario[:description]
+            csv << row
+          end
+        end
+
+        @test_scenarios.size
+      end
+
+      # Clear all test scenarios
+      def clear_scenarios
+        @test_scenarios = []
+        @test_results = []
+      end
+
+      private
+
+      def outputs_match?(actual, expected)
+        # Handle nil cases
+        return true if actual.nil? && expected.nil?
+        return false if actual.nil? || expected.nil?
+
+        # For simple values, do direct comparison
+        if actual.is_a?(Hash) && expected.is_a?(Hash)
+          actual.all? { |k, v| expected[k] == v }
+        else
+          actual.to_s == expected.to_s
+        end
+      end
+
+      def calculate_rule_coverage(decision, tests)
+        table = decision.decision_table
+        return { coverage: 0, tested_rules: [], untested_rules: [] } unless table
+
+        tested_rules = Set.new
+
+        # Run each test and track which rules matched
+        tests.each do |test|
+          evaluator = Evaluators::DmnEvaluator.new(
+            dmn_model: @model,
+            decision_id: decision.id
+          )
+
+          context = Context.new(test[:inputs])
+
+          begin
+            # This would need to be enhanced to track which rule matched
+            evaluator.evaluate(context: context)
+            # In a full implementation, we'd track the matched rule
+          rescue StandardError
+            # Ignore errors for coverage calculation
+          end
+        end
+
+        untested_rules = table.rules.map(&:id).reject { |rid| tested_rules.include?(rid) }
+
+        {
+          total_rules: table.rules.size,
+          tested_rules: tested_rules.size,
+          untested_rules: untested_rules,
+          coverage_percentage: if table.rules.size.positive?
+                                 (tested_rules.size.to_f / table.rules.size * 100).round(2)
+                               else
+                                 0
+                               end
+        }
+      end
+
+      def generate_test_report
+        total = @test_results.size
+        passed = @test_results.count { |r| r[:passed] }
+        failed = @test_results.count { |r| !r[:passed] }
+        errors = @test_results.count { |r| r[:status] == :error }
+
+        {
+          summary: {
+            total: total,
+            passed: passed,
+            failed: failed,
+            errors: errors,
+            pass_rate: total.positive? ? (passed.to_f / total * 100).round(2) : 0
+          },
+          results: @test_results,
+          coverage: generate_coverage_report
+        }
+      end
+
+      def parse_value(value)
+        return nil if value.nil? || value.empty?
+
+        # Try to parse as number
+        return value.to_i if value.match?(/^\d+$/)
+        return value.to_f if value.match?(/^\d+\.\d+$/)
+
+        # Try to parse as boolean
+        return true if value.downcase == "true"
+        return false if value.downcase == "false"
+
+        # Return as string
+        value
+      end
+    end
+
+    # Test Suite for organizing multiple DMN models' tests
+    class DmnTestSuite
+      attr_reader :models, :testers
+
+      def initialize
+        @models = {}
+        @testers = {}
+      end
+
+      # Add a model to the test suite
+      def add_model(model_id, model)
+        @models[model_id] = model
+        @testers[model_id] = DmnTester.new(model)
+      end
+
+      # Get tester for a model
+      def tester_for(model_id)
+        @testers[model_id]
+      end
+
+      # Run all tests for all models
+      def run_all
+        results = {}
+
+        @testers.each do |model_id, tester|
+          results[model_id] = tester.run_all_tests
+        end
+
+        generate_suite_report(results)
+      end
+
+      # Generate overall suite report
+      def generate_suite_report(results)
+        total_tests = results.values.sum { |r| r[:summary][:total] }
+        total_passed = results.values.sum { |r| r[:summary][:passed] }
+        total_failed = results.values.sum { |r| r[:summary][:failed] }
+
+        {
+          models_tested: results.size,
+          total_tests: total_tests,
+          total_passed: total_passed,
+          total_failed: total_failed,
+          overall_pass_rate: total_tests.positive? ? (total_passed.to_f / total_tests * 100).round(2) : 0,
+          model_results: results
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/decision_agent/dmn/validator.rb

@@ -0,0 +1,315 @@
+require_relative "errors"
+require_relative "feel/evaluator"
+
+module DecisionAgent
+  module Dmn
+    # Validates DMN model structure and semantics with enhanced validation
+    class Validator
+      attr_reader :errors, :warnings
+
+      def initialize(model = nil)
+        @model = model
+        @errors = []
+        @warnings = []
+        @feel_evaluator = Feel::Evaluator.new
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def validate(model = nil)
+        @model = model if model
+        return false unless @model
+
+        @errors = []
+        @warnings = []
+
+        # Basic structure validation
+        validate_model_structure
+        validate_decisions
+
+        # Semantic validation
+        validate_decision_dependencies
+        validate_decision_graph_cycles
+
+        # Business rule validation
+        validate_decision_tables
+
+        @errors.empty?
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # rubocop:disable Naming/PredicateMethod
+      def validate!
+        validate
+        raise InvalidDmnModelError, format_errors if @errors.any?
+
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      def valid?
+        @errors.empty?
+      end
+
+      private
+
+      # Basic structure validation
+      def validate_model_structure
+        @errors << "Model must have an ID" if @model.id.nil? || @model.id.empty?
+        @errors << "Model must have a name" if @model.name.nil? || @model.name.empty?
+        @errors << "Model must have a namespace" if @model.namespace.nil? || @model.namespace.empty?
+        @warnings << "Model has no decisions defined" if @model.decisions.empty?
+      end
+
+      def validate_decisions
+        decision_ids = Set.new
+
+        @model.decisions.each_with_index do |decision, idx|
+          validate_decision(decision, idx)
+
+          # Check for duplicate decision IDs
+          if decision_ids.include?(decision.id)
+            @errors << "Duplicate decision ID: #{decision.id}"
+          else
+            decision_ids.add(decision.id)
+          end
+        end
+      end
+
+      def validate_decision(decision, idx)
+        path = "Decision[#{idx}](#{decision.id})"
+
+        @errors << "#{path}: Decision must have an ID" if decision.id.nil? || decision.id.empty?
+        @errors << "#{path}: Decision must have a name" if decision.name.nil? || decision.name.empty?
+
+        # Validate decision has some form of logic
+        unless decision.decision_table || decision.decision_tree || decision.instance_variable_get(:@literal_expression)
+          @errors << "#{path}: Decision must have decision logic (table, tree, or literal expression)"
+        end
+
+        # Validate information requirements
+        validate_information_requirements(decision, path)
+      end
+
+      def validate_information_requirements(decision, path)
+        return unless decision.information_requirements
+
+        decision.information_requirements.each do |req|
+          required_decision_id = req[:decision_id]
+
+          # Check if required decision exists
+          @errors << "#{path}: References non-existent decision: #{required_decision_id}" unless @model.find_decision(required_decision_id)
+        end
+      end
+
+      # Semantic validation - check for circular dependencies
+      def validate_decision_graph_cycles
+        visited = Set.new
+        rec_stack = Set.new
+
+        @model.decisions.each do |decision|
+          @errors << "Circular dependency detected in decision graph involving: #{decision.id}" if cycle?(decision, visited, rec_stack)
+        end
+      end
+
+      def cycle?(decision, visited, rec_stack)
+        return false if visited.include?(decision.id)
+
+        visited.add(decision.id)
+        rec_stack.add(decision.id)
+
+        # Check all dependencies
+        decision.information_requirements.each do |req|
+          dep = @model.find_decision(req[:decision_id])
+          next unless dep
+
+          return true if !visited.include?(dep.id) && cycle?(dep, visited, rec_stack)
+          return true if rec_stack.include?(dep.id)
+        end
+
+        rec_stack.delete(decision.id)
+        false
+      end
+
+      def validate_decision_dependencies
+        # Check for unreachable decisions
+        reachable = Set.new
+        leaves = find_leaf_decisions
+
+        leaves.each do |leaf|
+          mark_reachable(leaf, reachable)
+        end
+
+        @model.decisions.each do |decision|
+          @warnings << "Decision #{decision.id} is not reachable from any leaf decision" unless reachable.include?(decision.id)
+        end
+      end
+
+      def find_leaf_decisions
+        # Leaf decisions are those that no other decision depends on
+        required_decisions = Set.new
+        @model.decisions.each do |decision|
+          decision.information_requirements.each do |req|
+            required_decisions.add(req[:decision_id])
+          end
+        end
+
+        @model.decisions.reject { |d| required_decisions.include?(d.id) }
+      end
+
+      def mark_reachable(decision, reachable)
+        return if reachable.include?(decision.id)
+
+        reachable.add(decision.id)
+
+        decision.information_requirements.each do |req|
+          dep = @model.find_decision(req[:decision_id])
+          mark_reachable(dep, reachable) if dep
+        end
+      end
+
+      # Business rule validation for decision tables
+      def validate_decision_tables
+        @model.decisions.each_with_index do |decision, idx|
+          next unless decision.decision_table
+
+          path = "Decision[#{idx}](#{decision.id})"
+          table = decision.decision_table
+
+          validate_table_structure(table, path)
+          validate_table_hit_policy(table, path)
+          validate_table_completeness(table, path)
+          validate_table_rules(table, path)
+        end
+      end
+
+      def validate_table_structure(table, path)
+        @errors << "#{path}: Decision table must have at least one input" if table.inputs.empty?
+        @errors << "#{path}: Decision table must have at least one output" if table.outputs.empty?
+        @warnings << "#{path}: Decision table has no rules defined" if table.rules.empty?
+
+        # Check for duplicate input/output IDs
+        input_ids = table.inputs.map(&:id)
+        @errors << "#{path}: Duplicate input IDs detected" if input_ids.size != input_ids.uniq.size
+
+        output_ids = table.outputs.map(&:id)
+        @errors << "#{path}: Duplicate output IDs detected" if output_ids.size != output_ids.uniq.size
+      end
+
+      def validate_table_hit_policy(table, path)
+        valid_policies = %w[UNIQUE FIRST PRIORITY ANY COLLECT]
+
+        unless valid_policies.include?(table.hit_policy)
+          @errors << "#{path}: Invalid hit policy '#{table.hit_policy}'. Must be one of: #{valid_policies.join(', ')}"
+        end
+
+        # Validate hit policy requirements
+        case table.hit_policy
+        when "UNIQUE"
+          # Check for overlapping rules (not fully implemented - would require rule evaluation)
+          @warnings << "#{path}: UNIQUE hit policy requires rules to be mutually exclusive"
+        when "PRIORITY"
+          # Check that outputs have defined allowed values with priorities
+          table.outputs.each do |output|
+            unless output.instance_variable_get(:@allowed_values)
+              @warnings << "#{path}: PRIORITY hit policy requires outputs to have defined allowed values"
+            end
+          end
+        end
+      end
+
+      def validate_table_completeness(table, path)
+        return if table.rules.empty?
+
+        # Check for rules with all wildcards and empty outputs
+        table.rules.each_with_index do |rule, idx|
+          all_wildcards = rule.input_entries.all? { |entry| entry.nil? || entry == "-" || entry.empty? }
+          @warnings << "#{path}.Rule[#{idx}]: Rule has all wildcard inputs - will match everything" if all_wildcards
+
+          # Check for empty output entries
+          rule.output_entries.each_with_index do |entry, output_idx|
+            next unless entry.nil? || entry.empty?
+
+            output = table.outputs[output_idx]
+            @warnings << "#{path}.Rule[#{idx}]: Empty output for '#{output&.label}'"
+          end
+        end
+      end
+
+      def validate_table_rules(table, path)
+        table.rules.each_with_index do |rule, idx|
+          validate_rule(rule, table, "#{path}.Rule[#{idx}]")
+          validate_rule_feel_expressions(rule, table, "#{path}.Rule[#{idx}]")
+        end
+      end
+
+      def validate_rule(rule, table, path)
+        expected_inputs = table.inputs.size
+        expected_outputs = table.outputs.size
+
+        if rule.input_entries.size != expected_inputs
+          @errors << "#{path}: Expected #{expected_inputs} input entries, got #{rule.input_entries.size}"
+        end
+
+        if rule.output_entries.size != expected_outputs
+          @errors << "#{path}: Expected #{expected_outputs} output entries, got #{rule.output_entries.size}"
+        end
+
+        # Validate rule has an ID
+        @errors << "#{path}: Rule must have an ID" if rule.id.nil? || rule.id.empty?
+      end
+
+      def validate_rule_feel_expressions(rule, table, path)
+        # Validate input entry expressions are valid FEEL
+        rule.input_entries.each_with_index do |entry, idx|
+          next if entry.nil? || entry == "-" || entry.empty?
+
+          input = table.inputs[idx]
+          validate_feel_expression(entry, "#{path}.Input[#{idx}](#{input&.label})")
+        end
+
+        # Validate output entry expressions
+        rule.output_entries.each_with_index do |entry, idx|
+          next if entry.nil? || entry.empty?
+
+          output = table.outputs[idx]
+          validate_feel_expression(entry, "#{path}.Output[#{idx}](#{output&.label})")
+        end
+      end
+
+      def validate_feel_expression(expression, path)
+        return if expression.nil? || expression.empty?
+
+        begin
+          # Try to parse the expression (basic validation)
+          # Full validation would require evaluating with sample context
+          @feel_evaluator.evaluate(expression.to_s, {})
+        rescue StandardError => e
+          # Only warn for FEEL validation errors since they might be context-dependent
+          @warnings << "#{path}: Possible FEEL expression issue: #{e.message}"
+        end
+      end
+
+      def format_errors
+        parts = []
+
+        if @errors.any?
+          parts << "DMN model validation failed with #{@errors.size} error(s):"
+          parts << ""
+          @errors.each_with_index do |err, idx|
+            parts << "  #{idx + 1}. #{err}"
+          end
+        end
+
+        if @warnings.any?
+          parts << "" if @errors.any?
+          parts << "Warnings (#{@warnings.size}):"
+          @warnings.each_with_index do |warn, idx|
+            parts << "  #{idx + 1}. #{warn}"
+          end
+        end
+
+        parts.join("\n")
+      end
+    end
+  end
+end