Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 auth_info.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "encoding/base64" "github.com/go-openapi/strfmt" "github.com/go-openapi/runtime" ) // PassThroughAuth never manipulates the request var PassThroughAuth runtime.ClientAuthInfoWriter func init() { PassThroughAuth = runtime.ClientAuthInfoWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) } // BasicAuth provides a basic auth info writer func BasicAuth(username, password string) runtime.ClientAuthInfoWriter { return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { encoded := base64.StdEncoding.EncodeToString([]byte(username + ":" + password)) return r.SetHeaderParam(runtime.HeaderAuthorization, "Basic "+encoded) }) } // APIKeyAuth provides an API key auth info writer func APIKeyAuth(name, in, value string) runtime.ClientAuthInfoWriter { if in == "query" { return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { return r.SetQueryParam(name, value) }) } if in == "header" { return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { return r.SetHeaderParam(name, value) }) } return nil } // BearerToken provides a header based oauth2 bearer access token auth info writer func BearerToken(token string) runtime.ClientAuthInfoWriter { return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { return r.SetHeaderParam(runtime.HeaderAuthorization, "Bearer "+token) }) } // Compose combines multiple ClientAuthInfoWriters into a single one. // Useful when multiple auth headers are needed. func Compose(auths ...runtime.ClientAuthInfoWriter) runtime.ClientAuthInfoWriter { return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { for _, auth := range auths { if auth == nil { continue } if err := auth.AuthenticateRequest(r, nil); err != nil { return err } } return nil }) }	2.54 KB	2025-05-25 12:27
📄 auth_info_test.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "net/http" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/go-openapi/runtime" ) func TestBasicAuth(t testing.T) { r := newRequest(http.MethodGet, "/", nil) writer := BasicAuth("someone", "with a password") err := writer.AuthenticateRequest(r, nil) require.NoError(t, err) req := new(http.Request) req.Header = make(http.Header) req.Header.Set(runtime.HeaderAuthorization, r.header.Get(runtime.HeaderAuthorization)) usr, pw, ok := req.BasicAuth() require.True(t, ok) assert.Equal(t, "someone", usr) assert.Equal(t, "with a password", pw) } func TestAPIKeyAuth_Query(t testing.T) { r := newRequest(http.MethodGet, "/", nil) writer := APIKeyAuth("api_key", "query", "the-shared-key") err := writer.AuthenticateRequest(r, nil) require.NoError(t, err) assert.Equal(t, "the-shared-key", r.query.Get("api_key")) } func TestAPIKeyAuth_Header(t testing.T) { r := newRequest(http.MethodGet, "/", nil) writer := APIKeyAuth("x-api-token", "header", "the-shared-key") err := writer.AuthenticateRequest(r, nil) require.NoError(t, err) assert.Equal(t, "the-shared-key", r.header.Get("x-api-token")) } func TestBearerTokenAuth(t testing.T) { r := newRequest(http.MethodGet, "/", nil) writer := BearerToken("the-shared-token") err := writer.AuthenticateRequest(r, nil) require.NoError(t, err) assert.Equal(t, "Bearer the-shared-token", r.header.Get(runtime.HeaderAuthorization)) } func TestCompose(t *testing.T) { r := newRequest(http.MethodGet, "/", nil) writer := Compose(APIKeyAuth("x-api-key", "header", "the-api-key"), APIKeyAuth("x-secret-key", "header", "the-secret-key")) err := writer.AuthenticateRequest(r, nil) require.NoError(t, err) assert.Equal(t, "the-api-key", r.header.Get("x-api-key")) assert.Equal(t, "the-secret-key", r.header.Get("x-secret-key")) }	2.43 KB	2025-05-25 12:27
📄 keepalive.go package client import ( "io" "net/http" "sync/atomic" ) // KeepAliveTransport drains the remaining body from a response // so that go will reuse the TCP connections. // This is not enabled by default because there are servers where // the response never gets closed and that would make the code hang forever. // So instead it's provided as a http client middleware that can be used to override // any request. func KeepAliveTransport(rt http.RoundTripper) http.RoundTripper { return &keepAliveTransport{wrapped: rt} } type keepAliveTransport struct { wrapped http.RoundTripper } func (k keepAliveTransport) RoundTrip(r http.Request) (http.Response, error) { resp, err := k.wrapped.RoundTrip(r) if err != nil { return resp, err } resp.Body = &drainingReadCloser{rdr: resp.Body} return resp, nil } type drainingReadCloser struct { rdr io.ReadCloser seenEOF uint32 } func (d drainingReadCloser) Read(p []byte) (n int, err error) { n, err = d.rdr.Read(p) if err == io.EOF \|\| n == 0 { atomic.StoreUint32(&d.seenEOF, 1) } return } func (d *drainingReadCloser) Close() error { // drain buffer if atomic.LoadUint32(&d.seenEOF) != 1 { // If the reader side (a HTTP server) is misbehaving, it still may send // some bytes, but the closer ignores them to keep the underling // connection open. _, _ = io.Copy(io.Discard, d.rdr) } return d.rdr.Close() }	1.36 KB	2025-05-25 12:27
📄 keepalive_test.go package client import ( "bytes" "io" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func newCountingReader(rdr io.Reader, readOnce bool) countingReadCloser { return &countingReadCloser{ rdr: rdr, readOnce: readOnce, } } type countingReadCloser struct { rdr io.Reader readOnce bool readCalled int closeCalled int } func (c countingReadCloser) Read(b []byte) (int, error) { c.readCalled++ if c.readCalled > 1 && c.readOnce { return 0, io.EOF } return c.rdr.Read(b) } func (c countingReadCloser) Close() error { c.closeCalled++ return nil } func TestDrainingReadCloser(t testing.T) { rdr := newCountingReader(bytes.NewBufferString("There are many things to do"), false) prevDisc := io.Discard disc := bytes.NewBuffer(nil) io.Discard = disc defer func() { io.Discard = prevDisc }() buf := make([]byte, 5) ts := &drainingReadCloser{rdr: rdr} _, err := ts.Read(buf) require.NoError(t, err) require.NoError(t, ts.Close()) assert.Equal(t, "There", string(buf)) assert.Equal(t, " are many things to do", disc.String()) assert.Equal(t, 3, rdr.readCalled) assert.Equal(t, 1, rdr.closeCalled) } func TestDrainingReadCloser_SeenEOF(t *testing.T) { rdr := newCountingReader(bytes.NewBufferString("There are many things to do"), true) prevDisc := io.Discard disc := bytes.NewBuffer(nil) io.Discard = disc defer func() { io.Discard = prevDisc }() buf := make([]byte, 5) ts := &drainingReadCloser{rdr: rdr} _, err := ts.Read(buf) require.NoError(t, err) _, err = ts.Read(nil) require.ErrorIs(t, err, io.EOF) require.NoError(t, ts.Close()) assert.Equal(t, "There", string(buf)) assert.Empty(t, disc.String()) assert.Equal(t, 2, rdr.readCalled) assert.Equal(t, 1, rdr.closeCalled) }	1.75 KB	2025-05-25 12:27
📄 opentelemetry.go package client import ( "fmt" "net/http" "strings" "github.com/go-openapi/runtime" "github.com/go-openapi/strfmt" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" semconv "go.opentelemetry.io/otel/semconv/v1.17.0" "go.opentelemetry.io/otel/semconv/v1.17.0/httpconv" "go.opentelemetry.io/otel/trace" ) const ( instrumentationVersion = "1.0.0" tracerName = "go-openapi" ) type config struct { Tracer trace.Tracer Propagator propagation.TextMapPropagator SpanStartOptions []trace.SpanStartOption SpanNameFormatter func(runtime.ClientOperation) string TracerProvider trace.TracerProvider } type OpenTelemetryOpt interface { apply(config) } type optionFunc func(config) func (o optionFunc) apply(c config) { o(c) } // WithTracerProvider specifies a tracer provider to use for creating a tracer. // If none is specified, the global provider is used. func WithTracerProvider(provider trace.TracerProvider) OpenTelemetryOpt { return optionFunc(func(c config) { if provider != nil { c.TracerProvider = provider } }) } // WithPropagators configures specific propagators. If this // option isn't specified, then the global TextMapPropagator is used. func WithPropagators(ps propagation.TextMapPropagator) OpenTelemetryOpt { return optionFunc(func(c config) { if ps != nil { c.Propagator = ps } }) } // WithSpanOptions configures an additional set of // trace.SpanOptions, which are applied to each new span. func WithSpanOptions(opts ...trace.SpanStartOption) OpenTelemetryOpt { return optionFunc(func(c config) { c.SpanStartOptions = append(c.SpanStartOptions, opts...) }) } // WithSpanNameFormatter takes a function that will be called on every // request and the returned string will become the Span Name. func WithSpanNameFormatter(f func(op runtime.ClientOperation) string) OpenTelemetryOpt { return optionFunc(func(c config) { c.SpanNameFormatter = f }) } func defaultTransportFormatter(op runtime.ClientOperation) string { if op.ID != "" { return op.ID } return fmt.Sprintf("%s_%s", strings.ToLower(op.Method), op.PathPattern) } type openTelemetryTransport struct { transport runtime.ClientTransport host string tracer trace.Tracer config config } func newOpenTelemetryTransport(transport runtime.ClientTransport, host string, opts []OpenTelemetryOpt) openTelemetryTransport { tr := &openTelemetryTransport{ transport: transport, host: host, } defaultOpts := []OpenTelemetryOpt{ WithSpanOptions(trace.WithSpanKind(trace.SpanKindClient)), WithSpanNameFormatter(defaultTransportFormatter), WithPropagators(otel.GetTextMapPropagator()), WithTracerProvider(otel.GetTracerProvider()), } c := newConfig(append(defaultOpts, opts...)...) tr.config = c return tr } func (t openTelemetryTransport) Submit(op runtime.ClientOperation) (interface{}, error) { if op.Context == nil { return t.transport.Submit(op) } params := op.Params reader := op.Reader var span trace.Span defer func() { if span != nil { span.End() } }() op.Params = runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { span = t.newOpenTelemetrySpan(op, req.GetHeaderParams()) return params.WriteToRequest(req, reg) }) op.Reader = runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if span != nil { statusCode := response.Code() // NOTE: this is replaced by semconv.HTTPResponseStatusCode in semconv v1.21 span.SetAttributes(semconv.HTTPStatusCode(statusCode)) // NOTE: the conversion from HTTP status code to trace code is no longer available with // semconv v1.21 span.SetStatus(httpconv.ServerStatus(statusCode)) } return reader.ReadResponse(response, consumer) }) submit, err := t.transport.Submit(op) if err != nil && span != nil { span.RecordError(err) span.SetStatus(codes.Error, err.Error()) } return submit, err } func (t openTelemetryTransport) newOpenTelemetrySpan(op runtime.ClientOperation, header http.Header) trace.Span { ctx := op.Context tracer := t.tracer if tracer == nil { if span := trace.SpanFromContext(ctx); span.SpanContext().IsValid() { tracer = newTracer(span.TracerProvider()) } else { tracer = newTracer(otel.GetTracerProvider()) } } ctx, span := tracer.Start(ctx, t.config.SpanNameFormatter(op), t.config.SpanStartOptions...) var scheme string if len(op.Schemes) > 0 { scheme = op.Schemes[0] } span.SetAttributes( attribute.String("net.peer.name", t.host), attribute.String(string(semconv.HTTPRouteKey), op.PathPattern), attribute.String(string(semconv.HTTPMethodKey), op.Method), attribute.String("span.kind", trace.SpanKindClient.String()), attribute.String("http.scheme", scheme), ) carrier := propagation.HeaderCarrier(header) t.config.Propagator.Inject(ctx, carrier) return span } func newTracer(tp trace.TracerProvider) trace.Tracer { return tp.Tracer(tracerName, trace.WithInstrumentationVersion(version())) } func newConfig(opts ...OpenTelemetryOpt) *config { c := &config{ Propagator: otel.GetTextMapPropagator(), } for _, opt := range opts { opt.apply(c) } // Tracer is only initialized if manually specified. Otherwise, can be passed with the tracing context. if c.TracerProvider != nil { c.Tracer = newTracer(c.TracerProvider) } return c } // Version is the current release version of the go-runtime instrumentation. func version() string { return instrumentationVersion }	5.52 KB	2025-05-25 12:27
📄 opentelemetry_test.go package client import ( "context" "net/http" "testing" "github.com/go-openapi/runtime" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" tracesdk "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/sdk/trace/tracetest" "go.opentelemetry.io/otel/trace" ) func Test_OpenTelemetryRuntime_submit(t testing.T) { t.Parallel() exporter := tracetest.NewInMemoryExporter() tp := tracesdk.NewTracerProvider( tracesdk.WithSampler(tracesdk.AlwaysSample()), tracesdk.WithSyncer(exporter), ) otel.SetTracerProvider(tp) tracer := tp.Tracer("go-runtime") ctx, span := tracer.Start(context.Background(), "op") defer span.End() assertOpenTelemetrySubmit(t, testOperation(ctx), exporter, 1) } func Test_OpenTelemetryRuntime_submit_nilAuthInfo(t testing.T) { t.Parallel() exporter := tracetest.NewInMemoryExporter() tp := tracesdk.NewTracerProvider( tracesdk.WithSampler(tracesdk.AlwaysSample()), tracesdk.WithSyncer(exporter), ) otel.SetTracerProvider(tp) tracer := tp.Tracer("go-runtime") ctx, span := tracer.Start(context.Background(), "op") defer span.End() operation := testOperation(ctx) operation.AuthInfo = nil assertOpenTelemetrySubmit(t, operation, exporter, 1) } func Test_OpenTelemetryRuntime_submit_nilContext(t testing.T) { exporter := tracetest.NewInMemoryExporter() tp := tracesdk.NewTracerProvider( tracesdk.WithSampler(tracesdk.AlwaysSample()), tracesdk.WithSyncer(exporter), ) otel.SetTracerProvider(tp) tracer := tp.Tracer("go-runtime") ctx, span := tracer.Start(context.Background(), "op") defer span.End() operation := testOperation(ctx) operation.Context = nil assertOpenTelemetrySubmit(t, operation, exporter, 0) // just don't panic } func Test_injectOpenTelemetrySpanContext(t testing.T) { t.Parallel() exporter := tracetest.NewInMemoryExporter() tp := tracesdk.NewTracerProvider( tracesdk.WithSampler(tracesdk.AlwaysSample()), tracesdk.WithSyncer(exporter), ) otel.SetTracerProvider(tp) tracer := tp.Tracer("go-runtime") ctx, span := tracer.Start(context.Background(), "op") defer span.End() operation := testOperation(ctx) header := map[string][]string{} tr := newOpenTelemetryTransport(&mockRuntime{runtime.TestClientRequest{Headers: header}}, "", nil) tr.config.Propagator = propagation.TraceContext{} _, err := tr.Submit(operation) require.NoError(t, err) assert.Len(t, header, 1) } func assertOpenTelemetrySubmit(t testing.T, operation runtime.ClientOperation, exporter *tracetest.InMemoryExporter, expectedSpanCount int) { header := map[string][]string{} tr := newOpenTelemetryTransport(&mockRuntime{runtime.TestClientRequest{Headers: header}}, "remote_host", nil) _, err := tr.Submit(operation) require.NoError(t, err) spans := exporter.GetSpans() assert.Len(t, spans, expectedSpanCount) if expectedSpanCount != 1 { return } span := spans[0] assert.Equal(t, "getCluster", span.Name) assert.Equal(t, "go-openapi", span.InstrumentationLibrary.Name) assert.Equal(t, codes.Error, span.Status.Code) assert.Equal(t, []attribute.KeyValue{ attribute.String("net.peer.name", "remote_host"), attribute.String("http.route", "/kubernetes-clusters/{cluster_id}"), attribute.String("http.method", http.MethodGet), attribute.String("span.kind", trace.SpanKindClient.String()), attribute.String("http.scheme", schemeHTTPS), // NOTE: this becomes http.response.status_code with semconv v1.21 attribute.Int("http.status_code", 490), }, span.Attributes) }	3.58 KB	2025-05-25 12:27
📄 opentracing.go package client import ( "fmt" "net/http" "github.com/go-openapi/strfmt" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" "github.com/opentracing/opentracing-go/log" "github.com/go-openapi/runtime" ) type tracingTransport struct { transport runtime.ClientTransport host string opts []opentracing.StartSpanOption } func newOpenTracingTransport(transport runtime.ClientTransport, host string, opts []opentracing.StartSpanOption, ) runtime.ClientTransport { return &tracingTransport{ transport: transport, host: host, opts: opts, } } func (t tracingTransport) Submit(op runtime.ClientOperation) (interface{}, error) { if op.Context == nil { return t.transport.Submit(op) } params := op.Params reader := op.Reader var span opentracing.Span defer func() { if span != nil { span.Finish() } }() op.Params = runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { span = createClientSpan(op, req.GetHeaderParams(), t.host, t.opts) return params.WriteToRequest(req, reg) }) op.Reader = runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if span != nil { code := response.Code() ext.HTTPStatusCode.Set(span, uint16(code)) if code >= 400 { ext.Error.Set(span, true) } } return reader.ReadResponse(response, consumer) }) submit, err := t.transport.Submit(op) if err != nil && span != nil { ext.Error.Set(span, true) span.LogFields(log.Error(err)) } return submit, err } func createClientSpan(op runtime.ClientOperation, header http.Header, host string, opts []opentracing.StartSpanOption) opentracing.Span { ctx := op.Context span := opentracing.SpanFromContext(ctx) if span != nil { opts = append(opts, ext.SpanKindRPCClient) span, _ = opentracing.StartSpanFromContextWithTracer( ctx, span.Tracer(), operationName(op), opts...) ext.Component.Set(span, "go-openapi") ext.PeerHostname.Set(span, host) span.SetTag("http.path", op.PathPattern) ext.HTTPMethod.Set(span, op.Method) _ = span.Tracer().Inject( span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(header)) return span } return nil } func operationName(op runtime.ClientOperation) string { if op.ID != "" { return op.ID } return fmt.Sprintf("%s_%s", op.Method, op.PathPattern) }	2.38 KB	2025-05-25 12:27
📄 opentracing_test.go package client import ( "bytes" "context" "io" "testing" "github.com/go-openapi/strfmt" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" "github.com/opentracing/opentracing-go/mocktracer" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/go-openapi/runtime" ) type tres struct { } func (r tres) Code() int { return 490 } func (r tres) Message() string { return "the message" } func (r tres) GetHeader(_ string) string { return "the header" } func (r tres) GetHeaders(_ string) []string { return []string{"the headers", "the headers2"} } func (r tres) Body() io.ReadCloser { return io.NopCloser(bytes.NewBufferString("the content")) } type mockRuntime struct { req runtime.TestClientRequest } func (m mockRuntime) Submit(operation runtime.ClientOperation) (interface{}, error) { _ = operation.Params.WriteToRequest(&m.req, nil) _, _ = operation.Reader.ReadResponse(&tres{}, nil) return map[string]interface{}{}, nil } func testOperation(ctx context.Context) runtime.ClientOperation { return &runtime.ClientOperation{ ID: "getCluster", Method: "GET", PathPattern: "/kubernetes-clusters/{cluster_id}", ProducesMediaTypes: []string{"application/json"}, ConsumesMediaTypes: []string{"application/json"}, Schemes: []string{schemeHTTPS}, Reader: runtime.ClientResponseReaderFunc(func(runtime.ClientResponse, runtime.Consumer) (interface{}, error) { return nil, nil }), Params: runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }), AuthInfo: PassThroughAuth, Context: ctx, } } func Test_TracingRuntime_submit(t testing.T) { t.Parallel() tracer := mocktracer.New() _, ctx := opentracing.StartSpanFromContextWithTracer(context.Background(), tracer, "op") testSubmit(t, testOperation(ctx), tracer, 1) } func Test_TracingRuntime_submit_nilAuthInfo(t testing.T) { t.Parallel() tracer := mocktracer.New() _, ctx := opentracing.StartSpanFromContextWithTracer(context.Background(), tracer, "op") operation := testOperation(ctx) operation.AuthInfo = nil testSubmit(t, operation, tracer, 1) } func Test_TracingRuntime_submit_nilContext(t testing.T) { t.Parallel() tracer := mocktracer.New() _, ctx := opentracing.StartSpanFromContextWithTracer(context.Background(), tracer, "op") operation := testOperation(ctx) operation.Context = nil testSubmit(t, operation, tracer, 0) // just don't panic } func testSubmit(t testing.T, operation runtime.ClientOperation, tracer mocktracer.MockTracer, expectedSpans int) { header := map[string][]string{} r := newOpenTracingTransport(&mockRuntime{runtime.TestClientRequest{Headers: header}}, "remote_host", []opentracing.StartSpanOption{opentracing.Tag{ Key: string(ext.PeerService), Value: "service", }}) _, err := r.Submit(operation) require.NoError(t, err) assert.Len(t, tracer.FinishedSpans(), expectedSpans) if expectedSpans == 1 { span := tracer.FinishedSpans()[0] assert.Equal(t, "getCluster", span.OperationName) assert.Equal(t, map[string]interface{}{ "component": "go-openapi", "http.method": "GET", "http.path": "/kubernetes-clusters/{cluster_id}", "http.status_code": uint16(490), "peer.hostname": "remote_host", "peer.service": "service", "span.kind": ext.SpanKindRPCClientEnum, "error": true, }, span.Tags()) } } func Test_injectSpanContext(t testing.T) { t.Parallel() tracer := mocktracer.New() _, ctx := opentracing.StartSpanFromContextWithTracer(context.Background(), tracer, "op") header := map[string][]string{} createClientSpan(testOperation(ctx), header, "", nil) // values are random - just check that something was injected assert.Len(t, header, 3) }	3.77 KB	2025-05-25 12:27
📄 request.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "bytes" "context" "fmt" "io" "log" "mime/multipart" "net/http" "net/textproto" "net/url" "os" "path" "path/filepath" "strings" "time" "github.com/go-openapi/strfmt" "github.com/go-openapi/runtime" ) // NewRequest creates a new swagger http client request func newRequest(method, pathPattern string, writer runtime.ClientRequestWriter) request { return &request{ pathPattern: pathPattern, method: method, writer: writer, header: make(http.Header), query: make(url.Values), timeout: DefaultTimeout, getBody: getRequestBuffer, } } // Request represents a swagger client request. // // This Request struct converts to a HTTP request. // There might be others that convert to other transports. // There is no error checking here, it is assumed to be used after a spec has been validated. // so impossible combinations should not arise (hopefully). // // The main purpose of this struct is to hide the machinery of adding params to a transport request. // The generated code only implements what is necessary to turn a param into a valid value for these methods. type request struct { pathPattern string method string writer runtime.ClientRequestWriter pathParams map[string]string header http.Header query url.Values formFields url.Values fileFields map[string][]runtime.NamedReadCloser payload interface{} timeout time.Duration buf bytes.Buffer getBody func(r request) []byte } var ( // ensure interface compliance _ runtime.ClientRequest = new(request) ) func (r request) isMultipart(mediaType string) bool { if len(r.fileFields) > 0 { return true } return runtime.MultipartFormMime == mediaType } // BuildHTTP creates a new http request based on the data from the params func (r request) BuildHTTP(mediaType, basePath string, producers map[string]runtime.Producer, registry strfmt.Registry) (http.Request, error) { return r.buildHTTP(mediaType, basePath, producers, registry, nil) } func escapeQuotes(s string) string { return strings.NewReplacer("\\", "\\\\", `"`, "\\\"").Replace(s) } func logClose(err error, pw io.PipeWriter) { log.Println(err) closeErr := pw.CloseWithError(err) if closeErr != nil { log.Println(closeErr) } } func (r request) buildHTTP(mediaType, basePath string, producers map[string]runtime.Producer, registry strfmt.Registry, auth runtime.ClientAuthInfoWriter) (http.Request, error) { //nolint:gocyclo,maintidx // build the data if err := r.writer.WriteToRequest(r, registry); err != nil { return nil, err } // Our body must be an io.Reader. // When we create the http.Request, if we pass it a // bytes.Buffer then it will wrap it in an io.ReadCloser // and set the content length automatically. var body io.Reader var pr io.PipeReader var pw io.PipeWriter r.buf = bytes.NewBuffer(nil) if r.payload != nil \|\| len(r.formFields) > 0 \|\| len(r.fileFields) > 0 { body = r.buf if r.isMultipart(mediaType) { pr, pw = io.Pipe() body = pr } } // check if this is a form type request if len(r.formFields) > 0 \|\| len(r.fileFields) > 0 { if !r.isMultipart(mediaType) { r.header.Set(runtime.HeaderContentType, mediaType) formString := r.formFields.Encode() r.buf.WriteString(formString) goto DoneChoosingBodySource } mp := multipart.NewWriter(pw) r.header.Set(runtime.HeaderContentType, mangleContentType(mediaType, mp.Boundary())) go func() { defer func() { mp.Close() pw.Close() }() for fn, v := range r.formFields { for _, vi := range v { if err := mp.WriteField(fn, vi); err != nil { logClose(err, pw) return } } } defer func() { for _, ff := range r.fileFields { for _, ffi := range ff { ffi.Close() } } }() for fn, f := range r.fileFields { for _, fi := range f { var fileContentType string if p, ok := fi.(interface { ContentType() string }); ok { fileContentType = p.ContentType() } else { // Need to read the data so that we can detect the content type buf := make([]byte, 512) size, err := fi.Read(buf) if err != nil && err != io.EOF { logClose(err, pw) return } fileContentType = http.DetectContentType(buf) fi = runtime.NamedReader(fi.Name(), io.MultiReader(bytes.NewReader(buf[:size]), fi)) } // Create the MIME headers for the new part h := make(textproto.MIMEHeader) h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`, escapeQuotes(fn), escapeQuotes(filepath.Base(fi.Name())))) h.Set("Content-Type", fileContentType) wrtr, err := mp.CreatePart(h) if err != nil { logClose(err, pw) return } if _, err := io.Copy(wrtr, fi); err != nil { logClose(err, pw) } } } }() goto DoneChoosingBodySource } // if there is payload, use the producer to write the payload, and then // set the header to the content-type appropriate for the payload produced if r.payload != nil { // TODO: infer most appropriate content type based on the producer used, // and the `consumers` section of the spec/operation r.header.Set(runtime.HeaderContentType, mediaType) if rdr, ok := r.payload.(io.ReadCloser); ok { body = rdr goto DoneChoosingBodySource } if rdr, ok := r.payload.(io.Reader); ok { body = rdr goto DoneChoosingBodySource } producer := producers[mediaType] if err := producer.Produce(r.buf, r.payload); err != nil { return nil, err } } DoneChoosingBodySource: if runtime.CanHaveBody(r.method) && body != nil && r.header.Get(runtime.HeaderContentType) == "" { r.header.Set(runtime.HeaderContentType, mediaType) } if auth != nil { // If we're not using r.buf as our http.Request's body, // either the payload is an io.Reader or io.ReadCloser, // or we're doing a multipart form/file. // // In those cases, if the AuthenticateRequest call asks for the body, // we must read it into a buffer and provide that, then use that buffer // as the body of our http.Request. // // This is done in-line with the GetBody() request rather than ahead // of time, because there's no way to know if the AuthenticateRequest // will even ask for the body of the request. // // If for some reason the copy fails, there's no way to return that // error to the GetBody() call, so return it afterwards. // // An error from the copy action is prioritized over any error // from the AuthenticateRequest call, because the mis-read // body may have interfered with the auth. // var copyErr error if buf, ok := body.(bytes.Buffer); body != nil && (!ok \|\| buf != r.buf) { var copied bool r.getBody = func(r request) []byte { if copied { return getRequestBuffer(r) } defer func() { copied = true }() if _, copyErr = io.Copy(r.buf, body); copyErr != nil { return nil } if closer, ok := body.(io.ReadCloser); ok { if copyErr = closer.Close(); copyErr != nil { return nil } } body = r.buf return getRequestBuffer(r) } } authErr := auth.AuthenticateRequest(r, registry) if copyErr != nil { return nil, fmt.Errorf("error retrieving the response body: %v", copyErr) } if authErr != nil { return nil, authErr } } // In case the basePath or the request pathPattern include static query parameters, // parse those out before constructing the final path. The parameters themselves // will be merged with the ones set by the client, with the priority given first to // the ones set by the client, then the path pattern, and lastly the base path. basePathURL, err := url.Parse(basePath) if err != nil { return nil, err } staticQueryParams := basePathURL.Query() pathPatternURL, err := url.Parse(r.pathPattern) if err != nil { return nil, err } for name, values := range pathPatternURL.Query() { if _, present := staticQueryParams[name]; present { staticQueryParams.Del(name) } for _, value := range values { staticQueryParams.Add(name, value) } } // create http request var reinstateSlash bool if pathPatternURL.Path != "" && pathPatternURL.Path != "/" && pathPatternURL.Path[len(pathPatternURL.Path)-1] == '/' { reinstateSlash = true } urlPath := path.Join(basePathURL.Path, pathPatternURL.Path) for k, v := range r.pathParams { urlPath = strings.ReplaceAll(urlPath, "{"+k+"}", url.PathEscape(v)) } if reinstateSlash { urlPath += "/" } req, err := http.NewRequestWithContext(context.Background(), r.method, urlPath, body) if err != nil { return nil, err } originalParams := r.GetQueryParams() // Merge the query parameters extracted from the basePath with the ones set by // the client in this struct. In case of conflict, the client wins. for k, v := range staticQueryParams { _, present := originalParams[k] if !present { if err = r.SetQueryParam(k, v...); err != nil { return nil, err } } } req.URL.RawQuery = r.query.Encode() req.Header = r.header return req, nil } func mangleContentType(mediaType, boundary string) string { if strings.ToLower(mediaType) == runtime.URLencodedFormMime { return fmt.Sprintf("%s; boundary=%s", mediaType, boundary) } return "multipart/form-data; boundary=" + boundary } func (r request) GetMethod() string { return r.method } func (r request) GetPath() string { path := r.pathPattern for k, v := range r.pathParams { path = strings.ReplaceAll(path, "{"+k+"}", v) } return path } func (r request) GetBody() []byte { return r.getBody(r) } func getRequestBuffer(r request) []byte { if r.buf == nil { return nil } return r.buf.Bytes() } // SetHeaderParam adds a header param to the request // when there is only 1 value provided for the varargs, it will set it. // when there are several values provided for the varargs it will add it (no overriding) func (r request) SetHeaderParam(name string, values ...string) error { if r.header == nil { r.header = make(http.Header) } r.header[http.CanonicalHeaderKey(name)] = values return nil } // GetHeaderParams returns the all headers currently set for the request func (r request) GetHeaderParams() http.Header { return r.header } // SetQueryParam adds a query param to the request // when there is only 1 value provided for the varargs, it will set it. // when there are several values provided for the varargs it will add it (no overriding) func (r request) SetQueryParam(name string, values ...string) error { if r.query == nil { r.query = make(url.Values) } r.query[name] = values return nil } // GetQueryParams returns a copy of all query params currently set for the request func (r request) GetQueryParams() url.Values { var result = make(url.Values) for key, value := range r.query { result[key] = append([]string{}, value...) } return result } // SetFormParam adds a forn param to the request // when there is only 1 value provided for the varargs, it will set it. // when there are several values provided for the varargs it will add it (no overriding) func (r request) SetFormParam(name string, values ...string) error { if r.formFields == nil { r.formFields = make(url.Values) } r.formFields[name] = values return nil } // SetPathParam adds a path param to the request func (r request) SetPathParam(name string, value string) error { if r.pathParams == nil { r.pathParams = make(map[string]string) } r.pathParams[name] = value return nil } // SetFileParam adds a file param to the request func (r request) SetFileParam(name string, files ...runtime.NamedReadCloser) error { for _, file := range files { if actualFile, ok := file.(os.File); ok { fi, err := os.Stat(actualFile.Name()) if err != nil { return err } if fi.IsDir() { return fmt.Errorf("%q is a directory, only files are supported", file.Name()) } } } if r.fileFields == nil { r.fileFields = make(map[string][]runtime.NamedReadCloser) } if r.formFields == nil { r.formFields = make(url.Values) } r.fileFields[name] = files return nil } func (r request) GetFileParam() map[string][]runtime.NamedReadCloser { return r.fileFields } // SetBodyParam sets a body parameter on the request. // This does not yet serialze the object, this happens as late as possible. func (r request) SetBodyParam(payload interface{}) error { r.payload = payload return nil } func (r request) GetBodyParam() interface{} { return r.payload } // SetTimeout sets the timeout for a request func (r *request) SetTimeout(timeout time.Duration) error { r.timeout = timeout return nil }	13 KB	2025-05-25 12:27
📄 request_test.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "bytes" "encoding/json" "encoding/xml" "errors" "io" "mime" "mime/multipart" "net/http" "net/http/httptest" "net/url" "os" "path/filepath" "strings" "testing" "github.com/go-openapi/strfmt" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/go-openapi/runtime" ) var testProducers = map[string]runtime.Producer{ runtime.JSONMime: runtime.JSONProducer(), runtime.XMLMime: runtime.XMLProducer(), runtime.TextMime: runtime.TextProducer(), } func TestBuildRequest_SetHeaders(t testing.T) { r := newRequest(http.MethodGet, "/flats/{id}/", nil) // single value _ = r.SetHeaderParam("X-Rate-Limit", "500") assert.Equal(t, "500", r.header.Get("X-Rate-Limit")) _ = r.SetHeaderParam("X-Rate-Limit", "400") assert.Equal(t, "400", r.header.Get("X-Rate-Limit")) // multi value _ = r.SetHeaderParam("X-Accepts", "json", "xml", "yaml") assert.EqualValues(t, []string{"json", "xml", "yaml"}, r.header["X-Accepts"]) } func TestBuildRequest_SetPath(t testing.T) { r := newRequest(http.MethodGet, "/flats/{id}/?hello=world", nil) _ = r.SetPathParam("id", "1345") assert.Equal(t, "1345", r.pathParams["id"]) } func TestBuildRequest_SetQuery(t testing.T) { r := newRequest(http.MethodGet, "/flats/{id}/", nil) // single value _ = r.SetQueryParam("hello", "there") assert.Equal(t, "there", r.query.Get("hello")) // multi value _ = r.SetQueryParam("goodbye", "cruel", "world") assert.Equal(t, []string{"cruel", "world"}, r.query["goodbye"]) } func TestBuildRequest_SetForm(t testing.T) { // non-multipart r := newRequest(http.MethodPost, "/flats", nil) _ = r.SetFormParam("hello", "world") assert.Equal(t, "world", r.formFields.Get("hello")) _ = r.SetFormParam("goodbye", "cruel", "world") assert.Equal(t, []string{"cruel", "world"}, r.formFields["goodbye"]) } func TestBuildRequest_SetFile(t testing.T) { // needs to convert form to multipart r := newRequest(http.MethodPost, "/flats/{id}/image", nil) // error if it isn't there err := r.SetFileParam("not there", os.NewFile(0, "./i-dont-exist")) require.Error(t, err) // error if it isn't a file err = r.SetFileParam("directory", os.NewFile(0, "../client")) require.Error(t, err) // success adds it to the map err = r.SetFileParam("file", mustGetFile("./runtime.go")) require.NoError(t, err) fl, ok := r.fileFields["file"] require.True(t, ok) assert.Equal(t, "runtime.go", filepath.Base(fl[0].Name())) // success adds a file param with multiple files err = r.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go")) require.NoError(t, err) fl, ok = r.fileFields["otherfiles"] require.True(t, ok) assert.Equal(t, "runtime.go", filepath.Base(fl[0].Name())) assert.Equal(t, "request.go", filepath.Base(fl[1].Name())) } func mustGetFile(path string) os.File { f, err := os.Open(path) if err != nil { panic(err) } return f } func TestBuildRequest_SetBody(t testing.T) { r := newRequest(http.MethodGet, "/flats/{id}/?hello=world", nil) bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}} _ = r.SetBodyParam(bd) assert.Equal(t, bd, r.payload) } func TestBuildRequest_BuildHTTP_NoPayload(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) } func TestBuildRequest_BuildHTTP_Payload(t testing.T) { bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}} reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(bd) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody, err := json.Marshal(bd) require.NoError(t, err) actualBody, err := io.ReadAll(req.Body) require.NoError(t, err) assert.Equal(t, append(expectedBody, '\n'), actualBody) } func TestBuildRequest_BuildHTTP_SetsInAuth(t testing.T) { bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}} reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(bd) _ = req.SetQueryParam("hello", "wrong") _ = req.SetPathParam("id", "wrong") _ = req.SetHeaderParam("X-Rate-Limit", "wrong") return nil }) auth := runtime.ClientAuthInfoWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(bd) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.buildHTTP(runtime.JSONMime, "", testProducers, nil, auth) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody, err := json.Marshal(bd) require.NoError(t, err) actualBody, err := io.ReadAll(req.Body) require.NoError(t, err) assert.Equal(t, append(expectedBody, '\n'), actualBody) } func TestBuildRequest_BuildHTTP_XMLPayload(t testing.T) { bd := []struct { XMLName xml.Name `xml:"person"` Name string `xml:"name"` Hobby string `xml:"hobby"` }{{xml.Name{}, "Tom", "Organ trail"}, {xml.Name{}, "John", "Bird watching"}} reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(bd) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.XMLMime) req, err := r.BuildHTTP(runtime.XMLMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody, err := xml.Marshal(bd) require.NoError(t, err) actualBody, err := io.ReadAll(req.Body) require.NoError(t, err) assert.Equal(t, expectedBody, actualBody) } func TestBuildRequest_BuildHTTP_TextPayload(t testing.T) { const bd = "Tom: Organ trail; John: Bird watching" reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(bd) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.TextMime) req, err := r.BuildHTTP(runtime.TextMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody := []byte(bd) actualBody, err := io.ReadAll(req.Body) require.NoError(t, err) assert.Equal(t, expectedBody, actualBody) } func TestBuildRequest_BuildHTTP_Form(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expected := []byte("something=some+value") actual, _ := io.ReadAll(req.Body) assert.Equal(t, expected, actual) } func TestBuildRequest_BuildHTTP_Form_URLEncoded(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.URLencodedFormMime) req, err := r.BuildHTTP(runtime.URLencodedFormMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, runtime.URLencodedFormMime, req.Header.Get(runtime.HeaderContentType)) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expected := []byte("something=some+value") actual, _ := io.ReadAll(req.Body) assert.Equal(t, expected, actual) } func TestBuildRequest_BuildHTTP_Form_Content_Length(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) assert.Condition(t, func() bool { return req.ContentLength > 0 }, "ContentLength must great than 0. got %d", req.ContentLength) expected := []byte("something=some+value") actual, _ := io.ReadAll(req.Body) assert.Equal(t, expected, actual) } func TestBuildRequest_BuildHTTP_FormMultipart(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime) req, err := r.BuildHTTP(runtime.MultipartFormMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expected1 := []byte("Content-Disposition: form-data; name=\"something\"") expected2 := []byte("some value") actual, err := io.ReadAll(req.Body) require.NoError(t, err) actuallines := bytes.Split(actual, []byte("\r\n")) assert.Len(t, actuallines, 6) boundary := string(actuallines[0]) lastboundary := string(actuallines[4]) assert.True(t, strings.HasPrefix(boundary, "--")) assert.True(t, strings.HasPrefix(lastboundary, "--") && strings.HasSuffix(lastboundary, "--")) assert.Equal(t, lastboundary, boundary+"--") assert.Equal(t, expected1, actuallines[1]) assert.Equal(t, expected2, actuallines[3]) } func TestBuildRequest_BuildHTTP_FormMultiples(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value", "another value") _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime) req, err := r.BuildHTTP(runtime.MultipartFormMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expected1 := []byte("Content-Disposition: form-data; name=\"something\"") expected2 := []byte("some value") expected3 := []byte("another value") actual, err := io.ReadAll(req.Body) require.NoError(t, err) actuallines := bytes.Split(actual, []byte("\r\n")) assert.Len(t, actuallines, 10) boundary := string(actuallines[0]) lastboundary := string(actuallines[8]) assert.True(t, strings.HasPrefix(boundary, "--")) assert.True(t, strings.HasPrefix(lastboundary, "--") && strings.HasSuffix(lastboundary, "--")) assert.Equal(t, lastboundary, boundary+"--") assert.Equal(t, expected1, actuallines[1]) assert.Equal(t, expected2, actuallines[3]) assert.Equal(t, actuallines[0], actuallines[4]) assert.Equal(t, expected1, actuallines[5]) assert.Equal(t, expected3, actuallines[7]) } func TestBuildRequest_BuildHTTP_Files(t testing.T) { cont, err := os.ReadFile("./runtime.go") require.NoError(t, err) cont2, err := os.ReadFile("./request.go") require.NoError(t, err) emptyFile, err := os.CreateTemp("", "empty") require.NoError(t, err) reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetFileParam("file", mustGetFile("./runtime.go")) _ = req.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go")) _ = req.SetFileParam("empty", emptyFile) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType)) require.NoError(t, err) assert.Equal(t, runtime.MultipartFormMime, mediaType) boundary := params["boundary"] mr := multipart.NewReader(req.Body, boundary) defer req.Body.Close() frm, err := mr.ReadForm(1 << 20) require.NoError(t, err) assert.Equal(t, "some value", frm.Value["something"][0]) fileverifier := func(name string, index int, filename string, content []byte) { mpff := frm.File[name][index] mpf, e := mpff.Open() require.NoError(t, e) defer mpf.Close() assert.Equal(t, filename, mpff.Filename) actual, e := io.ReadAll(mpf) require.NoError(t, e) assert.Equal(t, content, actual) } fileverifier("file", 0, "runtime.go", cont) fileverifier("otherfiles", 0, "runtime.go", cont) fileverifier("otherfiles", 1, "request.go", cont2) fileverifier("empty", 0, filepath.Base(emptyFile.Name()), []byte{}) } func TestBuildRequest_BuildHTTP_Files_URLEncoded(t testing.T) { cont, err := os.ReadFile("./runtime.go") require.NoError(t, err) cont2, err := os.ReadFile("./request.go") require.NoError(t, err) reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetFormParam("something", "some value") _ = req.SetFileParam("file", mustGetFile("./runtime.go")) _ = req.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go")) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.URLencodedFormMime) req, err := r.BuildHTTP(runtime.URLencodedFormMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType)) require.NoError(t, err) assert.Equal(t, runtime.URLencodedFormMime, mediaType) boundary := params["boundary"] mr := multipart.NewReader(req.Body, boundary) defer req.Body.Close() frm, err := mr.ReadForm(1 << 20) require.NoError(t, err) assert.Equal(t, "some value", frm.Value["something"][0]) fileverifier := func(name string, index int, filename string, content []byte) { mpff := frm.File[name][index] mpf, e := mpff.Open() require.NoError(t, e) defer mpf.Close() assert.Equal(t, filename, mpff.Filename) actual, e := io.ReadAll(mpf) require.NoError(t, e) assert.Equal(t, content, actual) } fileverifier("file", 0, "runtime.go", cont) fileverifier("otherfiles", 0, "runtime.go", cont) fileverifier("otherfiles", 1, "request.go", cont2) } type contentTypeProvider struct { runtime.NamedReadCloser contentType string } func (p contentTypeProvider) ContentType() string { return p.contentType } func TestBuildRequest_BuildHTTP_File_ContentType(t testing.T) { cont, err := os.ReadFile("./runtime.go") require.NoError(t, err) cont2, err := os.ReadFile("./request.go") require.NoError(t, err) reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetPathParam("id", "1234") _ = req.SetFileParam("file1", contentTypeProvider{ NamedReadCloser: mustGetFile("./runtime.go"), contentType: "application/octet-stream", }) _ = req.SetFileParam("file2", mustGetFile("./request.go")) return nil }) r := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr) _ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "/flats/1234/", req.URL.Path) mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType)) require.NoError(t, err) assert.Equal(t, runtime.MultipartFormMime, mediaType) boundary := params["boundary"] mr := multipart.NewReader(req.Body, boundary) defer req.Body.Close() frm, err := mr.ReadForm(1 << 20) require.NoError(t, err) fileverifier := func(name string, index int, filename string, content []byte, contentType string) { mpff := frm.File[name][index] mpf, e := mpff.Open() require.NoError(t, e) defer mpf.Close() assert.Equal(t, filename, mpff.Filename) actual, e := io.ReadAll(mpf) require.NoError(t, e) assert.Equal(t, content, actual) assert.Equal(t, mpff.Header.Get("Content-Type"), contentType) } fileverifier("file1", 0, "runtime.go", cont, "application/octet-stream") fileverifier("file2", 0, "request.go", cont2, "text/plain; charset=utf-8") } func TestBuildRequest_BuildHTTP_BasePath(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/basepath/flats/1234/", req.URL.Path) } func TestBuildRequest_BuildHTTP_EscapedPath(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234/?&^%") _ = req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/basepath/flats/1234/?&^%/", req.URL.Path) assert.Equal(t, "/basepath/flats/1234%2F%3F%2A&%5E%25/", req.URL.RawPath) assert.Equal(t, req.URL.RawPath, req.URL.EscapedPath()) } func TestBuildRequest_BuildHTTP_BasePathWithQueryParameters(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?foo=bar", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "bar", req.URL.Query().Get("foo")) assert.Equal(t, "/basepath/flats/1234/", req.URL.Path) } func TestBuildRequest_BuildHTTP_PathPatternWithQueryParameters(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "world") _ = req.SetPathParam("id", "1234") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/?foo=bar", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "bar", req.URL.Query().Get("foo")) assert.Equal(t, "/basepath/flats/1234/", req.URL.Path) } func TestBuildRequest_BuildHTTP_StaticParametersPathPatternPrevails(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetPathParam("id", "1234") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/?hello=world", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?hello=kitty", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/basepath/flats/1234/", req.URL.Path) } func TestBuildRequest_BuildHTTP_StaticParametersConflictClientPrevails(t testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { _ = req.SetBodyParam(nil) _ = req.SetQueryParam("hello", "there") _ = req.SetPathParam("id", "1234") return nil }) r := newRequest(http.MethodPost, "/flats/{id}/?hello=world", reqWrtr) req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?hello=kitty", testProducers, nil) require.NoError(t, err) require.NotNil(t, req) assert.Equal(t, "there", req.URL.Query().Get("hello")) assert.Equal(t, "/basepath/flats/1234/", req.URL.Path) } type testReqFn func(testing.T, http.Request) type testRoundTripper struct { tr http.RoundTripper testFn testReqFn testHarness testing.T } func (t testRoundTripper) RoundTrip(req http.Request) (resp http.Response, err error) { t.testFn(t.testHarness, req) return t.tr.RoundTrip(req) } func TestGetBodyCallsBeforeRoundTrip(t testing.T) { server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.WriteHeader(http.StatusCreated) _, err := rw.Write([]byte("test result")) require.NoError(t, err) })) defer server.Close() hu, err := url.Parse(server.URL) require.NoError(t, err) client := http.DefaultClient transport := http.DefaultTransport client.Transport = &testRoundTripper{ tr: transport, testHarness: t, testFn: func(t testing.T, req http.Request) { // Read the body once before sending the request body, e := req.GetBody() require.NoError(t, e) bodyContent, e := io.ReadAll(io.Reader(body)) require.NoError(t, e) require.Len(t, bodyContent, int(req.ContentLength)) require.EqualValues(t, "\"test body\"\n", string(bodyContent)) // Read the body a second time before sending the request body, e = req.GetBody() require.NoError(t, e) bodyContent, e = io.ReadAll(io.Reader(body)) require.NoError(t, e) require.Len(t, bodyContent, int(req.ContentLength)) require.EqualValues(t, "\"test body\"\n", string(bodyContent)) }, } rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return req.SetBodyParam("test body") }) operation := &runtime.ClientOperation{ ID: "getSites", Method: http.MethodPost, PathPattern: "/", Params: rwrtr, Client: client, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusCreated { var res string if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("unexpected error code") }), } openAPIClient := New(hu.Host, "/", []string{schemeHTTP}) res, err := openAPIClient.Submit(operation) require.NoError(t, err) actual := res.(string) require.EqualValues(t, "test result", actual) }	26.41 KB	2025-05-25 12:27
📄 response.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "io" "net/http" "github.com/go-openapi/runtime" ) var _ runtime.ClientResponse = response{} func newResponse(resp http.Response) runtime.ClientResponse { return response{resp: resp} } type response struct { resp http.Response } func (r response) Code() int { return r.resp.StatusCode } func (r response) Message() string { return r.resp.Status } func (r response) GetHeader(name string) string { return r.resp.Header.Get(name) } func (r response) GetHeaders(name string) []string { return r.resp.Header.Values(name) } func (r response) Body() io.ReadCloser { return r.resp.Body }	1.2 KB	2025-05-25 12:27
📄 response_test.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "bytes" "io" "net/http" "testing" "github.com/stretchr/testify/assert" "github.com/go-openapi/runtime" ) func TestResponse(t *testing.T) { under := new(http.Response) under.Status = "the status message" under.StatusCode = 392 under.Header = make(http.Header) under.Header.Set("Blah", "blahblah") under.Body = io.NopCloser(bytes.NewBufferString("some content")) var resp runtime.ClientResponse = response{under} assert.EqualValues(t, under.StatusCode, resp.Code()) assert.Equal(t, under.Status, resp.Message()) assert.Equal(t, "blahblah", resp.GetHeader("blah")) assert.Equal(t, []string{"blahblah"}, resp.GetHeaders("blah")) assert.Equal(t, under.Body, resp.Body()) }	1.28 KB	2025-05-25 12:27
📄 runtime.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "context" "crypto" "crypto/ecdsa" "crypto/rsa" "crypto/tls" "crypto/x509" "encoding/pem" "errors" "fmt" "mime" "net/http" "net/http/httputil" "os" "strings" "sync" "time" "github.com/go-openapi/strfmt" "github.com/opentracing/opentracing-go" "github.com/go-openapi/runtime" "github.com/go-openapi/runtime/logger" "github.com/go-openapi/runtime/middleware" "github.com/go-openapi/runtime/yamlpc" ) const ( schemeHTTP = "http" schemeHTTPS = "https" ) // TLSClientOptions to configure client authentication with mutual TLS type TLSClientOptions struct { // Certificate is the path to a PEM-encoded certificate to be used for // client authentication. If set then Key must also be set. Certificate string // LoadedCertificate is the certificate to be used for client authentication. // This field is ignored if Certificate is set. If this field is set, LoadedKey // is also required. LoadedCertificate x509.Certificate // Key is the path to an unencrypted PEM-encoded private key for client // authentication. This field is required if Certificate is set. Key string // LoadedKey is the key for client authentication. This field is required if // LoadedCertificate is set. LoadedKey crypto.PrivateKey // CA is a path to a PEM-encoded certificate that specifies the root certificate // to use when validating the TLS certificate presented by the server. If this field // (and LoadedCA) is not set, the system certificate pool is used. This field is ignored if LoadedCA // is set. CA string // LoadedCA specifies the root certificate to use when validating the server's TLS certificate. // If this field (and CA) is not set, the system certificate pool is used. LoadedCA x509.Certificate // LoadedCAPool specifies a pool of RootCAs to use when validating the server's TLS certificate. // If set, it will be combined with the other loaded certificates (see LoadedCA and CA). // If neither LoadedCA or CA is set, the provided pool with override the system // certificate pool. // The caller must not use the supplied pool after calling TLSClientAuth. LoadedCAPool x509.CertPool // ServerName specifies the hostname to use when verifying the server certificate. // If this field is set then InsecureSkipVerify will be ignored and treated as // false. ServerName string // InsecureSkipVerify controls whether the certificate chain and hostname presented // by the server are validated. If true, any certificate is accepted. InsecureSkipVerify bool // VerifyPeerCertificate, if not nil, is called after normal // certificate verification. It receives the raw ASN.1 certificates // provided by the peer and also any verified chains that normal processing found. // If it returns a non-nil error, the handshake is aborted and that error results. // // If normal verification fails then the handshake will abort before // considering this callback. If normal verification is disabled by // setting InsecureSkipVerify then this callback will be considered but // the verifiedChains argument will always be nil. VerifyPeerCertificate func(rawCerts [][]byte, verifiedChains [][]x509.Certificate) error // SessionTicketsDisabled may be set to true to disable session ticket and // PSK (resumption) support. Note that on clients, session ticket support is // also disabled if ClientSessionCache is nil. SessionTicketsDisabled bool // ClientSessionCache is a cache of ClientSessionState entries for TLS // session resumption. It is only used by clients. ClientSessionCache tls.ClientSessionCache // Prevents callers using unkeyed fields. _ struct{} } // TLSClientAuth creates a tls.Config for mutual auth func TLSClientAuth(opts TLSClientOptions) (tls.Config, error) { // create client tls config cfg := &tls.Config{ MinVersion: tls.VersionTLS12, } // load client cert if specified if opts.Certificate != "" { cert, err := tls.LoadX509KeyPair(opts.Certificate, opts.Key) if err != nil { return nil, fmt.Errorf("tls client cert: %v", err) } cfg.Certificates = []tls.Certificate{cert} } else if opts.LoadedCertificate != nil { block := pem.Block{Type: "CERTIFICATE", Bytes: opts.LoadedCertificate.Raw} certPem := pem.EncodeToMemory(&block) var keyBytes []byte switch k := opts.LoadedKey.(type) { case rsa.PrivateKey: keyBytes = x509.MarshalPKCS1PrivateKey(k) case ecdsa.PrivateKey: var err error keyBytes, err = x509.MarshalECPrivateKey(k) if err != nil { return nil, fmt.Errorf("tls client priv key: %v", err) } default: return nil, errors.New("tls client priv key: unsupported key type") } block = pem.Block{Type: "PRIVATE KEY", Bytes: keyBytes} keyPem := pem.EncodeToMemory(&block) cert, err := tls.X509KeyPair(certPem, keyPem) if err != nil { return nil, fmt.Errorf("tls client cert: %v", err) } cfg.Certificates = []tls.Certificate{cert} } cfg.InsecureSkipVerify = opts.InsecureSkipVerify cfg.VerifyPeerCertificate = opts.VerifyPeerCertificate cfg.SessionTicketsDisabled = opts.SessionTicketsDisabled cfg.ClientSessionCache = opts.ClientSessionCache // When no CA certificate is provided, default to the system cert pool // that way when a request is made to a server known by the system trust store, // the name is still verified switch { case opts.LoadedCA != nil: caCertPool := basePool(opts.LoadedCAPool) caCertPool.AddCert(opts.LoadedCA) cfg.RootCAs = caCertPool case opts.CA != "": // load ca cert caCert, err := os.ReadFile(opts.CA) if err != nil { return nil, fmt.Errorf("tls client ca: %v", err) } caCertPool := basePool(opts.LoadedCAPool) caCertPool.AppendCertsFromPEM(caCert) cfg.RootCAs = caCertPool case opts.LoadedCAPool != nil: cfg.RootCAs = opts.LoadedCAPool } // apply servername overrride if opts.ServerName != "" { cfg.InsecureSkipVerify = false cfg.ServerName = opts.ServerName } return cfg, nil } func basePool(pool x509.CertPool) x509.CertPool { if pool == nil { return x509.NewCertPool() } return pool } // TLSTransport creates a http client transport suitable for mutual tls auth func TLSTransport(opts TLSClientOptions) (http.RoundTripper, error) { cfg, err := TLSClientAuth(opts) if err != nil { return nil, err } return &http.Transport{TLSClientConfig: cfg}, nil } // TLSClient creates a http.Client for mutual auth func TLSClient(opts TLSClientOptions) (http.Client, error) { transport, err := TLSTransport(opts) if err != nil { return nil, err } return &http.Client{Transport: transport}, nil } // DefaultTimeout the default request timeout var DefaultTimeout = 30 * time.Second // Runtime represents an API client that uses the transport // to make http requests based on a swagger specification. type Runtime struct { DefaultMediaType string DefaultAuthentication runtime.ClientAuthInfoWriter Consumers map[string]runtime.Consumer Producers map[string]runtime.Producer Transport http.RoundTripper Jar http.CookieJar // Spec spec.Document Host string BasePath string Formats strfmt.Registry Context context.Context //nolint:containedctx // we precisely want this type to contain the request context Debug bool logger logger.Logger clientOnce sync.Once client http.Client schemes []string response ClientResponseFunc } // New creates a new default runtime for a swagger api runtime.Client func New(host, basePath string, schemes []string) Runtime { var rt Runtime rt.DefaultMediaType = runtime.JSONMime // TODO: actually infer this stuff from the spec rt.Consumers = map[string]runtime.Consumer{ runtime.YAMLMime: yamlpc.YAMLConsumer(), runtime.JSONMime: runtime.JSONConsumer(), runtime.XMLMime: runtime.XMLConsumer(), runtime.TextMime: runtime.TextConsumer(), runtime.HTMLMime: runtime.TextConsumer(), runtime.CSVMime: runtime.CSVConsumer(), runtime.DefaultMime: runtime.ByteStreamConsumer(), } rt.Producers = map[string]runtime.Producer{ runtime.YAMLMime: yamlpc.YAMLProducer(), runtime.JSONMime: runtime.JSONProducer(), runtime.XMLMime: runtime.XMLProducer(), runtime.TextMime: runtime.TextProducer(), runtime.HTMLMime: runtime.TextProducer(), runtime.CSVMime: runtime.CSVProducer(), runtime.DefaultMime: runtime.ByteStreamProducer(), } rt.Transport = http.DefaultTransport rt.Jar = nil rt.Host = host rt.BasePath = basePath rt.Context = context.Background() rt.clientOnce = new(sync.Once) if !strings.HasPrefix(rt.BasePath, "/") { rt.BasePath = "/" + rt.BasePath } rt.Debug = logger.DebugEnabled() rt.logger = logger.StandardLogger{} rt.response = newResponse if len(schemes) > 0 { rt.schemes = schemes } return &rt } // NewWithClient allows you to create a new transport with a configured http.Client func NewWithClient(host, basePath string, schemes []string, client http.Client) Runtime { rt := New(host, basePath, schemes) if client != nil { rt.clientOnce.Do(func() { rt.client = client }) } return rt } // WithOpenTracing adds opentracing support to the provided runtime. // A new client span is created for each request. // If the context of the client operation does not contain an active span, no span is created. // The provided opts are applied to each spans - for example to add global tags. func (r Runtime) WithOpenTracing(opts ...opentracing.StartSpanOption) runtime.ClientTransport { return newOpenTracingTransport(r, r.Host, opts) } // WithOpenTelemetry adds opentelemetry support to the provided runtime. // A new client span is created for each request. // If the context of the client operation does not contain an active span, no span is created. // The provided opts are applied to each spans - for example to add global tags. func (r Runtime) WithOpenTelemetry(opts ...OpenTelemetryOpt) runtime.ClientTransport { return newOpenTelemetryTransport(r, r.Host, opts) } func (r Runtime) pickScheme(schemes []string) string { if v := r.selectScheme(r.schemes); v != "" { return v } if v := r.selectScheme(schemes); v != "" { return v } return schemeHTTP } func (r Runtime) selectScheme(schemes []string) string { schLen := len(schemes) if schLen == 0 { return "" } scheme := schemes[0] // prefer https, but skip when not possible if scheme != schemeHTTPS && schLen > 1 { for _, sch := range schemes { if sch == schemeHTTPS { scheme = sch break } } } return scheme } func transportOrDefault(left, right http.RoundTripper) http.RoundTripper { if left == nil { return right } return left } // EnableConnectionReuse drains the remaining body from a response // so that go will reuse the TCP connections. // // This is not enabled by default because there are servers where // the response never gets closed and that would make the code hang forever. // So instead it's provided as a http client middleware that can be used to override // any request. func (r Runtime) EnableConnectionReuse() { if r.client == nil { r.Transport = KeepAliveTransport( transportOrDefault(r.Transport, http.DefaultTransport), ) return } r.client.Transport = KeepAliveTransport( transportOrDefault(r.client.Transport, transportOrDefault(r.Transport, http.DefaultTransport), ), ) } // takes a client operation and creates equivalent http.Request func (r Runtime) createHttpRequest(operation runtime.ClientOperation) (request, http.Request, error) { //nolint:revive,stylecheck params, _, auth := operation.Params, operation.Reader, operation.AuthInfo request := newRequest(operation.Method, operation.PathPattern, params) var accept []string accept = append(accept, operation.ProducesMediaTypes...) if err := request.SetHeaderParam(runtime.HeaderAccept, accept...); err != nil { return nil, nil, err } if auth == nil && r.DefaultAuthentication != nil { auth = runtime.ClientAuthInfoWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { if req.GetHeaderParams().Get(runtime.HeaderAuthorization) != "" { return nil } return r.DefaultAuthentication.AuthenticateRequest(req, reg) }) } // if auth != nil { // if err := auth.AuthenticateRequest(request, r.Formats); err != nil { // return nil, err // } //} // TODO: pick appropriate media type cmt := r.DefaultMediaType for _, mediaType := range operation.ConsumesMediaTypes { // Pick first non-empty media type if mediaType != "" { cmt = mediaType break } } if _, ok := r.Producers[cmt]; !ok && cmt != runtime.MultipartFormMime && cmt != runtime.URLencodedFormMime { return nil, nil, fmt.Errorf("none of producers: %v registered. try %s", r.Producers, cmt) } req, err := request.buildHTTP(cmt, r.BasePath, r.Producers, r.Formats, auth) if err != nil { return nil, nil, err } req.URL.Scheme = r.pickScheme(operation.Schemes) req.URL.Host = r.Host req.Host = r.Host return request, req, nil } func (r Runtime) CreateHttpRequest(operation runtime.ClientOperation) (req http.Request, err error) { //nolint:revive,stylecheck _, req, err = r.createHttpRequest(operation) return } // Submit a request and when there is a body on success it will turn that into the result // all other things are turned into an api error for swagger which retains the status code func (r Runtime) Submit(operation runtime.ClientOperation) (interface{}, error) { _, readResponse, _ := operation.Params, operation.Reader, operation.AuthInfo request, req, err := r.createHttpRequest(operation) if err != nil { return nil, err } r.clientOnce.Do(func() { r.client = &http.Client{ Transport: r.Transport, Jar: r.Jar, } }) if r.Debug { b, err2 := httputil.DumpRequestOut(req, true) if err2 != nil { return nil, err2 } r.logger.Debugf("%s\n", string(b)) } var parentCtx context.Context switch { case operation.Context != nil: parentCtx = operation.Context case r.Context != nil: parentCtx = r.Context default: parentCtx = context.Background() } var ( ctx context.Context cancel context.CancelFunc ) if request.timeout == 0 { // There may be a deadline in the context passed to the operation. // Otherwise, there is no timeout set. ctx, cancel = context.WithCancel(parentCtx) } else { // Sets the timeout passed from request params (by default runtime.DefaultTimeout). // If there is already a deadline in the parent context, the shortest will // apply. ctx, cancel = context.WithTimeout(parentCtx, request.timeout) } defer cancel() var client http.Client if operation.Client != nil { client = operation.Client } else { client = r.client } req = req.WithContext(ctx) res, err := client.Do(req) // make requests, by default follows 10 redirects before failing if err != nil { return nil, err } defer res.Body.Close() ct := res.Header.Get(runtime.HeaderContentType) if ct == "" { // this should really never occur ct = r.DefaultMediaType } if r.Debug { printBody := true if ct == runtime.DefaultMime { printBody = false // Spare the terminal from a binary blob. } b, err2 := httputil.DumpResponse(res, printBody) if err2 != nil { return nil, err2 } r.logger.Debugf("%s\n", string(b)) } mt, _, err := mime.ParseMediaType(ct) if err != nil { return nil, fmt.Errorf("parse content type: %s", err) } cons, ok := r.Consumers[mt] if !ok { if cons, ok = r.Consumers["/"]; !ok { // scream about not knowing what to do return nil, fmt.Errorf("no consumer: %q", ct) } } return readResponse.ReadResponse(r.response(res), cons) } // SetDebug changes the debug flag. // It ensures that client and middlewares have the set debug level. func (r Runtime) SetDebug(debug bool) { r.Debug = debug middleware.Debug = debug } // SetLogger changes the logger stream. // It ensures that client and middlewares use the same logger. func (r Runtime) SetLogger(logger logger.Logger) { r.logger = logger middleware.Logger = logger } type ClientResponseFunc = func(http.Response) runtime.ClientResponse //nolint:revive // SetResponseReader changes the response reader implementation. func (r *Runtime) SetResponseReader(f ClientResponseFunc) { if f == nil { return } r.response = f }	16.49 KB	2025-05-25 12:27
📄 runtime_test.go // Copyright 2015 go-swagger maintainers // // 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 client import ( "bytes" "context" "encoding/json" "encoding/xml" "errors" "fmt" "io" "net/http" "net/http/cookiejar" "net/http/httptest" "net/url" "testing" "time" "github.com/go-openapi/runtime" "github.com/go-openapi/strfmt" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const ( token = "the-super-secret-token" bearerToken = "Bearer " + token charsetUTF8 = ";charset=utf-8" ) // task This describes a task. Tasks require a content property to be set. type task struct { // Completed Completed bool `json:"completed" xml:"completed"` // Content Task content can contain [GFM](https://help.github.com/articles/github-flavored-markdown/). Content string `json:"content" xml:"content"` // ID This id property is autogenerated when a task is created. ID int64 `json:"id" xml:"id"` } type testCtxKey uint8 const rtKey testCtxKey = 1 func TestRuntime_Concurrent(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) require.NoError(t, jsongen.Encode(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) resCC := make(chan interface{}) errCC := make(chan error) var res interface{} for j := 0; j < 6; j++ { go func() { resC := make(chan interface{}) errC := make(chan error) go func() { var resp interface{} var errp error for i := 0; i < 3; i++ { resp, errp = rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) <-time.After(100 * time.Millisecond) } resC <- resp errC <- errp }() resCC <- <-resC errCC <- <-errC }() } c := 6 for c > 0 { res = <-resCC err = <-errCC c-- } require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_Canary(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) require.NoError(t, jsongen.Encode(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } type tasks struct { Tasks []task `xml:"task"` } func TestRuntime_XMLCanary(t testing.T) { // test that it can make a simple XML request // and get the response for it. result := tasks{ Tasks: []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, }, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.XMLMime) rw.WriteHeader(http.StatusOK) xmlgen := xml.NewEncoder(rw) require.NoError(t, xmlgen.Encode(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res tasks if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, tasks{}, res) actual := res.(tasks) assert.EqualValues(t, result, actual) } func TestRuntime_TextCanary(t testing.T) { // test that it can make a simple text request // and get the response for it. result := "1: task 1 content; 2: task 2 content" server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.TextMime) rw.WriteHeader(http.StatusOK) _, _ = rw.Write([]byte(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res string if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, "", res) actual := res.(string) assert.EqualValues(t, result, actual) } func TestRuntime_CSVCanary(t testing.T) { // test that it can make a simple csv request // and get the response for it. result := `task,content,result 1,task1,ok 2,task2,fail ` server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.CSVMime) rw.WriteHeader(http.StatusOK) _, _ = rw.Write([]byte(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res bytes.Buffer if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, bytes.Buffer{}, res) actual := res.(bytes.Buffer) assert.EqualValues(t, result, actual.String()) } type roundTripperFunc func(http.Request) (http.Response, error) func (fn roundTripperFunc) RoundTrip(req http.Request) (http.Response, error) { return fn(req) } func TestRuntime_CustomTransport(t testing.T) { rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } rt := New("localhost:3245", "/", []string{"ws", "wss", schemeHTTPS}) rt.Transport = roundTripperFunc(func(req http.Request) (http.Response, error) { if req.URL.Scheme != schemeHTTPS { return nil, errors.New("this was not a https request") } assert.Equal(t, "localhost:3245", req.Host) assert.Equal(t, "localhost:3245", req.URL.Host) var resp http.Response resp.StatusCode = http.StatusOK resp.Header = make(http.Header) resp.Header.Set("content-type", "application/json") buf := bytes.NewBuffer(nil) enc := json.NewEncoder(buf) require.NoError(t, enc.Encode(result)) resp.Body = io.NopCloser(buf) return &resp, nil }) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Schemes: []string{"ws", "wss", schemeHTTPS}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_CustomCookieJar(t testing.T) { server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { authenticated := false for _, cookie := range req.Cookies() { if cookie.Name == "sessionid" && cookie.Value == "abc" { authenticated = true } } if !authenticated { username, password, ok := req.BasicAuth() if ok && username == "username" && password == "password" { authenticated = true http.SetCookie(rw, &http.Cookie{Name: "sessionid", Value: "abc"}) } } if authenticated { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) require.NoError(t, jsongen.Encode([]task{})) } else { rw.WriteHeader(http.StatusUnauthorized) } })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) rt.Jar, err = cookiejar.New(nil) require.NoError(t, err) submit := func(authInfo runtime.ClientAuthInfoWriter) { _, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: rwrtr, AuthInfo: authInfo, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, _ runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { return map[string]interface{}{}, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) } submit(BasicAuth("username", "password")) submit(nil) } func TestRuntime_AuthCanary(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.Header.Get(runtime.HeaderAuthorization) != bearerToken { rw.WriteHeader(http.StatusUnauthorized) return } rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) require.NoError(t, jsongen.Encode(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), AuthInfo: BearerToken(token), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_PickConsumer(t testing.T) { result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.Header.Get("Content-Type") != "application/octet-stream" { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+charsetUTF8) rw.WriteHeader(http.StatusBadRequest) return } rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+charsetUTF8) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) _ = jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return req.SetBodyParam(bytes.NewBufferString("hello")) }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "POST", PathPattern: "/", Schemes: []string{schemeHTTP}, ConsumesMediaTypes: []string{"application/octet-stream"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), AuthInfo: BearerToken(token), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_ContentTypeCanary(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.Header.Get(runtime.HeaderAuthorization) != bearerToken { rw.WriteHeader(http.StatusBadRequest) return } rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+charsetUTF8) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) _ = jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Schemes: []string{schemeHTTP}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), AuthInfo: BearerToken(token), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_ChunkedResponse(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.Header.Get(runtime.HeaderAuthorization) != bearerToken { rw.WriteHeader(http.StatusBadRequest) return } rw.Header().Add(runtime.HeaderTransferEncoding, "chunked") rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+charsetUTF8) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) _ = jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) // specDoc, err := spec.Load("../../fixtures/codegen/todolist.simple.yml") hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Schemes: []string{schemeHTTP}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), AuthInfo: BearerToken(token), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_DebugValue(t testing.T) { t.Run("empty DEBUG means Debug is False", func(t testing.T) { t.Setenv("DEBUG", "") runtime := New("", "/", []string{schemeHTTPS}) assert.False(t, runtime.Debug) }) t.Run("non-Empty DEBUG means Debug is True", func(t testing.T) { t.Run("with numerical value", func(t testing.T) { t.Setenv("DEBUG", "1") runtime := New("", "/", []string{schemeHTTPS}) assert.True(t, runtime.Debug) }) t.Run("with boolean value true", func(t testing.T) { t.Setenv("DEBUG", "true") runtime := New("", "/", []string{schemeHTTPS}) assert.True(t, runtime.Debug) }) t.Run("with boolean value false", func(t testing.T) { t.Setenv("DEBUG", "false") runtime := New("", "/", []string{schemeHTTPS}) assert.False(t, runtime.Debug) }) t.Run("with string value ", func(t testing.T) { t.Setenv("DEBUG", "foo") runtime := New("", "/", []string{schemeHTTPS}) assert.True(t, runtime.Debug) }) }) } func TestRuntime_OverrideScheme(t testing.T) { runtime := New("", "/", []string{schemeHTTPS}) sch := runtime.pickScheme([]string{schemeHTTP}) assert.Equal(t, schemeHTTPS, sch) } func TestRuntime_OverrideClient(t testing.T) { client := &http.Client{} runtime := NewWithClient("", "/", []string{schemeHTTPS}, client) var i int runtime.clientOnce.Do(func() { i++ }) assert.Equal(t, client, runtime.client) assert.Equal(t, 0, i) } type overrideRoundTripper struct { overridden bool } func (o overrideRoundTripper) RoundTrip(_ http.Request) (http.Response, error) { o.overridden = true res := new(http.Response) res.StatusCode = http.StatusOK res.Body = io.NopCloser(bytes.NewBufferString("OK")) return res, nil } func TestRuntime_OverrideClientOperation(t testing.T) { client := &http.Client{} rt := NewWithClient("", "/", []string{schemeHTTPS}, client) var i int rt.clientOnce.Do(func() { i++ }) assert.Equal(t, client, rt.client) assert.Equal(t, 0, i) client2 := new(http.Client) var transport = &overrideRoundTripper{} client2.Transport = transport require.NotEqual(t, client, client2) _, err := rt.Submit(&runtime.ClientOperation{ Client: client2, Params: runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }), Reader: runtime.ClientResponseReaderFunc(func(_ runtime.ClientResponse, _ runtime.Consumer) (interface{}, error) { return map[string]interface{}{}, nil }), }) require.NoError(t, err) assert.True(t, transport.overridden) } func TestRuntime_PreserveTrailingSlash(t testing.T) { var redirected bool server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+charsetUTF8) if req.URL.Path == "/api/tasks" { redirected = true return } if req.URL.Path == "/api/tasks/" { rw.WriteHeader(http.StatusOK) } })) defer server.Close() hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) rwrtr := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) _, err = rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/api/tasks/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, _ runtime.Consumer) (interface{}, error) { if redirected { return nil, errors.New("expected Submit to preserve trailing slashes - this caused a redirect") } if response.Code() == http.StatusOK { return map[string]interface{}{}, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) } func TestRuntime_FallbackConsumer(t testing.T) { result := `W3siY29tcGxldGVkIjpmYWxzZSwiY29udGVudCI6ImRHRnpheUF4SUdOdmJuUmxiblE9IiwiaWQiOjF9XQ==` server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, "application/x-task") rw.WriteHeader(http.StatusOK) _, _ = rw.Write([]byte(result)) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return req.SetBodyParam(bytes.NewBufferString("hello")) }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) // without the fallback consumer _, err = rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "POST", PathPattern: "/", Schemes: []string{schemeHTTP}, ConsumesMediaTypes: []string{"application/octet-stream"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []byte if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.Error(t, err) assert.Equal(t, `no consumer: "application/x-task"`, err.Error()) // add the fallback consumer rt.Consumers["/"] = rt.Consumers[runtime.DefaultMime] res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "POST", PathPattern: "/", Schemes: []string{schemeHTTP}, ConsumesMediaTypes: []string{"application/octet-stream"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []byte if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, []byte{}, res) actual := res.([]byte) assert.EqualValues(t, result, actual) } func TestRuntime_AuthHeaderParamDetected(t testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.Header.Get(runtime.HeaderAuthorization) != bearerToken { rw.WriteHeader(http.StatusUnauthorized) return } rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) _ = jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return req.SetHeaderParam(runtime.HeaderAuthorization, bearerToken) }) hu, err := url.Parse(server.URL) require.NoError(t, err) rt := New(hu.Host, "/", []string{schemeHTTP}) rt.DefaultAuthentication = BearerToken("not-the-super-secret-token") res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil } return nil, errors.New("generic error") }), }) require.NoError(t, err) assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } func TestRuntime_Timeout(t testing.T) { //nolint:maintidx // linter evaluates the total lines of code, which is misleading const ( operationID = "getTasks" // these values should be sufficient for most CI engines clientTimeout time.Duration = 25 time.Millisecond serverDelay time.Duration = 100 * time.Millisecond clientNoTimeout time.Duration = 250 * time.Millisecond ctxError = "context deadline exceeded" ) result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } signedContext := func(value string) context.Context { return context.WithValue(context.Background(), rtKey, value) } requestWriter := func(timeout time.Duration) runtime.ClientRequestWriter { // this writer sets the timeout parameter of the ClientRequest return runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return req.SetTimeout(timeout) }) } requestReader := runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() != http.StatusOK { return nil, errors.New("generic error") } var res []task if e := consumer.Consume(response.Body(), &res); e != nil { return nil, e } return res, nil }) t.Run("with timeout specified as a request parameter, no operation context", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = signedContext("test") rt.Transport = testContextTransport(t, true, true, "test") t.Run("should not time out", func(t testing.T) { res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(clientNoTimeout), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out", func(t testing.T) { _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(clientTimeout), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with timeout specified as a request parameter, no context at all", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = nil rt.Transport = testContextTransport(t, true, false, "") t.Run("should not time out", func(t testing.T) { res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(clientNoTimeout), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out", func(t testing.T) { _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(clientTimeout), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with inherited operation context, timeout specified as operation context, request timeout set to 0", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = signedContext("test") rt.Transport = testContextTransport(t, true, true, "test") t.Run("should not time out", func(t testing.T) { operationCtx, cancel := context.WithTimeout(rt.Context, clientNoTimeout) defer cancel() res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter(0), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out", func(t testing.T) { operationCtx, cancel := context.WithTimeout(rt.Context, clientTimeout) defer cancel() _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter(0), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with a fresh operation context, timeout specified as operation context, request timeout set to 0", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = nil rt.Transport = testContextTransport(t, true, false, "") t.Run("should not time out", func(t testing.T) { operationCtx, cancel := context.WithTimeout(context.Background(), clientNoTimeout) defer cancel() res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter(0), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out", func(t testing.T) { operationCtx, cancel := context.WithTimeout(context.Background(), clientTimeout) defer cancel() _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter(0), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with an hypothetical timeout specified as runtime context, no operation context", func(t testing.T) { // in real life, the runtime context may be cancellable for other reasons than timeout host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) t.Run("should not time out", func(t testing.T) { rt := New(host, "/", []string{schemeHTTP}) ctx, cancel := context.WithTimeout(signedContext("test"), clientNoTimeout) defer cancel() rt.Context = ctx rt.Transport = testContextTransport(t, true, true, "test") res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(0), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out", func(t testing.T) { rt := New(host, "/", []string{schemeHTTP}) ctx, cancel := context.WithTimeout(signedContext("test"), clientTimeout) defer cancel() rt.Context = ctx rt.Transport = testContextTransport(t, true, true, "test") _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(0), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with multiple timeouts set, shortest wins", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) runtimeCtx, cancelRuntime := context.WithTimeout(signedContext("test"), clientNoTimeout) rt.Context = runtimeCtx defer cancelRuntime() rt.Transport = testContextTransport(t, true, true, "test") t.Run("should not time out", func(t testing.T) { operationCtx, cancelOperation := context.WithTimeout( signedContext("test"), serverDelay+(clientNoTimeout-serverDelay)/2, ) defer cancelOperation() res, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter(serverDelay + (clientNoTimeout-serverDelay)/3), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, res) }) t.Run("should time out on operation context deadline", func(t testing.T) { // NOTE: we'll be able to catch more precisely which context was canceled // in go1.21 and context.WithTimeoutCause. operationCtx, cancelOperation := context.WithTimeout( signedContext("test"), serverDelay-(clientNoTimeout-serverDelay)/4, // this one times out ) defer cancelOperation() _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter( serverDelay + (clientNoTimeout-serverDelay)/4, ), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) t.Run("should time out on operation timeout param", func(t testing.T) { operationCtx, cancelOperation := context.WithTimeout( signedContext("test"), serverDelay+(clientNoTimeout-serverDelay)/2, ) defer cancelOperation() _, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: operationCtx, Params: requestWriter( serverDelay - (clientNoTimeout-serverDelay)/4, // this one times out ), Reader: requestReader, }) require.Error(t, err) require.ErrorContains(t, err, ctxError) }) }) t.Run("with no context, explicit infinite wait", func(t testing.T) { host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = signedContext("test") rt.Transport = testContextTransport(t, false, true, "test") // verify that no deadline is passed to the emitted context t.Run("should not time out", func(t testing.T) { resp, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestWriter(0), Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, resp) }) }) t.Run("with no context, request uses the default timeout", func(t testing.T) { requestEmptyWriter := runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) host, cleaner := serverBuilder(t, serverDelay, result) t.Cleanup(cleaner) rt := New(host, "/", []string{schemeHTTP}) rt.Context = signedContext("test") rt.Transport = testDefaultsInTransport(t, "test") t.Run("should not time out", func(t testing.T) { resp, err := rt.Submit(&runtime.ClientOperation{ ID: operationID, Context: nil, Params: requestEmptyWriter, // leaves defaults Reader: requestReader, }) require.NoError(t, err) assertResult(result)(t, resp) }) }) } func isContextSigned(ctx context.Context, value string) bool { v, ok := ctx.Value(rtKey).(string) return ok && v == value } func testContextTransport(t testing.T, hasTimeout, expectSigned bool, value string) http.RoundTripper { // inject a round tripper to check the context in the request about to be emitted return roundTripperFunc(func(req http.Request) (http.Response, error) { ctx := req.Context() t.Run("request context should propagate value", func(t testing.T) { assert.Equal(t, expectSigned, isContextSigned(ctx, value), "expected the request context to inherit values") }) t.Run(fmt.Sprintf("request context should have a deadline %t", hasTimeout), func(t testing.T) { _, hasDeadline := ctx.Deadline() assert.Equalf(t, hasTimeout, hasDeadline, "expected request context to have a deadline") }) return http.DefaultTransport.RoundTrip(req) }) } func testDefaultsInTransport(t testing.T, value string) http.RoundTripper { // inject a round tripper to check the context in the request about to be emitted return roundTripperFunc(func(req http.Request) (http.Response, error) { ctx := req.Context() t.Run("request context should propagate value", func(t testing.T) { assert.True(t, isContextSigned(ctx, value), "expected the request context to inherit values") }) t.Run("request context should have a default deadline", func(t testing.T) { deadline, hasDeadline := ctx.Deadline() assert.True(t, hasDeadline, "expected request context to have a deadline") remainingDuration := time.Until(deadline).Seconds() assert.InDeltaf(t, DefaultTimeout.Seconds(), remainingDuration, 1.0, "expected timeout to be set to DefaultTimeout") }) return http.DefaultTransport.RoundTrip(req) }) } func assertResult(result []task) func(testing.TB, interface{}) { return func(t testing.TB, res interface{}) { assert.IsType(t, []task{}, res) actual, ok := res.([]task) require.True(t, ok) assert.EqualValues(t, result, actual) } } func serverBuilder(t testing.TB, delay time.Duration, result []task) (string, func()) { server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { ctx := req.Context() timer := time.NewTimer(delay) select { case <-ctx.Done(): http.Error(rw, ctx.Err().Error(), http.StatusInternalServerError) return case <-timer.C: rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) _ = jsongen.Encode(result) return } })) hu, err := url.Parse(server.URL) require.NoError(t, err) return hu.Host, server.Close }	38.22 KB	2025-05-25 12:27
📄 runtime_tls_test.go package client import ( "crypto" "crypto/tls" "crypto/x509" "encoding/json" "encoding/pem" "errors" "net/http" "net/http/httptest" "net/url" "os" "path/filepath" goruntime "runtime" "testing" "time" "github.com/go-openapi/runtime" "github.com/go-openapi/strfmt" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestRuntimeTLSOptions(t testing.T) { fixtures := newTLSFixtures(t) t.Run("with TLSAuthConfig configured with files", func(t testing.T) { opts := TLSClientOptions{ CA: fixtures.RSA.CAFile, Key: fixtures.RSA.KeyFile, Certificate: fixtures.RSA.CertFile, ServerName: fixtures.Subject, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) assert.Len(t, cfg.Certificates, 1) assert.NotNil(t, cfg.RootCAs) assert.Equal(t, fixtures.Subject, cfg.ServerName) }) t.Run("with loaded TLS material", func(t testing.T) { t.Run("with TLSConfig from loaded RSA key/cert pair", func(t testing.T) { opts := TLSClientOptions{ LoadedKey: fixtures.RSA.LoadedKey, LoadedCertificate: fixtures.RSA.LoadedCert, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) assert.Len(t, cfg.Certificates, 1) }) t.Run("with TLSAuthConfig configured with loaded TLS Elliptic Curve key/certificate", func(t testing.T) { opts := TLSClientOptions{ LoadedKey: fixtures.ECDSA.LoadedKey, LoadedCertificate: fixtures.ECDSA.LoadedCert, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) assert.Len(t, cfg.Certificates, 1) }) t.Run("with TLSAuthConfig configured with loaded Certificate Authority", func(t testing.T) { opts := TLSClientOptions{ LoadedCA: fixtures.RSA.LoadedCA, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) assert.NotNil(t, cfg.RootCAs) }) t.Run("with TLSAuthConfig configured with loaded CA pool", func(t testing.T) { pool := x509.NewCertPool() pool.AddCert(fixtures.RSA.LoadedCA) opts := TLSClientOptions{ LoadedCAPool: pool, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) require.NotNil(t, cfg.RootCAs) require.Equal(t, pool, cfg.RootCAs) }) t.Run("with TLSAuthConfig configured with loaded CA and CA pool", func(t testing.T) { pool := systemCAPool(t) opts := TLSClientOptions{ LoadedCAPool: pool, LoadedCA: fixtures.RSA.LoadedCA, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) require.NotNil(t, cfg.RootCAs) // verify that the CA cert is indeed valid against the configured pool. // NOTE: fixtures may be expired certs, but may validate with a fixed date in the past. chains, err := fixtures.RSA.LoadedCA.Verify(x509.VerifyOptions{ Roots: cfg.RootCAs, CurrentTime: time.Date(2017, 1, 1, 1, 1, 1, 1, time.UTC), }) require.NoError(t, err) require.NotEmpty(t, chains) }) t.Run("with TLSAuthConfig with VerifyPeer option", func(t testing.T) { verify := func(_ [][]byte, _ [][]x509.Certificate) error { return nil } opts := TLSClientOptions{ InsecureSkipVerify: true, VerifyPeerCertificate: verify, } cfg, err := TLSClientAuth(opts) require.NoError(t, err) require.NotNil(t, cfg) assert.True(t, cfg.InsecureSkipVerify) assert.NotNil(t, cfg.VerifyPeerCertificate) }) }) } func TestRuntimeManualCertificateValidation(t testing.T) { // test manual verification of server certificates // against root certificate on client side. // // The client compares the received cert against the root cert, // explicitly omitting DNSName check. fixtures := newTLSFixtures(t) result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } host, clean := testTLSServer(t, fixtures, result) t.Cleanup(clean) var certVerifyCalled bool client := testTLSClient(t, fixtures, &certVerifyCalled) rt := NewWithClient(host, "/", []string{schemeHTTPS}, client) var received []task operation := &runtime.ClientOperation{ ID: "getTasks", Method: http.MethodGet, PathPattern: "/", Params: runtime.ClientRequestWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }), Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == http.StatusOK { if e := consumer.Consume(response.Body(), &received); e != nil { return nil, e } return result, nil } return nil, errors.New("generic error") }), } resp, err := rt.Submit(operation) require.NoError(t, err) require.NotEmpty(t, resp) assert.IsType(t, []task{}, resp) assert.Truef(t, certVerifyCalled, "the client cert verification has not been called") assert.EqualValues(t, result, received) } func testTLSServer(t testing.TB, fixtures tlsFixtures, expectedResult []task) (string, func()) { server := httptest.NewUnstartedServer(http.HandlerFunc(func(rw http.ResponseWriter, _ http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) require.NoError(t, jsongen.Encode(expectedResult)) })) // create server tls config serverCACertPool := x509.NewCertPool() serverCACertPool.AddCert(fixtures.Server.LoadedCA) // load server certs serverCert, err := tls.LoadX509KeyPair( fixtures.Server.CertFile, fixtures.Server.KeyFile, ) require.NoError(t, err) server.TLS = &tls.Config{ RootCAs: serverCACertPool, MinVersion: tls.VersionTLS12, Certificates: []tls.Certificate{serverCert}, } require.NoError(t, err) server.StartTLS() testURL, err := url.Parse(server.URL) require.NoError(t, err) return testURL.Host, server.Close } func testTLSClient(t testing.TB, fixtures tlsFixtures, verifyCalled bool) http.Client { client, err := TLSClient(TLSClientOptions{ InsecureSkipVerify: true, VerifyPeerCertificate: func(rawCerts [][]byte, _ [][]x509.Certificate) error { verifyCalled = true caCertPool := x509.NewCertPool() caCertPool.AddCert(fixtures.RSA.LoadedCA) opts := x509.VerifyOptions{ Roots: caCertPool, CurrentTime: time.Date(2017, time.July, 1, 1, 1, 1, 1, time.UTC), } cert, e := x509.ParseCertificate(rawCerts[0]) if e != nil { return e } _, e = cert.Verify(opts) return e }, }) require.NoError(t, err) return client } type ( tlsFixtures struct { RSA tlsFixture ECDSA tlsFixture Server tlsFixture Subject string } tlsFixture struct { LoadedCA x509.Certificate LoadedCert x509.Certificate LoadedKey crypto.PrivateKey CAFile string KeyFile string CertFile string } ) // newTLSFixtures loads TLS material for testing func newTLSFixtures(t testing.TB) tlsFixtures { const subject = "somewhere" certFixturesDir := filepath.Join("..", "fixtures", "certs") keyFile := filepath.Join(certFixturesDir, "myclient.key") keyPem, err := os.ReadFile(keyFile) require.NoError(t, err) keyDer, _ := pem.Decode(keyPem) require.NotNil(t, keyDer) key, err := x509.ParsePKCS1PrivateKey(keyDer.Bytes) require.NoError(t, err) certFile := filepath.Join(certFixturesDir, "myclient.crt") certPem, err := os.ReadFile(certFile) require.NoError(t, err) certDer, _ := pem.Decode(certPem) require.NotNil(t, certDer) cert, err := x509.ParseCertificate(certDer.Bytes) require.NoError(t, err) eccKeyFile := filepath.Join(certFixturesDir, "myclient-ecc.key") eckeyPem, err := os.ReadFile(eccKeyFile) require.NoError(t, err) _, remainder := pem.Decode(eckeyPem) ecKeyDer, _ := pem.Decode(remainder) require.NotNil(t, ecKeyDer) ecKey, err := x509.ParseECPrivateKey(ecKeyDer.Bytes) require.NoError(t, err) eccCertFile := filepath.Join(certFixturesDir, "myclient-ecc.crt") ecCertPem, err := os.ReadFile(eccCertFile) require.NoError(t, err) ecCertDer, _ := pem.Decode(ecCertPem) require.NotNil(t, ecCertDer) ecCert, err := x509.ParseCertificate(ecCertDer.Bytes) require.NoError(t, err) caFile := filepath.Join(certFixturesDir, "myCA.crt") caPem, err := os.ReadFile(caFile) require.NoError(t, err) caBlock, _ := pem.Decode(caPem) require.NotNil(t, caBlock) caCert, err := x509.ParseCertificate(caBlock.Bytes) require.NoError(t, err) serverKeyFile := filepath.Join(certFixturesDir, "mycert1.key") serverKeyPem, err := os.ReadFile(serverKeyFile) require.NoError(t, err) serverKeyDer, _ := pem.Decode(serverKeyPem) require.NotNil(t, serverKeyDer) serverKey, err := x509.ParsePKCS1PrivateKey(serverKeyDer.Bytes) require.NoError(t, err) serverCertFile := filepath.Join(certFixturesDir, "mycert1.crt") serverCertPem, err := os.ReadFile(serverCertFile) require.NoError(t, err) serverCertDer, _ := pem.Decode(serverCertPem) require.NotNil(t, serverCertDer) serverCert, err := x509.ParseCertificate(serverCertDer.Bytes) require.NoError(t, err) return &tlsFixtures{ Subject: subject, RSA: tlsFixture{ CAFile: caFile, KeyFile: keyFile, CertFile: certFile, LoadedCA: caCert, LoadedKey: key, LoadedCert: cert, }, ECDSA: tlsFixture{ KeyFile: eccKeyFile, CertFile: eccCertFile, LoadedKey: ecKey, LoadedCert: ecCert, }, Server: tlsFixture{ KeyFile: serverKeyFile, CertFile: serverCertFile, LoadedCA: caCert, LoadedKey: serverKey, LoadedCert: serverCert, }, } } func systemCAPool(t testing.TB) x509.CertPool { if goruntime.GOOS == "windows" { // Windows doesn't have the system cert pool. return x509.NewCertPool() } pool, err := x509.SystemCertPool() require.NoError(t, err) return pool }	9.6 KB	2025-05-25 12:27

Terminal