Function TestVM_Limits

vm/vm_test.go:1366–1432

(t *testing.T)

}

func TestVM_Limits(t *testing.T) {
	tests := []struct {
		name         string
		expr         string
		memoryBudget uint
		maxNodes     uint
		env          map[string]any
		expectError  string
	}{
		{
			name:         "nested arithmetic allowed with max nodes and memory budget",
			expr:         createNestedArithmeticExpr(t, 100),
			env:          map[string]any{"a": 1},
			maxNodes:     1000,
			memoryBudget: 1, // arithmetic expressions not counted towards memory budget
		},
		{
			name:         "nested arithmetic blocked by max nodes",
			expr:         createNestedArithmeticExpr(t, 10000),
			env:          map[string]any{"a": 1},
			maxNodes:     100,
			memoryBudget: 1, // arithmetic expressions not counted towards memory budget
			expectError:  "compilation failed: expression exceeds maximum allowed nodes",
		},
		{
			name:         "nested map blocked by memory budget",
			expr:         createNestedMapExpr(t, 100),
			env:          map[string]any{},
			maxNodes:     1000,
			memoryBudget: 10, // Small memory budget to trigger limit
			expectError:  "memory budget exceeded",
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			var options []expr.Option
			options = append(options, expr.Env(test.env))
			if test.maxNodes > 0 {
				options = append(options, func(c *conf.Config) {
					c.MaxNodes = test.maxNodes
				})
			}

			program, err := expr.Compile(test.expr, options...)
			if err != nil {
				if test.expectError != "" && strings.Contains(err.Error(), test.expectError) {
					return
				}
				t.Fatal(err)
			}

			testVM := &vm.VM{
				MemoryBudget: test.memoryBudget,
			}

			_, err = testVM.Run(program, test.env)