restapi/api_test.go at main · Arhius/restapi · 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
package restapi

import (
	"errors"
	"net/http"
	"testing"
)

func TestNewAPI_NoOptions_UsesDefaultRegistry(t *testing.T) {
	t.Parallel()

	api := NewAPI()
	if api == nil {
		t.Fatal("NewAPI returned nil")
	}
	if api.registry == nil {
		t.Fatal("api.registry is nil; expected fallback to Default().registry")
	}
	if api.registry != Default().registry {
		t.Fatal("api.registry should alias Default().registry when no option is supplied")
	}
}

func TestNewAPI_NilOption_Skipped(t *testing.T) {
	t.Parallel()

	api := NewAPI(nil)
	if api == nil || api.registry == nil {
		t.Fatal("NewAPI must tolerate nil options")
	}
}

func TestNewAPI_WithErrorRegistry_Nil_FallsBack(t *testing.T) {
	t.Parallel()

	api := NewAPI(WithErrorRegistry(nil))
	if api.registry != Default().registry {
		t.Fatal("WithErrorRegistry(nil) must leave registry unchanged so default fallback kicks in")
	}
}

func TestNewAPI_WithErrorRegistry_Custom(t *testing.T) {
	t.Parallel()

	fallback := ErrorRegistryEntry{StatusCode: http.StatusTeapot, ErrorCode: 9999, Message: "teapot"}
	custom, err := NewErrorRegistry(fallback)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	api := NewAPI(WithErrorRegistry(custom))
	if api.Registry() != custom {
		t.Fatal("expected custom registry to be returned by Registry()")
	}
}

func TestDefault_SetDefault_SwapAndPanicOnNil(t *testing.T) {
	prev := Default()
	t.Cleanup(func() { defaultAPI.Store(prev) })

	fallback := ErrorRegistryEntry{StatusCode: http.StatusTeapot, ErrorCode: 9999, Message: "swap"}
	custom, err := NewErrorRegistry(fallback)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	swap := NewAPI(WithErrorRegistry(custom))
	SetDefault(swap)
	if Default() != swap {
		t.Fatal("SetDefault did not swap defaultAPI")
	}

	defer func() {
		if r := recover(); r == nil {
			t.Fatal("SetDefault(nil) must panic")
		}
	}()
	SetDefault(nil)
}

func TestAPI_Delegation(t *testing.T) {
	t.Parallel()

	fallback := ErrorRegistryEntry{StatusCode: 500, ErrorCode: 1, Message: "fallback"}
	reg, err := NewErrorRegistry(fallback)
	if err != nil {
		t.Fatalf("NewErrorRegistry: %v", err)
	}
	api := NewAPI(WithErrorRegistry(reg))

	if api.IsRegistered(2) {
		t.Fatal("2 should not be registered")
	}

	entry := ErrorRegistryEntry{StatusCode: http.StatusNotFound, ErrorCode: 2, Message: "nope"}
	if err := api.Register(entry); err != nil {
		t.Fatalf("Register: %v", err)
	}
	if !api.IsRegistered(2) {
		t.Fatal("2 should be registered after Register")
	}

	got, ok := api.Lookup(2)
	if !ok || got != entry {
		t.Fatalf("Lookup(2) = %#v, %v; want %#v, true", got, ok, entry)
	}

	_, err = api.MustLookup(999)
	if !errors.Is(err, ErrUnknownErrorCode) {
		t.Fatalf("MustLookup(999) must wrap ErrUnknownErrorCode; got %v", err)
	}

	api.MustRegister(ErrorRegistryEntry{StatusCode: 201, ErrorCode: 3, Message: "ok"})
	if !api.IsRegistered(3) {
		t.Fatal("3 should be registered after MustRegister")
	}

	defer func() {
		if r := recover(); r == nil {
			t.Fatal("MustRegister on duplicate must panic")
		}
	}()
	api.MustRegister(entry)
}