homelab/traefik
1
0
Fork 0
Code Activity

Bump to go1.24

Browse source 
Co-authored-by: Romain <rtribotte@users.noreply.github.com>
This commit is contained in:
Kevin Pollet 2025-06-02 10:36:05 +02:00 • committed by GitHub
parent 5f35c88805
commit cd16321dd9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
88 changed files with 284 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

2
pkg/middlewares/accesslog/logger_test.go
View file

@ -926,7 +926,7 @@ func doLoggingWithAbortedStream(t *testing.T, config *types.AccessLog) {
require.NoError(t, err, "logger should create "+config.FilePath)
}
reqContext, cancelRequest := context.WithCancel(context.Background())
reqContext, cancelRequest := context.WithCancel(t.Context())
req := &http.Request{
Header: map[string][]string{

5
pkg/middlewares/addprefix/add_prefix_test.go
View file

@ -1,7 +1,6 @@
package addprefix
import (
"context"
"net/http"
"testing"
@ -34,7 +33,7 @@ func TestNewAddPrefix(t *testing.T) {
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
_, err := New(context.Background(), next, test.prefix, "foo-add-prefix")
_, err := New(t.Context(), next, test.prefix, "foo-add-prefix")
if test.expectsError {
assert.Error(t, err)
} else {
@ -87,7 +86,7 @@ func TestAddPrefix(t *testing.T) {
req := testhelpers.MustNewRequest(http.MethodGet, "http://localhost"+test.path, nil)
handler, err := New(context.Background(), next, test.prefix, "foo-add-prefix")
handler, err := New(t.Context(), next, test.prefix, "foo-add-prefix")
require.NoError(t, err)
handler.ServeHTTP(nil, req)

15
pkg/middlewares/auth/basic_auth_test.go
View file

@ -1,7 +1,6 @@
package auth
import (
"context"
"fmt"
"io"
"net/http"
@ -23,13 +22,13 @@ func TestBasicAuthFail(t *testing.T) {
auth := dynamic.BasicAuth{
Users: []string{"test"},
}
_, err := NewBasic(context.Background(), next, auth, "authName")
_, err := NewBasic(t.Context(), next, auth, "authName")
require.Error(t, err)
auth2 := dynamic.BasicAuth{
Users: []string{"test:test"},
}
authMiddleware, err := NewBasic(context.Background(), next, auth2, "authTest")
authMiddleware, err := NewBasic(t.Context(), next, auth2, "authTest")
require.NoError(t, err)
ts := httptest.NewServer(authMiddleware)
@ -52,7 +51,7 @@ func TestBasicAuthSuccess(t *testing.T) {
auth := dynamic.BasicAuth{
Users: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/"},
}
authMiddleware, err := NewBasic(context.Background(), next, auth, "authName")
authMiddleware, err := NewBasic(t.Context(), next, auth, "authName")
require.NoError(t, err)
ts := httptest.NewServer(authMiddleware)
@ -83,7 +82,7 @@ func TestBasicAuthUserHeader(t *testing.T) {
Users: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/"},
HeaderField: "X-Webauth-User",
}
middleware, err := NewBasic(context.Background(), next, auth, "authName")
middleware, err := NewBasic(t.Context(), next, auth, "authName")
require.NoError(t, err)
ts := httptest.NewServer(middleware)
@ -114,7 +113,7 @@ func TestBasicAuthHeaderRemoved(t *testing.T) {
RemoveHeader: true,
Users: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/"},
}
middleware, err := NewBasic(context.Background(), next, auth, "authName")
middleware, err := NewBasic(t.Context(), next, auth, "authName")
require.NoError(t, err)
ts := httptest.NewServer(middleware)
@ -145,7 +144,7 @@ func TestBasicAuthHeaderPresent(t *testing.T) {
auth := dynamic.BasicAuth{
Users: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/"},
}
middleware, err := NewBasic(context.Background(), next, auth, "authName")
middleware, err := NewBasic(t.Context(), next, auth, "authName")
require.NoError(t, err)
ts := httptest.NewServer(middleware)
@ -231,7 +230,7 @@ func TestBasicAuthUsersFromFile(t *testing.T) {
fmt.Fprintln(w, "traefik")
})
authenticator, err := NewBasic(context.Background(), next, authenticatorConfiguration, "authName")
authenticator, err := NewBasic(t.Context(), next, authenticatorConfiguration, "authName")
require.NoError(t, err)
ts := httptest.NewServer(authenticator)

7
pkg/middlewares/auth/digest_auth_test.go
View file

@ -1,7 +1,6 @@
package auth
import (
"context"
"fmt"
"io"
"net/http"
@ -23,7 +22,7 @@ func TestDigestAuthError(t *testing.T) {
auth := dynamic.DigestAuth{
Users: []string{"test"},
}
_, err := NewDigest(context.Background(), next, auth, "authName")
_, err := NewDigest(t.Context(), next, auth, "authName")
assert.Error(t, err)
}
@ -35,7 +34,7 @@ func TestDigestAuthFail(t *testing.T) {
auth := dynamic.DigestAuth{
Users: []string{"test:traefik:a2688e031edb4be6a3797f3882655c05"},
}
authMiddleware, err := NewDigest(context.Background(), next, auth, "authName")
authMiddleware, err := NewDigest(t.Context(), next, auth, "authName")
require.NoError(t, err)
assert.NotNil(t, authMiddleware, "this should not be nil")
@ -109,7 +108,7 @@ func TestDigestAuthUsersFromFile(t *testing.T) {
fmt.Fprintln(w, "traefik")
})
authenticator, err := NewDigest(context.Background(), next, authenticatorConfiguration, "authName")
authenticator, err := NewDigest(t.Context(), next, authenticatorConfiguration, "authName")
require.NoError(t, err)
ts := httptest.NewServer(authenticator)

15
pkg/middlewares/auth/forward_test.go
View file

@ -1,7 +1,6 @@
package auth
import (
"context"
"fmt"
"io"
"net/http"
@ -30,7 +29,7 @@ func TestForwardAuthFail(t *testing.T) {
}))
t.Cleanup(server.Close)
middleware, err := NewForward(context.Background(), next, dynamic.ForwardAuth{
middleware, err := NewForward(t.Context(), next, dynamic.ForwardAuth{
Address: server.URL,
}, "authTest")
require.NoError(t, err)
@ -77,7 +76,7 @@ func TestForwardAuthSuccess(t *testing.T) {
AuthResponseHeaders: []string{"X-Auth-User", "X-Auth-Group"},
AuthResponseHeadersRegex: "^Foo-",
}
middleware, err := NewForward(context.Background(), next, auth, "authTest")
middleware, err := NewForward(t.Context(), next, auth, "authTest")
require.NoError(t, err)
ts := httptest.NewServer(middleware)
@ -110,7 +109,7 @@ func TestForwardAuthRedirect(t *testing.T) {
auth := dynamic.ForwardAuth{Address: authTs.URL}
authMiddleware, err := NewForward(context.Background(), next, auth, "authTest")
authMiddleware, err := NewForward(t.Context(), next, auth, "authTest")
require.NoError(t, err)
ts := httptest.NewServer(authMiddleware)
@ -161,7 +160,7 @@ func TestForwardAuthRemoveHopByHopHeaders(t *testing.T) {
auth := dynamic.ForwardAuth{Address: authTs.URL}
authMiddleware, err := NewForward(context.Background(), next, auth, "authTest")
authMiddleware, err := NewForward(t.Context(), next, auth, "authTest")
require.NoError(t, err)
ts := httptest.NewServer(authMiddleware)
@ -207,7 +206,7 @@ func TestForwardAuthFailResponseHeaders(t *testing.T) {
auth := dynamic.ForwardAuth{
Address: authTs.URL,
}
authMiddleware, err := NewForward(context.Background(), next, auth, "authTest")
authMiddleware, err := NewForward(t.Context(), next, auth, "authTest")
require.NoError(t, err)
ts := httptest.NewServer(authMiddleware)
@ -469,10 +468,10 @@ func TestForwardAuthUsesTracing(t *testing.T) {
tr, _ := tracing.NewTracing("testApp", 100, &mockBackend{tracer})
next, err := NewForward(context.Background(), next, auth, "authTest")
next, err := NewForward(t.Context(), next, auth, "authTest")
require.NoError(t, err)
next = tracingMiddleware.NewEntryPoint(context.Background(), tr, "tracingTest", next)
next = tracingMiddleware.NewEntryPoint(t.Context(), tr, "tracingTest", next)
ts := httptest.NewServer(next)
t.Cleanup(ts.Close)

3
pkg/middlewares/buffering/buffering_test.go
View file

@ -2,7 +2,6 @@ package buffering
import (
"bytes"
"context"
"crypto/rand"
"math"
"net/http"
@ -57,7 +56,7 @@ func TestBuffering(t *testing.T) {
require.NoError(t, err)
})
buffMiddleware, err := New(context.Background(), next, test.config, "foo")
buffMiddleware, err := New(t.Context(), next, test.config, "foo")
require.NoError(t, err)
req := httptest.NewRequest(http.MethodPost, "http://localhost", bytes.NewBuffer(test.body))

23
pkg/middlewares/compress/compress_test.go
View file

@ -1,7 +1,6 @@
package compress
import (
"context"
"io"
"net/http"
"net/http/httptest"
@ -34,7 +33,7 @@ func TestShouldCompressWhenNoContentEncodingHeader(t *testing.T) {
_, err := rw.Write(baseBody)
assert.NoError(t, err)
})
handler, err := New(context.Background(), next, dynamic.Compress{}, "testing")
handler, err := New(t.Context(), next, dynamic.Compress{}, "testing")
require.NoError(t, err)
rw := httptest.NewRecorder()
@ -61,7 +60,7 @@ func TestShouldNotCompressWhenContentEncodingHeader(t *testing.T) {
http.Error(rw, err.Error(), http.StatusInternalServerError)
}
})
handler, err := New(context.Background(), next, dynamic.Compress{}, "testing")
handler, err := New(t.Context(), next, dynamic.Compress{}, "testing")
require.NoError(t, err)
rw := httptest.NewRecorder()
@ -83,7 +82,7 @@ func TestShouldNotCompressWhenNoAcceptEncodingHeader(t *testing.T) {
http.Error(rw, err.Error(), http.StatusInternalServerError)
}
})
handler, err := New(context.Background(), next, dynamic.Compress{}, "testing")
handler, err := New(t.Context(), next, dynamic.Compress{}, "testing")
require.NoError(t, err)
rw := httptest.NewRecorder()
@ -144,7 +143,7 @@ func TestShouldNotCompressWhenSpecificContentType(t *testing.T) {
}
})
handler, err := New(context.Background(), next, test.conf, "test")
handler, err := New(t.Context(), next, test.conf, "test")
require.NoError(t, err)
rw := httptest.NewRecorder()
@ -194,7 +193,7 @@ func TestIntegrationShouldNotCompress(t *testing.T) {
for _, test := range testCases {
t.Run(test.name, func(t *testing.T) {
compress, err := New(context.Background(), test.handler, dynamic.Compress{}, "testing")
compress, err := New(t.Context(), test.handler, dynamic.Compress{}, "testing")
require.NoError(t, err)
ts := httptest.NewServer(compress)
@ -229,7 +228,7 @@ func TestShouldWriteHeaderWhenFlush(t *testing.T) {
http.Error(rw, err.Error(), http.StatusInternalServerError)
}
})
handler, err := New(context.Background(), next, dynamic.Compress{}, "testing")
handler, err := New(t.Context(), next, dynamic.Compress{}, "testing")
require.NoError(t, err)
ts := httptest.NewServer(handler)
@ -280,7 +279,7 @@ func TestIntegrationShouldCompress(t *testing.T) {
for _, test := range testCases {
t.Run(test.name, func(t *testing.T) {
compress, err := New(context.Background(), test.handler, dynamic.Compress{}, "testing")
compress, err := New(t.Context(), test.handler, dynamic.Compress{}, "testing")
require.NoError(t, err)
ts := httptest.NewServer(compress)
@ -337,7 +336,7 @@ func TestMinResponseBodyBytes(t *testing.T) {
}
})
handler, err := New(context.Background(), next, dynamic.Compress{MinResponseBodyBytes: test.minResponseBodyBytes}, "testing")
handler, err := New(t.Context(), next, dynamic.Compress{MinResponseBodyBytes: test.minResponseBodyBytes}, "testing")
require.NoError(t, err)
rw := httptest.NewRecorder()
@ -373,7 +372,7 @@ func Test1xxResponses(t *testing.T) {
}
})
compress, err := New(context.Background(), next, dynamic.Compress{MinResponseBodyBytes: 1024}, "testing")
compress, err := New(t.Context(), next, dynamic.Compress{MinResponseBodyBytes: 1024}, "testing")
require.NoError(t, err)
server := httptest.NewServer(compress)
@ -417,7 +416,7 @@ func Test1xxResponses(t *testing.T) {
return nil
},
}
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), http.MethodGet, server.URL, nil)
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(t.Context(), trace), http.MethodGet, server.URL, nil)
req.Header.Add(acceptEncodingHeader, gzipValue)
res, err := frontendClient.Do(req)
@ -478,7 +477,7 @@ func BenchmarkCompress(b *testing.B) {
_, err := rw.Write(baseBody)
assert.NoError(b, err)
})
handler, _ := New(context.Background(), next, dynamic.Compress{}, "testing")
handler, _ := New(b.Context(), next, dynamic.Compress{}, "testing")
req, _ := http.NewRequest(http.MethodGet, "/whatever", nil)
req.Header.Set("Accept-Encoding", "gzip")

6
pkg/middlewares/customerrors/custom_errors_test.go
View file

@ -170,7 +170,7 @@ func TestHandler(t *testing.T) {
}
_, _ = fmt.Fprintln(w, http.StatusText(test.backendCode))
})
errorPageHandler, err := New(context.Background(), handler, *test.errorPage, serviceBuilderMock, "test")
errorPageHandler, err := New(t.Context(), handler, *test.errorPage, serviceBuilderMock, "test")
require.NoError(t, err)
req := testhelpers.MustNewRequest(http.MethodGet, "http://localhost/test?foo=bar&baz=buz", nil)
@ -205,7 +205,7 @@ func Test1xxResponses(t *testing.T) {
config := dynamic.ErrorPage{Service: "error", Query: "/", Status: []string{"200"}}
errorPageHandler, err := New(context.Background(), next, config, serviceBuilderMock, "test")
errorPageHandler, err := New(t.Context(), next, config, serviceBuilderMock, "test")
require.NoError(t, err)
server := httptest.NewServer(errorPageHandler)
@ -249,7 +249,7 @@ func Test1xxResponses(t *testing.T) {
return nil
},
}
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), http.MethodGet, server.URL, nil)
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(t.Context(), trace), http.MethodGet, server.URL, nil)
res, err := frontendClient.Do(req)
assert.NoError(t, err)

11
pkg/middlewares/headers/headers_test.go
View file

@ -3,7 +3,6 @@ package headers
// Middleware tests based on https://github.com/unrolled/secure
import (
"context"
"io"
"net/http"
"net/http/httptest"
@ -20,7 +19,7 @@ import (
func TestNew_withoutOptions(t *testing.T) {
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
mid, err := New(context.Background(), next, dynamic.Headers{}, "testing")
mid, err := New(t.Context(), next, dynamic.Headers{}, "testing")
require.Errorf(t, err, "headers configuration not valid")
assert.Nil(t, mid)
@ -55,7 +54,7 @@ func TestNew_allowedHosts(t *testing.T) {
AllowedHosts: []string{"foo.com", "bar.com"},
}
mid, err := New(context.Background(), emptyHandler, cfg, "foo")
mid, err := New(t.Context(), emptyHandler, cfg, "foo")
require.NoError(t, err)
for _, test := range testCases {
@ -86,7 +85,7 @@ func TestNew_customHeaders(t *testing.T) {
},
}
mid, err := New(context.Background(), next, cfg, "testing")
mid, err := New(t.Context(), next, cfg, "testing")
require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/foo", nil)
@ -134,7 +133,7 @@ func Test1xxResponses(t *testing.T) {
},
}
mid, err := New(context.Background(), next, cfg, "testing")
mid, err := New(t.Context(), next, cfg, "testing")
require.NoError(t, err)
server := httptest.NewServer(mid)
@ -178,7 +177,7 @@ func Test1xxResponses(t *testing.T) {
return nil
},
}
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), http.MethodGet, server.URL, nil)
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(t.Context(), trace), http.MethodGet, server.URL, nil)
res, err := frontendClient.Do(req)
assert.NoError(t, err)

5
pkg/middlewares/ipallowlist/ip_allowlist_test.go
View file

@ -1,7 +1,6 @@
package ipallowlist
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -37,7 +36,7 @@ func TestNewIPAllowLister(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
allowLister, err := New(context.Background(), next, test.allowList, "traefikTest")
allowLister, err := New(t.Context(), next, test.allowList, "traefikTest")
if test.expectedError {
assert.Error(t, err)
@ -79,7 +78,7 @@ func TestIPAllowLister_ServeHTTP(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
allowLister, err := New(context.Background(), next, test.allowList, "traefikTest")
allowLister, err := New(t.Context(), next, test.allowList, "traefikTest")
require.NoError(t, err)
recorder := httptest.NewRecorder()

5
pkg/middlewares/ipwhitelist/ip_whitelist_test.go
View file

@ -1,7 +1,6 @@
package ipwhitelist
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -37,7 +36,7 @@ func TestNewIPWhiteLister(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
whiteLister, err := New(context.Background(), next, test.whiteList, "traefikTest")
whiteLister, err := New(t.Context(), next, test.whiteList, "traefikTest")
if test.expectedError {
assert.Error(t, err)
@ -79,7 +78,7 @@ func TestIPWhiteLister_ServeHTTP(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
whiteLister, err := New(context.Background(), next, test.whiteList, "traefikTest")
whiteLister, err := New(t.Context(), next, test.whiteList, "traefikTest")
require.NoError(t, err)
recorder := httptest.NewRecorder()

5
pkg/middlewares/passtlsclientcert/pass_tls_client_cert_test.go
View file

@ -1,7 +1,6 @@
package passtlsclientcert
import (
"context"
"crypto/tls"
"crypto/x509"
"encoding/pem"
@ -313,7 +312,7 @@ func TestPassTLSClientCert_PEM(t *testing.T) {
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
tlsClientHeaders, err := New(context.Background(), next, test.config, "foo")
tlsClientHeaders, err := New(t.Context(), next, test.config, "foo")
require.NoError(t, err)
res := httptest.NewRecorder()
@ -535,7 +534,7 @@ func TestPassTLSClientCert_certInfo(t *testing.T) {
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
tlsClientHeaders, err := New(context.Background(), next, test.config, "foo")
tlsClientHeaders, err := New(t.Context(), next, test.config, "foo")
require.NoError(t, err)
res := httptest.NewRecorder()

7
pkg/middlewares/pipelining/pipelining_test.go
View file

@ -1,7 +1,6 @@
package pipelining
import (
"context"
"io"
"net/http"
"net/http/httptest"
@ -62,7 +61,7 @@ func TestNew(t *testing.T) {
assert.Equal(t, test.implementCloseNotifier, ok)
w.WriteHeader(http.StatusOK)
})
handler := New(context.Background(), nextHandler, "pipe")
handler := New(t.Context(), nextHandler, "pipe")
req := httptest.NewRequest(test.HTTPMethod, "http://localhost", nil)
@ -87,7 +86,7 @@ func Test1xxResponses(t *testing.T) {
_, _ = w.Write([]byte("Hello"))
})
pipe := New(context.Background(), next, "pipe")
pipe := New(t.Context(), next, "pipe")
server := httptest.NewServer(pipe)
t.Cleanup(server.Close)
@ -130,7 +129,7 @@ func Test1xxResponses(t *testing.T) {
return nil
},
}
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), http.MethodGet, server.URL, nil)
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(t.Context(), trace), http.MethodGet, server.URL, nil)
res, err := frontendClient.Do(req)
assert.NoError(t, err)

5
pkg/middlewares/ratelimiter/rate_limiter_test.go
View file

@ -1,7 +1,6 @@
package ratelimiter
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
@ -94,7 +93,7 @@ func TestNewRateLimiter(t *testing.T) {
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
h, err := New(context.Background(), next, test.config, "rate-limiter")
h, err := New(t.Context(), next, test.config, "rate-limiter")
if test.expectedError != "" {
assert.EqualError(t, err, test.expectedError)
} else {
@ -258,7 +257,7 @@ func TestRateLimit(t *testing.T) {
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reqCount++
})
h, err := New(context.Background(), next, test.config, "rate-limiter")
h, err := New(t.Context(), next, test.config, "rate-limiter")
require.NoError(t, err)
loadPeriod := time.Duration(1e9 / test.incomingLoad)

3
pkg/middlewares/recovery/recovery_test.go
View file

@ -1,7 +1,6 @@
package recovery
import (
"context"
"errors"
"io"
"net/http"
@ -47,7 +46,7 @@ func TestRecoverHandler(t *testing.T) {
}
panic(test.panicErr)
}
recovery, err := New(context.Background(), http.HandlerFunc(fn))
recovery, err := New(t.Context(), http.HandlerFunc(fn))
require.NoError(t, err)
server := httptest.NewServer(recovery)

3
pkg/middlewares/redirect/redirect_regex_test.go
View file

@ -1,7 +1,6 @@
package redirect
import (
"context"
"crypto/tls"
"net/http"
"net/http/httptest"
@ -158,7 +157,7 @@ func TestRedirectRegexHandler(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
handler, err := NewRedirectRegex(context.Background(), next, test.config, "traefikTest")
handler, err := NewRedirectRegex(t.Context(), next, test.config, "traefikTest")
if test.errorExpected {
require.Error(t, err)

3
pkg/middlewares/redirect/redirect_scheme_test.go
View file

@ -1,7 +1,6 @@
package redirect
import (
"context"
"crypto/tls"
"net/http"
"net/http/httptest"
@ -287,7 +286,7 @@ func TestRedirectSchemeHandler(t *testing.T) {
t.Parallel()
next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
handler, err := NewRedirectScheme(context.Background(), next, test.config, "traefikTest")
handler, err := NewRedirectScheme(t.Context(), next, test.config, "traefikTest")
if test.errorExpected {
require.Error(t, err)

3
pkg/middlewares/replacepath/replace_path_test.go
View file

@ -1,7 +1,6 @@
package replacepath
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -82,7 +81,7 @@ func TestReplacePath(t *testing.T) {
requestURI = r.RequestURI
})
handler, err := New(context.Background(), next, test.config, "foo-replace-path")
handler, err := New(t.Context(), next, test.config, "foo-replace-path")
require.NoError(t, err)
server := httptest.NewServer(handler)

3
pkg/middlewares/replacepathregex/replace_path_regex_test.go
View file

@ -1,7 +1,6 @@
package replacepathregex
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -150,7 +149,7 @@ func TestReplacePathRegex(t *testing.T) {
requestURI = r.RequestURI
})
handler, err := New(context.Background(), next, test.config, "foo-replace-path-regexp")
handler, err := New(t.Context(), next, test.config, "foo-replace-path-regexp")
if test.expectsError {
require.Error(t, err)
return

3
pkg/middlewares/requestdecorator/hostresolver_test.go
View file

@ -1,7 +1,6 @@
package requestdecorator
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
@ -43,7 +42,7 @@ func TestCNAMEFlatten(t *testing.T) {
ResolvDepth: 5,
}
flatH := hostResolver.CNAMEFlatten(context.Background(), test.domain)
flatH := hostResolver.CNAMEFlatten(t.Context(), test.domain)
assert.Equal(t, test.expectedDomain, flatH)
})
}

17
pkg/middlewares/retry/retry_test.go
View file

@ -1,7 +1,6 @@
package retry
import (
"context"
"fmt"
"io"
"net/http"
@ -129,7 +128,7 @@ func TestRetry(t *testing.T) {
})
retryListener := &countingRetryListener{}
retry, err := New(context.Background(), next, test.config, retryListener, "traefikTest")
retry, err := New(t.Context(), next, test.config, retryListener, "traefikTest")
require.NoError(t, err)
recorder := httptest.NewRecorder()
@ -149,7 +148,7 @@ func TestRetryEmptyServerList(t *testing.T) {
})
retryListener := &countingRetryListener{}
retry, err := New(context.Background(), next, dynamic.Retry{Attempts: 3}, retryListener, "traefikTest")
retry, err := New(t.Context(), next, dynamic.Retry{Attempts: 3}, retryListener, "traefikTest")
require.NoError(t, err)
recorder := httptest.NewRecorder()
@ -185,7 +184,7 @@ func TestMultipleRetriesShouldNotLooseHeaders(t *testing.T) {
rw.WriteHeader(http.StatusNoContent)
})
retry, err := New(context.Background(), next, dynamic.Retry{Attempts: 3}, &countingRetryListener{}, "traefikTest")
retry, err := New(t.Context(), next, dynamic.Retry{Attempts: 3}, &countingRetryListener{}, "traefikTest")
require.NoError(t, err)
res := httptest.NewRecorder()
@ -219,7 +218,7 @@ func TestRetryShouldNotLooseHeadersOnWrite(t *testing.T) {
require.NoError(t, err)
})
retry, err := New(context.Background(), next, dynamic.Retry{Attempts: 3}, &countingRetryListener{}, "traefikTest")
retry, err := New(t.Context(), next, dynamic.Retry{Attempts: 3}, &countingRetryListener{}, "traefikTest")
require.NoError(t, err)
res := httptest.NewRecorder()
@ -243,7 +242,7 @@ func TestRetryWithFlush(t *testing.T) {
}
})
retry, err := New(context.Background(), next, dynamic.Retry{Attempts: 1}, &countingRetryListener{}, "traefikTest")
retry, err := New(t.Context(), next, dynamic.Retry{Attempts: 1}, &countingRetryListener{}, "traefikTest")
require.NoError(t, err)
responseRecorder := httptest.NewRecorder()
@ -312,7 +311,7 @@ func TestRetryWebsocket(t *testing.T) {
})
retryListener := &countingRetryListener{}
retryH, err := New(context.Background(), next, dynamic.Retry{Attempts: test.maxRequestAttempts}, retryListener, "traefikTest")
retryH, err := New(t.Context(), next, dynamic.Retry{Attempts: test.maxRequestAttempts}, retryListener, "traefikTest")
require.NoError(t, err)
retryServer := httptest.NewServer(retryH)
@ -345,7 +344,7 @@ func Test1xxResponses(t *testing.T) {
})
retryListener := &countingRetryListener{}
retry, err := New(context.Background(), next, dynamic.Retry{Attempts: 1}, retryListener, "traefikTest")
retry, err := New(t.Context(), next, dynamic.Retry{Attempts: 1}, retryListener, "traefikTest")
require.NoError(t, err)
server := httptest.NewServer(retry)
@ -389,7 +388,7 @@ func Test1xxResponses(t *testing.T) {
return nil
},
}
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), http.MethodGet, server.URL, nil)
req, _ := http.NewRequestWithContext(httptrace.WithClientTrace(t.Context(), trace), http.MethodGet, server.URL, nil)
res, err := frontendClient.Do(req)
assert.NoError(t, err)

3
pkg/middlewares/stripprefix/strip_prefix_test.go
View file

@ -1,7 +1,6 @@
package stripprefix
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -189,7 +188,7 @@ func TestStripPrefix(t *testing.T) {
requestURI = r.RequestURI
})
handler, err := New(context.Background(), next, test.config, "foo-strip-prefix")
handler, err := New(t.Context(), next, test.config, "foo-strip-prefix")
require.NoError(t, err)
req := testhelpers.MustNewRequest(http.MethodGet, "http://localhost"+test.path, nil)

3
pkg/middlewares/stripprefixregex/strip_prefix_regex_test.go
View file

@ -1,7 +1,6 @@
package stripprefixregex
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -118,7 +117,7 @@ func TestStripPrefixRegex(t *testing.T) {
actualHeader = r.Header.Get(stripprefix.ForwardedPrefixHeader)
requestURI = r.RequestURI
})
handler, err := New(context.Background(), handlerPath, testPrefixRegex, "foo-strip-prefix-regex")
handler, err := New(t.Context(), handlerPath, testPrefixRegex, "foo-strip-prefix-regex")
require.NoError(t, err)
req := testhelpers.MustNewRequest(http.MethodGet, "http://localhost"+test.path, nil)

3
pkg/middlewares/tcp/inflightconn/inflight_conn_test.go
View file

@ -1,7 +1,6 @@
package tcpinflightconn
import (
"context"
"net"
"testing"
"time"
@ -27,7 +26,7 @@ func TestInFlightConn_ServeTCP(t *testing.T) {
finishCh <- struct{}{}
})
middleware, err := New(context.Background(), next, dynamic.TCPInFlightConn{Amount: 1}, "foo")
middleware, err := New(t.Context(), next, dynamic.TCPInFlightConn{Amount: 1}, "foo")
require.NoError(t, err)
// The first connection should succeed and wait.

4
pkg/middlewares/tcp/ipallowlist/ip_allowlist_test.go
View file

@ -43,7 +43,7 @@ func TestNewIPAllowLister(t *testing.T) {
t.Parallel()
next := tcp.HandlerFunc(func(conn tcp.WriteCloser) {})
allowLister, err := New(context.Background(), next, test.allowList, "traefikTest")
allowLister, err := New(t.Context(), next, test.allowList, "traefikTest")
if test.expectedError {
assert.Error(t, err)
@ -92,7 +92,7 @@ func TestIPAllowLister_ServeHTTP(t *testing.T) {
require.NoError(t, err)
})
allowLister, err := New(context.Background(), next, test.allowList, "traefikTest")
allowLister, err := New(t.Context(), next, test.allowList, "traefikTest")
require.NoError(t, err)
server, client := net.Pipe()

4
pkg/middlewares/tcp/ipwhitelist/ip_whitelist_test.go
View file

@ -43,7 +43,7 @@ func TestNewIPWhiteLister(t *testing.T) {
t.Parallel()
next := tcp.HandlerFunc(func(conn tcp.WriteCloser) {})
whiteLister, err := New(context.Background(), next, test.whiteList, "traefikTest")
whiteLister, err := New(t.Context(), next, test.whiteList, "traefikTest")
if test.expectedError {
assert.Error(t, err)
@ -92,7 +92,7 @@ func TestIPWhiteLister_ServeHTTP(t *testing.T) {
require.NoError(t, err)
})
whiteLister, err := New(context.Background(), next, test.whiteList, "traefikTest")
whiteLister, err := New(t.Context(), next, test.whiteList, "traefikTest")
require.NoError(t, err)
server, client := net.Pipe()

3
pkg/middlewares/tracing/entrypoint_test.go
View file

@ -1,7 +1,6 @@
package tracing
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -79,7 +78,7 @@ func TestEntryPointMiddleware(t *testing.T) {
assert.Equal(t, test.expected.OperationName, span.OpName)
})
handler := NewEntryPoint(context.Background(), newTracing, test.entryPoint, next)
handler := NewEntryPoint(t.Context(), newTracing, test.entryPoint, next)
handler.ServeHTTP(rw, req)
})
}

3
pkg/middlewares/tracing/forwarder_test.go
View file

@ -1,7 +1,6 @@
package tracing
import (
"context"
"net/http"
"net/http/httptest"
"testing"
@ -129,7 +128,7 @@ func TestNewForwarder(t *testing.T) {
assert.Equal(t, test.expected.OperationName, span.OpName)
})
handler := NewForwarder(context.Background(), test.router, test.service, next)
handler := NewForwarder(t.Context(), test.router, test.service, next)
handler.ServeHTTP(rw, req)
})
}