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
|
{ :document, Node } = js.global
import div, h1, ul, li, pre from require './html.moon'
test_group = (name) ->
list = ul!
root = div (h1 name), list
root, (name, test) ->
ok, err = pcall test
list\appendChild li if ok
"passed '#{name}'"
else
"failed '#{name}'", pre err
node, run_test = test_group 'component.moon'
document.body\appendChild node
local ReactiveVar, ReactiveElement
run_test "exports ReactiveVar, ReactiveElement", ->
import ReactiveVar, ReactiveElement from require './component.moon'
assert ReactiveVar, "ReactiveVar not exported"
assert ReactiveElement, "ReactiveElement not exported"
run_test "exports text helper", ->
import text from require './component.moon'
assert 'function' == (type text), "ReactiveVar not exported"
node = text 'a test string'
assert (js.instanceof node, js.global.Node), "expected text to generate a Node"
assert node.data == 'a test string', "expected text to store the string"
run_test "text joins multiple arguments", ->
import text from require './component.moon'
node = text 'a', 'test', 'string'
assert node.data == 'a test string', "expected text to join arguments with spaces"
node, run_test = test_group 'ReactiveVar'
document.body\appendChild node
run_test "stores a value", ->
reactive = ReactiveVar 'test'
assert 'test' == reactive\get!, "expected x to be 'test'"
run_test "propagates updates", ->
local done
reactive = ReactiveVar 'test'
reactive\subscribe coroutine.wrap (next) ->
assert next == 'toast', "expected next to be 'toast'"
assert coroutine.yield! == 'cheese', "expected next to be 'cheese'"
done = true
reactive\set 'toast'
assert 'toast' == reactive\get!, "expected #get to return 'toast'"
reactive\set 'cheese'
assert done, "expected to reach the end"
run_test "passed old value as well", ->
local done
reactive = ReactiveVar 1
reactive\subscribe coroutine.wrap (next, last) ->
assert last == 1, "expected last:1 to be 1"
next, last = coroutine.yield!
assert last == 2, "expected last:2 to be 2"
done = true
reactive\set 2
reactive\set 3
assert done, "expected to reach the end"
run_test "#subscribe returns function to unsubscribe", ->
calls = 0
reactive = ReactiveVar 1
unsub = reactive\subscribe coroutine.wrap () ->
calls += 1
coroutine.yield!
calls += 1
coroutine.yield!
calls += 1
assert 'function' == (type unsub), "expected to receive a function"
reactive\set 2
reactive\set 3
assert calls == 2, "wat"
unsub!
reactive\set 4
assert calls == 2, "expected to stop receiving updates"
run_test "tracks multiple subscriptions at once", ->
reactive = ReactiveVar 'test'
unsub = reactive\subscribe coroutine.wrap (next) ->
assert next == 'toast', "expected next to be toast"
next = coroutine.yield!
assert next == 'cheese', "expected next to be cheese"
coroutine.yield!
error "expected not to get here"
reactive\set 'toast'
local done
reactive\subscribe coroutine.wrap (next) ->
assert next == 'cheese', "expected next to be cheese"
next = coroutine.yield!
assert next == 'test', "expected next to be test"
done = true
reactive\set 'cheese'
unsub!
reactive\set 'test'
assert done, "expected to reach the end"
node, run_test = test_group 'ReactiveElement'
document.body\appendChild node
run_test "creates a HTML element", ->
elem = ReactiveElement 'span'
assert elem.node and elem.node.localName == 'span', "expected Node to be a <span>"
run_test "sets attributes from a table arg", ->
elem = ReactiveElement 'span', class: 'never'
assert elem.node.class == 'never', "expected class to be 'never'"
run_test "appends Nodes from arguments", ->
e_div, e_pre = div!, pre!
elem = ReactiveElement 'span', e_div, e_pre
assert elem.node.firstElementChild == e_div, "expected div to be the first child of elem"
assert elem.node.lastElementChild == e_pre, "expected pre to be the last child of elem"
run_test "can append ReactiveElements and text", ->
e_div = ReactiveElement 'div'
elem = ReactiveElement 'div', e_div, 'testtext'
assert elem.node.firstElementChild == e_div.node, "expected div to be the first child of elem"
assert elem.node.lastChild.data == 'testtext', "expected last child of elem to be 'testtext'"
run_test "accepts attributes after children", ->
e_div = div!
elem = ReactiveElement 'div', e_div, class: 'test'
assert elem.node.firstElementChild == e_div, "expected div to be the first child of elem"
assert elem.node.class == 'test', "expected class to be 'test'"
run_test "allows mixing attributes and children in a single table", ->
e_div, e_pre = div!, pre!
elem = ReactiveElement 'div', { class: 'test', e_div, e_pre }
assert elem.node.firstElementChild == e_div, "expected div to be the first child of elem"
assert elem.node.lastElementChild == e_pre, "expected pre to be the last child of elem"
assert elem.node.class == 'test', "expected class to be 'test'"
run_test "can unwrap and track attributes from ReactiveVars", ->
klass = ReactiveVar 'test'
elem = ReactiveElement 'div', class: klass
assert elem.node.class == 'test', "expected class to be 'test'"
klass\set 'toast'
assert elem.node.class == 'toast', "expected class to be 'toast'"
run_test "can unwrap and track children from ReactiveVars", ->
child = ReactiveVar h1 'test'
elem = ReactiveElement 'div', child, pre 'fixed'
assert elem.node.firstElementChild.localName == 'h1', "expected first child to be h1"
assert elem.node.childElementCount == 2, "expected node to have two children"
child\set div 'toast'
assert elem.node.firstElementChild.localName == 'div', "expected first child to be div"
assert elem.node.childElementCount == 2, "expected node to have two children"
run_test "warns when appending a string from a ReactiveVar", ->
import text from require './component.moon'
export print
_print = print
calls = 0
print = (msg) -> calls += 1 if 'WARN: string' == msg\sub 1, 12
str = ReactiveVar 'test'
elem = ReactiveElement 'div', str
assert calls == 1, "expected to print warning"
str\set 'string too'
assert calls == 2, "expected to print warning again"
str\set text 'this is text'
assert calls == 2, "expected not to print warning with text node"
print = _print
|
