| // Copyright 2019 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package cel |
| |
| import ( |
| "fmt" |
| "strings" |
| "testing" |
| "time" |
| |
| "google.golang.org/protobuf/proto" |
| |
| "cel.dev/cel-go/checker/decls" |
| celast "cel.dev/cel-go/common/ast" |
| "cel.dev/cel-go/common/operators" |
| "cel.dev/cel-go/common/types" |
| "cel.dev/cel-go/common/types/ref" |
| |
| proto3pb "cel.dev/cel-go/test/proto3pb" |
| exprpb "google.golang.org/genproto/googleapis/api/expr/v1alpha1" |
| ) |
| |
| func TestRefValueToValueRoundTrip(t *testing.T) { |
| tests := []struct { |
| value any |
| }{ |
| {value: types.NullValue}, |
| {value: types.Bool(true)}, |
| {value: types.String("abc")}, |
| {value: types.Double(0.0)}, |
| {value: types.Bytes(make([]byte, 0, 5))}, |
| {value: types.Int(0)}, |
| {value: types.Uint(0)}, |
| {value: types.Duration{Duration: time.Hour}}, |
| {value: types.Timestamp{Time: time.Unix(0, 0)}}, |
| {value: types.IntType}, |
| {value: types.NewOpaqueType("CustomType")}, |
| {value: map[int64]int64{1: 1}}, |
| {value: []any{true, "abc"}}, |
| {value: &proto3pb.TestAllTypes{SingleString: "abc"}}, |
| } |
| |
| env, err := NewEnv(Types(&proto3pb.TestAllTypes{})) |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| |
| for i, tst := range tests { |
| tc := tst |
| t.Run(fmt.Sprintf("[%d]%v", i, tc.value), func(t *testing.T) { |
| refVal := env.TypeAdapter().NativeToValue(tc.value) |
| val, err := RefValueToValue(refVal) |
| if err != nil { |
| t.Fatalf("RefValueToValue(%v) failed with error: %v", refVal, err) |
| } |
| actual, err := ValueToRefValue(env.TypeAdapter(), val) |
| if err != nil { |
| t.Fatalf("ValueToRefValue() failed: %v", err) |
| } |
| if refVal.Equal(actual) != types.True { |
| t.Errorf("got val %v, wanted %v", actual, refVal) |
| } |
| }) |
| } |
| } |
| |
| func TestAstToProto(t *testing.T) { |
| stdEnv, _ := NewEnv(Declarations( |
| decls.NewVar("a", decls.Dyn), |
| decls.NewVar("b", decls.Dyn), |
| )) |
| ast, iss := stdEnv.Parse("a + b") |
| if iss.Err() != nil { |
| t.Fatalf("Parse('a + b') failed: %v", iss.Err()) |
| } |
| parsed, err := AstToParsedExpr(ast) |
| if err != nil { |
| t.Fatalf("AstToParsedExpr() failed: %v", err) |
| } |
| ast2 := ParsedExprToAst(parsed) |
| if !proto.Equal(ast2.Expr(), ast.Expr()) { |
| t.Errorf("got expr %v, wanted %v", ast2, ast) |
| } |
| ast3 := ParsedExprToAstWithSource(parsed, ast.Source()) |
| if !proto.Equal(ast3.Expr(), ast.Expr()) { |
| t.Errorf("got expr %v, wanted %v", ast2, ast) |
| } |
| if ast3.Source() != ast.Source() { |
| t.Errorf("got source %v, wanted %v", ast3.Source(), ast.Source()) |
| } |
| |
| _, err = AstToCheckedExpr(ast) |
| if err == nil { |
| t.Error("expected error converting unchecked ast") |
| } |
| ast, iss = stdEnv.Check(ast) |
| if iss != nil && iss.Err() != nil { |
| t.Fatalf("stdEnv.Check(ast) failed: %v", iss.Err()) |
| } |
| checked, err := AstToCheckedExpr(ast) |
| if err != nil { |
| t.Fatalf("AstToCheckedExpr(ast) failed: %v", err) |
| } |
| ast4 := CheckedExprToAst(checked) |
| if !proto.Equal(ast4.Expr(), ast.Expr()) { |
| t.Fatalf("got ast %v, wanted %v", ast4, ast) |
| } |
| ast5, err := CheckedExprToAstWithSource(checked, ast.Source()) |
| if err != nil { |
| t.Fatalf("CheckedExprToAstWithSource() failed: %v", err) |
| } |
| if !proto.Equal(ast5.Expr(), ast.Expr()) { |
| t.Errorf("got expr %v, wanted %v", ast5, ast) |
| } |
| if ast5.Source() != ast.Source() { |
| t.Errorf("got source %v, wanted %v", ast5.Source(), ast.Source()) |
| } |
| } |
| |
| func TestAstToString(t *testing.T) { |
| stdEnv, err := NewEnv() |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| in := "a + b - (c ? (-d + 4) : e)" |
| ast, iss := stdEnv.Parse(in) |
| if iss.Err() != nil { |
| t.Fatalf("stdEnv.Parse(%q) failed: %v", in, iss.Err()) |
| } |
| expr, err := AstToString(ast) |
| if err != nil { |
| t.Fatalf("AstToString(ast) failed: %v", err) |
| } |
| if expr != in { |
| t.Errorf("got %v, wanted %v", expr, in) |
| } |
| } |
| |
| func TestExprToString(t *testing.T) { |
| stdEnv, err := NewEnv(EnableMacroCallTracking()) |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| in := "[a, b].filter(i, (i > 0) ? (-i + 4) : i)" |
| ast, iss := stdEnv.Parse(in) |
| if iss.Err() != nil { |
| t.Fatalf("stdEnv.Parse(%q) failed: %v", in, iss.Err()) |
| } |
| expr, err := ExprToString(ast.NativeRep().Expr(), ast.NativeRep().SourceInfo()) |
| if err != nil { |
| t.Fatalf("ExprToString(ast) failed: %v", err) |
| } |
| if expr != in { |
| t.Errorf("got %v, wanted %v", expr, in) |
| } |
| |
| // Test sub-expression unparsing. |
| navExpr := celast.NavigateAST(ast.NativeRep()) |
| condExpr := celast.MatchDescendants(navExpr, celast.FunctionMatcher(operators.Conditional))[0] |
| want := `(i > 0) ? (-i + 4) : i` |
| expr, err = ExprToString(condExpr, ast.NativeRep().SourceInfo()) |
| if err != nil { |
| t.Fatalf("ExprToString(ast) failed: %v", err) |
| } |
| if expr != want { |
| t.Errorf("got %v, wanted %v", expr, want) |
| } |
| |
| // Also passes with a nil source info, but only because the sub-expr doesn't contain macro calls. |
| expr, err = ExprToString(condExpr, nil) |
| if err != nil { |
| t.Fatalf("ExprToString(ast) failed: %v", err) |
| } |
| if expr != want { |
| t.Errorf("got %v, wanted %v", expr, want) |
| } |
| |
| // Fails do to missing macro information. |
| _, err = ExprToString(ast.NativeRep().Expr(), nil) |
| if err == nil { |
| t.Error("ExprToString() succeeded, wanted error") |
| } |
| } |
| |
| func TestRefValToExprValue(t *testing.T) { |
| tests := []struct { |
| name string |
| refVal ref.Val |
| expectError bool |
| }{ |
| { |
| name: "unknown value", |
| refVal: types.NewUnknown(1, nil), |
| expectError: false, |
| }, |
| { |
| name: "error value", |
| refVal: types.NewErr("test error"), |
| expectError: false, |
| }, |
| { |
| name: "bool value", |
| refVal: types.Bool(true), |
| expectError: false, |
| }, |
| { |
| name: "string value", |
| refVal: types.String("test"), |
| expectError: false, |
| }, |
| { |
| name: "int value", |
| refVal: types.Int(1), |
| expectError: false, |
| }, |
| } |
| for _, tst := range tests { |
| tc := tst |
| t.Run(tc.name, func(t *testing.T) { |
| exprVal, err := ExprValueAsProto(tc.refVal) |
| if tc.expectError { |
| if err == nil { |
| t.Errorf("RefValToExprValue(%v) expected error, got %v", tc.refVal, exprVal) |
| } |
| } else { |
| if err != nil { |
| t.Errorf("RefValToExprValue(%v) failed with error: %v", tc.refVal, err) |
| } |
| if exprVal == nil { |
| t.Errorf("RefValToExprValue(%v) expected value, got nil", tc.refVal) |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestAstToStringNil(t *testing.T) { |
| expr, err := AstToString(nil) |
| if err == nil || !strings.Contains(err.Error(), "unsupported expr") { |
| t.Errorf("env.AstToString() got (%v, %v) wanted unsupported expr error", expr, err) |
| } |
| } |
| |
| func TestAstToCheckedExprNil(t *testing.T) { |
| expr, err := AstToCheckedExpr(nil) |
| if err == nil || !strings.Contains(err.Error(), "cannot convert unchecked ast") { |
| t.Errorf("env.AstToCheckedExpr() got (%v, %v) wanted conversion error", expr, err) |
| } |
| } |
| |
| func TestAstToParsedExprNil(t *testing.T) { |
| expr, err := AstToParsedExpr(nil) |
| if err != nil { |
| t.Errorf("env.AstToParsedExpr() got (%v, %v) wanted conversion error", expr, err) |
| } |
| } |
| |
| func TestCheckedExprToAstConstantExpr(t *testing.T) { |
| stdEnv, err := NewEnv() |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| in := "10" |
| ast, iss := stdEnv.Compile(in) |
| if iss.Err() != nil { |
| t.Fatalf("stdEnv.Compile(%q) failed: %v", in, iss.Err()) |
| } |
| expr, err := AstToCheckedExpr(ast) |
| if err != nil { |
| t.Fatalf("AstToCheckedExpr(ast) failed: %v", err) |
| } |
| ast2 := CheckedExprToAst(expr) |
| if !proto.Equal(ast2.Expr(), ast.Expr()) { |
| t.Fatalf("got ast %v, wanted %v", ast2, ast) |
| } |
| } |
| |
| func TestCheckedExprToAstMissingInfo(t *testing.T) { |
| stdEnv, err := NewEnv() |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| in := "10" |
| ast, iss := stdEnv.Parse(in) |
| if iss.Err() != nil { |
| t.Fatalf("stdEnv.Compile(%q) failed: %v", in, iss.Err()) |
| } |
| if ast.ResultType() != decls.Dyn { |
| t.Fatalf("ast.ResultType() got %v, wanted 'dyn'", ast.ResultType()) |
| } |
| expr, err := AstToParsedExpr(ast) |
| if err != nil { |
| t.Fatalf("AstToParsedExpr(ast) failed: %v", err) |
| } |
| checkedExpr := &exprpb.CheckedExpr{ |
| TypeMap: map[int64]*exprpb.Type{expr.GetExpr().GetId(): decls.Int}, |
| Expr: expr.GetExpr(), |
| } |
| ast2 := CheckedExprToAst(checkedExpr) |
| if !ast2.IsChecked() { |
| t.Fatal("CheckedExprToAst() did not produce a 'checked' ast") |
| } |
| if ast2.ResultType() != decls.Int { |
| t.Fatalf("ast2.ResultType() got %v, wanted 'int'", ast.ResultType()) |
| } |
| } |
| |
| // deepBoolExpr builds a synthetic deeply nested proto Expr by stacking `depth` unary `!` calls |
| // on top of a boolean literal. A depth well above the 250 default but far below the Go stack |
| // limit keeps the test itself from overflowing while still exercising the depth guard. |
| func deepBoolExpr(depth int) *exprpb.Expr { |
| expr := &exprpb.Expr{ |
| Id: 1, |
| ExprKind: &exprpb.Expr_ConstExpr{ |
| ConstExpr: &exprpb.Constant{ |
| ConstantKind: &exprpb.Constant_BoolValue{BoolValue: true}, |
| }, |
| }, |
| } |
| for i := 0; i < depth; i++ { |
| expr = &exprpb.Expr{ |
| Id: int64(i + 2), |
| ExprKind: &exprpb.Expr_CallExpr{ |
| CallExpr: &exprpb.Expr_Call{ |
| Function: operators.LogicalNot, |
| Args: []*exprpb.Expr{expr}, |
| }, |
| }, |
| } |
| } |
| return expr |
| } |
| |
| func TestLoadedAstDepthLimit(t *testing.T) { |
| env, err := NewEnv() |
| if err != nil { |
| t.Fatalf("NewEnv() failed: %v", err) |
| } |
| |
| // Sanity check: a shallow parsed expression still checks and plans clean. |
| shallow, iss := env.Parse("1 + 2") |
| if iss.Err() != nil { |
| t.Fatalf("Parse('1 + 2') failed: %v", iss.Err()) |
| } |
| if _, iss := env.Check(shallow); iss.Err() != nil { |
| t.Fatalf("Check(shallow) failed: %v", iss.Err()) |
| } |
| if _, err := env.Program(shallow); err != nil { |
| t.Fatalf("Program(shallow) failed: %v", err) |
| } |
| |
| const depth = 300 |
| deepExpr := deepBoolExpr(depth) |
| |
| // ParsedExprToAst flags the over-deep AST at conversion time. Because the conversion helper |
| // has no error return, the violation is surfaced as a normal error when the AST is later |
| // planned or checked, rather than recursing into a Go stack overflow. |
| deepParsed := ParsedExprToAst(&exprpb.ParsedExpr{Expr: deepExpr}) |
| if _, err := env.Program(deepParsed); err == nil { |
| t.Errorf("Program(deepParsed) expected an error, got nil") |
| } else if !strings.Contains(err.Error(), "maximum expression nesting depth") { |
| t.Errorf("Program(deepParsed) error = %v, want it to mention 'maximum expression nesting depth'", err) |
| } |
| if _, iss := env.Check(deepParsed); iss.Err() == nil { |
| t.Errorf("Check(deepParsed) expected an error, got nil") |
| } else if !strings.Contains(iss.Err().Error(), "maximum expression nesting depth") { |
| t.Errorf("Check(deepParsed) error = %v, want it to mention 'maximum expression nesting depth'", iss.Err()) |
| } |
| |
| // CheckedExprToAstWithSource returns the depth error directly since it has an error return. |
| if _, err := CheckedExprToAstWithSource(&exprpb.CheckedExpr{Expr: deepExpr}, nil); err == nil { |
| t.Errorf("CheckedExprToAstWithSource(deep) expected an error, got nil") |
| } else if !strings.Contains(err.Error(), "maximum expression nesting depth") { |
| t.Errorf("CheckedExprToAstWithSource(deep) error = %v, want it to mention 'maximum expression nesting depth'", err) |
| } |
| |
| // Embedders in full control of their AST inputs can skip the check by building the AST through |
| // the common/ast package directly rather than the cel conversion helpers. |
| nativeExpr, err := celast.ProtoToExpr(deepExpr) |
| if err != nil { |
| t.Fatalf("celast.ProtoToExpr() failed: %v", err) |
| } |
| bypass := &Ast{impl: celast.NewAST(nativeExpr, celast.NewSourceInfo(nil))} |
| if _, err := env.Program(bypass); err != nil { |
| t.Errorf("Program(bypass) built directly via common/ast failed: %v", err) |
| } |
| } |
| |
| func TestExpressionNestingDepthLimitConfigRoundTrip(t *testing.T) { |
| env, err := NewEnv(ExpressionNestingDepthLimit(128)) |
| if err != nil { |
| t.Fatalf("NewEnv(ExpressionNestingDepthLimit(128)) failed: %v", err) |
| } |
| conf, err := env.ToConfig("depth-limit") |
| if err != nil { |
| t.Fatalf("env.ToConfig() failed: %v", err) |
| } |
| found := false |
| for _, limit := range conf.Limits { |
| if limit.Name == "cel.limit.max_ast_depth" { |
| found = true |
| if limit.Value != 128 { |
| t.Errorf("limit %q value = %d, wanted 128", limit.Name, limit.Value) |
| } |
| } |
| } |
| if !found { |
| t.Errorf("env config limits %v missing 'cel.limit.max_ast_depth'", conf.Limits) |
| } |
| } |
| |
| func TestRefValueToValue_Error(t *testing.T) { |
| _, err := RefValueToValue(types.NewErr("test error")) |
| if err == nil { |
| t.Error("RefValueToValue(err) should return error") |
| } |
| } |
| |
| func TestExprValueAsAlphaProto(t *testing.T) { |
| // Exercise the ExprValueAsAlphaProto wrapper (0% coverage) |
| res, err := ExprValueAsAlphaProto(types.Int(42)) |
| if err != nil { |
| t.Fatalf("ExprValueAsAlphaProto() failed: %v", err) |
| } |
| if res.GetValue() == nil { |
| t.Error("ExprValueAsAlphaProto() returned nil value") |
| } |
| } |
| |
| func TestRefValToExprValue_Wrappers(t *testing.T) { |
| // Exercise the RefValToExprValue wrapper (0% coverage) |
| res, err := RefValToExprValue(types.String("hello")) |
| if err != nil { |
| t.Fatalf("RefValToExprValue() failed: %v", err) |
| } |
| if res.GetValue() == nil { |
| t.Error("RefValToExprValue() returned nil value") |
| } |
| } |
