diff --git a/plugins/inputs/nats/nats_test.go b/plugins/inputs/nats/nats_test.go index 588a958e8..37b9618b6 100644 --- a/plugins/inputs/nats/nats_test.go +++ b/plugins/inputs/nats/nats_test.go @@ -71,11 +71,17 @@ func TestMetricsCorrect(t *testing.T) { var acc testutil.Accumulator srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - require.Equal(t, "/varz", r.URL.Path, "Cannot handle request") + if r.URL.Path != "/varz" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, expected: %q, actual: %q", "/varz", r.URL.Path) + return + } - rsp := sampleVarz - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleVarz); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer srv.Close() diff --git a/plugins/inputs/neptune_apex/neptune_apex_test.go b/plugins/inputs/neptune_apex/neptune_apex_test.go index 56d2a66ee..2f52bee7d 100644 --- a/plugins/inputs/neptune_apex/neptune_apex_test.go +++ b/plugins/inputs/neptune_apex/neptune_apex_test.go @@ -16,9 +16,12 @@ import ( func TestGather(t *testing.T) { h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := w.Write([]byte("data")); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusNotFound) - _, err := w.Write([]byte("data")) - require.NoError(t, err) }) c, destroy := fakeHTTPClient(h) defer destroy() @@ -402,11 +405,13 @@ func TestSendRequest(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { t.Parallel() - h := http.HandlerFunc(func( - w http.ResponseWriter, _ *http.Request) { + h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(test.statusCode) - _, err := w.Write([]byte("data")) - require.NoError(t, err) + if _, err := w.Write([]byte("data")); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } }) c, destroy := fakeHTTPClient(h) defer destroy() diff --git a/plugins/inputs/nginx/nginx_test.go b/plugins/inputs/nginx/nginx_test.go index 358fe33de..58f69d9e6 100644 --- a/plugins/inputs/nginx/nginx_test.go +++ b/plugins/inputs/nginx/nginx_test.go @@ -46,11 +46,16 @@ func TestNginxGeneratesMetrics(t *testing.T) { } else if r.URL.Path == "/tengine_status" { rsp = tengineSampleResponse } else { - require.Fail(t, "Cannot handle request") + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, unknown path") + return } - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, rsp); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/nginx_plus/nginx_plus_test.go b/plugins/inputs/nginx_plus/nginx_plus_test.go index 7e5c92b6e..115ff31f0 100644 --- a/plugins/inputs/nginx_plus/nginx_plus_test.go +++ b/plugins/inputs/nginx_plus/nginx_plus_test.go @@ -246,20 +246,22 @@ const sampleStatusResponse = ` } } } -} -` +}` func TestNginxPlusGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - var rsp string + if r.URL.Path != "/status" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, expected: %q, actual: %q", "/status", r.URL.Path) + return + } - require.Equal(t, "/status", r.URL.Path, "Cannot handle request") - - rsp = sampleStatusResponse w.Header()["Content-Type"] = []string{"application/json"} - - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleStatusResponse); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/nginx_plus_api/nginx_plus_api_metrics_test.go b/plugins/inputs/nginx_plus_api/nginx_plus_api_metrics_test.go index 17f3d71d6..0a2a9cbdd 100644 --- a/plugins/inputs/nginx_plus_api/nginx_plus_api_metrics_test.go +++ b/plugins/inputs/nginx_plus_api/nginx_plus_api_metrics_test.go @@ -1496,8 +1496,11 @@ func TestServerError(t *testing.T) { func TestMalformedJSON(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "application/json; charset=utf-8") - _, err := fmt.Fprintln(w, "this is not JSON") - require.NoError(t, err) + if _, err := fmt.Fprintln(w, "this is not JSON"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -1554,11 +1557,19 @@ func prepareAddr(t *testing.T, ts *httptest.Server) (*url.URL, string, string) { func prepareEndpoint(t *testing.T, path, payload string) (*httptest.Server, *NginxPlusAPI) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - require.Equal(t, r.URL.Path, fmt.Sprintf("/api/%d/%s", defaultAPIVersion, path), "unknown request path") + fullPath := fmt.Sprintf("/api/%d/%s", defaultAPIVersion, path) + if r.URL.Path != fullPath { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Unknown request path, expected: %q, actual: %q", fullPath, r.URL.Path) + return + } w.Header()["Content-Type"] = []string{"application/json"} - _, err := fmt.Fprintln(w, payload) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, payload); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) n := &NginxPlusAPI{ diff --git a/plugins/inputs/nginx_sts/nginx_sts_test.go b/plugins/inputs/nginx_sts/nginx_sts_test.go index 4576f5c61..496a87e2e 100644 --- a/plugins/inputs/nginx_sts/nginx_sts_test.go +++ b/plugins/inputs/nginx_sts/nginx_sts_test.go @@ -160,20 +160,22 @@ const sampleStatusResponse = ` } ] } -} -` +}` func TestNginxPlusGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - var rsp string + if r.URL.Path != "/status" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, expected: %q, actual: %q", "/status", r.URL.Path) + return + } - require.Equal(t, "/status", r.URL.Path, "Cannot handle request") - - rsp = sampleStatusResponse w.Header()["Content-Type"] = []string{"application/json"} - - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleStatusResponse); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/nginx_upstream_check/nginx_upstream_check_test.go b/plugins/inputs/nginx_upstream_check/nginx_upstream_check_test.go index 141111351..4cd10020e 100644 --- a/plugins/inputs/nginx_upstream_check/nginx_upstream_check_test.go +++ b/plugins/inputs/nginx_upstream_check/nginx_upstream_check_test.go @@ -39,20 +39,22 @@ const sampleStatusResponse = ` } ] } -} -` +}` func TestNginxUpstreamCheckData(test *testing.T) { testServer := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) { - var response string + if request.URL.Path != "/status" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Cannot handle request, expected: %q, actual: %q", "/status", request.URL.Path) + return + } - require.Equal(test, "/status", request.URL.Path, "Cannot handle request") - - response = sampleStatusResponse responseWriter.Header()["Content-Type"] = []string{"application/json"} - - _, err := fmt.Fprintln(responseWriter, response) - require.NoError(test, err) + if _, err := fmt.Fprintln(responseWriter, sampleStatusResponse); err != nil { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Error(err) + return + } })) defer testServer.Close() @@ -101,20 +103,39 @@ func TestNginxUpstreamCheckData(test *testing.T) { func TestNginxUpstreamCheckRequest(test *testing.T) { testServer := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) { - var response string + if request.URL.Path != "/status" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Cannot handle request, expected: %q, actual: %q", "/status", request.URL.Path) + return + } - require.Equal(test, "/status", request.URL.Path, "Cannot handle request") - - response = sampleStatusResponse responseWriter.Header()["Content-Type"] = []string{"application/json"} + if _, err := fmt.Fprintln(responseWriter, sampleStatusResponse); err != nil { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Error(err) + return + } - _, err := fmt.Fprintln(responseWriter, response) - require.NoError(test, err) - - require.Equal(test, "POST", request.Method) - require.Equal(test, "test-value", request.Header.Get("X-Test")) - require.Equal(test, "Basic dXNlcjpwYXNzd29yZA==", request.Header.Get("Authorization")) - require.Equal(test, "status.local", request.Host) + if request.Method != "POST" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Not equal, expected: %q, actual: %q", "POST", request.Method) + return + } + if request.Header.Get("X-Test") != "test-value" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Not equal, expected: %q, actual: %q", "test-value", request.Header.Get("X-Test")) + return + } + if request.Header.Get("Authorization") != "Basic dXNlcjpwYXNzd29yZA==" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Not equal, expected: %q, actual: %q", "Basic dXNlcjpwYXNzd29yZA==", request.Header.Get("Authorization")) + return + } + if request.Host != "status.local" { + responseWriter.WriteHeader(http.StatusInternalServerError) + test.Errorf("Not equal, expected: %q, actual: %q", "status.local", request.Host) + return + } })) defer testServer.Close() diff --git a/plugins/inputs/nginx_vts/nginx_vts_test.go b/plugins/inputs/nginx_vts/nginx_vts_test.go index 35bfe3f14..d80b296d5 100644 --- a/plugins/inputs/nginx_vts/nginx_vts_test.go +++ b/plugins/inputs/nginx_vts/nginx_vts_test.go @@ -197,20 +197,22 @@ const sampleStatusResponse = ` } } } -} -` +}` func TestNginxPlusGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - var rsp string + if r.URL.Path != "/status" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, expected: %q, actual: %q", "/status", r.URL.Path) + return + } - require.Equal(t, "/status", r.URL.Path, "Cannot handle request") - - rsp = sampleStatusResponse w.Header()["Content-Type"] = []string{"application/json"} - - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleStatusResponse); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/nomad/nomad_test.go b/plugins/inputs/nomad/nomad_test.go index d0f903e09..0c195c120 100644 --- a/plugins/inputs/nomad/nomad_test.go +++ b/plugins/inputs/nomad/nomad_test.go @@ -80,11 +80,19 @@ func TestNomadStats(t *testing.T) { t.Run(tt.name, func(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.RequestURI == "/v1/metrics" { - w.WriteHeader(http.StatusOK) responseKeyMetrics, err := os.ReadFile("testdata/response_key_metrics.json") - require.NoError(t, err) - _, err = fmt.Fprintln(w, string(responseKeyMetrics)) - require.NoError(t, err) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + + if _, err = fmt.Fprintln(w, string(responseKeyMetrics)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + w.WriteHeader(http.StatusOK) } })) defer ts.Close() diff --git a/plugins/inputs/nsq/nsq_test.go b/plugins/inputs/nsq/nsq_test.go index 21a254a1b..b2887c2b6 100644 --- a/plugins/inputs/nsq/nsq_test.go +++ b/plugins/inputs/nsq/nsq_test.go @@ -14,9 +14,12 @@ import ( func TestNSQStatsV1(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, responseV1); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, responseV1) - require.NoError(t, err) })) defer ts.Close() @@ -271,9 +274,12 @@ var responseV1 = ` // TestNSQStatsPreV1 is for backwards compatibility with nsq versions < 1.0 func TestNSQStatsPreV1(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, responsePreV1); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, responsePreV1) - require.NoError(t, err) })) defer ts.Close() diff --git a/plugins/inputs/openweathermap/openweathermap_test.go b/plugins/inputs/openweathermap/openweathermap_test.go index aefad28ab..59650c7cc 100644 --- a/plugins/inputs/openweathermap/openweathermap_test.go +++ b/plugins/inputs/openweathermap/openweathermap_test.go @@ -100,8 +100,10 @@ func TestCases(t *testing.T) { key := strings.TrimPrefix(r.URL.Path, "/data/2.5/") if resp, found := input[key]; found { w.Header()["Content-Type"] = []string{"application/json"} - _, err := w.Write(resp) - require.NoError(t, err) + if _, err := w.Write(resp); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + } return } @@ -115,8 +117,10 @@ func TestCases(t *testing.T) { key += "_" + ids[0] if resp, found := input[key]; found { w.Header()["Content-Type"] = []string{"application/json"} - _, err := w.Write(resp) - require.NoError(t, err) + if _, err := w.Write(resp); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + } return } } diff --git a/plugins/inputs/phpfpm/fcgi_test.go b/plugins/inputs/phpfpm/fcgi_test.go index bff634618..f96c22b6f 100644 --- a/plugins/inputs/phpfpm/fcgi_test.go +++ b/plugins/inputs/phpfpm/fcgi_test.go @@ -10,8 +10,6 @@ import ( "io" "net/http" "testing" - - "github.com/stretchr/testify/require" ) const requestID uint16 = 1 @@ -238,13 +236,13 @@ func TestChildServeCleansUp(t *testing.T) { copy(input, tt.input) rc := nopWriteCloser{bytes.NewBuffer(input)} done := make(chan bool) - c := newChild(rc, http.HandlerFunc(func( - _ http.ResponseWriter, - r *http.Request, - ) { + c := newChild(rc, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // block on reading body of request _, err := io.Copy(io.Discard, r.Body) - require.ErrorIs(t, err, tt.err) + if !errors.Is(err, tt.err) { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Not equal, expected: %v, actual: %v", tt.err, err) + } // not reached if body of request isn't closed done <- true })) diff --git a/plugins/inputs/phpfpm/phpfpm_test.go b/plugins/inputs/phpfpm/phpfpm_test.go index 329538585..92b3affa7 100644 --- a/plugins/inputs/phpfpm/phpfpm_test.go +++ b/plugins/inputs/phpfpm/phpfpm_test.go @@ -39,11 +39,19 @@ func (s statServer) ServeHTTP(w http.ResponseWriter, _ *http.Request) { func TestPhpFpmGeneratesMetrics_From_Http(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - require.Equal(t, "ok", r.URL.Query().Get("test")) + if r.URL.Query().Get("test") != "ok" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Not equal, expected: %q, actual: %q", "ok", r.URL.Query().Get("test")) + return + } + w.Header().Set("Content-Type", "text/plain") w.Header().Set("Content-Length", strconv.Itoa(len(outputSample))) - _, err := fmt.Fprint(w, outputSample) - require.NoError(t, err) + if _, err := fmt.Fprint(w, outputSample); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -85,8 +93,11 @@ func TestPhpFpmGeneratesJSONMetrics_From_Http(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "text/json") w.Header().Set("Content-Length", strconv.Itoa(len(outputSampleJSON))) - _, err := fmt.Fprint(w, string(outputSampleJSON)) - require.NoError(t, err) + if _, err := fmt.Fprint(w, string(outputSampleJSON)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer server.Close() diff --git a/plugins/inputs/prometheus/prometheus_test.go b/plugins/inputs/prometheus/prometheus_test.go index c3d125be0..995ec9c8d 100644 --- a/plugins/inputs/prometheus/prometheus_test.go +++ b/plugins/inputs/prometheus/prometheus_test.go @@ -53,8 +53,11 @@ go_goroutines 15 1490802350000` func TestPrometheusGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -83,14 +86,23 @@ func TestPrometheusCustomHeader(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.Header.Get("accept") { case "application/vnd.google.protobuf;proto=io.prometheus.client.MetricFamily;encoding=delimited;q=0.7,text/plain;version=0.0.4;q=0.3": - _, err := fmt.Fprintln(w, "proto 15 1490802540000") - require.NoError(t, err) + if _, err := fmt.Fprintln(w, "proto 15 1490802540000"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } case "text/plain": - _, err := fmt.Fprintln(w, "plain 42 1490802380000") - require.NoError(t, err) + if _, err := fmt.Fprintln(w, "plain 42 1490802380000"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } default: - _, err := fmt.Fprintln(w, "other 44 1490802420000") - require.NoError(t, err) + if _, err := fmt.Fprintln(w, "other 44 1490802420000"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } } })) defer ts.Close() @@ -139,8 +151,11 @@ func TestPrometheusCustomHeader(t *testing.T) { func TestPrometheusGeneratesMetricsWithHostNameTag(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -174,8 +189,11 @@ func TestPrometheusWithTimestamp(t *testing.T) { # TYPE test_counter counter test_counter{label="test"} 1 1685443805885` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, prommetric) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, prommetric); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -210,8 +228,11 @@ func TestPrometheusGeneratesMetricsAlthoughFirstDNSFailsIntegration(t *testing.T } ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -237,8 +258,11 @@ func TestPrometheusGeneratesMetricsAlthoughFirstDNSFailsIntegration(t *testing.T func TestPrometheusGeneratesMetricsSlowEndpoint(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { time.Sleep(4 * time.Second) - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -269,8 +293,11 @@ func TestPrometheusGeneratesMetricsSlowEndpoint(t *testing.T) { func TestPrometheusGeneratesMetricsSlowEndpointHitTheTimeout(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { time.Sleep(6 * time.Second) - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -298,8 +325,11 @@ func TestPrometheusGeneratesMetricsSlowEndpointHitTheTimeout(t *testing.T) { func TestPrometheusGeneratesMetricsSlowEndpointNewConfigParameter(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { time.Sleep(4 * time.Second) - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -328,8 +358,11 @@ func TestPrometheusGeneratesMetricsSlowEndpointNewConfigParameter(t *testing.T) func TestPrometheusGeneratesMetricsSlowEndpointHitTheTimeoutNewConfigParameter(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { time.Sleep(6 * time.Second) - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -350,8 +383,11 @@ func TestPrometheusGeneratesMetricsSlowEndpointHitTheTimeoutNewConfigParameter(t func TestPrometheusContentLengthLimit(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -370,8 +406,11 @@ func TestPrometheusContentLengthLimit(t *testing.T) { func TestPrometheusGeneratesSummaryMetricsV2(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleSummaryTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleSummaryTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -404,8 +443,11 @@ go_gc_duration_seconds_sum 42.0 go_gc_duration_seconds_count 42` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, data) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -473,8 +515,11 @@ go_gc_duration_seconds_count 42` func TestPrometheusGeneratesGaugeMetricsV2(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleGaugeTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleGaugeTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -499,8 +544,11 @@ func TestPrometheusGeneratesGaugeMetricsV2(t *testing.T) { func TestPrometheusGeneratesMetricsWithIgnoreTimestamp(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, sampleTextFormat) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleTextFormat); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -599,8 +647,11 @@ func TestPrometheusInternalOk(t *testing.T) { # TYPE test_counter counter test_counter{label="test"} 1 1685443805885` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, prommetric) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, prommetric); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -640,8 +691,11 @@ func TestPrometheusInternalContentBadFormat(t *testing.T) { # TYPE test_counter counter Flag test` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, prommetric) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, prommetric); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -726,8 +780,11 @@ go_memstats_heap_alloc_bytes 1.581062048e+09 ` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Add("Content-Type", "application/openmetrics-text;version=1.0.0") - _, err := w.Write([]byte(data)) - require.NoError(t, err) + if _, err := w.Write([]byte(data)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -775,8 +832,11 @@ func TestOpenmetricsProtobuf(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Add("Content-Type", "application/openmetrics-protobuf;version=1.0.0") - _, err := w.Write(data) - require.NoError(t, err) + if _, err := w.Write(data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -834,8 +894,11 @@ go_memstats_heap_alloc_bytes 1.581062048e+09 ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { // Provide a wrong version w.Header().Add("Content-Type", "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited") - _, err := w.Write([]byte(data)) - require.NoError(t, err) + if _, err := w.Write([]byte(data)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/rabbitmq/rabbitmq_test.go b/plugins/inputs/rabbitmq/rabbitmq_test.go index 8e0722802..e6607a4e6 100644 --- a/plugins/inputs/rabbitmq/rabbitmq_test.go +++ b/plugins/inputs/rabbitmq/rabbitmq_test.go @@ -33,15 +33,23 @@ func TestRabbitMQGeneratesMetricsSet1(t *testing.T) { case "/api/nodes/rabbit@vagrant-ubuntu-trusty-64/memory": jsonFilePath = "testdata/set1/memory.json" default: - http.Error(w, fmt.Sprintf("unknown path %q", r.URL.Path), http.StatusNotFound) + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("unknown path %q", r.URL.Path) return } data, err := os.ReadFile(jsonFilePath) - require.NoErrorf(t, err, "could not read from data file %s", jsonFilePath) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Could not read from data file %q: %v", jsonFilePath, err) + return + } - _, err = w.Write(data) - require.NoError(t, err) + if _, err = w.Write(data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -244,15 +252,23 @@ func TestRabbitMQGeneratesMetricsSet2(t *testing.T) { case "/api/nodes/rabbit@rmqserver/memory": jsonFilePath = "testdata/set2/memory.json" default: - http.Error(w, fmt.Sprintf("unknown path %q", r.URL.Path), http.StatusNotFound) + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("unknown path %q", r.URL.Path) return } data, err := os.ReadFile(jsonFilePath) - require.NoErrorf(t, err, "could not read from data file %s", jsonFilePath) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Could not read from data file %q: %v", jsonFilePath, err) + return + } - _, err = w.Write(data) - require.NoError(t, err) + if _, err = w.Write(data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/raindrops/raindrops_test.go b/plugins/inputs/raindrops/raindrops_test.go index 92e86c9f6..82def94f1 100644 --- a/plugins/inputs/raindrops/raindrops_test.go +++ b/plugins/inputs/raindrops/raindrops_test.go @@ -30,8 +30,7 @@ writing: 200 0.0.0.0:3000 active: 11 0.0.0.0:3000 queued: 12 /tmp/listen.me active: 13 -/tmp/listen.me queued: 14 -` +/tmp/listen.me queued: 14` // Verify that raindrops tags are properly parsed based on the server func TestRaindropsTags(t *testing.T) { @@ -47,13 +46,17 @@ func TestRaindropsTags(t *testing.T) { func TestRaindropsGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - var rsp string + if r.URL.Path != "/_raindrops" { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request, expected: %q, actual: %q", "/_raindrops", r.URL.Path) + return + } - require.Equal(t, "/_raindrops", r.URL.Path, "Cannot handle request") - rsp = sampleResponse - - _, err := fmt.Fprintln(w, rsp) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, sampleResponse); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/ravendb/ravendb_test.go b/plugins/inputs/ravendb/ravendb_test.go index a3733693b..64f87c3e5 100644 --- a/plugins/inputs/ravendb/ravendb_test.go +++ b/plugins/inputs/ravendb/ravendb_test.go @@ -25,16 +25,24 @@ func TestRavenDBGeneratesMetricsFull(t *testing.T) { jsonFilePath = "testdata/indexes_full.json" case "/admin/monitoring/v1/collections": jsonFilePath = "testdata/collections_full.json" - default: - require.Failf(t, "Cannot handle request for uri %s", r.URL.Path) + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request for uri %s", r.URL.Path) + return } data, err := os.ReadFile(jsonFilePath) - require.NoErrorf(t, err, "could not read from data file %s", jsonFilePath) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Could not read from data file %q: %v", jsonFilePath, err) + return + } - _, err = w.Write(data) - require.NoError(t, err) + if _, err = w.Write(data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() @@ -227,14 +235,23 @@ func TestRavenDBGeneratesMetricsMin(t *testing.T) { case "/admin/monitoring/v1/collections": jsonFilePath = "testdata/collections_min.json" default: - require.Failf(t, "Cannot handle request for uri %s", r.URL.Path) + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Cannot handle request for uri %s", r.URL.Path) + return } data, err := os.ReadFile(jsonFilePath) - require.NoErrorf(t, err, "could not read from data file %s", jsonFilePath) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Could not read from data file %q: %v", jsonFilePath, err) + return + } - _, err = w.Write(data) - require.NoError(t, err) + if _, err = w.Write(data); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/riak/riak_test.go b/plugins/inputs/riak/riak_test.go index bebf1c9c7..0575cd0cd 100644 --- a/plugins/inputs/riak/riak_test.go +++ b/plugins/inputs/riak/riak_test.go @@ -15,9 +15,12 @@ import ( func TestRiak(t *testing.T) { // Create a test server with the const response JSON ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, response); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, response) - require.NoError(t, err) })) defer ts.Close() diff --git a/plugins/inputs/salesforce/salesforce_test.go b/plugins/inputs/salesforce/salesforce_test.go index da66d4a46..2ec82ddb3 100644 --- a/plugins/inputs/salesforce/salesforce_test.go +++ b/plugins/inputs/salesforce/salesforce_test.go @@ -15,8 +15,11 @@ import ( func Test_Gather(t *testing.T) { fakeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Add("Content-Type", "application/json") - _, err := w.Write([]byte(testJSON)) - require.NoError(t, err) + if _, err := w.Write([]byte(testJSON)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer fakeServer.Close() diff --git a/plugins/inputs/slurm/slurm_test.go b/plugins/inputs/slurm/slurm_test.go index 4da047d1a..526851a00 100644 --- a/plugins/inputs/slurm/slurm_test.go +++ b/plugins/inputs/slurm/slurm_test.go @@ -121,11 +121,19 @@ func TestCases(t *testing.T) { ts.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { resp, ok := pathToResponse[strings.TrimPrefix(r.URL.Path, "/slurm/v0.0.38/")] - require.True(t, ok) + if !ok { + w.WriteHeader(http.StatusInternalServerError) + t.Errorf("Expected to have path to response: %s", r.URL.Path) + return + } w.Header().Add("Content-Type", "application/json") + + if _, err := w.Write(resp); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := w.Write(resp) - require.NoError(t, err) }) // Load the test-specific configuration diff --git a/plugins/inputs/solr/solr_test.go b/plugins/inputs/solr/solr_test.go index bc6bdabb3..1cf9a8177 100644 --- a/plugins/inputs/solr/solr_test.go +++ b/plugins/inputs/solr/solr_test.go @@ -68,8 +68,12 @@ func TestCases(t *testing.T) { w.WriteHeader(http.StatusNotFound) return } - _, err := w.Write(page) - require.NoError(t, err) + + if _, err := w.Write(page); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) require.NotNil(t, server) defer server.Close() diff --git a/plugins/inputs/tengine/tengine_test.go b/plugins/inputs/tengine/tengine_test.go index fbd5b3ac0..c3e527514 100644 --- a/plugins/inputs/tengine/tengine_test.go +++ b/plugins/inputs/tengine/tengine_test.go @@ -28,8 +28,11 @@ func TestTengineTags(t *testing.T) { func TestTengineGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - _, err := fmt.Fprintln(w, tengineSampleResponse) - require.NoError(t, err) + if _, err := fmt.Fprintln(w, tengineSampleResponse); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } })) defer ts.Close() diff --git a/plugins/inputs/tomcat/tomcat_test.go b/plugins/inputs/tomcat/tomcat_test.go index eaa2e01ac..47a36d42b 100644 --- a/plugins/inputs/tomcat/tomcat_test.go +++ b/plugins/inputs/tomcat/tomcat_test.go @@ -40,9 +40,12 @@ var tomcatStatus8 = ` func TestHTTPTomcat8(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, tomcatStatus8); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, tomcatStatus8) - require.NoError(t, err) })) defer ts.Close() @@ -125,9 +128,12 @@ var tomcatStatus6 = ` func TestHTTPTomcat6(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, tomcatStatus6); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, tomcatStatus6) - require.NoError(t, err) })) defer ts.Close() diff --git a/plugins/inputs/uwsgi/uwsgi_test.go b/plugins/inputs/uwsgi/uwsgi_test.go index d000c3f1b..9f28bde11 100644 --- a/plugins/inputs/uwsgi/uwsgi_test.go +++ b/plugins/inputs/uwsgi/uwsgi_test.go @@ -113,8 +113,11 @@ func TestBasic(t *testing.T) { fakeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/" { - _, err := w.Write([]byte(js)) - require.NoError(t, err) + if _, err := w.Write([]byte(js)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } } else { w.WriteHeader(http.StatusNotFound) } @@ -145,8 +148,11 @@ func TestInvalidJSON(t *testing.T) { fakeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/" { - _, err := w.Write([]byte(js)) - require.NoError(t, err) + if _, err := w.Write([]byte(js)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } } else { w.WriteHeader(http.StatusNotFound) } diff --git a/plugins/inputs/vault/vault_test.go b/plugins/inputs/vault/vault_test.go index 987b70bec..813e2bce6 100644 --- a/plugins/inputs/vault/vault_test.go +++ b/plugins/inputs/vault/vault_test.go @@ -76,11 +76,19 @@ func TestVaultStats(t *testing.T) { t.Run(tt.name, func(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.RequestURI == "/v1/sys/metrics" { - w.WriteHeader(http.StatusOK) responseKeyMetrics, err := os.ReadFile("testdata/response_key_metrics.json") - require.NoError(t, err) - _, err = fmt.Fprintln(w, string(responseKeyMetrics)) - require.NoError(t, err) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + + if _, err = fmt.Fprintln(w, string(responseKeyMetrics)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + w.WriteHeader(http.StatusOK) } })) defer ts.Close() @@ -157,9 +165,12 @@ func TestRedirect(t *testing.T) { redirectURL := "http://" + r.Host + "/custom/metrics" http.Redirect(w, r, redirectURL, http.StatusTemporaryRedirect) case "/custom/metrics": + if _, err := w.Write(response); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := w.Write(response) - require.NoError(t, err) } })) defer server.Close() diff --git a/plugins/inputs/xtremio/xtremio_test.go b/plugins/inputs/xtremio/xtremio_test.go index 36a814384..1955f36c5 100644 --- a/plugins/inputs/xtremio/xtremio_test.go +++ b/plugins/inputs/xtremio/xtremio_test.go @@ -80,21 +80,41 @@ func TestFixedValue(t *testing.T) { if r.URL.Path == "/api/json/v3/commands/login" { cookie := &http.Cookie{Name: "sessid", Value: "cookie:123456789"} http.SetCookie(w, cookie) + + if _, err := fmt.Fprintln(w, "authentication succeeded"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err := fmt.Fprintln(w, "authentication succeeded") - require.NoError(t, err) } else if r.URL.Path == "/api/json/v3/types/bbus" { sampleGetBBUsResponse, err := os.ReadFile(filepath.Join(testdataDir, "sample_get_bbu_response.json")) - require.NoError(t, err) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + + if _, err = fmt.Fprintln(w, string(sampleGetBBUsResponse)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err = fmt.Fprintln(w, string(sampleGetBBUsResponse)) - require.NoError(t, err) } else if r.URL.Path == "/api/json/v3/types/bbus/987654321abcdef" { sampleBBUResponseOne, err := os.ReadFile(filepath.Join(testdataDir, "sample_bbu_response.json")) - require.NoError(t, err) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } + + if _, err = fmt.Fprintln(w, string(sampleBBUResponseOne)); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusOK) - _, err = fmt.Fprintln(w, string(sampleBBUResponseOne)) - require.NoError(t, err) } }, ), @@ -154,9 +174,12 @@ func TestAuthenticationFailed(t *testing.T) { ts := httptest.NewServer( http.HandlerFunc( func(w http.ResponseWriter, _ *http.Request) { + if _, err := fmt.Fprintln(w, "bad request"); err != nil { + w.WriteHeader(http.StatusInternalServerError) + t.Error(err) + return + } w.WriteHeader(http.StatusBadRequest) - _, err := fmt.Fprintln(w, "bad request") - require.NoError(t, err) }, ), )