-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathinjectWebEnv_test.go
262 lines (232 loc) · 5.82 KB
/
injectWebEnv_test.go
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
package spaserve
import (
"bytes"
"errors"
"testing"
"github.com/psanford/memfs"
"golang.org/x/net/html"
)
func TestInjectWebEnv(t *testing.T) {
// Create a mock file system
fsys := memfs.New()
_ = fsys.MkdirAll(".", 0755)
_ = fsys.WriteFile("index.html", []byte("<html><head></head><body></body></html>"), 0644)
// Define the web environment configuration
conf := struct {
Foo string `json:"foo"`
Bar int `json:"bar"`
}{
Foo: "hello",
Bar: 42,
}
// Define the namespace
ns := "myNamespace"
// Call the InjectWebEnv function
result, err := InjectWebEnv(fsys, conf, ns)
// Check for errors
if err != nil {
t.Errorf("InjectWebEnv returned an unexpected error: %v", err)
}
// Check if the index.html file exists in the result file system
if !indexExists(result) {
t.Error("InjectWebEnv did not inject the web environment into the index.html file")
}
// Check if ns is a valid namespace
if _, err = InjectWebEnv(fsys, conf, ""); !errors.Is(err, ErrNoNamespace) {
t.Errorf("InjectWebEnv did not return ErrNoNamespace: %v", err)
}
if _, err = InjectWebEnv(fsys, conf, "!!!!"); !errors.Is(err, ErrCouldNotParseNamespace) {
t.Errorf("InjectWebEnv did not return ErrCouldNotParseNamespace: %v", err)
}
// Check if index file exists
if _, err = InjectWebEnv(memfs.New(), conf, ns); !errors.Is(err, ErrNoIndexFound) {
t.Errorf("InjectWebEnv did not return ErrNoIndexFound: %v", err)
}
}
func TestAppendToIndex(t *testing.T) {
scriptNode := html.Node{
Type: html.ElementNode,
Data: "script",
Attr: []html.Attribute{
{Key: "type", Val: "text/javascript"},
},
FirstChild: &html.Node{
Type: html.TextNode,
Data: "window.webEnv = {\"foo\":\"hello\",\"bar\":42};",
},
}
var data bytes.Buffer
if err := html.Render(&data, &html.Node{
Type: html.ElementNode,
Data: "html",
FirstChild: &html.Node{
Type: html.ElementNode,
Data: "head",
},
LastChild: &html.Node{
Type: html.ElementNode,
Data: "body",
},
}); err != nil {
t.Fatalf("html.Render() returned an unexpected error: %v", err)
}
s := scriptNode
var want bytes.Buffer
if err := html.Render(&want, &html.Node{
Type: html.ElementNode,
Data: "html",
FirstChild: &html.Node{
Type: html.ElementNode,
Data: "head",
FirstChild: &s,
NextSibling: &html.Node{
Type: html.ElementNode,
Data: "body",
},
},
}); err != nil {
t.Fatalf("html.Render() returned an unexpected error: %v", err)
}
tt := []struct {
name string
path string
data []byte
want []byte
}{
{
name: "when path is not index.html should return data",
path: "not-index.html",
data: []byte("Hello, World!"),
want: []byte("Hello, World!"),
},
{
name: "when path is index.html should return data with script tag",
path: "index.html",
data: data.Bytes(),
want: want.Bytes(),
},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
if got, err := appendToIndex(&scriptNode)(tc.path, tc.data); err != nil {
t.Errorf("appendToIndex() error = %v, want nil", err)
} else if !bytes.Equal(got, tc.want) {
t.Errorf("appendToIndex() = %s, want %s", got, tc.want)
}
})
}
}
func TestFindHead(t *testing.T) {
headNode := &html.Node{
Type: html.ElementNode,
Data: "head",
}
tt := []struct {
name string
node *html.Node
want *html.Node
}{
{
name: "when head first should return node",
node: &html.Node{
Type: html.ElementNode,
Data: "html",
FirstChild: headNode,
LastChild: &html.Node{
Type: html.ElementNode,
Data: "body",
},
},
want: headNode,
},
{
name: "when body first should return nil",
node: &html.Node{
Type: html.ElementNode,
Data: "html",
FirstChild: &html.Node{
Type: html.ElementNode,
Data: "body",
},
LastChild: headNode,
},
want: nil,
},
{
name: "when no head or body should return nil",
node: &html.Node{
Type: html.ElementNode,
Data: "html",
FirstChild: &html.Node{
Type: html.ElementNode,
Data: "div",
},
LastChild: &html.Node{
Type: html.ElementNode,
Data: "div",
},
},
want: nil,
},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
if got := findHead(tc.node); got != tc.want {
t.Errorf("findHead() = %v, want %v", got, tc.want)
}
})
}
}
func TestIndexExists(t *testing.T) {
fsWithIndex := memfs.New()
_ = fsWithIndex.MkdirAll(".", 0755)
_ = fsWithIndex.WriteFile("index.html", []byte("Hello, World!"), 0644)
fsWithoutIndex := memfs.New()
_ = fsWithoutIndex.MkdirAll(".", 0755)
t.Run("index exists", func(t *testing.T) {
exists := indexExists(fsWithIndex)
if !exists {
t.Errorf("indexExists() = false, want true")
}
})
t.Run("index does not exist", func(t *testing.T) {
exists := indexExists(fsWithoutIndex)
if exists {
t.Errorf("indexExists() = true, want false")
}
})
}
func TestConstructScriptTag(t *testing.T) {
conf := struct {
Foo string `json:"foo"`
Bar int `json:"bar"`
}{
Foo: "hello",
Bar: 42,
}
ns := "myNamespace"
want := `<script type="text/javascript">window.myNamespace = {"foo":"hello","bar":42};</script>`
scriptTag, err := constructScriptTag(ns, conf)
if err != nil {
t.Fatalf("constructScriptTag() returned an unexpected error: %v", err)
}
var buf bytes.Buffer
if err := html.Render(&buf, scriptTag); err != nil {
t.Fatalf("html.Render() returned an unexpected error: %v", err)
}
got := buf.String()
if got != want {
t.Errorf("constructScriptTag() = %s, want %s", got, want)
}
}
func TestConstructScriptTag_MarshalError(t *testing.T) {
ns := "myNamespace"
wantErr := ErrCouldNotMarshalConfig
_, err := constructScriptTag(ns, make(chan int))
if err == nil {
t.Fatal("constructScriptTag() did not return an error")
}
if !errors.Is(err, wantErr) {
t.Errorf("constructScriptTag() error = %v, want %v", err, wantErr)
}
}