问无法在Go中创建以错误响应的处理程序以导致重试

EN

func DefaultRetryPolicy() func(ctx context.Context, resp *http.Response, err error) (bool, error) {
    return func(ctx context.Context, resp *http.Response, err error) (bool, error) {
        // do not retry on context.Canceled or context.DeadlineExceeded
        //fmt.Printf("jkajsuiohsd %v\n", ctx.Err())
        if ctx.Err() != nil {
            return false, ctx.Err()
        }

        if err != nil {
            if v, ok := err.(*url.Error); ok {
                // Don't retry if the error was due to too many redirects.
                if redirectsErrorRegex.MatchString(v.Error()) {
                    return false, nil
                }

                // Don't retry if the error was due to an invalid protocol scheme.
                if schemeErrorRegex.MatchString(v.Error()) {
                    return false, nil
                }

                // Don't retry if the error was due to TLS cert verification failure.
                if _, ok := v.Err.(x509.UnknownAuthorityError); ok {
                    return false, nil
                }
            }

            // The error is likely recoverable so retry.
            return true, nil
        }
        //EXPECT HANDLING BASED ON STATUS CODES, BUT ABSENT
        return false, nil
    }
}

func baseRetryPolicy(resp *http.Response, err error) (bool, error) {
    if err != nil {
        if v, ok := err.(*url.Error); ok {
            // Don't retry if the error was due to too many redirects.
            if redirectsErrorRe.MatchString(v.Error()) {
                return false, v
            }

            // Don't retry if the error was due to an invalid protocol scheme.
            if schemeErrorRe.MatchString(v.Error()) {
                return false, v
            }

            // Don't retry if the error was due to TLS cert verification failure.
            if notTrustedErrorRe.MatchString(v.Error()) {
                return false, v
            }
            if _, ok := v.Err.(x509.UnknownAuthorityError); ok {
                return false, v
            }
        }

        // The error is likely recoverable so retry.
        return true, nil
    }

    // 429 Too Many Requests is recoverable. Sometimes the server puts
    // a Retry-After response header to indicate when the server is
    // available to start processing request from client.
    if resp.StatusCode == http.StatusTooManyRequests {
        return true, nil
    }

    // Check the response code. We retry on 500-range responses to allow
    // the server time to recover, as 500's are typically not permanent
    // errors and may relate to outages on the server side. This will catch
    // invalid response codes as well, like 0 and 999.
    //THIS PART HERE FLAGS RETRIES ON STATUS CODES!
    if resp.StatusCode == 0 || (resp.StatusCode >= 500 && resp.StatusCode != http.StatusNotImplemented) {
        return true, fmt.Errorf("unexpected HTTP status %s", resp.Status)
    }

    return false, nil
}

func TestCreateToolsClient(t *testing.T) {
    ts := httptest.NewServer(http.HandlerFunc(InternalServerErrorHandler))
    defer ts.Close()

    request, err := retryablehttp.NewRequest(http.MethodGet, ts.URL, nil)
    if err != nil {
        log.Fatal(err)
    }
    var options retryablehttp.Options
    options.RetryWaitMin = 10 * time.Millisecond
    options.RetryWaitMax = 50 * time.Millisecond
    options.RetryMax = 6
    options.Timeout = 60 * time.Second

    //options.Timeout = 30000 * time.Millisecond
    retryableClient := retryablehttp.NewClient(options)
    retryCount := -1
    // to verify from stdout if the # of retry actually is getting counted
    retryableClient.RequestLogHook = func(req *http.Request, retryNumber int) {
        retryCount = retryNumber
        log.Println("Retrying")
    }

    // A regular expression to match the error returned by net/http when the
    // configured number of redirects is exhausted. This error isn't typed
    // specifically so we resort to matching on the error string.
    redirectsErrorRe := regexp.MustCompile(`stopped after \d+ redirects\z`)

    // A regular expression to match the error returned by net/http when the
    // scheme specified in the URL is invalid. This error isn't typed
    // specifically so we resort to matching on the error string.
    schemeErrorRe := regexp.MustCompile(`unsupported protocol scheme`)

    // A regular expression to match the error returned by net/http when the
    // TLS certificate is not trusted. This error isn't typed
    // specifically so we resort to matching on the error string.
    notTrustedErrorRe := regexp.MustCompile(`certificate is not trusted`)
    retryableClient.CheckRetry = func(_ context.Context, resp *http.Response, err error) (bool, error) {
        if err != nil {
            if v, ok := err.(*url.Error); ok {
                // Don't retry if the error was due to too many redirects.
                if redirectsErrorRe.MatchString(v.Error()) {
                    return false, v
                }

                // Don't retry if the error was due to an invalid protocol scheme.
                if schemeErrorRe.MatchString(v.Error()) {
                    return false, v
                }

                // Don't retry if the error was due to TLS cert verification failure.
                if notTrustedErrorRe.MatchString(v.Error()) {
                    return false, v
                }
                if _, ok := v.Err.(x509.UnknownAuthorityError); ok {
                    return false, v
                }
            }

            // The error is likely recoverable so retry.
            return true, nil
        }

        // 429 Too Many Requests is recoverable. Sometimes the server puts
        // a Retry-After response header to indicate when the server is
        // available to start processing request from client.
        if resp.StatusCode == http.StatusTooManyRequests {
            return true, nil
        }

        // Check the response code. We retry on 500-range responses to allow
        // the server time to recover, as 500's are typically not permanent
        // errors and may relate to outages on the server side. This will catch
        // invalid response codes as well, like 0 and 999.
        if resp.StatusCode == 0 || (resp.StatusCode >= 500 && resp.StatusCode != http.StatusNotImplemented) {
            return true, fmt.Errorf("unexpected HTTP status %s", resp.Status)
        }

        return false, nil
    }