clientip/test_helpers_test.go at main · abczzz13/clientip · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package clientip

import (
	"errors"
	"net/http"
	"net/netip"
	"net/url"
	"strings"
	"testing"
)

type extractionState struct {
	HasIP  bool
	IP     string
	Source Source
}

type errorTextState struct {
	HasErr       bool
	ContainsText bool
}

func errorIsType(err error, target any) bool {
	if err == nil {
		return false
	}
	switch target.(type) {
	case *ExtractionError:
		var e *ExtractionError
		return asError(err, &e)
	case *MultipleHeadersError:
		var e *MultipleHeadersError
		return asError(err, &e)
	case *ProxyValidationError:
		var e *ProxyValidationError
		return asError(err, &e)
	case *InvalidIPError:
		var e *InvalidIPError
		return asError(err, &e)
	case *RemoteAddrError:
		var e *RemoteAddrError
		return asError(err, &e)
	default:
		return false
	}
}

func asError(err error, target any) bool {
	switch v := target.(type) {
	case **ExtractionError:
		return errors.As(err, v)
	case **MultipleHeadersError:
		return errors.As(err, v)
	case **ProxyValidationError:
		return errors.As(err, v)
	case **InvalidIPError:
		return errors.As(err, v)
	case **RemoteAddrError:
		return errors.As(err, v)
	default:
		return false
	}
}

func extractionStateOf(extraction Extraction) extractionState {
	state := extractionState{
		HasIP:  extraction.IP.IsValid(),
		Source: extraction.Source,
	}

	if extraction.IP.IsValid() {
		state.IP = extraction.IP.String()
	}

	return state
}

func errorTextStateOf(err error, contains string) errorTextState {
	return errorTextState{
		HasErr:       err != nil,
		ContainsText: err != nil && strings.Contains(err.Error(), contains),
	}
}

func mustNewExtractor(t *testing.T, cfg Config) *Extractor {
	t.Helper()

	extractor, err := New(cfg)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	return extractor
}

func mustProxyPrefixesFromAddrs(t *testing.T, addrs ...netip.Addr) []netip.Prefix {
	t.Helper()

	prefixes, err := ProxyPrefixesFromAddrs(addrs...)
	if err != nil {
		t.Fatalf("ProxyPrefixesFromAddrs() error = %v", err)
	}

	return prefixes
}

func mustParseCIDRs(t *testing.T, cidrs ...string) []netip.Prefix {
	t.Helper()

	prefixes, err := ParseCIDRs(cidrs...)
	if err != nil {
		t.Fatalf("ParseCIDRs() error = %v", err)
	}

	return prefixes
}

func newTestRequest(remoteAddr, path string) *http.Request {
	req := &http.Request{
		RemoteAddr: remoteAddr,
		Header:     make(http.Header),
	}

	if path != "" {
		req.URL = &url.URL{Path: path}
	}

	return req
}