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
|
package gomponents_test
import (
"errors"
"fmt"
"io"
"strings"
"testing"
g "github.com/maragudk/gomponents"
"github.com/maragudk/gomponents/assert"
)
func TestNodeFunc(t *testing.T) {
t.Run("implements fmt.Stringer", func(t *testing.T) {
fn := g.NodeFunc(func(w io.Writer) error {
_, _ = w.Write([]byte("hat"))
return nil
})
if fn.String() != "hat" {
t.FailNow()
}
})
}
func TestAttr(t *testing.T) {
t.Run("renders just the local name with one argument", func(t *testing.T) {
a := g.Attr("required")
assert.Equal(t, " required", a)
})
t.Run("renders the name and value when given two arguments", func(t *testing.T) {
a := g.Attr("id", "hat")
assert.Equal(t, ` id="hat"`, a)
})
t.Run("panics with more than two arguments", func(t *testing.T) {
called := false
defer func() {
if err := recover(); err != nil {
called = true
}
}()
g.Attr("name", "value", "what is this?")
if !called {
t.FailNow()
}
})
t.Run("implements fmt.Stringer", func(t *testing.T) {
a := g.Attr("required")
s := fmt.Sprintf("%v", a)
if s != " required" {
t.FailNow()
}
})
t.Run("escapes attribute values", func(t *testing.T) {
a := g.Attr(`id`, `hat"><script`)
assert.Equal(t, ` id="hat"><script"`, a)
})
}
func BenchmarkAttr(b *testing.B) {
b.Run("boolean attributes", func(b *testing.B) {
for i := 0; i < b.N; i++ {
a := g.Attr("hat")
_ = a.Render(&strings.Builder{})
}
})
b.Run("name-value attributes", func(b *testing.B) {
for i := 0; i < b.N; i++ {
a := g.Attr("hat", "party")
_ = a.Render(&strings.Builder{})
}
})
}
type outsider struct{}
func (o outsider) String() string {
return "outsider"
}
func (o outsider) Render(w io.Writer) error {
_, _ = w.Write([]byte("outsider"))
return nil
}
func TestEl(t *testing.T) {
t.Run("renders an empty element if no children given", func(t *testing.T) {
e := g.El("div")
assert.Equal(t, "<div></div>", e)
})
t.Run("renders an empty element without closing tag if it's a void kind element", func(t *testing.T) {
e := g.El("hr")
assert.Equal(t, "<hr>", e)
e = g.El("br")
assert.Equal(t, "<br>", e)
e = g.El("img")
assert.Equal(t, "<img>", e)
})
t.Run("renders an empty element if only attributes given as children", func(t *testing.T) {
e := g.El("div", g.Attr("class", "hat"))
assert.Equal(t, `<div class="hat"></div>`, e)
})
t.Run("renders an element, attributes, and element children", func(t *testing.T) {
e := g.El("div", g.Attr("class", "hat"), g.El("br"))
assert.Equal(t, `<div class="hat"><br></div>`, e)
})
t.Run("renders attributes at the correct place regardless of placement in parameter list", func(t *testing.T) {
e := g.El("div", g.El("br"), g.Attr("class", "hat"))
assert.Equal(t, `<div class="hat"><br></div>`, e)
})
t.Run("renders outside if node does not implement placer", func(t *testing.T) {
e := g.El("div", outsider{})
assert.Equal(t, `<div>outsider</div>`, e)
})
t.Run("does not fail on nil node", func(t *testing.T) {
e := g.El("div", nil, g.El("br"), nil, g.El("br"))
assert.Equal(t, `<div><br><br></div>`, e)
})
t.Run("returns render error on cannot write", func(t *testing.T) {
e := g.El("div")
err := e.Render(&erroringWriter{})
assert.Error(t, err)
})
}
func BenchmarkEl(b *testing.B) {
b.Run("normal elements", func(b *testing.B) {
for i := 0; i < b.N; i++ {
e := g.El("div")
_ = e.Render(&strings.Builder{})
}
})
}
type erroringWriter struct{}
func (w *erroringWriter) Write(p []byte) (n int, err error) {
return 0, errors.New("no thanks")
}
func TestText(t *testing.T) {
t.Run("renders escaped text", func(t *testing.T) {
e := g.Text("<div>")
assert.Equal(t, "<div>", e)
})
}
func TestTextf(t *testing.T) {
t.Run("renders interpolated and escaped text", func(t *testing.T) {
e := g.Textf("<%v>", "div")
assert.Equal(t, "<div>", e)
})
}
func TestRaw(t *testing.T) {
t.Run("renders raw text", func(t *testing.T) {
e := g.Raw("<div>")
assert.Equal(t, "<div>", e)
})
}
func TestGroup(t *testing.T) {
t.Run("groups multiple nodes into one", func(t *testing.T) {
children := []g.Node{g.El("br", g.Attr("id", "hat")), g.El("hr")}
e := g.El("div", g.Attr("class", "foo"), g.El("img"), g.Group(children))
assert.Equal(t, `<div class="foo"><img><br id="hat"><hr></div>`, e)
})
t.Run("panics on direct render", func(t *testing.T) {
e := g.Group(nil)
panicked := false
defer func() {
if err := recover(); err != nil {
panicked = true
}
}()
_ = e.Render(nil)
if !panicked {
t.FailNow()
}
})
t.Run("panics on direct string", func(t *testing.T) {
e := g.Group(nil).(fmt.Stringer)
panicked := false
defer func() {
if err := recover(); err != nil {
panicked = true
}
}()
_ = e.String()
if !panicked {
t.FailNow()
}
})
}
func TestMap(t *testing.T) {
t.Run("maps slices to nodes", func(t *testing.T) {
items := []string{"hat", "partyhat", "turtlehat"}
lis := g.Map(len(items), func(i int) g.Node {
return g.El("li", g.Text(items[i]))
})
list := g.El("ul", lis...)
assert.Equal(t, `<ul><li>hat</li><li>partyhat</li><li>turtlehat</li></ul>`, list)
})
}
func TestIf(t *testing.T) {
t.Run("returns node if condition is true", func(t *testing.T) {
n := g.El("div", g.If(true, g.El("span")))
assert.Equal(t, "<div><span></span></div>", n)
})
t.Run("returns nil if condition is false", func(t *testing.T) {
n := g.El("div", g.If(false, g.El("span")))
assert.Equal(t, "<div></div>", n)
})
}
|