dingtalk-workspace-cli/internal/errors/validation_test.go

// Copyright 2026 Alibaba Group
// 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 errors

import (
	"context"
	stderrors "errors"
	"fmt"
	"testing"
)

type validationTestExitError struct{}

func (validationTestExitError) Error() string { return "explicit" }
func (validationTestExitError) ExitCode() int { return ExitCodeAuth }

func TestCrossPlatformCoverageNormalizeValidation(t *testing.T) {
	raw := stderrors.New("bad argument")
	err := NormalizeValidation(raw, WithReason("invalid_parameters"))
	var typed *Error
	if !stderrors.As(err, &typed) {
		t.Fatalf("NormalizeValidation() = %T, want *Error", err)
	}
	if typed.Category != CategoryValidation || typed.Reason != "invalid_parameters" || typed.Cause != raw {
		t.Fatalf("NormalizeValidation() = %#v", typed)
	}
	if !stderrors.Is(err, raw) {
		t.Fatal("NormalizeValidation() lost its cause")
	}

	apiErr := NewAPI("upstream failed")
	if got := NormalizeValidation(apiErr); got != apiErr {
		t.Fatalf("typed error changed: got %p want %p", got, apiErr)
	}
	exitErr := validationTestExitError{}
	if got := NormalizeValidation(exitErr); got != exitErr {
		t.Fatalf("ExitCoder changed: got %#v want %#v", got, exitErr)
	}
	for _, preserved := range []error{context.Canceled, context.DeadlineExceeded} {
		if got := NormalizeValidation(preserved); got != preserved {
			t.Fatalf("context error changed: got %v want %v", got, preserved)
		}
	}
	if NormalizeValidation(nil) != nil {
		t.Fatal("NormalizeValidation(nil) must be nil")
	}
}

func TestCrossPlatformCoveragePreserveClassification(t *testing.T) {
	for _, err := range []error{nil, stderrors.New("raw validation error")} {
		if PreserveClassification(err) {
			t.Fatalf("unclassified error protected: %v", err)
		}
	}
	for _, cause := range []error{NewAPI("api"), validationTestExitError{}, context.Canceled, context.DeadlineExceeded} {
		err := fmt.Errorf("outer: %w", fmt.Errorf("inner: %w", cause))
		if !PreserveClassification(err) || NormalizeValidation(err) != err {
			t.Fatalf("wrapped error identity lost: %v", err)
		}
		if ExitCode(err) != ExitCode(NormalizeValidation(err)) {
			t.Fatal("exit code changed")
		}
	}
}

func TestCrossPlatformCoverageDeclaresClassification(t *testing.T) {
	for _, err := range []error{
		nil,
		stderrors.New("raw business error"),
		context.Canceled,
		context.DeadlineExceeded,
		fmt.Errorf("outer: %w", context.DeadlineExceeded),
	} {
		if DeclaresClassification(err) {
			t.Fatalf("error carrying no contract of its own claimed one: %v", err)
		}
	}
	for _, err := range []error{
		NewAPI("api"),
		validationTestExitError{},
		fmt.Errorf("outer: %w", fmt.Errorf("inner: %w", NewAPI("api"))),
		fmt.Errorf("outer: %w", validationTestExitError{}),
	} {
		if !DeclaresClassification(err) {
			t.Fatalf("error carrying its own contract was not recognized: %v", err)
		}
	}
	// The two predicates differ exactly on the cancellation and deadline
	// sentinels: a validation boundary preserves their identity, while a
	// classification boundary still owns them and must classify them itself.
	for _, err := range []error{context.Canceled, context.DeadlineExceeded} {
		if !PreserveClassification(err) || DeclaresClassification(err) {
			t.Fatalf("predicate boundary drifted for %v", err)
		}
	}
}