mirror of https://github.com/milvus-io/milvus.git
98 lines
3.5 KiB
Go
98 lines
3.5 KiB
Go
// Licensed to the LF AI & Data foundation under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you 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 merr
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/cockroachdb/errors"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestIsNonRetryableErr(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
expected bool
|
|
}{
|
|
// Permanent errors - should NOT retry
|
|
{"KeyNotFound", ErrIoKeyNotFound, true},
|
|
{"PermissionDenied", ErrIoPermissionDenied, true},
|
|
{"BucketNotFound", ErrIoBucketNotFound, true},
|
|
{"InvalidCredentials", ErrIoInvalidCredentials, true},
|
|
|
|
// Client validation errors - should NOT retry
|
|
{"InvalidArgument", ErrIoInvalidArgument, true},
|
|
{"InvalidRange", ErrIoInvalidRange, true},
|
|
{"EntityTooLarge", ErrIoEntityTooLarge, true},
|
|
|
|
// Transient errors - SHOULD retry (return false)
|
|
{"UnexpectedEOF", ErrIoUnexpectEOF, false},
|
|
{"TooManyRequests", ErrIoTooManyRequests, false},
|
|
{"ServiceNotReady", ErrServiceNotReady, false},
|
|
{"ServiceUnavailable", ErrServiceUnavailable, false},
|
|
|
|
// Generic error - SHOULD retry (return false)
|
|
{"GenericError", errors.New("network error"), false},
|
|
|
|
// Nil error
|
|
{"NilError", nil, false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := IsNonRetryableErr(tt.err)
|
|
assert.Equal(t, tt.expected, result,
|
|
"IsNonRetryableErr(%v) = %v, want %v", tt.err, result, tt.expected)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsNonRetryableErr_WrappedErrors(t *testing.T) {
|
|
// Test that wrapped errors are detected correctly
|
|
wrappedPermDenied := fmt.Errorf("failed to read: %w", ErrIoPermissionDenied)
|
|
assert.True(t, IsNonRetryableErr(wrappedPermDenied))
|
|
|
|
wrappedInvalidArg := fmt.Errorf("validation failed: %w", ErrIoInvalidArgument)
|
|
assert.True(t, IsNonRetryableErr(wrappedInvalidArg))
|
|
|
|
wrappedRetryable := fmt.Errorf("network issue: %w", ErrIoUnexpectEOF)
|
|
assert.False(t, IsNonRetryableErr(wrappedRetryable))
|
|
}
|
|
|
|
func TestIsMilvusError_WrappedChain(t *testing.T) {
|
|
// Direct milvus error
|
|
assert.True(t, IsMilvusError(ErrCollectionNotFound))
|
|
|
|
// Wrapped via errors.Wrap — milvusError is root, both impls handle this
|
|
assert.True(t, IsMilvusError(errors.Wrap(ErrCollectionNotFound, "context")))
|
|
|
|
// Combined: plain error first, milvusError second.
|
|
// errors.Cause: multiErrors has no Cause() method, returns multiErrors itself — type
|
|
// assertion to milvusError fails. errors.As: multiErrors.Unwrap() returns errs[1] directly
|
|
// (ErrCollectionNotFound), so errors.As finds it.
|
|
// Known limitation: Combine(milvusErr, plain) is NOT covered — Unwrap exposes errs[1:] only,
|
|
// so milvusError at index 0 would not be found by errors.As either.
|
|
combined := Combine(errors.New("plain"), ErrCollectionNotFound)
|
|
assert.True(t, IsMilvusError(combined), "milvusError at tail of Combine chain should be detected")
|
|
|
|
// Non-milvus error
|
|
assert.False(t, IsMilvusError(errors.New("plain error")))
|
|
assert.False(t, IsMilvusError(nil))
|
|
}
|