Merge branch 'master' into fix/issue-1333

Author: TristonianJones

cel/env_test.go

@@ -1280,3 +1280,65 @@ func (p *customCELProvider) FindStructFieldType(structType, fieldName string) (*
 func (p *customCELProvider) NewValue(structType string, fields map[string]ref.Val) ref.Val {
 	return p.provider.NewValue(structType, fields)
 }
+
+func TestCELTypeAdapter(t *testing.T) {
+	env, err := NewEnv()
+	if err != nil {
+		t.Fatalf("NewEnv() failed: %v", err)
+	}
+	adapter := env.CELTypeAdapter()
+	if adapter == nil {
+		t.Error("CELTypeAdapter() returned nil")
+	}
+}
+
+type mockTypeProvider struct {
+	ref.TypeProvider
+}
+
+func TestMaybeInteropProvider_Error(t *testing.T) {
+	_, err := maybeInteropProvider(123)
+	if err == nil {
+		t.Error("maybeInteropProvider(int) should return error")
+	}
+}
+
+func TestMaybeInteropProvider_LegacyTypeProvider(t *testing.T) {
+	tp := &mockTypeProvider{}
+	p, err := maybeInteropProvider(tp)
+	if err != nil {
+		t.Fatalf("maybeInteropProvider(mockTypeProvider) failed: %v", err)
+	}
+	if _, ok := p.(*interopCELTypeProvider); !ok {
+		t.Errorf("expected *interopCELTypeProvider, got %T", p)
+	}
+}
+
+func TestParserErrorRecoveryLimit(t *testing.T) {
+	env, err := NewEnv(ParserErrorRecoveryLimit(10))
+	if err != nil {
+		t.Fatalf("NewEnv(ParserErrorRecoveryLimit(10)) failed: %v", err)
+	}
+	if env.limits[limitParseErrorRecovery] != 10 {
+		t.Errorf("limitParseErrorRecovery = %d, want 10", env.limits[limitParseErrorRecovery])
+	}
+}
+
+func TestEnableHiddenAccumulatorName(t *testing.T) {
+	_, err := NewEnv(EnableHiddenAccumulatorName(true))
+	if err != nil {
+		t.Fatalf("NewEnv(EnableHiddenAccumulatorName(true)) failed: %v", err)
+	}
+}
+
+func TestDeclareContextProto_Duplicate(t *testing.T) {
+	desc := (&proto3pb.TestAllTypes{}).ProtoReflect().Descriptor()
+	env, err := NewEnv(DeclareContextProto(desc))
+	if err != nil {
+		t.Fatalf("NewEnv(DeclareContextProto()) failed: %v", err)
+	}
+	_, err = DeclareContextProto(desc)(env)
+	if err == nil {
+		t.Error("DeclareContextProto() twice should fail")
+	}
+}

cel/folding.go

@@ -97,7 +97,7 @@ func (opt *constantFoldingOptimizer) Optimize(ctx *OptimizerContext, a *ast.AST)
 				continue
 			}
 			// Late-bound function calls cannot be folded.
-			if fold.Kind() == ast.CallKind && isLateBoundFunctionCall(ctx, a, fold) {
+			if fold.Kind() == ast.CallKind && isLateBoundFunctionCall(ctx, fold) {
 				continue
 			}
 			// Otherwise, assume all context is needed to evaluate the expression.
@@ -168,7 +168,7 @@ func (opt *constantFoldingOptimizer) tryFold(ctx *OptimizerContext, a *ast.AST,
 	return nil
 }
 
-func isLateBoundFunctionCall(ctx *OptimizerContext, a *ast.AST, expr ast.Expr) bool {
+func isLateBoundFunctionCall(ctx *OptimizerContext, expr ast.Expr) bool {
 	call := expr.AsCall()
 	function := ctx.Functions()[call.FunctionName()]
 	if function == nil {
@@ -518,7 +518,7 @@ func (opt *constantFoldingOptimizer) constantExprMatcher(ctx *OptimizerContext,
 				constantExprs = false
 			}
 			// Late-bound function calls cannot be folded.
-			if e.Kind() == ast.CallKind && isLateBoundFunctionCall(ctx, a, e) {
+			if e.Kind() == ast.CallKind && isLateBoundFunctionCall(ctx, e) {
 				constantExprs = false
 			}
 		})

cel/io_test.go

@@ -420,3 +420,32 @@ func TestExpressionNestingDepthLimitConfigRoundTrip(t *testing.T) {
 		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")
+	}
+}