nexarch/internal/httpclient/httpclient_test.go

package httpclient

import (
	"io/fs"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"testing"
	"time"
)

func TestDefaultHasTimeout(t *testing.T) {
	if Default().Timeout != DefaultTimeout || DefaultTimeout <= 0 {
		t.Fatalf("timeout = %s", Default().Timeout)
	}
}

func TestClientGivesUpOnHangingServer(t *testing.T) {
	release := make(chan struct{})
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { <-release }))
	defer srv.Close()
	defer close(release)

	start := time.Now()
	resp, err := New(200 * time.Millisecond).Get(srv.URL)
	if err == nil {
		_ = resp.Body.Close()
		t.Fatal("kein fehler bei haengendem server")
	}
	if elapsed := time.Since(start); elapsed > 5*time.Second {
		t.Fatalf("aufruf dauerte %s", elapsed)
	}
}

func TestClientDoesNotFollowRedirects(t *testing.T) {
	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t.Error("weiterleitungsziel wurde aufgerufen (Service-Token-Leck)")
	}))
	defer target.Close()
	redirector := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, target.URL, http.StatusTemporaryRedirect)
	}))
	defer redirector.Close()

	req, _ := http.NewRequest(http.MethodPost, redirector.URL, strings.NewReader("x"))
	req.Header.Set("X-Service-Token", "geheim")
	resp, err := Default().Do(req)
	if err != nil {
		t.Fatalf("do: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusTemporaryRedirect {
		t.Fatalf("status = %d, erwartet 307", resp.StatusCode)
	}
}

// Architekturtest: im Produktivcode dieses Moduls gibt es keine Aufrufe ueber
// den Standard-Client ohne Zeitlimit, auch keinen ungebundenen http.Client{}.
func TestNoUnboundedDefaultClientInProductionCode(t *testing.T) {
	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
	if err != nil {
		t.Fatal(err)
	}
	// Core-root-Modul lebt am Repo-Wurzelverzeichnis neben den eigenstaendigen
	// Modulen (dms/, archive/, mail/, ...) - nur internal/ und cmd/ gehoeren
	// zu diesem Modul, der Rest wird von den jeweiligen Modul-Architekturtests
	// abgedeckt.
	scanDirs := []string{"internal", "cmd"}
	forbidden := regexp.MustCompile(`http\.DefaultClient|http\.(Get|Post|Head|PostForm)\(|http\.Client\{\}`)
	for _, dir := range scanDirs {
		root := filepath.Join(repoRoot, dir)
		if _, err := os.Stat(root); os.IsNotExist(err) {
			continue
		}
		err = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
			if err != nil {
				return err
			}
			if d.IsDir() {
				if n := d.Name(); n == "node_modules" || n == "testdata" || n == ".git" {
					return filepath.SkipDir
				}
				return nil
			}
			if !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "_test.go") {
				return nil
			}
			data, err := os.ReadFile(path)
			if err != nil {
				return err
			}
			for i, line := range strings.Split(string(data), "\n") {
				if t := strings.TrimSpace(line); strings.HasPrefix(t, "//") {
					continue
				}
				if forbidden.MatchString(line) {
					rel, _ := filepath.Rel(repoRoot, path)
					t.Errorf("%s:%d nutzt den Standard-Client ohne Zeitlimit: %s", rel, i+1, strings.TrimSpace(line))
				}
			}
			return nil
		})
		if err != nil {
			t.Fatal(err)
		}
	}
}