decision_agent 0.2.0 → 0.3.0

data/spec/dmn/decision_tree_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decision_agent/dmn/decision_tree"
+
+RSpec.describe DecisionAgent::Dmn::DecisionTree do
+  describe "basic tree structure" do
+    let(:tree) do
+      described_class.new(id: "tree1", name: "Loan Approval Tree")
+    end
+
+    it "creates a tree with root node" do
+      expect(tree.root).to be_a(DecisionAgent::Dmn::TreeNode)
+      expect(tree.root.id).to eq("root")
+    end
+
+    it "allows adding children to nodes" do
+      child1 = DecisionAgent::Dmn::TreeNode.new(id: "child1", label: "Check Age")
+      tree.root.add_child(child1)
+
+      expect(tree.root.children).to include(child1)
+      expect(child1.parent).to eq(tree.root)
+    end
+  end
+
+  describe "tree evaluation" do
+    let(:tree) do
+      # Build a simple decision tree for loan approval
+      tree = described_class.new(id: "loan_tree", name: "Loan Approval")
+
+      # Root node
+      root = tree.root
+
+      # First level - check age
+      age_check = DecisionAgent::Dmn::TreeNode.new(
+        id: "age_check",
+        label: "Age >= 18?",
+        condition: "age >= 18"
+      )
+      root.add_child(age_check)
+
+      # Second level under age check - check credit score
+      good_credit = DecisionAgent::Dmn::TreeNode.new(
+        id: "good_credit",
+        label: "Credit Score >= 650?",
+        condition: "credit_score >= 650"
+      )
+      age_check.add_child(good_credit)
+
+      # Leaf nodes - decisions
+      approved = DecisionAgent::Dmn::TreeNode.new(
+        id: "approved",
+        label: "Approved",
+        decision: "Approved"
+      )
+      good_credit.add_child(approved)
+
+      rejected_credit = DecisionAgent::Dmn::TreeNode.new(
+        id: "rejected_credit",
+        label: "Rejected - Poor Credit",
+        decision: "Rejected - Poor Credit"
+      )
+      good_credit.add_child(rejected_credit)
+
+      # Rejected for age
+      rejected_age = DecisionAgent::Dmn::TreeNode.new(
+        id: "rejected_age",
+        label: "Rejected - Too Young",
+        decision: "Rejected - Too Young"
+      )
+      root.add_child(rejected_age)
+
+      tree
+    end
+
+    it "evaluates tree with context matching approved path" do
+      context = { age: 25, credit_score: 700 }
+      result = tree.evaluate(context)
+      expect(result).to eq("Approved")
+    end
+
+    it "evaluates tree with poor credit" do
+      context = { age: 25, credit_score: 600 }
+      result = tree.evaluate(context)
+      expect(result).to eq("Rejected - Poor Credit")
+    end
+
+    it "evaluates tree with age too young" do
+      context = { age: 16, credit_score: 700 }
+      result = tree.evaluate(context)
+      expect(result).to eq("Rejected - Too Young")
+    end
+
+    it "returns nil when no path matches" do
+      context = {}
+      result = tree.evaluate(context)
+      expect(result).to be_nil
+    end
+  end
+
+  describe "tree serialization" do
+    let(:tree_hash) do
+      {
+        id: "test_tree",
+        name: "Test Tree",
+        root: {
+          id: "root",
+          label: "Root",
+          condition: nil,
+          decision: nil,
+          children: [
+            {
+              id: "node1",
+              label: "Node 1",
+              condition: "x > 5",
+              decision: nil,
+              children: [
+                {
+                  id: "leaf1",
+                  label: "Leaf 1",
+                  condition: nil,
+                  decision: "Result A",
+                  children: []
+                }
+              ]
+            }
+          ]
+        }
+      }
+    end
+
+    it "converts tree to hash" do
+      tree = described_class.new(id: "tree1", name: "Tree 1")
+      node1 = DecisionAgent::Dmn::TreeNode.new(id: "node1", condition: "x > 5")
+      tree.root.add_child(node1)
+
+      hash = tree.to_h
+      expect(hash[:id]).to eq("tree1")
+      expect(hash[:name]).to eq("Tree 1")
+      expect(hash[:root][:children].length).to eq(1)
+    end
+
+    it "builds tree from hash" do
+      tree = described_class.from_hash(tree_hash)
+
+      expect(tree.id).to eq("test_tree")
+      expect(tree.name).to eq("Test Tree")
+      expect(tree.root.children.length).to eq(1)
+      expect(tree.root.children.first.id).to eq("node1")
+    end
+  end
+
+  describe "tree analysis" do
+    let(:tree) do
+      tree = described_class.new(id: "analysis_tree", name: "Analysis Tree")
+
+      level1 = DecisionAgent::Dmn::TreeNode.new(id: "level1")
+      tree.root.add_child(level1)
+
+      level2a = DecisionAgent::Dmn::TreeNode.new(id: "level2a")
+      level2b = DecisionAgent::Dmn::TreeNode.new(id: "level2b")
+      level1.add_child(level2a)
+      level1.add_child(level2b)
+
+      leaf1 = DecisionAgent::Dmn::TreeNode.new(id: "leaf1", decision: "Result 1")
+      leaf2 = DecisionAgent::Dmn::TreeNode.new(id: "leaf2", decision: "Result 2")
+      level2a.add_child(leaf1)
+      level2b.add_child(leaf2)
+
+      tree
+    end
+
+    it "collects all leaf nodes" do
+      leaves = tree.leaf_nodes
+      expect(leaves.length).to eq(2)
+      expect(leaves.map(&:id)).to include("leaf1", "leaf2")
+    end
+
+    it "calculates tree depth" do
+      expect(tree.depth).to eq(3) # root -> level1 -> level2 -> leaf (depth 3)
+    end
+
+    it "collects all paths from root to leaves" do
+      paths = tree.paths
+      expect(paths.length).to eq(2)
+      expect(paths.first.length).to be >= 3
+    end
+  end
+
+  describe DecisionAgent::Dmn::TreeNode do
+    it "identifies leaf nodes correctly" do
+      node = DecisionAgent::Dmn::TreeNode.new(id: "test", decision: "Decision")
+      expect(node.leaf?).to be true
+    end
+
+    it "identifies non-leaf nodes correctly" do
+      node = DecisionAgent::Dmn::TreeNode.new(id: "test")
+      child = DecisionAgent::Dmn::TreeNode.new(id: "child")
+      node.add_child(child)
+      expect(node.leaf?).to be false
+    end
+  end
+end

data/spec/dmn/feel/errors_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "decision_agent/dmn/errors"
+
+RSpec.describe "FEEL Errors" do
+  describe DecisionAgent::Dmn::FeelParseError do
+    it "creates error with message only" do
+      error = DecisionAgent::Dmn::FeelParseError.new("Parse failed")
+      expect(error.message).to eq("Parse failed")
+    end
+  end
+
+  describe DecisionAgent::Dmn::FeelEvaluationError do
+    it "creates error with message only" do
+      error = DecisionAgent::Dmn::FeelEvaluationError.new("Evaluation failed")
+      expect(error.message).to eq("Evaluation failed")
+    end
+  end
+end

data/spec/dmn/feel/functions_spec.rb

@@ -0,0 +1,400 @@
+require "spec_helper"
+require "decision_agent/dmn/feel/functions"
+
+RSpec.describe DecisionAgent::Dmn::Feel::Functions do
+  describe "String Functions" do
+    describe "substring" do
+      it "extracts substring with start and length" do
+        result = described_class.execute("substring", ["hello world", 1, 5])
+        expect(result).to eq("hello")
+      end
+
+      it "extracts substring from start to end" do
+        result = described_class.execute("substring", ["hello world", 7])
+        expect(result).to eq("world")
+      end
+
+      it "handles 1-based indexing" do
+        result = described_class.execute("substring", ["abc", 2, 1])
+        expect(result).to eq("b")
+      end
+    end
+
+    describe "string length" do
+      it "returns length of string" do
+        result = described_class.execute("string length", ["hello"])
+        expect(result).to eq(5)
+      end
+
+      it "returns 0 for empty string" do
+        result = described_class.execute("string length", [""])
+        expect(result).to eq(0)
+      end
+    end
+
+    describe "upper case" do
+      it "converts to uppercase" do
+        result = described_class.execute("upper case", ["hello"])
+        expect(result).to eq("HELLO")
+      end
+    end
+
+    describe "lower case" do
+      it "converts to lowercase" do
+        result = described_class.execute("lower case", ["HELLO"])
+        expect(result).to eq("hello")
+      end
+    end
+
+    describe "contains" do
+      it "returns true when substring is found" do
+        result = described_class.execute("contains", ["hello world", "world"])
+        expect(result).to be true
+      end
+
+      it "returns false when substring is not found" do
+        result = described_class.execute("contains", ["hello world", "xyz"])
+        expect(result).to be false
+      end
+    end
+
+    describe "starts with" do
+      it "returns true when string starts with prefix" do
+        result = described_class.execute("starts with", ["hello world", "hello"])
+        expect(result).to be true
+      end
+
+      it "returns false when string does not start with prefix" do
+        result = described_class.execute("starts with", ["hello world", "world"])
+        expect(result).to be false
+      end
+    end
+
+    describe "ends with" do
+      it "returns true when string ends with suffix" do
+        result = described_class.execute("ends with", ["hello world", "world"])
+        expect(result).to be true
+      end
+
+      it "returns false when string does not end with suffix" do
+        result = described_class.execute("ends with", ["hello world", "hello"])
+        expect(result).to be false
+      end
+    end
+
+    describe "substring before" do
+      it "returns substring before match" do
+        result = described_class.execute("substring before", ["hello world", " "])
+        expect(result).to eq("hello")
+      end
+
+      it "returns empty string when match not found" do
+        result = described_class.execute("substring before", %w[hello x])
+        expect(result).to eq("")
+      end
+    end
+
+    describe "substring after" do
+      it "returns substring after match" do
+        result = described_class.execute("substring after", ["hello world", " "])
+        expect(result).to eq("world")
+      end
+
+      it "returns empty string when match not found" do
+        result = described_class.execute("substring after", %w[hello x])
+        expect(result).to eq("")
+      end
+    end
+
+    describe "replace" do
+      it "replaces all occurrences" do
+        result = described_class.execute("replace", ["hello world", "l", "L"])
+        expect(result).to eq("heLLo worLd")
+      end
+    end
+  end
+
+  describe "Numeric Functions" do
+    describe "abs" do
+      it "returns absolute value of positive number" do
+        result = described_class.execute("abs", [5])
+        expect(result).to eq(5.0)
+      end
+
+      it "returns absolute value of negative number" do
+        result = described_class.execute("abs", [-5])
+        expect(result).to eq(5.0)
+      end
+    end
+
+    describe "floor" do
+      it "rounds down to integer" do
+        result = described_class.execute("floor", [3.7])
+        expect(result).to eq(3)
+      end
+
+      it "handles negative numbers" do
+        result = described_class.execute("floor", [-3.2])
+        expect(result).to eq(-4)
+      end
+    end
+
+    describe "ceiling" do
+      it "rounds up to integer" do
+        result = described_class.execute("ceiling", [3.2])
+        expect(result).to eq(4)
+      end
+
+      it "handles negative numbers" do
+        result = described_class.execute("ceiling", [-3.7])
+        expect(result).to eq(-3)
+      end
+    end
+
+    describe "round" do
+      it "rounds to nearest integer" do
+        result = described_class.execute("round", [3.7])
+        expect(result).to eq(4)
+      end
+
+      it "rounds to specified precision" do
+        result = described_class.execute("round", [3.14159, 2])
+        expect(result).to be_within(0.001).of(3.14)
+      end
+    end
+
+    describe "sqrt" do
+      it "calculates square root" do
+        result = described_class.execute("sqrt", [16])
+        expect(result).to eq(4.0)
+      end
+    end
+
+    describe "modulo" do
+      it "calculates remainder" do
+        result = described_class.execute("modulo", [10, 3])
+        expect(result).to eq(1.0)
+      end
+    end
+
+    describe "odd" do
+      it "returns true for odd numbers" do
+        result = described_class.execute("odd", [5])
+        expect(result).to be true
+      end
+
+      it "returns false for even numbers" do
+        result = described_class.execute("odd", [4])
+        expect(result).to be false
+      end
+    end
+
+    describe "even" do
+      it "returns true for even numbers" do
+        result = described_class.execute("even", [4])
+        expect(result).to be true
+      end
+
+      it "returns false for odd numbers" do
+        result = described_class.execute("even", [5])
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe "List Functions" do
+    describe "count" do
+      it "returns length of list" do
+        result = described_class.execute("count", [[1, 2, 3, 4, 5]])
+        expect(result).to eq(5)
+      end
+
+      it "returns 0 for empty list" do
+        result = described_class.execute("count", [[]])
+        expect(result).to eq(0)
+      end
+
+      it "returns 0 for non-array" do
+        result = described_class.execute("count", [42])
+        expect(result).to eq(0)
+      end
+    end
+
+    describe "sum" do
+      it "calculates sum of list" do
+        result = described_class.execute("sum", [[1, 2, 3, 4, 5]])
+        expect(result).to eq(15.0)
+      end
+
+      it "returns 0 for empty list" do
+        result = described_class.execute("sum", [[]])
+        expect(result).to eq(0)
+      end
+    end
+
+    describe "mean" do
+      it "calculates average of list" do
+        result = described_class.execute("mean", [[1, 2, 3, 4, 5]])
+        expect(result).to eq(3.0)
+      end
+
+      it "returns 0 for empty list" do
+        result = described_class.execute("mean", [[]])
+        expect(result).to eq(0)
+      end
+    end
+
+    describe "min" do
+      it "returns minimum value from list" do
+        result = described_class.execute("min", [[5, 2, 8, 1, 9]])
+        expect(result).to eq(1.0)
+      end
+
+      it "returns minimum from multiple arguments" do
+        result = described_class.execute("min", [5, 2, 8, 1, 9])
+        expect(result).to eq(1.0)
+      end
+
+      it "returns nil for empty list" do
+        result = described_class.execute("min", [[]])
+        expect(result).to be_nil
+      end
+    end
+
+    describe "max" do
+      it "returns maximum value from list" do
+        result = described_class.execute("max", [[5, 2, 8, 1, 9]])
+        expect(result).to eq(9.0)
+      end
+
+      it "returns maximum from multiple arguments" do
+        result = described_class.execute("max", [5, 2, 8, 1, 9])
+        expect(result).to eq(9.0)
+      end
+    end
+
+    describe "append" do
+      it "appends items to list" do
+        result = described_class.execute("append", [[1, 2], 3, 4])
+        expect(result).to eq([1, 2, 3, 4])
+      end
+    end
+
+    describe "reverse" do
+      it "reverses list" do
+        result = described_class.execute("reverse", [[1, 2, 3, 4, 5]])
+        expect(result).to eq([5, 4, 3, 2, 1])
+      end
+    end
+
+    describe "index of" do
+      it "returns 1-based index of element" do
+        result = described_class.execute("index of", [[10, 20, 30], 20])
+        expect(result).to eq(2)
+      end
+
+      it "returns -1 when element not found" do
+        result = described_class.execute("index of", [[10, 20, 30], 40])
+        expect(result).to eq(-1)
+      end
+    end
+
+    describe "distinct values" do
+      it "removes duplicates" do
+        result = described_class.execute("distinct values", [[1, 2, 2, 3, 3, 3]])
+        expect(result).to eq([1, 2, 3])
+      end
+    end
+  end
+
+  describe "Boolean Functions" do
+    describe "not" do
+      it "negates true" do
+        result = described_class.execute("not", [true])
+        expect(result).to be false
+      end
+
+      it "negates false" do
+        result = described_class.execute("not", [false])
+        expect(result).to be true
+      end
+    end
+
+    describe "all" do
+      it "returns true when all items are true" do
+        result = described_class.execute("all", [[true, true, true]])
+        expect(result).to be true
+      end
+
+      it "returns false when any item is false" do
+        result = described_class.execute("all", [[true, false, true]])
+        expect(result).to be false
+      end
+    end
+
+    describe "any" do
+      it "returns true when any item is true" do
+        result = described_class.execute("any", [[false, true, false]])
+        expect(result).to be true
+      end
+
+      it "returns false when all items are false" do
+        result = described_class.execute("any", [[false, false, false]])
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe "Date/Time Functions" do
+    describe "date" do
+      it "parses ISO 8601 date string" do
+        result = described_class.execute("date", ["2024-01-15T10:30:00Z"])
+        expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::Date)
+      end
+    end
+
+    describe "time" do
+      it "parses ISO 8601 time string" do
+        result = described_class.execute("time", ["2024-01-15T10:30:00Z"])
+        expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::Time)
+      end
+    end
+
+    describe "duration" do
+      it "parses ISO 8601 duration" do
+        result = described_class.execute("duration", ["P1Y2M3DT4H5M6S"])
+        expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::Duration)
+        expect(result.years).to eq(1)
+        expect(result.months).to eq(2)
+      end
+    end
+  end
+
+  describe "Function Registry" do
+    it "lists all registered functions" do
+      functions = described_class.list
+      expect(functions).to include("substring")
+      expect(functions).to include("sum")
+      expect(functions).to include("abs")
+    end
+
+    it "gets function by name" do
+      func = described_class.get("substring")
+      expect(func).not_to be_nil
+    end
+
+    it "raises error for unknown function" do
+      expect do
+        described_class.execute("unknown_func", [])
+      end.to raise_error(DecisionAgent::Dmn::FeelFunctionError, /Unknown function/)
+    end
+  end
+
+  describe "Argument Validation" do
+    it "raises error for wrong argument count" do
+      expect do
+        described_class.execute("substring", ["hello"])
+      end.to raise_error(DecisionAgent::Dmn::FeelFunctionError, /Wrong number of arguments/)
+    end
+  end
+end